1 // definition of variables ranges
2 const Double_t nevtmin = 0;
3 const Double_t nevtmax = 5;
5 const Double_t trigmin = 0;
6 const Double_t trigmax = 4;
7 const Int_t trigsidemin = 0;
8 const Int_t trigsidemax = 4;
9 const Int_t chargemin = -3;
10 const Int_t chargemax = 3;
12 const Double_t ymin = -4.5;
13 const Double_t ymax = -2.0;
14 const Double_t etamin = -4.5;
15 const Double_t etamax = -2.0;
16 const Double_t rabsmin = 15;
17 const Double_t rabsmax = 90;
18 const Double_t ptmin = 0;
19 const Double_t ptmax = 100;
20 const Double_t thabsmin = 170;
21 const Double_t thabsmax = 180;
22 const Double_t vzmin = -50;
23 const Double_t vzmax = 50;
24 const Double_t dcamin = 0;
25 const Double_t dcamax = 100;
26 const Double_t pmin = 0;
27 const Double_t pmax = 100;
28 const Double_t mmin = 0;
29 const Double_t mmax = 15;
32 const Int_t PDG = 553; // Upsilon
34 ///// Setting up the container grid
36 // CONTAINER DEFINITION
37 UInt_t nevent = 0; // number of event
38 UInt_t y = 1; // dimuon rapidity
39 UInt_t pt = 2; // dimuon pt
40 UInt_t imass = 3; // dimuon invariant mass
41 UInt_t trig = 4; // single muon track-trigger matching
42 UInt_t ptmu = 5; // single muon pt
43 UInt_t pmu = 6; // single muon p
44 UInt_t trigside = 7; // event trigger side (AC, B, E)
45 UInt_t rabsmu = 8; // single muon Rabs
46 UInt_t charge = 9; // total charge of dimuon tracks
47 UInt_t etamu = 10; // single muon eta
48 UInt_t thabsmu = 11; // single muon theta_abs
49 UInt_t vzmu = 12; // single muon Vz
50 UInt_t dcamu = 13; // single muon DCA
54 // Setting up the container grid
55 UInt_t nstep = 5 ; //number of selection steps : MC and ESD for simulation, CINT1B, CMUS1B for real data
57 const Int_t nvar = 14; //number of variables on the grid
58 const Int_t nbin1 = 5;
59 const Int_t nbin2 = 15;
60 const Int_t nbin3 = 100;
61 const Int_t nbin4 = 300;
62 const Int_t nbin5 = 40;
63 const Int_t nbin6 = 100;
64 const Int_t nbin7 = 100;
65 const Int_t nbin8 = 4;
66 const Int_t nbin9 = 300;
67 const Int_t nbin10 = 6;
68 const Int_t nbin11 = 100;
69 const Int_t nbin12 = 200;
70 const Int_t nbin13 = 100;
71 const Int_t nbin14 = 100;
73 class AliAnalysisGrid;
76 Bool_t AliCFMuonResUpsilon(
77 const char* runtype = "local", // local, proof or grid
78 const char* taskname = "CFMuonResUpsilon", // task name
79 const bool readAOD = 0, // 1 = AOD based analysis
80 const bool readMC = 0, // 1 = Read MC
81 const bool usePlugin = 0, // grid mode : use plugin
82 const char* gridmode = "test" // plugin mode ("full","test","offline","submit" or "terminate"
86 //load the required aliroot libraries
87 gSystem->Load("libCore.so");
88 gSystem->Load("libTree.so");
89 gSystem->Load("libGeom.so");
90 gSystem->Load("libVMC.so");
91 gSystem->Load("libPhysics.so");
92 gSystem->Load("libSTEERBase");
93 gSystem->Load("libESD");
94 gSystem->Load("libAOD") ;
95 gSystem->Load("libANALYSIS") ;
96 gSystem->Load("libANALYSISalice") ;
98 //load correction framework library
99 gSystem->Load("libCORRFW.so") ;
101 //compile online the task class
102 gSystem->SetIncludePath("-I. -I$ALICE_ROOT/include -I$ROOTSYS/include -I$ALICE_ROOT/PWG3/muon");
103 gROOT->LoadMacro("./AliCFMuonResUpsilon.cxx++g");
107 // -----------------------------------------------
109 // arrays for the number of bins in each dimension
126 // arrays for lower bounds :
127 Double_t *binLim1=new Double_t[nbin1+1];
128 Double_t *binLim2=new Double_t[nbin2+1];
129 Double_t *binLim3=new Double_t[nbin3+1];
130 Double_t *binLim4=new Double_t[nbin4+1];
131 Double_t *binLim5=new Double_t[nbin5+1];
132 Double_t *binLim6=new Double_t[nbin6+1];
133 Double_t *binLim7=new Double_t[nbin7+1];
134 Double_t *binLim8=new Double_t[nbin8+1];
135 Double_t *binLim9=new Double_t[nbin9+1];
136 Double_t *binLim10=new Double_t[nbin10+1];
137 Double_t *binLim11=new Double_t[nbin11+1];
138 Double_t *binLim12=new Double_t[nbin12+1];
139 Double_t *binLim13=new Double_t[nbin13+1];
140 Double_t *binLim14=new Double_t[nbin14+1];
142 // values for bin lower bounds
143 for(Int_t i=0; i<=nbin1; i++) binLim1[i]=(Double_t)nevtmin+(nevtmax-nevtmin)/nbin1*(Double_t)i ;
144 for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Double_t)ymin+(ymax-ymin)/nbin2*(Double_t)i ;
145 for(Int_t i=0; i<=nbin3; i++) binLim3[i]=(Double_t)ptmin+(ptmax-ptmin)/nbin3*(Double_t)i ;
146 for(Int_t i=0; i<=nbin4; i++) binLim4[i]=(Double_t)mmin+(mmax-mmin)/nbin4*(Double_t)i ;
147 for(Int_t i=0; i<=nbin5; i++) binLim5[i]=(Double_t)trigmin+(trigmax-trigmin)/nbin5*(Double_t)i ;
148 for(Int_t i=0; i<=nbin6; i++) binLim6[i]=(Double_t)ptmin+(ptmax-ptmin)/nbin6*(Double_t)i ;
149 for(Int_t i=0; i<=nbin7; i++) binLim7[i]=(Double_t)pmin+(pmax-pmin)/nbin7*(Double_t)i ;
150 for(Int_t i=0; i<=nbin8; i++) binLim8[i]=(Double_t)trigsidemin+(trigsidemax-trigsidemin)/nbin8*(Double_t)i ;
151 for(Int_t i=0; i<=nbin9; i++) binLim9[i]=(Double_t)rabsmin+(rabsmax-rabsmin)/nbin9*(Double_t)i ;
152 for(Int_t i=0; i<=nbin10; i++) binLim10[i]=(Double_t)chargemin+(chargemax-chargemin)/nbin10*(Double_t)i ;
153 for(Int_t i=0; i<=nbin11; i++) binLim11[i]=(Double_t)etamin+(etamax-etamin)/nbin11*(Double_t)i ;
154 for(Int_t i=0; i<=nbin12; i++) binLim12[i]=(Double_t)thabsmin+(thabsmax-thabsmin)/nbin12*(Double_t)i ;
155 for(Int_t i=0; i<=nbin13; i++) binLim13[i]=(Double_t)vzmin+(vzmax-vzmin)/nbin13*(Double_t)i ;
156 for(Int_t i=0; i<=nbin14; i++) binLim14[i]=(Double_t)dcamin+(dcamax-dcamin)/nbin14*(Double_t)i ;
158 // one container of 2 steps (MC and ESD) with 12 variables
159 AliCFContainer* container = new AliCFContainer("container","container for tracks",nstep,nvar,iBin);
160 // setting the bin limits
161 container -> SetBinLimits(nevent,binLim1);
162 container -> SetBinLimits(y,binLim2);
163 container -> SetBinLimits(pt,binLim3);
164 container -> SetBinLimits(imass,binLim4);
165 container -> SetBinLimits(trig,binLim5);
166 container -> SetBinLimits(ptmu,binLim6);
167 container -> SetBinLimits(pmu,binLim7);
168 container -> SetBinLimits(trigside,binLim8);
169 container -> SetBinLimits(rabsmu,binLim9);
170 container -> SetBinLimits(charge,binLim10);
171 container -> SetBinLimits(etamu,binLim11);
172 container -> SetBinLimits(thabsmu,binLim12);
173 container -> SetBinLimits(vzmu,binLim13);
174 container -> SetBinLimits(dcamu,binLim14);
176 // create AliCFManager
177 AliCFManager* man = new AliCFManager();
178 // set particle container
179 man->SetParticleContainer(container);
181 // ----------------------------------------------
184 if(runtype != "local" && runtype != "proof" && runtype != "grid") {
185 printf("Incorrect runtype! choose \"local\", \"prootf\" or \"grid\"\n");
189 printf("runtype : %s\n", runtype);
191 // Make the analysis manager
192 AliAnalysisManager *mgr = new AliAnalysisManager(Form("%sAnalysis",taskname));
195 if (runtype == "grid" && usePlugin) {
197 // set package for grid(API,ROOT,ALIROOT)
198 const char *package[3] = {"V1.1x","v5-28-00a","v4-21-18-AN"};
200 AliAnalysisGrid *alienHandler = CreateAlienHandler(taskname,gridmode,package);
201 if (!alienHandler) return;
203 mgr->SetGridHandler(alienHandler);
209 analysisChain = new TChain("aodTree");
212 analysisChain->Add("/home/sahn/alice/mc_prod/PDC09/AODs-100421-100436v2/000/033/AliAODs.root"); // PDC09 AOD
213 //analysisChain->Add("/home/sahn/alice/mc_prod/upsilon/local/run/muonAcc/residual/AODs/AliAODs.root"); // muon acceptance production with residual alignment AOD
216 analysisChain->Add("/home/sahn/alice/p2_prod/LHC10g/AODs/135658/019/AliAOD.Dimuons.root"); // LHC10g-run135658 AOD
217 //analysisChain->Add("/home/sahn/alice/p2_prod/LHC10g/AODs/135658/020/AliAOD.Dimuons.root"); // LHC10g-run135658 AOD
222 analysisChain = new TChain("esdTree");
225 analysisChain->Add("/home/sahn/alice/mc_prod/upsilon/local/run/muonAcc/residual/005/AliESDs.root"); // muon acceptance production with residual alignment
228 analysisChain->Add("/home/sahn/alice/p2_prod/LHC10g/000135748/ESDs/pass1/10000135748001.150/AliESDs.root"); // LHC10g-run135748
234 AliCFMuonResUpsilon *task = new AliCFMuonResUpsilon(taskname);
237 TList* qaList = new TList();
240 // Choice of the Resonance
241 if(readMC && !readAOD) {
242 AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts");
243 mcGenCuts->SetRequirePdgCode(PDG);
244 mcGenCuts->SetQAOn(qaList);
246 // Set a pt range of the resonance
247 AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts");
248 mcKineCuts->SetPtRange(ptmin,ptmax);
249 mcKineCuts->SetQAOn(qaList);
251 // Create and fill the list associated
252 TObjArray* mcList = new TObjArray(0) ;
253 mcList->AddLast(mcKineCuts);
254 mcList->AddLast(mcGenCuts);
256 // kinematic cuts on muons rapidity
257 AliCFTrackKineCuts *recKineCuts = new AliCFTrackKineCuts("recKineCuts","rec-level kine cuts");
258 recKineCuts->SetRapidityRange(ymin,ymax);
259 recKineCuts->SetQAOn(qaList);
260 TObjArray* recList = new TObjArray(0) ;
261 recList->AddLast(recKineCuts);
263 man->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList);
264 man->SetParticleCutsList(AliCFManager::kPartAccCuts,recList);
266 else if(readMC && readAOD) { // for MC in AOD
267 task->SetRequirePdgCode(PDG);
268 task->SetPtRange(ptmin,ptmax);
269 task->SetRapidityRange(ymin,ymax);
272 task->SetCFManager(man); //here is set the CF manager
273 task->SetQAList(qaList);
275 if(readAOD) task->SetReadAODData();
276 if(readMC) task->SetReadMCInfo();
278 if(readMC && !readAOD) {
279 AliMCEventHandler* mcHandler = new AliMCEventHandler();
280 mgr->SetMCtruthEventHandler(mcHandler);
284 AliAODInputHandler *dataHandler = new AliAODInputHandler();
285 mgr->SetInputEventHandler(dataHandler);
289 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
290 AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
294 AliESDInputHandler *dataHandler = new AliESDInputHandler();
295 mgr->SetInputEventHandler(dataHandler);
299 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
300 AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
305 // Create and connect containers for input/output
306 AliAnalysisDataContainer *cinput = mgr->CreateContainer("cchain",TChain::Class(),AliAnalysisManager::kInputContainer);
310 sprintf(file,"container.%s.%s.%s.%s.root",taskname,runtype,readAOD ? "AOD":"ESD",readMC ? "MC":"Real");
312 AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist0", TH1D::Class(),AliAnalysisManager::kOutputContainer,file);
313 AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("container", AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,file);
317 mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
318 mgr->ConnectOutput(task,1,coutput1);
319 mgr->ConnectOutput(task,2,coutput2);
321 if (!mgr->InitAnalysis()) return;
324 if(usePlugin) mgr->StartAnalysis(runtype);
325 else mgr->StartAnalysis(runtype,analysisChain);
330 AliAnalysisGrid* CreateAlienHandler(const char *taskname, const char *gridmode, const char* package[3])
332 //if (!AliAnalysisGrid::CreateToken()) return NULL;
333 AliAnalysisAlien *plugin = new AliAnalysisAlien();
336 plugin->SetRunMode(gridmode);
339 //plugin->SetCheckCopy(kFALSE);
342 plugin->SetMergeViaJDL(kTRUE);
343 plugin->SetOneStageMerging(kFALSE);
344 plugin->SetMaxMergeStages(3);
347 plugin->SetAPIVersion(package[0]);
348 plugin->SetROOTVersion(package[1]);
349 plugin->SetAliROOTVersion(package[2]);
350 plugin->SetDataPattern("ESDs/pass1/*AliESDs.root");
355 //______________________________________________________
357 plugin->SetGridDataDir("/alice/data/2010/LHC10f/");
358 const Int_t nruns=24;
360 Int_t run_number[nruns] = { 133006, 133010, 133327, 133330, 133414, 133419, 133563, 133800, 133924, 133969,
361 133985, 134094, 134198, 134204, 134304, 134497, 134666, 134679, 134685, 134690,
362 134841, 134905, 134914, 134919 };
364 plugin->SetGridWorkingDir(Form("workdir-%s",taskname));
366 //______________________________________________________
369 plugin->SetGridDataDir("/alice/data/2010/LHC10g/");
371 const Int_t nruns=12;
373 Int_t run_number[nruns] = { 135658, 135704, 135709, 135712, 135748, 135761, 135795, 136177, 136180, 136189, 136372, 136376 };
375 plugin->SetGridWorkingDir(Form("workdir-%s",taskname));
378 // Set Prefix for real data
379 plugin->SetRunPrefix("000");
381 // Adding run numbers
382 for(int i=0; i<nruns; i++) {
383 plugin->AddRunNumber(run_number[i]);
387 plugin->SetGridOutputDir("output");
388 plugin->SetAnalysisSource("AliCFMuonResUpsilon.cxx");
389 plugin->SetAdditionalLibs("AliCFMuonResUpsilon.h AliCFMuonResUpsilon.cxx");
390 //plugin->SetSplitMaxInputFileNumber(20);
391 plugin->SetTTL(86400);
392 plugin->SetInputFormat("xml-single");
394 plugin->SetUseSubmitPolicy();