]>
Commit | Line | Data |
---|---|---|
cd54ca47 | 1 | |
2 | Bool_t kPrint = kFALSE; | |
193828fd | 3 | Bool_t kSimulation = kFALSE; |
4 | Bool_t kUseKinematics = kFALSE; | |
5 | Bool_t kOutputAOD = kFALSE; | |
531f682d | 6 | Bool_t kEventSelection= kFALSE; |
7 | Bool_t kExotic = kTRUE; | |
8 | Bool_t kNonLinearity = kFALSE; | |
193828fd | 9 | Int_t kYears = 2011; |
cd54ca47 | 10 | TString kCollisions = "pp"; |
11 | TString kTrig = "EMC7" ; | |
193828fd | 12 | TString kClusterArray = ""; |
8bd000ef | 13 | TString kData = ""; // MC or deltaAOD |
193828fd | 14 | TString kInputDataType = "ESD"; |
15 | TString kCalorimeter = "EMCAL"; | |
531f682d | 16 | Bool_t kTM = kTRUE; |
17 | Bool_t kRecalTM = kTRUE; | |
18 | Int_t kMinCen = -1; | |
19 | Int_t kMaxCen = -1; | |
20 | TString kName = ""; | |
21 | Int_t kDebug = -1; | |
22 | Bool_t kQA = kFALSE; | |
23 | Bool_t kHadronAN = kFALSE; | |
023e6936 | 24 | Bool_t kCalibE = kTRUE; |
25 | Bool_t kCalibT = kTRUE; | |
26 | Bool_t kBadMap = kTRUE; | |
27 | ||
8bd000ef | 28 | AliAnalysisTaskCaloTrackCorrelation *AddTaskCaloTrackCorr(const TString data = "", |
ac0610dc | 29 | const TString calorimeter = "EMCAL", |
30 | const Bool_t simulation = kFALSE, | |
31 | const Bool_t eventsel = kFALSE, | |
32 | const Bool_t exotic = kTRUE, | |
33 | const Bool_t nonlin = kFALSE, | |
34 | TString outputfile = "", | |
35 | const Int_t year = 2010, | |
36 | const TString col = "pp", | |
37 | const TString trigger = "MB", | |
38 | const TString clustersArray = "V1", | |
39 | const Bool_t recaltm = kTRUE, | |
40 | const Bool_t tm = kTRUE, | |
41 | const Int_t minCen = -1, | |
42 | const Int_t maxCen = -1, | |
43 | const Bool_t qaan = kFALSE, | |
44 | const Bool_t hadronan = kFALSE, | |
45 | const Bool_t calibE = kTRUE, | |
46 | const Bool_t badmap = kTRUE, | |
47 | const Bool_t calibT = kTRUE, | |
48 | const Bool_t outputAOD = kFALSE, | |
49 | const Bool_t printSettings = kFALSE, | |
50 | const Double_t scaleFactor = -1 | |
531f682d | 51 | ) |
193828fd | 52 | { |
372e67a3 | 53 | // Creates a CaloTrackCorr task, configures it and adds it to the analysis manager. |
90eb3a19 | 54 | |
cd54ca47 | 55 | kPrint = printSettings; |
193828fd | 56 | kSimulation = simulation; |
193828fd | 57 | kYears = year; |
58 | kCollisions = col; | |
531f682d | 59 | kExotic = exotic; |
60 | kNonLinearity = nonlin; | |
193828fd | 61 | kTrig = trigger; |
62 | kClusterArray = clustersArray; | |
63 | kData = data; | |
64 | kCalorimeter = calorimeter; | |
65 | kOutputAOD = outputAOD; | |
531f682d | 66 | kTM = tm; |
67 | kRecalTM = recaltm; | |
68 | kMinCen = minCen; | |
69 | kMaxCen = maxCen; | |
70 | kEventSelection= eventsel; | |
71 | kQA = qaan; | |
72 | kHadronAN = hadronan; | |
023e6936 | 73 | kCalibE = calibE; |
74 | kCalibT = calibT; | |
75 | kBadMap = badmap; | |
193828fd | 76 | |
90eb3a19 | 77 | // Get the pointer to the existing analysis manager via the static access method. |
193828fd | 78 | |
90eb3a19 | 79 | AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); |
531f682d | 80 | if (!mgr) |
81 | { | |
193828fd | 82 | ::Error("AddTask", "No analysis manager to connect to."); |
90eb3a19 | 83 | return NULL; |
84 | } | |
193828fd | 85 | |
86 | // Check the analysis type using the event handlers connected to the analysis manager. | |
87 | ||
531f682d | 88 | if (!mgr->GetInputEventHandler()) |
89 | { | |
193828fd | 90 | ::Error("AddTask", "This task requires an input event handler"); |
91 | return NULL; | |
92 | } | |
531f682d | 93 | |
193828fd | 94 | kInputDataType = "AOD"; |
95 | if(!kData.Contains("delta")) | |
96 | kInputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" | |
97 | ||
531f682d | 98 | if(kSimulation) |
99 | { | |
1e3689fa | 100 | kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE; |
193828fd | 101 | if (!kUseKinematics && data=="AOD" && kInputDataType != "ESD") kUseKinematics = kTRUE; //AOD primary should be available ... |
1e3689fa | 102 | } |
103 | ||
104 | cout<<"********* ACCESS KINE? "<<kUseKinematics<<endl; | |
105 | ||
531f682d | 106 | // Name for containers |
107 | ||
108 | kName = Form("%s_Trig%s_Cl%s_TM%d",kCalorimeter.Data(), kTrig.Data(),kClusterArray.Data(),kTM); | |
109 | ||
110 | if(kCollisions=="PbPb" && kMaxCen>=0) kName+=Form("Cen%d_%d",kMinCen,kMaxCen); | |
111 | ||
112 | printf("<<<< NAME: %s >>>>>\n",kName.Data()); | |
113 | ||
193828fd | 114 | // #### Configure analysis #### |
cd54ca47 | 115 | |
745913ae | 116 | AliAnaCaloTrackCorrMaker * maker = new AliAnaCaloTrackCorrMaker(); |
193828fd | 117 | |
1806f9c0 | 118 | maker->SetScaleFactor(scaleFactor); // for MC, negative (not scaled) by default |
119 | ||
193828fd | 120 | // General frame setting and configuration |
121 | maker->SetReader (ConfigureReader() ); | |
122 | maker->SetCaloUtils(ConfigureCaloUtils()); | |
123 | ||
124 | // Analysis tasks setting and configuration | |
125 | Int_t n = 0;//Analysis number, order is important | |
193828fd | 126 | |
cd54ca47 | 127 | // Isolation settings |
66e64043 | 128 | Int_t partInCone = AliIsolationCut::kNeutralAndCharged; // kOnlyCharged; |
ac0610dc | 129 | Int_t thresType = AliIsolationCut::kPtThresIC;// AliIsolationCut::kSumPtFracIC ; |
531f682d | 130 | |
ac0610dc | 131 | // Photon analysis |
531f682d | 132 | |
133 | maker->AddAnalysis(ConfigurePhotonAnalysis(), n++); // Photon cluster selection | |
e9de0d57 | 134 | |
135 | // Invariant mass analysis Put here to tag selected photons as decay | |
136 | maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0", AliAnaPi0EbE::kIMCalo), n++); // Pi0 event by event selection, invariant mass and photon tagging from decay | |
137 | maker->AddAnalysis(ConfigurePi0EbEAnalysis("Eta", AliAnaPi0EbE::kIMCalo), n++); // Eta event by event selection, invariant mass and photon tagging from decay | |
138 | ||
139 | // Photon analysis | |
531f682d | 140 | maker->AddAnalysis(ConfigureIsolationAnalysis("Photon", partInCone,thresType), n++); // Photon isolation |
531f682d | 141 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",kFALSE), n++); // Gamma hadron correlation |
142 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",kTRUE) , n++); // Isolated gamma hadron correlation | |
ac0610dc | 143 | //maker->AddAnalysis(ConfigureIsolationAnalysis("Photon", partInCone,thresType,kTRUE), n++); // Photon multi isolation, leave it the last |
144 | ||
e9de0d57 | 145 | |
ac0610dc | 146 | // Split cluster analysis |
147 | if(kCalorimeter == "EMCAL") | |
148 | { | |
149 | maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0", AliAnaPi0EbE::kSSCalo), n++); // Pi0 event by event selection, cluster splitting | |
150 | maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SS", partInCone,thresType), n++); // Pi0 isolation, cluster splits | |
151 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SS" ,kFALSE), n++); // Pi0 hadron correlation | |
152 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SS" ,kTRUE) , n++); // Isolated pi0 hadron correlation | |
153 | //maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SS", partInCone,thresType,kTRUE), n++); // Pi0 multi isolation, split cluster | |
154 | //maker->AddAnalysis(ConfigureInClusterIMAnalysis(0.5,3), n++); | |
155 | } | |
156 | ||
157 | // Invariant mass analysis | |
ac0610dc | 158 | maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0SideBand", AliAnaPi0EbE::kIMCalo), n++); // Pi0 event by event selection, and photon tagging from decay |
ac0610dc | 159 | maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0", partInCone,thresType), n++); // Pi0 isolation, invariant mass |
160 | maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SideBand", partInCone,thresType), n++); // Pi0 isolation, side band | |
531f682d | 161 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0" ,kFALSE), n++); // Pi0 hadron correlation |
162 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0" ,kTRUE) , n++); // Isolated pi0 hadron correlation | |
ac0610dc | 163 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SideBand" ,kFALSE), n++); // Pi0 hadron correlation |
164 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SideBand" ,kTRUE) , n++); // Isolated pi0 hadron correlation | |
165 | //maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0", partInCone,thresType,kTRUE), n++); // Pi0 multi isolation, invariant mass, leave it the last | |
166 | ||
531f682d | 167 | if(kHadronAN) |
8f880b6e | 168 | { |
8f880b6e | 169 | maker->AddAnalysis(ConfigureChargedAnalysis(), n++); // track selection |
531f682d | 170 | maker->AddAnalysis(ConfigureIsolationAnalysis("Hadron",AliIsolationCut::kOnlyCharged,thresType), n++); // track isolation |
8f880b6e | 171 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Hadron",kFALSE), n++); // track-track correlation |
172 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Hadron",kTRUE) , n++); // Isolated track-track correlation | |
ac0610dc | 173 | //maker->AddAnalysis(ConfigureIsolationAnalysis("Hadron",partInCone,thresType,kTRUE), n++);// Hadron multi isolation |
cd54ca47 | 174 | } |
531f682d | 175 | |
bef94c35 | 176 | // Analysis with ghost triggers, only for Min Bias like events |
ac0610dc | 177 | if( kTrig.Contains("INT") || kTrig.Contains("Central") || kTrig.Contains("MB") ) |
bef94c35 | 178 | { |
179 | maker->AddAnalysis(ConfigureRandomTriggerAnalysis(), n++); | |
180 | maker->AddAnalysis(ConfigureIsolationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()), partInCone,thresType), n++); // Ghost trigger isolation | |
181 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()),kFALSE), n++); // Ghost trigger hadron correlation | |
182 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()),kTRUE) , n++); // Isolated ghost hadron correlation | |
ac0610dc | 183 | //maker->AddAnalysis(ConfigureIsolationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()), partInCone,thresType,kTRUE), n++); // Ghost multi isolation |
bef94c35 | 184 | |
185 | if(kHadronAN) | |
186 | { | |
187 | maker->AddAnalysis(ConfigureRandomTriggerAnalysis("CTS"), n++); // track selection | |
188 | maker->AddAnalysis(ConfigureIsolationAnalysis("RandomTriggerCTS",AliIsolationCut::kOnlyCharged,thresType), n++); // track isolation | |
189 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("RandomTriggerCTS",kFALSE), n++); // track-track correlation | |
190 | maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("RandomTriggerCTS",kTRUE) , n++); // Isolated track-track correlation | |
ac0610dc | 191 | //maker->AddAnalysis(ConfigureIsolationAnalysis("RandomTriggerCTS",AliIsolationCut::kOnlyCharged,thresType,kTRUE), n++); // Ghost multi isolation |
192 | ||
bef94c35 | 193 | } |
194 | } | |
195 | ||
ac0610dc | 196 | if(kQA) maker->AddAnalysis(ConfigureQAAnalysis(),n++); |
531f682d | 197 | |
198 | maker->SetAnaDebug(kDebug) ; | |
193828fd | 199 | maker->SwitchOnHistogramsMaker() ; |
200 | if(kData.Contains("delta")) maker->SwitchOffAODsMaker() ; | |
201 | else maker->SwitchOnAODsMaker() ; | |
531f682d | 202 | |
193828fd | 203 | if(kPrint) maker->Print(""); |
204 | ||
cd54ca47 | 205 | printf("<< End Configuration of %d analysis for calorimeter %s >>\n",n, kCalorimeter.Data()); |
e9de0d57 | 206 | |
193828fd | 207 | // Create task |
208 | ||
531f682d | 209 | AliAnalysisTaskCaloTrackCorrelation * task = new AliAnalysisTaskCaloTrackCorrelation (Form("CaloTrackCorr%s",kName.Data())); |
193828fd | 210 | task->SetConfigFileName(""); //Don't configure the analysis via configuration file. |
531f682d | 211 | task->SetDebugLevel(kDebug); |
212 | task->SetBranches("ESD:AliESDRun.,AliESDHeader"); | |
193828fd | 213 | task->SetAnalysisMaker(maker); |
214 | mgr->AddTask(task); | |
215 | ||
216 | //Create containers | |
217 | ||
531f682d | 218 | if(outputfile.Length()==0) outputfile = AliAnalysisManager::GetCommonFileName(); |
193828fd | 219 | |
531f682d | 220 | AliAnalysisDataContainer *cout_pc = mgr->CreateContainer(kName, TList::Class(), |
193828fd | 221 | AliAnalysisManager::kOutputContainer, |
222 | Form("%s",outputfile.Data())); | |
223 | ||
1806f9c0 | 224 | AliAnalysisDataContainer *cout_cuts = mgr->CreateContainer(Form("Param_%s",kName.Data()), TList::Class(), |
193828fd | 225 | AliAnalysisManager::kParamContainer, |
1806f9c0 | 226 | "AnalysisParameters.root"); |
3e0ccecf | 227 | |
193828fd | 228 | // Create ONLY the output containers for the data produced by the task. |
229 | // Get and connect other common input/output containers via the manager as below | |
230 | //============================================================================== | |
231 | mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer()); | |
232 | // AOD output slot will be used in a different way in future | |
233 | if(!kData.Contains("delta") && outputAOD) mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer()); | |
234 | mgr->ConnectOutput (task, 1, cout_pc); | |
235 | mgr->ConnectOutput (task, 2, cout_cuts); | |
236 | ||
237 | ||
d2655d46 | 238 | if(kTrig=="EMC7") |
239 | { | |
531f682d | 240 | printf("CaloTrackCorr trigger EMC7\n"); |
193828fd | 241 | task->SelectCollisionCandidates(AliVEvent::kEMC7); |
242 | } | |
d2655d46 | 243 | else if (kTrig=="INT7") |
244 | { | |
531f682d | 245 | printf("CaloTrackCorr trigger INT7\n"); |
193828fd | 246 | task->SelectCollisionCandidates(AliVEvent::kINT7); |
247 | } | |
d2655d46 | 248 | else if(kTrig=="EMC1") |
249 | { | |
531f682d | 250 | printf("CaloTrackCorr trigger EMC1\n"); |
193828fd | 251 | task->SelectCollisionCandidates(AliVEvent::kEMC1); |
252 | } | |
d2655d46 | 253 | else if(kTrig=="MB") |
254 | { | |
531f682d | 255 | printf("CaloTrackCorr trigger MB\n"); |
193828fd | 256 | task->SelectCollisionCandidates(AliVEvent::kMB); |
257 | } | |
d2655d46 | 258 | else if(kTrig=="PHOS") |
259 | { | |
531f682d | 260 | printf("CaloTrackCorr trigger PHOS\n"); |
cd54ca47 | 261 | task->SelectCollisionCandidates(AliVEvent::kPHI7); |
531f682d | 262 | } |
d2655d46 | 263 | else if(kTrig=="PHOSPb") |
264 | { | |
531f682d | 265 | printf("CaloTrackCorr trigger PHOSPb\n"); |
266 | task->SelectCollisionCandidates(AliVEvent::kPHOSPb); | |
267 | } | |
268 | else if(kTrig=="AnyINT") | |
269 | { | |
270 | printf("CaloTrackCorr trigger AnyINT\n"); | |
271 | task->SelectCollisionCandidates(AliVEvent::kAnyINT); | |
272 | } | |
273 | else if(kTrig=="INT") | |
274 | { | |
275 | printf("CaloTrackCorr trigger AnyINT\n"); | |
276 | task->SelectCollisionCandidates(AliVEvent::kAny); | |
277 | } | |
278 | else if(kTrig=="EMCEGA") | |
279 | { | |
280 | printf("CaloTrackCorr trigger EMC Gamma\n"); | |
281 | task->SelectCollisionCandidates(AliVEvent::kEMCEGA); | |
282 | } | |
283 | else if(kTrig=="EMCEJE") | |
284 | { | |
285 | printf("CaloTrackCorr trigger EMC Jet\n"); | |
286 | task->SelectCollisionCandidates(AliVEvent::kEMCEJE); | |
287 | } | |
288 | else if(kTrig=="Central") | |
289 | { | |
290 | printf("CaloTrackCorr trigger Central\n"); | |
291 | task->SelectCollisionCandidates(AliVEvent::kCentral); | |
292 | } | |
293 | else if(kTrig=="SemiCentral") | |
294 | { | |
295 | printf("CaloTrackCorr trigger SemiCentral\n"); | |
296 | task->SelectCollisionCandidates(AliVEvent::kSemiCentral); | |
cd54ca47 | 297 | } |
193828fd | 298 | |
299 | return task; | |
300 | } | |
301 | ||
302 | //____________________________________ | |
303 | AliCaloTrackReader * ConfigureReader() | |
304 | { | |
305 | ||
306 | AliCaloTrackReader * reader = 0; | |
8bd000ef | 307 | if (kInputDataType == "ESD"&& kData=="MC" ) |
308 | reader = new AliCaloTrackMCReader(); | |
309 | else if(kInputDataType=="AOD" || kData.Contains("AOD")) | |
310 | reader = new AliCaloTrackAODReader(); | |
311 | else if(kInputDataType=="ESD") | |
312 | reader = new AliCaloTrackESDReader(); | |
313 | else | |
314 | printf("AliCaloTrackReader::ConfigureReader() - Data combination not known kData=%s, kInputData=%s\n",kData.Data(),kInputDataType.Data()); | |
1e3689fa | 315 | |
531f682d | 316 | reader->SetDebug(kDebug);//10 for lots of messages |
193828fd | 317 | |
cd54ca47 | 318 | //Delta AOD? |
319 | //reader->SetDeltaAODFileName(""); | |
320 | if(kOutputAOD) reader->SwitchOnWriteDeltaAOD() ; | |
321 | ||
322 | // MC settings | |
323 | if(kUseKinematics){ | |
324 | if(kInputDataType == "ESD"){ | |
325 | reader->SwitchOnStack(); | |
326 | reader->SwitchOffAODMCParticles(); | |
327 | } | |
328 | else if(kInputDataType == "AOD"){ | |
329 | reader->SwitchOffStack(); | |
330 | reader->SwitchOnAODMCParticles(); | |
331 | } | |
332 | } | |
333 | ||
334 | //------------------------ | |
335 | // Detector input filling | |
336 | //------------------------ | |
337 | ||
338 | //Min cluster/track E | |
d2655d46 | 339 | reader->SetEMCALEMin(0.3); |
cd54ca47 | 340 | reader->SetEMCALEMax(1000); |
341 | reader->SetPHOSEMin(0.3); | |
342 | reader->SetPHOSEMax(1000); | |
050ad675 | 343 | reader->SetCTSPtMin(0.2); |
cd54ca47 | 344 | reader->SetCTSPtMax(1000); |
d2655d46 | 345 | |
346 | if(!kSimulation && kCalibT) reader->SetEMCALTimeCut(-30,30); | |
347 | else reader->SetEMCALTimeCut(-1000,1000); // Open time cut | |
348 | ||
531f682d | 349 | reader->SwitchOnFiducialCut(); |
350 | reader->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ; | |
351 | ||
cd54ca47 | 352 | // Tracks |
353 | reader->SwitchOnCTS(); | |
531f682d | 354 | if(kInputDataType=="ESD") |
355 | { | |
356 | gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/CreateTrackCutsPWGJE.C"); | |
357 | AliESDtrackCuts * esdTrackCuts = CreateTrackCutsPWGJE(10041004); | |
66e64043 | 358 | reader->SetTrackCuts(esdTrackCuts); |
6962f0e8 | 359 | reader->SwitchOnConstrainTrackToVertex(); |
66e64043 | 360 | } |
531f682d | 361 | else if(kInputDataType=="AOD") |
362 | { | |
ac0610dc | 363 | reader->SwitchOnAODHybridTrackSelection(); |
364 | reader->SetTrackFilterMask(128); // Filter bit, not mask, use if off hybrid | |
66e64043 | 365 | } |
cd54ca47 | 366 | |
367 | // Calorimeter | |
368 | ||
193828fd | 369 | reader->SetEMCALClusterListName(kClusterArray); |
531f682d | 370 | if(kClusterArray == "") |
371 | { | |
5eef1db1 | 372 | printf("**************** Standard EMCAL clusters branch analysis **************** \n"); |
cd54ca47 | 373 | reader->SwitchOnClusterRecalculation(); |
5eef1db1 | 374 | // Check in ConfigureCaloUtils that the recalibration and bad map are ON |
193828fd | 375 | } |
531f682d | 376 | else |
377 | { | |
193828fd | 378 | printf("**************** Input for analysis is Clusterizer %s **************** \n", kClusterArray.Data()); |
cd54ca47 | 379 | reader->SwitchOffClusterRecalculation(); |
380 | } | |
193828fd | 381 | |
cd54ca47 | 382 | //if(kCalorimeter == "EMCAL") { |
afabc52f | 383 | reader->SwitchOnEMCALCells(); |
69652c63 | 384 | reader->SwitchOnEMCAL(); |
cd54ca47 | 385 | //} |
386 | //if(kCalorimeter == "PHOS") { | |
afabc52f | 387 | reader->SwitchOnPHOSCells(); |
388 | reader->SwitchOnPHOS(); | |
cd54ca47 | 389 | //} |
1e3689fa | 390 | |
193828fd | 391 | // for case data="deltaAOD", no need to fill the EMCAL/PHOS cluster lists |
392 | if(kData.Contains("delta")){ | |
1e3689fa | 393 | reader->SwitchOffEMCAL(); |
394 | reader->SwitchOffPHOS(); | |
395 | reader->SwitchOffEMCALCells(); | |
396 | reader->SwitchOffPHOSCells(); | |
1e86c71e | 397 | } |
1e3689fa | 398 | |
cd54ca47 | 399 | //----------------- |
400 | // Event selection | |
401 | //----------------- | |
402 | ||
cd54ca47 | 403 | //if(!kUseKinematics) reader->SetFiredTriggerClassName("CEMC7EGA-B-NOPF-CENTNOTRD"); // L1 Gamma |
193828fd | 404 | |
029dea5a | 405 | // For mixing with AliAnaParticleHadronCorrelation switch it off |
406 | reader->SwitchOnEventTriggerAtSE(); | |
407 | reader->SetEventTriggerMaks(AliVEvent::kEMC7); // Only for mixing and SwitchOffEventTriggerAtSE(); | |
408 | ||
531f682d | 409 | reader->SetZvertexCut(10.); // Open cut |
d2655d46 | 410 | reader->SwitchOnPrimaryVertexSelection(); // and besides primary vertex |
411 | ||
531f682d | 412 | if(kEventSelection) |
413 | { | |
414 | reader->SwitchOnEventSelection(); // remove pileup by default | |
415 | reader->SwitchOnV0ANDSelection() ; // and besides v0 AND | |
193828fd | 416 | } |
531f682d | 417 | else |
418 | { | |
193828fd | 419 | reader->SwitchOffEventSelection(); // remove pileup by default |
420 | reader->SwitchOffV0ANDSelection() ; // and besides v0 AND | |
531f682d | 421 | } |
cd54ca47 | 422 | |
531f682d | 423 | if(kCollisions=="PbPb") |
424 | { | |
cd54ca47 | 425 | // Centrality |
426 | reader->SetCentralityClass("V0M"); | |
745913ae | 427 | reader->SetCentralityOpt(10); // 10 (c= 0-10, 10-20 ...), 20 (c= 0-5, 5-10 ...) or 100 (c= 1, 2, 3 ..) |
531f682d | 428 | reader->SetCentralityBin(kMinCen,kMaxCen); // Accept all events, if not select range |
cd54ca47 | 429 | |
430 | // Event plane (only used in AliAnaPi0 for the moment) | |
431 | reader->SetEventPlaneMethod("Q"); | |
69652c63 | 432 | } |
afabc52f | 433 | |
8f880b6e | 434 | reader->SetImportGeometryFromFile(kTRUE); |
435 | ||
193828fd | 436 | if(kPrint) reader->Print(""); |
437 | ||
438 | return reader; | |
439 | ||
440 | } | |
69652c63 | 441 | |
193828fd | 442 | //_______________________________________ |
443 | AliCalorimeterUtils* ConfigureCaloUtils() | |
444 | { | |
445 | ||
fa991e42 | 446 | AliCalorimeterUtils *cu = new AliCalorimeterUtils; |
531f682d | 447 | cu->SetDebug(kDebug); |
69652c63 | 448 | |
193828fd | 449 | // Remove clusters close to borders, at least max energy cell is 1 cell away |
fa991e42 | 450 | cu->SetNumberOfCellsFromEMCALBorder(1); |
1e3689fa | 451 | cu->SetNumberOfCellsFromPHOSBorder(2); |
1e3689fa | 452 | |
531f682d | 453 | // Search of local maxima in cluster |
454 | if(kCollisions=="pp") | |
455 | { | |
456 | cu->SetLocalMaximaCutE(0.1); | |
457 | cu->SetLocalMaximaCutEDiff(0.03); | |
458 | } | |
459 | else | |
460 | { | |
461 | cu->SetLocalMaximaCutE(0.2); | |
462 | cu->SetLocalMaximaCutEDiff(0.03); | |
463 | } | |
464 | ||
465 | cu->SwitchOffClusterPlot(); | |
466 | ||
467 | if(kRecalTM) cu->SwitchOnRecalculateClusterTrackMatching(); // Done in clusterization | |
468 | else cu->SwitchOffRecalculateClusterTrackMatching(); | |
1e3689fa | 469 | |
15882d9f | 470 | cu->SwitchOnBadChannelsRemoval() ; |
1e3689fa | 471 | |
15882d9f | 472 | //EMCAL settings |
531f682d | 473 | |
474 | if(!kSimulation) | |
475 | cu->SwitchOnLoadOwnEMCALGeometryMatrices(); | |
476 | ||
477 | AliEMCALRecoUtils * recou = cu->GetEMCALRecoUtils(); | |
478 | ||
023e6936 | 479 | |
531f682d | 480 | cu->SwitchOnRecalibration(); // Check the reader if it is taken into account during filtering |
481 | ||
482 | ||
483 | gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/ConfigureEMCALRecoUtils.C"); | |
484 | ConfigureEMCALRecoUtils(recou, | |
485 | kSimulation, | |
486 | kExotic, | |
487 | kNonLinearity, | |
023e6936 | 488 | kCalibE, |
489 | kBadMap, | |
490 | kCalibT); | |
531f682d | 491 | |
c2091d88 | 492 | if( kNonLinearity ) |
493 | { | |
494 | printf("ConfigureCaloUtils() - Apply non linearity to EMCAL\n"); | |
495 | cu->SwitchOnCorrectClusterLinearity(); | |
496 | } | |
497 | ||
531f682d | 498 | printf("ConfigureCaloUtils() - EMCAL Recalibration ON? %d %d\n",recou->IsRecalibrationOn(), cu->IsRecalibrationOn()); |
499 | printf("ConfigureCaloUtils() - EMCAL BadMap ON? %d %d\n",recou->IsBadChannelsRemovalSwitchedOn(), cu->IsBadChannelsRemovalSwitchedOn()); | |
500 | ||
15882d9f | 501 | |
531f682d | 502 | // PHOS |
503 | cu->SwitchOffLoadOwnPHOSGeometryMatrices(); | |
15882d9f | 504 | |
193828fd | 505 | if(kPrint) cu->Print(""); |
afabc52f | 506 | |
193828fd | 507 | return cu; |
508 | ||
509 | } | |
510 | ||
511 | //_____________________________________ | |
512 | AliAnaPhoton* ConfigurePhotonAnalysis() | |
513 | { | |
4df35693 | 514 | |
531f682d | 515 | AliAnaPhoton *ana = new AliAnaPhoton(); |
516 | ana->SetDebug(kDebug); //10 for lots of messages | |
cd54ca47 | 517 | |
518 | // cluster selection cuts | |
519 | ||
531f682d | 520 | ana->SwitchOffFiducialCut(); |
521 | ||
522 | ana->SetCalorimeter(kCalorimeter); | |
193828fd | 523 | |
531f682d | 524 | if(kCalorimeter == "PHOS") |
525 | { | |
526 | ana->SetNCellCut(2);// At least 3 cells | |
527 | ana->SetMinPt(0.3); | |
528 | ana->SetMinDistanceToBadChannel(2, 4, 5); | |
529 | ana->SetTimeCut(-2000,2000); // open cut | |
57eb7f00 | 530 | } |
531f682d | 531 | else |
532 | {//EMCAL | |
533 | ana->SetNCellCut(1);// At least 2 cells | |
050ad675 | 534 | ana->SetMinEnergy(0.3); // avoid mip peak at E = 260 MeV |
531f682d | 535 | ana->SetMaxEnergy(1000); |
536 | ana->SetTimeCut(-1000,1000); // open cut, usual time window of [425-825] ns if time recalibration is off | |
15882d9f | 537 | // restrict to less than 100 ns when time calibration is on |
531f682d | 538 | ana->SetMinDistanceToBadChannel(2, 4, 6); |
57eb7f00 | 539 | } |
193828fd | 540 | |
531f682d | 541 | if(kTM) |
542 | { | |
543 | ana->SwitchOnTrackMatchRejection() ; | |
544 | ana->SwitchOffTMHistoFill() ; | |
545 | } | |
546 | else | |
547 | { | |
548 | ana->SwitchOffTrackMatchRejection() ; | |
549 | ana->SwitchOnTMHistoFill() ; | |
550 | } | |
193828fd | 551 | |
cd54ca47 | 552 | //PID cuts (shower shape) |
531f682d | 553 | ana->SwitchOnCaloPID(); // do PID selection, unless specified in GetCaloPID, selection not based on bayesian |
554 | AliCaloPID* caloPID = ana->GetCaloPID(); | |
c1624f38 | 555 | //Not used in bayesian |
556 | ||
557 | //EMCAL | |
531f682d | 558 | caloPID->SetEMCALLambda0CutMax(0.27); |
c1624f38 | 559 | caloPID->SetEMCALLambda0CutMin(0.10); |
560 | ||
561 | caloPID->SetEMCALDEtaCut(0.025); | |
531f682d | 562 | caloPID->SetEMCALDPhiCut(0.030); |
bef94c35 | 563 | |
c1624f38 | 564 | //PHOS |
565 | caloPID->SetPHOSDispersionCut(2.5); | |
566 | caloPID->SetPHOSRCut(2.); | |
8bd000ef | 567 | if(kInputData=="AOD") caloPID->SetPHOSRCut(2000.); // Open cut since dX, dZ not stored |
bef94c35 | 568 | |
531f682d | 569 | ana->SwitchOffFillShowerShapeHistograms(); // Filled before photon shower shape selection |
193828fd | 570 | |
cd54ca47 | 571 | // Input / output delta AOD settings |
1e3689fa | 572 | |
531f682d | 573 | if(!kData.Contains("delta")) |
574 | { | |
575 | ana->SetOutputAODName(Form("Photon%s",kName.Data())); | |
576 | ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation"); | |
577 | //ana->SetOutputAODClassName("AliAODPWG4Particle"); // use if no correlation done | |
4df35693 | 578 | } |
531f682d | 579 | else ana->SetInputAODName(Form("Photon%s",kName.Data())); |
193828fd | 580 | |
cd54ca47 | 581 | //Set Histograms name tag, bins and ranges |
582 | ||
531f682d | 583 | ana->AddToHistogramsName(Form("AnaPhoton_TM%d_",kTM)); |
584 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
193828fd | 585 | |
cd54ca47 | 586 | // Number of particle type MC histograms |
ac0610dc | 587 | ana->FillNOriginHistograms(20); |
588 | ana->FillNPrimaryHistograms(20); | |
531f682d | 589 | |
590 | ConfigureMC(ana); | |
591 | ||
592 | if(kPrint) ana->Print(""); | |
7e7694bb | 593 | |
531f682d | 594 | return ana; |
595 | ||
596 | } | |
597 | ||
bef94c35 | 598 | //________________________________________________________________________________ |
599 | AliAnaElectron* ConfigureElectronAnalysis() | |
600 | { | |
601 | ||
602 | AliAnaElectron *ana = new AliAnaElectron(); | |
603 | ana->SetDebug(kDebug); //10 for lots of messages | |
604 | ||
605 | if(kCalorimeter == "PHOS") | |
606 | { | |
607 | ana->SetNCellCut(2);// At least 2 cells | |
608 | ana->SetMinPt(0.3); | |
609 | ana->SetMinDistanceToBadChannel(2, 4, 5); | |
610 | } | |
611 | else | |
612 | {//EMCAL | |
613 | ana->SetNCellCut(1);// At least 2 cells | |
614 | ana->SetMinPt(0.5); // no effect minium EMCAL cut. | |
615 | ana->SetMaxPt(100); | |
616 | //ana->SetTimeCut(400,900);// Time window of [400-900] ns | |
617 | ana->SetMinDistanceToBadChannel(2, 4, 6); | |
618 | } | |
619 | ||
620 | //Electron selection cuts with tracks | |
d2655d46 | 621 | ana->SetEOverP(0.85, 1.2); |
bef94c35 | 622 | // TO DO, find a more suitable way to set this |
623 | if(kSimulation) | |
624 | { // LHC11a | |
625 | ana->SetdEdxCut(76, 85); | |
626 | } | |
627 | else // LHC11c | |
628 | { | |
629 | ana->SetdEdxCut(56, 64); | |
630 | } | |
631 | ||
632 | ana->SetCalorimeter(kCalorimeter); | |
633 | ||
634 | ana->SwitchOffCaloPID(); | |
635 | ana->SwitchOffFillShowerShapeHistograms(); | |
636 | ana->SwitchOffFillWeightHistograms() ; | |
637 | ana->SwitchOffFiducialCut(); | |
638 | ||
639 | if(!kData.Contains("delta")) | |
640 | { | |
641 | ana->SetOutputAODName(Form("Electron%s",kName.Data())); | |
642 | ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation"); | |
643 | } | |
644 | else ana->SetInputAODName(Form("Electron%s",kName.Data())); | |
645 | ||
646 | //Set Histograms name tag, bins and ranges | |
647 | ||
648 | ana->AddToHistogramsName(Form("AnaElectron_TM%d_",kTM)); | |
649 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
650 | ||
651 | ConfigureMC(ana); | |
652 | ||
653 | if(kPrint) ana->Print(""); | |
654 | ||
655 | return ana ; | |
656 | ||
657 | } | |
658 | ||
531f682d | 659 | //__________________________________________________________________________________________ |
bef94c35 | 660 | AliAnaRandomTrigger* ConfigureRandomTriggerAnalysis(TString detector = "") |
531f682d | 661 | { |
bef94c35 | 662 | |
663 | AliAnaRandomTrigger *ana = new AliAnaRandomTrigger(); | |
664 | ana->SetDebug(kDebug); //10 for lots of messages | |
665 | ||
666 | if(detector=="") detector = kCalorimeter; | |
667 | ana->SetDetector(detector); | |
668 | ||
669 | // selection cuts | |
670 | ana->SetMinPt(4.); | |
671 | ana->SetMaxPt(51.); | |
672 | ||
673 | if (detector=="EMCAL") | |
674 | { | |
675 | ana->SetEtaCut(-0.71,0.71); | |
676 | ana->SetPhiCut(100*TMath::DegToRad(), 160*TMath::DegToRad()); | |
677 | } | |
678 | else if(detector=="PHOS") | |
679 | { | |
680 | ana->SetEtaCut(-0.13,0.13); | |
681 | ana->SetPhiCut(260*TMath::DegToRad(), 320*TMath::DegToRad()); | |
682 | } | |
683 | else if(detector=="CTS") | |
684 | { | |
685 | ana->SetEtaCut(-0.9,0.9); | |
686 | ana->SetPhiCut(0, TMath::TwoPi()); | |
687 | } | |
688 | ||
689 | // AOD branch | |
690 | if(!kData.Contains("delta")) | |
691 | { | |
692 | ana->SetOutputAODName(Form("RandomTrigger%s%s",detector.Data(),kName.Data())); | |
693 | ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation"); | |
694 | } | |
695 | else | |
696 | ana->SetInputAODName(Form("RandomTrigger%s%s",detector.Data(),kName.Data())); | |
697 | ||
698 | printf("Set RandomTrigger%s%s\n",detector.Data(),kName.Data()); | |
699 | ||
700 | //Set Histograms name tag, bins and ranges | |
701 | ||
702 | ana->AddToHistogramsName(Form("AnaRandomTrigger%s_",detector.Data())); | |
703 | ||
704 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
705 | ||
706 | if(detector=="CTS") | |
707 | { | |
708 | ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ; | |
709 | ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ; | |
710 | } | |
711 | ||
712 | if(kPrint) ana->Print(""); | |
713 | ||
714 | return ana; | |
715 | ||
716 | } | |
745913ae | 717 | |
bef94c35 | 718 | //__________________________________________________________________________________________ |
719 | AliAnaInsideClusterInvariantMass* ConfigureInClusterIMAnalysis(Float_t l0min, Float_t l0max) | |
720 | { | |
531f682d | 721 | AliAnaInsideClusterInvariantMass *ana = new AliAnaInsideClusterInvariantMass(); |
722 | ana->SetDebug(kDebug); //10 for lots of messages | |
723 | ||
724 | // selection cuts | |
193828fd | 725 | |
531f682d | 726 | ana->SetMinEnergy(5); |
727 | ana->SetMaxEnergy(200.); | |
728 | ana->SetMinNCells(3); | |
729 | ana->SetM02Cut(l0min,l0max); | |
730 | ana->SetCalorimeter(kCalorimeter); | |
731 | ||
732 | //ana->AddToHistogramsName(Form("AnaInClusterIM_%1.2f_%1.2f_",l0min,l0max)); | |
733 | ana->AddToHistogramsName("AnaInClusterIM_"); | |
734 | ||
735 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
bef94c35 | 736 | |
531f682d | 737 | AliCaloPID* caloPID = ana->GetCaloPID(); |
738 | caloPID->SetEMCALDEtaCut(0.025); | |
739 | caloPID->SetEMCALDPhiCut(0.030); | |
740 | caloPID->SetClusterSplittingM02Cut(0,100); // Do the selection in the analysis class and not in the PID method to fill SS histograms | |
741 | ||
d2655d46 | 742 | caloPID->SetPi0MassRange(0.10, 0.18); |
743 | caloPID->SetEtaMassRange(0.40, 0.60); | |
744 | caloPID->SetPhotonMassRange(0.00, 0.08); | |
745 | ||
531f682d | 746 | ConfigureMC(ana); |
747 | ||
748 | if(kPrint) ana->Print(""); | |
749 | ||
750 | return ana; | |
15882d9f | 751 | |
193828fd | 752 | } |
753 | ||
cd54ca47 | 754 | //_______________________________________________ |
755 | AliAnaChargedParticles* ConfigureChargedAnalysis() | |
756 | { | |
757 | ||
531f682d | 758 | AliAnaChargedParticles *ana = new AliAnaChargedParticles(); |
759 | ana->SetDebug(kDebug); //10 for lots of messages | |
cd54ca47 | 760 | |
761 | // selection cuts | |
762 | ||
050ad675 | 763 | ana->SetMinPt(0.5); |
531f682d | 764 | ana->SwitchOnFiducialCut(); |
050ad675 | 765 | ana->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ; //more restrictive cut in reader and after in isolation |
531f682d | 766 | |
cd54ca47 | 767 | // Input / output delta AOD settings |
768 | ||
531f682d | 769 | if(!kData.Contains("delta")) |
770 | { | |
771 | ana->SetOutputAODName(Form("Hadron%s",kName.Data())); | |
772 | ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation"); | |
773 | //ana->SetOutputAODClassName("AliAODPWG4Particle"); // use if no correlation done | |
cd54ca47 | 774 | } |
531f682d | 775 | else |
776 | ana->SetInputAODName(Form("Hadron%s",kName.Data())); | |
777 | printf("Set Hadron%s\n",kName.Data()); | |
cd54ca47 | 778 | //Set Histograms name tag, bins and ranges |
779 | ||
531f682d | 780 | ana->AddToHistogramsName("AnaHadrons_"); |
781 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
cd54ca47 | 782 | |
531f682d | 783 | ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ; |
784 | ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ; | |
745913ae | 785 | |
531f682d | 786 | ConfigureMC(ana); |
cd54ca47 | 787 | |
531f682d | 788 | if(kPrint) ana->Print(""); |
789 | ||
790 | return ana; | |
cd54ca47 | 791 | |
792 | } | |
793 | ||
794 | ||
193828fd | 795 | //_______________________________ |
796 | AliAnaPi0* ConfigurePi0Analysis() | |
797 | { | |
1e3689fa | 798 | |
531f682d | 799 | AliAnaPi0 *ana = new AliAnaPi0(); |
cd54ca47 | 800 | |
531f682d | 801 | ana->SetDebug(kDebug);//10 for lots of messages |
cd54ca47 | 802 | |
803 | // Input delta AOD settings | |
c2091d88 | 804 | ana->SetInputAODName(Form("Photon%s",kName.Data())); |
cd54ca47 | 805 | |
806 | // Calorimeter settings | |
531f682d | 807 | ana->SetCalorimeter(kCalorimeter); |
808 | if(kCalorimeter=="PHOS") ana->SetNumberOfModules(3); //PHOS first year | |
809 | else | |
810 | { | |
811 | if (kYears == 2010) ana->SetNumberOfModules( 4); // EMCAL first year | |
812 | else if(kYears == 2011) ana->SetNumberOfModules(10); // Second year | |
813 | else ana->SetNumberOfModules(12); | |
cd54ca47 | 814 | } |
193828fd | 815 | |
816 | //settings for pp collision mixing | |
531f682d | 817 | ana->SwitchOnOwnMix(); //Off when mixing done with general mixing frame |
193828fd | 818 | |
cd54ca47 | 819 | // Cuts |
531f682d | 820 | if(kCalorimeter=="EMCAL") ana->SetPairTimeCut(70); |
cd54ca47 | 821 | |
531f682d | 822 | if (kCollisions=="pp" ) |
823 | { | |
824 | ana->SetNCentrBin(1); | |
825 | ana->SetNZvertBin(10); | |
826 | ana->SetNRPBin(1); | |
827 | ana->SetNMaxEvMix(100); | |
bef94c35 | 828 | ana->SwitchOnSMCombinations(); |
193828fd | 829 | } |
531f682d | 830 | else if(kCollisions=="PbPb") |
831 | { | |
832 | ana->SetNCentrBin(10); | |
833 | ana->SetNZvertBin(10); | |
834 | ana->SetNRPBin(4); | |
835 | ana->SetNMaxEvMix(10); | |
836 | ana->SwitchOffSMCombinations(); | |
193828fd | 837 | } |
bef94c35 | 838 | |
839 | ana->SwitchOffMultipleCutAnalysis(); | |
840 | ||
cd54ca47 | 841 | //Set Histograms name tag, bins and ranges |
193828fd | 842 | |
531f682d | 843 | ana->AddToHistogramsName(Form("AnaPi0_TM%d_",kTM)); |
844 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
745913ae | 845 | |
531f682d | 846 | ConfigureMC(ana); |
847 | ||
848 | if(kPrint) ana->Print(""); | |
849 | ||
850 | return ana; | |
193828fd | 851 | |
852 | } | |
af7b3903 | 853 | |
193828fd | 854 | //_____________________________________________________ |
855 | AliAnaPi0EbE* ConfigurePi0EbEAnalysis(TString particle, | |
856 | Int_t analysis) | |
857 | { | |
7e7694bb | 858 | |
531f682d | 859 | AliAnaPi0EbE *ana = new AliAnaPi0EbE(); |
860 | ana->SetDebug(kDebug);//10 for lots of messages | |
cd54ca47 | 861 | |
531f682d | 862 | ana->SetAnalysisType(analysis); |
193828fd | 863 | TString opt = ""; |
864 | if(analysis==AliAnaPi0EbE::kIMCaloTracks) opt = "Conv"; | |
865 | if(analysis==AliAnaPi0EbE::kSSCalo) opt = "SS"; | |
866 | ||
531f682d | 867 | ana->SetMinPt(0.5); |
868 | ||
869 | if(kCalorimeter=="EMCAL")ana->SetPairTimeCut(15); // More strict than in pi0 inv mass analysis | |
870 | ||
871 | ana->SetCalorimeter(kCalorimeter); | |
193828fd | 872 | |
cd54ca47 | 873 | // Input / output delta AOD settings |
874 | ||
531f682d | 875 | ana->SetInputAODName(Form("Photon%s",kName.Data())); |
876 | if(!kInputDataType.Contains("delta")) | |
877 | { | |
878 | ana->SetOutputAODName(Form("%s%s%s",particle.Data(), opt.Data(), kName.Data())); | |
879 | ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation"); | |
32301b07 | 880 | } |
531f682d | 881 | else |
882 | ana->SetInputAODName(Form("%s%s%s",particle.Data(),opt.Data(),kName.Data())); | |
193828fd | 883 | |
531f682d | 884 | if(analysis == AliAnaPi0EbE::kIMCaloTracks) ana->SetInputAODGammaConvName("PhotonsCTS"); |
4f155d15 | 885 | |
531f682d | 886 | if(analysis!=AliAnaPi0EbE::kSSCalo) |
887 | { | |
888 | AliNeutralMesonSelection *nms = ana->GetNeutralMesonSelection(); | |
193828fd | 889 | nms->SetParticle(particle); |
bef94c35 | 890 | |
891 | // Tighten a bit mass cut with respect to default window | |
892 | if(particle=="Pi0") nms->SetInvMassCutRange(0.120,0.150); | |
893 | if(particle=="Eta") nms->SetInvMassCutRange(0.520,0.580); | |
894 | ||
531f682d | 895 | nms->SwitchOnAngleSelection(); |
193828fd | 896 | nms->KeepNeutralMesonSelectionHistos(kTRUE); |
897 | //nms->SetAngleMaxParam(2,0.2); | |
531f682d | 898 | nms->SetHistoERangeAndNBins(0, 20, 80) ; |
193828fd | 899 | //nms->SetHistoIMRangeAndNBins(0, 1, 400); |
57b97dc6 | 900 | } |
d2655d46 | 901 | else |
902 | { // cluster splitting settings | |
903 | ana->SetTimeCut(-1000,1000); // Open time cut | |
904 | AliCaloPID* caloPID = ana->GetCaloPID(); | |
905 | caloPID->SetPi0MassRange(0.10, 0.18); | |
906 | caloPID->SetEtaMassRange(0.40, 0.60); | |
907 | caloPID->SetPhotonMassRange(0.00, 0.08); | |
908 | caloPID->SetClusterSplittingM02Cut(0.5,100); // Do the selection in the analysis class and not in the PID method to fill SS histograms | |
909 | } | |
193828fd | 910 | |
531f682d | 911 | ana->SwitchOffSelectedClusterHistoFill(); |
912 | ana->SwitchOffFillWeightHistograms(); | |
913 | ||
914 | if(!kTM) ana->SwitchOnTMHistoFill(); | |
915 | else ana->SwitchOffTMHistoFill(); | |
916 | ||
cd54ca47 | 917 | //Set Histograms name tag, bins and ranges |
193828fd | 918 | |
531f682d | 919 | ana->AddToHistogramsName(Form("Ana%s%sEbE_TM%d_",particle.Data(),opt.Data(),kTM)); |
920 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
745913ae | 921 | |
531f682d | 922 | ConfigureMC(ana); |
193828fd | 923 | |
531f682d | 924 | if(kPrint) ana->Print(""); |
193828fd | 925 | |
531f682d | 926 | return ana; |
193828fd | 927 | |
928 | } | |
929 | ||
531f682d | 930 | //____________________________________________________________________________________________________ |
cd54ca47 | 931 | AliAnaParticleIsolation* ConfigureIsolationAnalysis(TString particle="Photon", |
932 | Int_t partInCone = AliIsolationCut::kOnlyCharged, | |
933 | Int_t thresType = AliIsolationCut::kSumPtFracIC, | |
934 | Bool_t multi = kFALSE) | |
193828fd | 935 | { |
936 | ||
531f682d | 937 | AliAnaParticleIsolation *ana = new AliAnaParticleIsolation(); |
938 | //ana->SetDebug(kDebug); | |
939 | ana->SetDebug(kDebug); | |
cd54ca47 | 940 | |
531f682d | 941 | ana->SwitchOnFiducialCut(); |
942 | //Avoid borders of EMCal | |
943 | if(kCalorimeter=="EMCAL") | |
944 | ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.6, 86, 174) ; | |
945 | ||
946 | // Same Eta as EMCal, cut in phi if EMCAL was triggering | |
bef94c35 | 947 | if(particle=="Hadron" || particle.Contains("CTS")) |
531f682d | 948 | { |
949 | if(kTrig.Contains("EMC")) | |
050ad675 | 950 | ana->GetFiducialCut()->SetSimpleCTSFiducialCut (0.6, 260, 360) ; |
531f682d | 951 | else |
952 | ana->GetFiducialCut()->SetSimpleCTSFiducialCut (0.6, 0, 360) ; | |
953 | } | |
954 | ||
3e0ccecf | 955 | ana->SetMinPt(4); |
cd54ca47 | 956 | |
957 | // Input / output delta AOD settings | |
958 | ||
531f682d | 959 | ana->SetInputAODName(Form("%s%s",particle.Data(),kName.Data())); |
960 | ana->SetAODObjArrayName(Form("IC%sTM%d",particle.Data(),kTM)); | |
961 | ||
962 | ana->SetCalorimeter(kCalorimeter); | |
963 | ||
964 | if(!kTM) ana->SwitchOnTMHistoFill(); | |
965 | else ana->SwitchOffTMHistoFill(); | |
193828fd | 966 | |
531f682d | 967 | ana->SwitchOffSSHistoFill(); |
193828fd | 968 | |
cd54ca47 | 969 | //Do settings for main isolation cut class |
531f682d | 970 | AliIsolationCut * ic = ana->GetIsolationCut(); |
971 | ic->SetDebug(kDebug); | |
972 | ||
531f682d | 973 | |
050ad675 | 974 | if(kCollisions=="pp") |
975 | { | |
976 | ic->SetPtThreshold(0.5); | |
1806f9c0 | 977 | ic->SetConeSize(0.5); |
050ad675 | 978 | } |
979 | if(kCollisions=="PbPb") | |
980 | { | |
981 | ic->SetPtThreshold(2.); | |
531f682d | 982 | //ic->SetPtThreshold(1.); |
050ad675 | 983 | ic->SetConeSize(0.3); |
984 | } | |
531f682d | 985 | |
2244659d | 986 | ic->SetPtFraction(0.1); |
987 | ic->SetSumPtThreshold(1.0) ; | |
cd54ca47 | 988 | ic->SetParticleTypeInCone(partInCone); |
989 | ic->SetICMethod(thresType); | |
1e3689fa | 990 | |
90eb3a19 | 991 | //Do or not do isolation with previously produced AODs. |
992 | //No effect if use of SwitchOnSeveralIsolation() | |
531f682d | 993 | ana->SwitchOffReIsolation(); |
994 | ||
90eb3a19 | 995 | //Multiple IC |
531f682d | 996 | if(multi) |
997 | { | |
998 | ic->SetConeSize(1.); // Take all for first iteration | |
999 | ic->SetPtThreshold(100);// Take all for first iteration | |
1000 | ana->SwitchOnSeveralIsolation() ; | |
531f682d | 1001 | ana->SetAODObjArrayName(Form("MultiIC%sTM%d",particle.Data(),kTM)); |
ac0610dc | 1002 | |
1003 | ana->SetNCones(4); | |
1004 | ana->SetNPtThresFrac(4); | |
1005 | ana->SetConeSizes(0,0.3); ana->SetConeSizes(1,0.4); | |
1006 | ana->SetConeSizes(2,0.5); ana->SetConeSizes(3,0.6); | |
1007 | ana->SetPtThresholds(0, 0.5); ana->SetPtThresholds(1, 1); ana->SetPtThresholds(2, 2); | |
1008 | ana->SetPtFractions (0, 0.05) ; ana->SetPtFractions (1, 0.1); ana->SetPtFractions (2, 0.2) ; ana->SetPtFractions (3, 0.3) ; | |
1009 | ana->SetSumPtThresholds(0, 1) ; ana->SetSumPtThresholds(1, 3) ; ana->SetSumPtThresholds(2, 5); ana->SetSumPtThresholds(3, 7) ; | |
1010 | ||
531f682d | 1011 | ana->SwitchOffTMHistoFill(); |
1012 | ana->SwitchOffSSHistoFill(); | |
1013 | } | |
1014 | else | |
1015 | ana->SwitchOffSeveralIsolation() ; | |
1016 | ||
1017 | AliCaloPID* caloPID = ana->GetCaloPID(); | |
1018 | caloPID->SetEMCALDEtaCut(0.025); | |
1019 | caloPID->SetEMCALDPhiCut(0.030); | |
cd54ca47 | 1020 | |
1021 | //Set Histograms name tag, bins and ranges | |
1022 | ||
ac0610dc | 1023 | if(!multi)ana->AddToHistogramsName(Form("AnaIsol%s_TM%d_",particle.Data(),kTM)); |
1024 | else ana->AddToHistogramsName(Form("AnaMultiIsol%s_TM%d_",particle.Data(),kTM)); | |
1025 | ||
531f682d | 1026 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below |
cd54ca47 | 1027 | |
531f682d | 1028 | ana->SetHistoPtInConeRangeAndNBins(0, 50 , 250); |
1029 | ana->SetHistoPtSumRangeAndNBins (0, 100, 250); | |
1030 | ||
bef94c35 | 1031 | if(particle=="Hadron" || particle.Contains("CTS")) |
531f682d | 1032 | { |
1033 | ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ; | |
1034 | ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ; | |
1035 | } | |
193828fd | 1036 | |
531f682d | 1037 | ConfigureMC(ana); |
745913ae | 1038 | |
531f682d | 1039 | if(kPrint) ic ->Print(""); |
1040 | if(kPrint) ana->Print(""); | |
1041 | ||
1042 | return ana; | |
193828fd | 1043 | |
1044 | } | |
1045 | ||
1046 | //___________________________________________________________________________________ | |
1047 | AliAnaParticleHadronCorrelation* ConfigureHadronCorrelationAnalysis(TString particle, | |
1048 | Int_t bIsolated) | |
1049 | { | |
90eb3a19 | 1050 | |
531f682d | 1051 | AliAnaParticleHadronCorrelation *ana = new AliAnaParticleHadronCorrelation(); |
1052 | ana->SetDebug(kDebug); | |
1053 | ||
3e0ccecf | 1054 | ana->SetMinimumTriggerPt(4); |
531f682d | 1055 | ana->SetAssociatedPtRange(0.2,200); |
907b38cd | 1056 | ana->SetDeltaPhiCutRange( TMath::Pi()/2,3*TMath::Pi()/2 ); //[90 deg, 270 deg] |
050ad675 | 1057 | |
907b38cd | 1058 | ana->SelectIsolated(bIsolated); // do correlation with isolated photons |
1059 | ||
1060 | ana->SwitchOnAbsoluteLeading(); // Select trigger leading particle of all the selected tracks | |
1061 | ana->SwitchOffNearSideLeading(); // Select trigger leading particle of all the particles at +-90 degrees, default | |
cd54ca47 | 1062 | |
029dea5a | 1063 | // Mixing with own pool |
1064 | ana->SwitchOffOwnMix(); | |
1065 | ana->SetNCentrBin(9); | |
1066 | ana->SetNZvertBin(10); | |
1067 | if(kCollisions=="pp") | |
1068 | { | |
1069 | ana->SetNMaxEvMix(10); | |
1070 | ana->SwitchOnTrackMultBins(); | |
1071 | } | |
1072 | else | |
1073 | { | |
1074 | ana->SetNMaxEvMix(2); | |
1075 | ana->SwitchOffTrackMultBins(); | |
050ad675 | 1076 | } |
1077 | ||
1078 | ana->SwitchOnFiducialCut(); | |
1079 | ||
531f682d | 1080 | //Avoid borders of EMCal, same as for isolation |
1081 | if(kCalorimeter=="EMCAL") | |
1082 | ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.6, 86, 174) ; | |
1083 | ||
1084 | // Same Eta as EMCal, cut in phi if EMCAL was triggering | |
bef94c35 | 1085 | if(particle=="Hadron" || particle.Contains("CTS")) |
531f682d | 1086 | { |
1087 | if(kTrig.Contains("EMC")) | |
050ad675 | 1088 | ana->GetFiducialCut()->SetSimpleCTSFiducialCut (0.6, 260, 360) ; |
531f682d | 1089 | else |
1090 | ana->GetFiducialCut()->SetSimpleCTSFiducialCut (0.6, 0, 360) ; | |
1091 | } | |
cd54ca47 | 1092 | |
1093 | // Input / output delta AOD settings | |
1094 | ||
531f682d | 1095 | ana->SetInputAODName(Form("%s%s",particle.Data(),kName.Data())); |
1096 | ana->SetAODObjArrayName(Form("%sHadronCorrIso%dTM%d",particle.Data(),bIsolated,kTM)); | |
193828fd | 1097 | |
907b38cd | 1098 | // Fill extra plots on tagged decay photons |
1099 | // If trigger is pi0/eta found with invariant mass, get the decays | |
1100 | // If trigger is photon, check if it was tagged as decay previously | |
050ad675 | 1101 | if(particle!="Hadron" ) |
907b38cd | 1102 | { |
050ad675 | 1103 | if(particle=="Pi0" || particle =="Eta") |
1104 | { | |
1105 | if(!particle.Contains("SS")) ana->SwitchOnPi0TriggerDecayCorr(); | |
1106 | else ana->SwitchOffPi0TriggerDecayCorr(); | |
1107 | ana->SwitchOffDecayTriggerDecayCorr(); | |
1108 | } | |
1109 | else | |
1110 | { | |
1111 | ana->SwitchOffPi0TriggerDecayCorr(); | |
1112 | ana->SwitchOnDecayTriggerDecayCorr(); // Make sure pi0 decay tagging runs before this task | |
1113 | } | |
907b38cd | 1114 | } |
1115 | else | |
1116 | { | |
1117 | ana->SwitchOffPi0TriggerDecayCorr(); | |
050ad675 | 1118 | ana->SwitchOffDecayTriggerDecayCorr(); |
907b38cd | 1119 | } |
193828fd | 1120 | |
907b38cd | 1121 | // if triggering on PHOS and EMCAL is on |
1122 | //if(kCalorimeter=="PHOS") ana->SwitchOnNeutralCorr(); | |
1123 | ana->SwitchOffNeutralCorr(); // Do only correlation with TPC | |
1124 | ||
1125 | ana->SwitchOffHMPIDCorrelation(); | |
cd54ca47 | 1126 | |
907b38cd | 1127 | ana->SwitchOffFillBradHistograms(); |
023e6936 | 1128 | |
907b38cd | 1129 | // Underlying event |
050ad675 | 1130 | ana->SwitchOffEventSelection(); |
531f682d | 1131 | ana->SwitchOnSeveralUECalculation(); |
1132 | ana->SetUeDeltaPhiCutRange(TMath::Pi()/3, 2*TMath::Pi()/3); | |
907b38cd | 1133 | ana->SetMultiBin(1); |
cd54ca47 | 1134 | |
1135 | //Set Histograms name tag, bins and ranges | |
1136 | ||
531f682d | 1137 | ana->AddToHistogramsName(Form("Ana%sHadronCorr_Iso%d_TM%d_",particle.Data(),bIsolated,kTM)); |
1138 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
1139 | ||
bef94c35 | 1140 | if(particle=="Hadron" || particle.Contains("CTS")) |
531f682d | 1141 | { |
1142 | ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ; | |
1143 | ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ; | |
1144 | } | |
745913ae | 1145 | |
531f682d | 1146 | ConfigureMC(ana); |
cd54ca47 | 1147 | |
531f682d | 1148 | if(kPrint) ana->Print(""); |
1e3689fa | 1149 | |
531f682d | 1150 | return ana; |
1e3689fa | 1151 | |
193828fd | 1152 | } |
69652c63 | 1153 | |
193828fd | 1154 | //________________________________________ |
1155 | AliAnaCalorimeterQA* ConfigureQAAnalysis() | |
1156 | { | |
90eb3a19 | 1157 | |
531f682d | 1158 | AliAnaCalorimeterQA *ana = new AliAnaCalorimeterQA(); |
1159 | ana->SetDebug(kDebug); //10 for lots of messages | |
1160 | ana->SetCalorimeter(kCalorimeter); | |
a3aebfff | 1161 | |
531f682d | 1162 | ana->SetTimeCut(-1000,1000); // Open time cut |
5eef1db1 | 1163 | |
66e64043 | 1164 | // Study inter detector correlation (PHOS, EMCAL, Tracks, V0) |
d2655d46 | 1165 | if(kCalorimeter=="PHOS" && kTrig=="PHOS") |
531f682d | 1166 | ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON |
d2655d46 | 1167 | if(kCalorimeter=="EMCAL" && kClusterArray=="") |
531f682d | 1168 | ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON |
d2655d46 | 1169 | else |
531f682d | 1170 | ana->SwitchOffCorrelation(); |
66e64043 | 1171 | |
1172 | // Study exotic clusters PHOS and EMCAL | |
d2655d46 | 1173 | if(kClusterArray=="") ana->SwitchOnStudyBadClusters() ; |
1174 | else ana->SwitchOffStudyBadClusters() ; | |
1175 | ||
8f880b6e | 1176 | |
531f682d | 1177 | ana->SwitchOffFiducialCut(); |
1178 | ana->SwitchOffFillAllTH3Histogram(); | |
1179 | ana->SwitchOffFillAllPositionHistogram(); | |
1180 | ana->SwitchOffFillAllPositionHistogram2(); | |
1181 | if(!kExotic)ana->SwitchOnStudyBadClusters(); | |
1182 | else ana->SwitchOffStudyBadClusters(); | |
1183 | ana->SwitchOffStudyClustersAsymmetry(); | |
1184 | ana->SwitchOffStudyWeight(); | |
1185 | ana->SwitchOnFillAllTrackMatchingHistogram(); | |
193828fd | 1186 | |
8f880b6e | 1187 | if(kCalorimeter=="EMCAL") |
1188 | { | |
531f682d | 1189 | if (kYears==2010) ana->SetNumberOfModules(4); |
1190 | else if(kYears==2011) ana->SetNumberOfModules(10); | |
1191 | else ana->SetNumberOfModules(12); | |
8f880b6e | 1192 | } |
1193 | else | |
1194 | {//PHOS | |
531f682d | 1195 | ana->SetNumberOfModules(3); |
8f880b6e | 1196 | } |
1197 | ||
531f682d | 1198 | ana->AddToHistogramsName("QA_"); //Begining of histograms name |
1199 | SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below | |
745913ae | 1200 | |
531f682d | 1201 | ConfigureMC(ana); |
cd54ca47 | 1202 | |
531f682d | 1203 | if(kPrint) ana->Print(""); |
193828fd | 1204 | |
531f682d | 1205 | return ana; |
69652c63 | 1206 | |
90eb3a19 | 1207 | } |
193828fd | 1208 | |
cd54ca47 | 1209 | //________________________________________________________ |
531f682d | 1210 | void ConfigureMC(AliAnaCaloTrackCorrBaseClass* ana) |
1211 | { | |
1212 | if(kSimulation) ana->SwitchOnDataMC() ;//Access MC stack and fill more histograms, AOD MC not implemented yet. | |
1213 | else ana->SwitchOffDataMC() ; | |
1214 | ||
1215 | //Set here generator name, default pythia | |
1216 | //ana->GetMCAnalysisUtils()->SetMCGenerator(""); | |
1217 | } | |
1218 | ||
1219 | //________________________________________________________ | |
1220 | void SetHistoRangeAndNBins (AliHistogramRanges* histoRanges) | |
cd54ca47 | 1221 | { |
1222 | // Set common bins for all analysis and MC histograms filling | |
745913ae | 1223 | |
531f682d | 1224 | histoRanges->SetHistoPtRangeAndNBins(0, 100, 200) ; // Energy and pt histograms |
cd54ca47 | 1225 | |
531f682d | 1226 | if(kCalorimeter=="EMCAL") |
1227 | { | |
1228 | if(kYears==2010) | |
1229 | { | |
1230 | histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 122*TMath::DegToRad(), 78) ; | |
1231 | histoRanges->SetHistoXRangeAndNBins(-230,90,120); // QA | |
1232 | histoRanges->SetHistoYRangeAndNBins(370,450,40); // QA | |
cd54ca47 | 1233 | } |
531f682d | 1234 | else if(kYears==2011) |
1235 | { | |
1236 | histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 182*TMath::DegToRad(), 108) ; | |
1237 | histoRanges->SetHistoXRangeAndNBins(-600,90,200); // QA | |
1238 | histoRanges->SetHistoYRangeAndNBins(100,450,100); // QA | |
cd54ca47 | 1239 | } |
531f682d | 1240 | else |
1241 | { | |
1242 | histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 190*TMath::DegToRad(), 122) ; | |
1243 | histoRanges->SetHistoXRangeAndNBins(-100,90,200); // QA | |
1244 | histoRanges->SetHistoYRangeAndNBins(50,450,100); // QA | |
1245 | } | |
1246 | ||
1247 | histoRanges->SetHistoEtaRangeAndNBins(-0.72, 0.72, 144) ; | |
cd54ca47 | 1248 | } |
531f682d | 1249 | else |
1250 | { | |
1251 | histoRanges->SetHistoPhiRangeAndNBins(260*TMath::DegToRad(), 320*TMath::DegToRad(), 60) ; | |
1252 | histoRanges->SetHistoEtaRangeAndNBins(-0.13, 0.13, 130) ; | |
745913ae | 1253 | } |
1254 | ||
bef94c35 | 1255 | histoRanges->SetHistoShowerShapeRangeAndNBins(-0.1, 4.9, 500); |
cd54ca47 | 1256 | |
531f682d | 1257 | // Invariant mass histoRangeslysis |
1258 | histoRanges->SetHistoMassRangeAndNBins(0., 1., 200) ; | |
1259 | histoRanges->SetHistoAsymmetryRangeAndNBins(0., 1. , 100) ; | |
cd54ca47 | 1260 | |
1261 | // check if time calibration is on | |
531f682d | 1262 | histoRanges->SetHistoTimeRangeAndNBins(-1000.,1000,1000); |
1263 | histoRanges->SetHistoDiffTimeRangeAndNBins(-200, 200, 800); | |
cd54ca47 | 1264 | |
09273901 | 1265 | // track-cluster residuals |
531f682d | 1266 | histoRanges->SetHistoTrackResidualEtaRangeAndNBins(-0.15,0.15,300); |
1267 | histoRanges->SetHistoTrackResidualPhiRangeAndNBins(-0.15,0.15,300); | |
6962f0e8 | 1268 | histoRanges->SetHistodRRangeAndNBins(0.,0.15,150);//QA |
531f682d | 1269 | |
cd54ca47 | 1270 | // QA, electron, charged |
531f682d | 1271 | histoRanges->SetHistoPOverERangeAndNBins(0,10.,100); |
1272 | histoRanges->SetHistodEdxRangeAndNBins(0.,200.,200); | |
cd54ca47 | 1273 | |
1274 | // QA | |
531f682d | 1275 | histoRanges->SetHistoFinePtRangeAndNBins(0, 10, 200) ; // bining for fhAmpId |
531f682d | 1276 | histoRanges->SetHistoRatioRangeAndNBins(0.,2.,100); |
1277 | histoRanges->SetHistoVertexDistRangeAndNBins(0.,500.,500); | |
1278 | histoRanges->SetHistoNClusterCellRangeAndNBins(0,500,500); | |
1279 | histoRanges->SetHistoZRangeAndNBins(-400,400,200); | |
1280 | histoRanges->SetHistoRRangeAndNBins(400,450,25); | |
1281 | histoRanges->SetHistoV0SignalRangeAndNBins(0,5000,500); | |
1282 | histoRanges->SetHistoV0MultiplicityRangeAndNBins(0,5000,500); | |
1283 | histoRanges->SetHistoTrackMultiplicityRangeAndNBins(0,5000,500); | |
cd54ca47 | 1284 | |
1285 | } | |
193828fd | 1286 |