[u/mrichter/AliRoot.git] / PWGJE / macros / AddTaskJetsReader.C

Float_t kPtTrackMin = 0.15; // pt cut on tracks
Int_t kDetectorType = 1;    // 0 = MC, 1 = TPC

AliAnalysisDataContainer*  cout_jet_cont = 0x0;

void SetJetReaderExchangeContainer(AliAnalysisDataContainer* acont) {
  cout_jet_cont = acont;

}

AliAnalysisDataContainer* GetJetReaderExchangeContainer() { return cout_jet_cont;}
AliAnalysisDataContainer* AddJetExchangeContainer(const char* contname) { return AliAnalysisManager::GetAnalysisManager()->CreateContainer(contname, TTree::Class(),AliAnalysisManager::kExchangeContainer);}

AliJetReader *CreateJetReader(AliAnalysisDataContainer* contname,Char_t *jr,UInt_t filterMask); // Common config

AliAnalysisTaskJetsReader *AddTaskJetsReader(AliAnalysisDataContainer* contname,Char_t *jr, UInt_t filterMask = 0,Float_t ptTrackMin = 0.15 , Int_t dettype = 1); // for the new AF
Int_t AddTaskJetsReaderDelta(AliAnalysisDataContainer* contname,char *nonStdFile = "",UInt_t filterMask = 0,Bool_t kUseAODMC = kTRUE,UInt_t runFlag = 1|4|32|128|256);     
AliAnalysisTaskJetsReader *AddTaskJetsReader(AliAnalysisDataContainer* contname,UInt_t filterMask = 0);

AliAnalysisTaskJetsReader *AddTaskJetsReader(const char* contname, UInt_t filterMask = 0) { return AddTaskJetsReader(AddJetExchangeContainer(contname),filterMask); } // LEGO trains  
AliAnalysisTaskJetsReader *AddTaskJetsReader(const char* contname,Char_t *jr, UInt_t filterMask = 0,Float_t ptTrackMin = 0.15 , Int_t dettype = 1) {  
 return AddTaskJetsReader(AddJetExchangeContainer(contname),jr,filterMask,ptTrackMin,dettype); 

}

AliAnalysisTaskJetsReader *AddTaskJetsReader(AliAnalysisDataContainer* contname,UInt_t filterMask){
  // fills the standard input "jets" branch in the AOD
  // need the ESDFilter to run before, to access the AODtracks
  // Tracks selected by the first Filter (1<<0)
  // needs to be adapted for different cuts
  

  return AddTaskJetsReader(contname,"AOD",filterMask);

}


Int_t AddTaskJetsReaderDelta(AliAnalysisDataContainer* contname,char *nonStdFile,UInt_t filterMask,Bool_t kUseAODMC,UInt_t runFlag){

  // Adds a whole set of jet finders  all to be written
  // to a delta AOD
  
  // this can in principle be done also with on the fly 
  // if we have an ESD input jet fidner task does automatically fetch the ouput aod

  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddTaskJetsReaderDelta", "No analysis manager to connect to.");
    return -1;
  }  
  
  
  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler()) {
    ::Error("AddTaskJetsReaderDelta", "This task requires an input event handler");
    return -1;
  }


  AliAODHandler *aodh = (AliAODHandler*)mgr->GetOutputEventHandler();
  if (!aodh) {
    ::Error("AddTaskJetsReaderDelta", "This task needs an output event handler");
    return -1;
  }

  TString outFile(nonStdFile);


  AliAnalysisTaskJetsReader *taskjetsReader = 0;
  Int_t iCount = 0;

  const char *cReader[4] = {"AOD","AODMC","AODMC2","AODMC2b"};  

  
  // Ligne a revoir
  //  if(!kUseAODMC)ib=1; // switch OFF MC if we do not have it
  for(int ib = 0;ib<4;ib++){      
    if(1<<ib){
      cout << "cReader[" << ib << "]: " << cReader[ib] << ", filterMask: " << filterMask << endl;
      taskjetsReader = AddTaskJetsReader(contname,cReader[ib],filterMask);
      if(taskjetsReader){
	if(outFile.Length()>0)taskjetsReader->SetNonStdOutputFile(outFile.Data());
      }
    }
  }
  return 0;
}

AliAnalysisTaskJetsReader *AddTaskJetsReader(AliAnalysisDataContainer* contname,Char_t *jr, UInt_t filterMask,Float_t ptTrackMin,Int_t dettype)
{
  // Creates a jet finder task, configures it and adds it to the analysis manager.

  kPtTrackMin = ptTrackMin;
  kDetectorType = dettype;

  // Get the pointer to the existing analysis manager via the static access method.
  //==============================================================================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddTaskJetsReader", "No analysis manager to connect to.");
    return NULL;
  }  
  
  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler()) {
    ::Error("AddTaskJetsReader", "This task requires an input event handler");
    return NULL;
  }

  AliAODHandler *aodh = (AliAODHandler*)mgr->GetOutputEventHandler();
  if (!aodh) {
    ::Error("AddTaskJetsReader", "This task needs an output event handler");
    return NULL;
  }   
  

  // Create the task and configure it.
  //===========================================================================
  AliAnalysisTaskJetsReader *taskjetsReader;
  AliJetReader *er = CreateJetReader(contname,jr,filterMask);

  taskjetsReader = new AliAnalysisTaskJetsReader(Form("JetAnalysis%s",jr));

  // Connect jet finder to task.
  taskjetsReader->SetJetReader(er);
  taskjetsReader->SetConfigFile("");
  taskjetsReader->SetDebugLevel(-1);
  mgr->SetGlobalStr(cout_jet_cont->GetName(),Form("%s#_Filter%05d_Cut%05d",jr,filterMask,(int)((1000.*ptTrackMin))));
  mgr->AddTask(taskjetsReader);

  cout_jet_cont = GetJetReaderExchangeContainer();
  if(! cout_jet_cont) { ::Error("AddTaskJetsReader", "This task needs an Exchange container");  return NULL;}
  // Create ONLY the output containers for the data produced by the task.
  // Get and connect other common input/output containers via the manager as below
  //==============================================================================
  mgr->ConnectInput  (taskjetsReader, 0, mgr->GetCommonInputContainer());
  mgr->ConnectOutput (taskjetsReader, 0, mgr->GetCommonOutputContainer());
  mgr->ConnectOutput (taskjetsReader, 1, cout_jet_cont); 
   

  return taskjetsReader;
}


AliJetReader *CreateJetReader(AliAnalysisDataContainer* contname,Char_t *jr,UInt_t filterMask){
  AliJetReader *er = 0;
  SetJetReaderExchangeContainer(contname);
  Float_t ptCut  = kPtTrackMin ; // cut on track p_T
 
  switch (jr) {
  case "ESD":
    AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
    jrh->SetDataType("ESD");
    jrh->SetComment("ESD Reader");
    jrh->SetDebug(-1);
    jrh->SetPtCut(ptCut);
    jrh->SetFiducialEta(-0.9,0.9);
    jrh->SetFiducialPhi(0,2*TMath::Pi());
    // Define reader and set its header                                     
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;
  case "AOD":
    AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
    jrh->SetDataType("AOD");
    jrh->SetComment("AOD Reader");
    jrh->SetDebug(-1);
    jrh->SetPtCut(ptCut);
    jrh->SetTestFilterMask(32); // Change this one for a different set of cuts
    if(filterMask>0)jrh->SetTestFilterMask(filterMask); 
    jrh->SetFilterType(0); // Filter type
    jrh->SetFiducialEta(-0.9,0.9);
    jrh->SetFiducialPhi(0,2*TMath::Pi());
    // Define reader and set its header
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;
  case "AODMC":
    AliJetReaderHeader *jrh = new AliJetReaderHeader(/*kDetectorType =*/0);
    jrh->SetComment("AOD MC Reader");
    jrh->SetDataType("AODMC");
    jrh->SetDebug(-1);
    jrh->SetPtCut(ptCut);
    jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0.9
    // Define reader and set its header
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;
  case "AODMC2":
    AliJetReaderHeader *jrh = new AliJetReaderHeader(/*kDetectorType =*/0);
    jrh->SetDataType("AODMC2");
    jrh->SetComment("AOD MC Reader");
    jrh->SetDebug(-1);
    jrh->SetPtCut(ptCut);
    jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0.9
    // Define reader and set its header
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;
  case "AODMC2b":
    AliJetReaderHeader *jrh = new AliJetReaderHeader(/*kDetectorType =*/0);
    jrh->SetDataType("AODMC2b");
    jrh->SetComment("AOD MC Reader");
    jrh->SetDebug(-1);
    jrh->SetPtCut(ptCut);
    jrh->SetFiducialEta(-0.9,0.9); 
    // Define reader and set its header
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;
  case "AODextra":
    AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
    jrh->SetDataType("AODextra");
    jrh->SetComment("AOD Reader with extra branch");
    jrh->SetDebug(-1);
    jrh->SetPtCut(ptCut);
    jrh->SetTestFilterMask(32); // Change this one for a different set of cuts
    if(filterMask>0)jrh->SetTestFilterMask(filterMask);
    // Define reader and set its header
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;
  case "AODextraonly":
    AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
    jrh->SetDataType("AODextraonly");
    jrh->SetComment("AOD Reader with extra branch");
    jrh->SetDebug(-1);
    jrh->SetPtCut(ptCut);
    jrh->SetTestFilterMask(32); // Change this one for a different set of cuts
    if(filterMask>0)jrh->SetTestFilterMask(filterMask);
    // Define reader and set its header
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;

  case "MC":
    AliJetKineReaderHeader *jrh = new AliJetKineReaderHeader();
    jrh->SetDataType("MC");
    jrh->SetComment("MC full Kinematics");
    jrh->SetDebug(-1);
    jrh->SetFastSimTPC(kFALSE);
    jrh->SetFastSimEMCAL(kFALSE);
    jrh->SetPtCut(ptCut);
    jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0.9                                                                             
    // Define reader and set its header                                     
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;
  case "MC2":
    AliJetKineReaderHeader *jrh = new AliJetKineReaderHeader();
    jrh->SetDataType("MC2");
    jrh->SetComment("MC full Kinematics spearate config charged only");
    jrh->SetDebug(-1);
    jrh->SetFastSimTPC(kFALSE);
    jrh->SetFastSimEMCAL(kFALSE);
    jrh->SetChargedOnly(kTRUE);
    jrh->SetPtCut(ptCut);
    jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0 .9                                                                             
    // Define reader and set its header                                     
    er = new AliJetReader();
    er->SetReaderHeader(jrh);
    break;

  default:
    ::Error("AddTaskJetsReader", Form("Wrong jet reader selected: %s\n",jr));
    return 0x0;
    break;
  }

  return er;

}
Commit	Line	Data
7e4f0fd4	1	Float_t kPtTrackMin = 0.15; // pt cut on tracks
	2	Int_t kDetectorType = 1; // 0 = MC, 1 = TPC
	3
	4	AliAnalysisDataContainer* cout_jet_cont = 0x0;
	5
	6	void SetJetReaderExchangeContainer(AliAnalysisDataContainer* acont) {
	7	cout_jet_cont = acont;
	8
	9	}
	10
	11	AliAnalysisDataContainer* GetJetReaderExchangeContainer() { return cout_jet_cont;}
	12	AliAnalysisDataContainer* AddJetExchangeContainer(const char* contname) { return AliAnalysisManager::GetAnalysisManager()->CreateContainer(contname, TTree::Class(),AliAnalysisManager::kExchangeContainer);}
	13
	14	AliJetReader CreateJetReader(AliAnalysisDataContainer contname,Char_t *jr,UInt_t filterMask); // Common config
	15
	16	AliAnalysisTaskJetsReader AddTaskJetsReader(AliAnalysisDataContainer contname,Char_t *jr, UInt_t filterMask = 0,Float_t ptTrackMin = 0.15 , Int_t dettype = 1); // for the new AF
	17	Int_t AddTaskJetsReaderDelta(AliAnalysisDataContainer* contname,char *nonStdFile = "",UInt_t filterMask = 0,Bool_t kUseAODMC = kTRUE,UInt_t runFlag = 1\|4\|32\|128\|256);
	18	AliAnalysisTaskJetsReader AddTaskJetsReader(AliAnalysisDataContainer contname,UInt_t filterMask = 0);
	19
7f435d7a	20	AliAnalysisTaskJetsReader AddTaskJetsReader(const char contname, UInt_t filterMask = 0) { return AddTaskJetsReader(AddJetExchangeContainer(contname),filterMask); } // LEGO trains
	21	AliAnalysisTaskJetsReader AddTaskJetsReader(const char contname,Char_t *jr, UInt_t filterMask = 0,Float_t ptTrackMin = 0.15 , Int_t dettype = 1) {
	22	return AddTaskJetsReader(AddJetExchangeContainer(contname),jr,filterMask,ptTrackMin,dettype);
	23
	24	}
	25
7e4f0fd4	26	AliAnalysisTaskJetsReader AddTaskJetsReader(AliAnalysisDataContainer contname,UInt_t filterMask){
	27	// fills the standard input "jets" branch in the AOD
	28	// need the ESDFilter to run before, to access the AODtracks
	29	// Tracks selected by the first Filter (1<<0)
	30	// needs to be adapted for different cuts
	31
	32
	33	return AddTaskJetsReader(contname,"AOD",filterMask);
	34
	35	}
	36
	37
	38
	39	Int_t AddTaskJetsReaderDelta(AliAnalysisDataContainer* contname,char *nonStdFile,UInt_t filterMask,Bool_t kUseAODMC,UInt_t runFlag){
	40
	41	// Adds a whole set of jet finders all to be written
	42	// to a delta AOD
	43
	44	// this can in principle be done also with on the fly
	45	// if we have an ESD input jet fidner task does automatically fetch the ouput aod
	46
	47
	48	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	49	if (!mgr) {
	50	::Error("AddTaskJetsReaderDelta", "No analysis manager to connect to.");
	51	return -1;
	52	}
	53
	54
	55	// Check the analysis type using the event handlers connected to the analysis manager.
	56	//==============================================================================
	57	if (!mgr->GetInputEventHandler()) {
	58	::Error("AddTaskJetsReaderDelta", "This task requires an input event handler");
	59	return -1;
	60	}
	61
	62
	63	AliAODHandler aodh = (AliAODHandler)mgr->GetOutputEventHandler();
	64	if (!aodh) {
	65	::Error("AddTaskJetsReaderDelta", "This task needs an output event handler");
	66	return -1;
	67	}
	68
	69	TString outFile(nonStdFile);
	70
	71
	72	AliAnalysisTaskJetsReader *taskjetsReader = 0;
	73	Int_t iCount = 0;
	74
	75	const char *cReader[4] = {"AOD","AODMC","AODMC2","AODMC2b"};
	76
	77
	78
	79	// Ligne a revoir
	80	// if(!kUseAODMC)ib=1; // switch OFF MC if we do not have it
	81	for(int ib = 0;ib<4;ib++){
	82	if(1<<ib){
	83	cout << "cReader[" << ib << "]: " << cReader[ib] << ", filterMask: " << filterMask << endl;
	84	taskjetsReader = AddTaskJetsReader(contname,cReader[ib],filterMask);
	85	if(taskjetsReader){
	86	if(outFile.Length()>0)taskjetsReader->SetNonStdOutputFile(outFile.Data());
	87	}
	88	}
	89	}
90	return 0;
91	}
92
93	AliAnalysisTaskJetsReader AddTaskJetsReader(AliAnalysisDataContainer contname,Char_t *jr, UInt_t filterMask,Float_t ptTrackMin,Int_t dettype)
94	{
95	// Creates a jet finder task, configures it and adds it to the analysis manager.
96
97	kPtTrackMin = ptTrackMin;
98	kDetectorType = dettype;
99
100	// Get the pointer to the existing analysis manager via the static access method.
101	//==============================================================================
102	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
103	if (!mgr) {
104	::Error("AddTaskJetsReader", "No analysis manager to connect to.");
105	return NULL;
106	}
107
108	// Check the analysis type using the event handlers connected to the analysis manager.
109	//==============================================================================
110	if (!mgr->GetInputEventHandler()) {
111	::Error("AddTaskJetsReader", "This task requires an input event handler");
112	return NULL;
113	}
114
115	AliAODHandler aodh = (AliAODHandler)mgr->GetOutputEventHandler();
116	if (!aodh) {
117	::Error("AddTaskJetsReader", "This task needs an output event handler");
118	return NULL;
119	}
120
121
122	// Create the task and configure it.
123	//===========================================================================
124	AliAnalysisTaskJetsReader *taskjetsReader;
125	AliJetReader *er = CreateJetReader(contname,jr,filterMask);
126
127	taskjetsReader = new AliAnalysisTaskJetsReader(Form("JetAnalysis%s",jr));
128
129	// Connect jet finder to task.
130	taskjetsReader->SetJetReader(er);
131	taskjetsReader->SetConfigFile("");
132	taskjetsReader->SetDebugLevel(-1);
133	mgr->SetGlobalStr(cout_jet_cont->GetName(),Form("%s#_Filter%05d_Cut%05d",jr,filterMask,(int)((1000.*ptTrackMin))));
134	mgr->AddTask(taskjetsReader);
135
136	cout_jet_cont = GetJetReaderExchangeContainer();
137	if(! cout_jet_cont) { ::Error("AddTaskJetsReader", "This task needs an Exchange container"); return NULL;}
138	// Create ONLY the output containers for the data produced by the task.
139	// Get and connect other common input/output containers via the manager as below
140	//==============================================================================
141	mgr->ConnectInput (taskjetsReader, 0, mgr->GetCommonInputContainer());
142	mgr->ConnectOutput (taskjetsReader, 0, mgr->GetCommonOutputContainer());
143	mgr->ConnectOutput (taskjetsReader, 1, cout_jet_cont);
144
145
146	return taskjetsReader;
147	}
148
149
150	AliJetReader CreateJetReader(AliAnalysisDataContainer contname,Char_t *jr,UInt_t filterMask){
151	AliJetReader *er = 0;
152	SetJetReaderExchangeContainer(contname);
153	Float_t ptCut = kPtTrackMin ; // cut on track p_T
154
155	switch (jr) {
156	case "ESD":
157	AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
158	jrh->SetDataType("ESD");
159	jrh->SetComment("ESD Reader");
160	jrh->SetDebug(-1);
161	jrh->SetPtCut(ptCut);
162	jrh->SetFiducialEta(-0.9,0.9);
163	jrh->SetFiducialPhi(0,2*TMath::Pi());
164	// Define reader and set its header
165	er = new AliJetReader();
166	er->SetReaderHeader(jrh);
167	break;
168	case "AOD":
169	AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
170	jrh->SetDataType("AOD");
171	jrh->SetComment("AOD Reader");
172	jrh->SetDebug(-1);
173	jrh->SetPtCut(ptCut);
174	jrh->SetTestFilterMask(32); // Change this one for a different set of cuts
175	if(filterMask>0)jrh->SetTestFilterMask(filterMask);
176	jrh->SetFilterType(0); // Filter type
177	jrh->SetFiducialEta(-0.9,0.9);
178	jrh->SetFiducialPhi(0,2*TMath::Pi());
179	// Define reader and set its header
180	er = new AliJetReader();
181	er->SetReaderHeader(jrh);
182	break;
183	case "AODMC":
184	AliJetReaderHeader jrh = new AliJetReaderHeader(/kDetectorType =*/0);
185	jrh->SetComment("AOD MC Reader");
186	jrh->SetDataType("AODMC");
187	jrh->SetDebug(-1);
188	jrh->SetPtCut(ptCut);
189	jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0.9
190	// Define reader and set its header
191	er = new AliJetReader();
192	er->SetReaderHeader(jrh);
193	break;
194	case "AODMC2":
195	AliJetReaderHeader jrh = new AliJetReaderHeader(/kDetectorType =*/0);
196	jrh->SetDataType("AODMC2");
197	jrh->SetComment("AOD MC Reader");
198	jrh->SetDebug(-1);
199	jrh->SetPtCut(ptCut);
200	jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0.9
201	// Define reader and set its header
202	er = new AliJetReader();
203	er->SetReaderHeader(jrh);
204	break;
205	case "AODMC2b":
206	AliJetReaderHeader jrh = new AliJetReaderHeader(/kDetectorType =*/0);
207	jrh->SetDataType("AODMC2b");
208	jrh->SetComment("AOD MC Reader");
209	jrh->SetDebug(-1);
210	jrh->SetPtCut(ptCut);
211	jrh->SetFiducialEta(-0.9,0.9);
212	// Define reader and set its header
213	er = new AliJetReader();
214	er->SetReaderHeader(jrh);
215	break;
216	case "AODextra":
217	AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
218	jrh->SetDataType("AODextra");
219	jrh->SetComment("AOD Reader with extra branch");
220	jrh->SetDebug(-1);
221	jrh->SetPtCut(ptCut);
222	jrh->SetTestFilterMask(32); // Change this one for a different set of cuts
223	if(filterMask>0)jrh->SetTestFilterMask(filterMask);
224	// Define reader and set its header
225	er = new AliJetReader();
226	er->SetReaderHeader(jrh);
227	break;
228	case "AODextraonly":
229	AliJetReaderHeader *jrh = new AliJetReaderHeader(kDetectorType);
230	jrh->SetDataType("AODextraonly");
231	jrh->SetComment("AOD Reader with extra branch");
232	jrh->SetDebug(-1);
233	jrh->SetPtCut(ptCut);
234	jrh->SetTestFilterMask(32); // Change this one for a different set of cuts
235	if(filterMask>0)jrh->SetTestFilterMask(filterMask);
236	// Define reader and set its header
237	er = new AliJetReader();
238	er->SetReaderHeader(jrh);
239	break;
240
241	case "MC":
242	AliJetKineReaderHeader *jrh = new AliJetKineReaderHeader();
243	jrh->SetDataType("MC");
244	jrh->SetComment("MC full Kinematics");
245	jrh->SetDebug(-1);
246	jrh->SetFastSimTPC(kFALSE);
247	jrh->SetFastSimEMCAL(kFALSE);
248	jrh->SetPtCut(ptCut);
249	jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0.9
250	// Define reader and set its header
251	er = new AliJetReader();
252	er->SetReaderHeader(jrh);
253	break;
254	case "MC2":
255	AliJetKineReaderHeader *jrh = new AliJetKineReaderHeader();
256	jrh->SetDataType("MC2");
257	jrh->SetComment("MC full Kinematics spearate config charged only");
258	jrh->SetDebug(-1);
259	jrh->SetFastSimTPC(kFALSE);
260	jrh->SetFastSimEMCAL(kFALSE);
261	jrh->SetChargedOnly(kTRUE);
262	jrh->SetPtCut(ptCut);
263	jrh->SetFiducialEta(-2.1,2.1); // to take all MC particles default is 0 .9
264	// Define reader and set its header
265	er = new AliJetReader();
266	er->SetReaderHeader(jrh);
267	break;
268
269	default:
270	::Error("AddTaskJetsReader", Form("Wrong jet reader selected: %s\n",jr));
271	return 0x0;
272	break;
273	}
274
275	return er;
276
277	}