TrainSetup version of official QA train
[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / trains / QATrain.C
1 #include "TrainSetup.C"
2 #include <AliESDInputHandlerRP.h>
3 #include <AliCDBManager.h>
4
5 //====================================================================
6 /**
7  * Analysis train to do energy loss fits
8  * 
9  * @ingroup pwg2_forward_trains
10  */
11 class QATrain : public TrainSetup
12 {
13 public:
14   enum { 
15     kCDBConnect = 0x1, 
16     kEventStats = 0x2,  // Event Statistics (Jan Fiete)
17     kCentrality = 0x4,  // Centrality (A. Toia)
18     kDefaultFlags = (kCDBConnect|kEventStats|kCentrality)
19   };
20   enum { 
21     kVertex     = 0x000001,  // Vertexing (A. Dainese)
22     kSymmetric  = 0x000002,  // TPC QA (E. Sicking)
23     kVZERO      = 0x000004,  // VZERO QA  (C. Cheshkov)
24     kTPC        = 0x000008,  // TPC (Jacek Otwinowski & Michael Knichel)
25     kSPD        = 0x000010,  // SPD (A. Mastroserio) - Needs RP
26     kSDD        = 0x000020,  // SDD (F. Prino) Needs RP
27     kSSD        = 0x000040,  // SSD dEdx (Marek Chojnacki)
28     kITS        = 0x000080,  // 
29     kITSSA      = 0x000100,  // ITS saTracks (F.Prino)
30     kITSAlign   = 0x000200,  // ITS align (F.Prino)
31     kTRD        = 0x000400,  // TRD (Alex Bercuci, M. Fasel) 
32     kZDC        = 0x000800,  // ZDC (Chiara Oppedisano) 
33     kCALO       = 0x001000,  // Calorimetry (Gustavo Conesa)
34     kMUONTRG    = 0x002000,  // Muon Trigger
35     kMUONEff    = 0x004000,  // Muon Efficiency (not used) Need geo 
36     kV0         = 0x008000,  // V0-Decay Reconstruction (Ana Marin)
37                              // (not used) Need MC truth 
38     kBRes       = 0x010000,  // Impact parameter resolution
39                              // (xianbao.yuan@pd.infn.it,
40                              // andrea.dainese@pd.infn.it) 
41     kMUON       = 0x020000,  // MUON QA (Philippe Pillot)
42     kTOF        = 0x040000,  // TOF (Francesca Bellini)
43     kPIDRes     = 0x080000,  // PIDResponse (Jens)
44     kPID        = 0x100000,  // PIDqa (Jens)
45     kHMPID      = 0x200000,  // HMPID QA (Giacomo Volpe)
46     kT0         = 0x400000,  // T0 QA (Alla Mayevskaya)
47     kFMD        = 0x800000,  // FMD QA (Christian Holm Christiansen)
48     kDefaultModules  = (kVertex|kSymmetric|kVZERO|kTPC|kSPD|kSDD|kSSD|kITS|
49                         kITSSA|kITSAlign|kTRD|kZDC|kCALO|kMUONTRG|kBRes|
50                         kMUON|kTOF|kPIDRes|kPID|kHMPID|kT0|kFMD)
51   };
52     
53     
54
55   /** 
56    * Constructor.  Date and time must be specified when running this
57    * in Termiante mode on Grid
58    * 
59    * @param name     Name of train 
60    * @param useCent  Whether to use centrality or not 
61    * @param dateTime Append date and time to name
62    * @param year     Year
63    * @param month    Month 
64    * @param day      Day
65    * @param hour     Hour 
66    * @param min      Minutes
67    */
68   QATrain(UInt_t      run  = 0,
69           UShort_t    flags = kDefaultFlags, 
70           UInt_t      modules = kDefaultModules)
71     : TrainSetup("PilotAnalysis", false, 0, 0, 0, 0, 0), 
72       fRun(run),
73       fFlags(flags), 
74       fModules(modules), 
75       fTriggerMask(AliVEvent::kAnyINT), 
76       fTriggerHM(AliVEvent::kHighMult),
77       fTriggerEMC(AliVEvent::kEMC7), 
78       fTriggerMUONBarrel(AliVEvent::kMUU7),
79       fCollisionType(0) // 0: pp, 1: PbPb
80   {}
81   //__________________________________________________________________
82   /** 
83    * Run this analysis 
84    * 
85    * @param mode     Mode
86    * @param oper     Operation
87    * @param nEvents  Number of events (negative means all)
88    * @param mc       If true, assume simulated events 
89    * @param par      IF true, use par files 
90    */
91   void Run(const char* oper, 
92            Int_t nEvents=-1, Bool_t mc=false, Bool_t par=false)
93   {
94     Exec("ESD", "Local", oper, nEvents, mc, par);
95   }
96   //__________________________________________________________________
97   /** 
98    * Run this analysis 
99    * 
100    * @param mode     Mode
101    * @param oper     Operation
102    * @param nEvents  Number of events (negative means all)
103    * @param mc       If true, assume simulated events 
104    * @param par      IF true, use par files 
105    */
106   void Run(EOper oper, Int_t nEvents=-1, Bool_t mc=false,
107            Bool_t par=false)
108   {
109     Exec(kESD, kLocal, oper, nEvents, mc, par);
110   }
111 protected:
112   AliVEventHandler* CreateInputHandler(EType type)
113   {
114     if (type != kESD) return 0;
115     AliAnalysisManager::GetAnalysisManager()->SetRunFromPath(fRun);
116     
117     AliESDInputHandlerRP* ih = new AliESDInputHandlerRP();
118     ih->SetReadFriends(kTRUE);
119     ih->SetActiveBranches("ESDfriend");
120     return ih;
121   }
122   AliAnalysisTaskSE* CreateTaskAndSetCollisionCandidates(const char* macro)
123   {
124     Long_t ret = gROOT->Macro(macro);
125     if (!ret) return 0;
126     AliAnalysisTaskSE* task = reinterpret_cast<AliAnalysisTaskSE*>(ret);
127     task->SelectCollisionCandidates(fTriggerMask);
128     return task;
129   }
130   void CreateCDBConnect()
131   {                                 
132     ::Info("CreateCDBConnect", "Loading CDB connect w/run=%d", fRun);
133     Long_t ret = gROOT->Macro(Form("AddTaskCDBconnect.C(%d)", fRun));
134     ::Info("CreateCDBConnect", "Loaded %p", fRun);
135     if (!ret) return;
136     AliCDBManager::Instance()->SetDefaultStorage("raw://");
137   }
138   void CreatePhysicsSelection(Bool_t mc,
139                               AliAnalysisManager* mgr)
140   {
141     // Event Statistics (Jan Fiete)
142     if (!(fFlags & kEventStats)) return;
143     TrainSetup::CreatePhysicsSelection(mc, mgr);
144   }
145   void CreateCentralitySelection(Bool_t mc, AliAnalysisManager* mgr)
146   {
147     // Centrality (A. Toia)
148     if (!(fFlags & kCentrality)) return;
149     TrainSetup::CreateCentralitySelection(mc, mgr);
150   } 
151   void CreateVertex()
152   {
153     // Vertexing (A. Dainese)
154     gROOT->Macro(Form("AddTaskVertexESD.C(kFALSE,0x%x)", fTriggerMask));
155   }
156   void CreateSymmetric()
157   {
158     // TPC QA (E. Sicking)
159     gROOT->Macro(Form("AddTaskQAsym.C(0,0x%x,0x%x,0x%x,0x%x)",
160                       fTriggerMask, fTriggerHM, fTriggerEMC, 
161                       fTriggerMUONBarrel));
162   }
163   void CreateVZERO()
164   {
165     //  VZERO QA  (C. Cheshkov)
166     gROOT->Macro("AddTaskVZEROQA.C(0)");
167   }
168   void CreateTPC()
169   {
170     // TPC (Jacek Otwinowski & Michael Knichel)
171     //
172     // Optionally MC information can be used by setting the 1st
173     // argument to true 
174     // 
175     // Optionally friends information can be switched off by setting
176     // the 2st argument to false
177     // 
178     // Optionally highMult axis can be used by setting the 3st
179     // argument to true (for PbPb)
180     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/TPC/macros",
181                              gROOT->GetMacroPath()));
182     CreateTaskAndSetCollisionCandidates("AddTaskPerformanceTPCdEdxQA.C(kFALSE,kTRUE,kFALSE)");
183   }
184   void CreateSPD()
185   {
186     // SPD (A. Mastroserio)
187     CreateTaskAndSetCollisionCandidates("AddTaskSPDQA.C");
188     // AliAnalysisTask* task = 
189     //   CreateTaskAndSetCollisionCandidates("AddTaskSPDQA.C");
190     // if (!task) return;
191     // task->SetOCDBInfo(fRun, "raw://");
192   }
193   void CreateSDD()
194   {
195     // SDD (F. Prino)
196     CreateTaskAndSetCollisionCandidates("AddSDDPoints.C");
197   }
198   void CreateSSD()
199   {
200     // SSD dEdx (Marek Chojnacki)
201     CreateTaskAndSetCollisionCandidates("AddTaskdEdxSSDQA.C");
202   }
203   void CreateITS()
204   {
205     gROOT->Macro("AddTaskPerformanceITS.C(kFALSE)");
206     if (fCollisionType == 0) return;
207
208     gROOT->ProcessLine("AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,3500,10000)");
209     gROOT->ProcessLine("AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,590,1570)");
210     gROOT->ProcessLine("AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,70,310)");
211   }
212   void CreateITSSA() 
213   {
214     // ITS saTracks, align (F.Prino)
215     CreateTaskAndSetCollisionCandidates("AddTaskITSsaTracks.C(kFALSE,kFALSE)");
216   }
217   void CreateITSAlign()
218   {
219     // ITS saTracks, align (F.Prino)
220     gROOT->Macro("AddTaskITSAlign.C(0,2011");
221   }
222   void CreateTRD()
223   {
224     // TRD (Alex Bercuci, M. Fasel) 
225     gSystem->AddIncludePath("-I${ALICE_ROOT}/PWG1/TRD");
226     gROOT->Macro("AddTrainPerformanceTRD.C(\"ESD DET EFF RES PID\")"); 
227   }
228   void CreateZDC()
229   {
230     // ZDC (Chiara Oppedisano)
231     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/ZDC",
232                              gROOT->GetMacroPath()));
233     CreateTaskAndSetCollisionCandidates("AddTaskZDCQA.C");
234   }
235   void CreateCALO(EMode mode, Bool_t par)
236   {
237     // Calorimetry (Gustavo Conesa)
238     LoadLibrary("EMCALUtils", mode, par, true);
239     LoadLibrary("PHOSUtils", mode, par, true);
240     LoadLibrary("PWG4PartCorrBase", mode, par, true);
241     LoadLibrary("PWG4PartCorrDep", mode, par, true);
242     
243     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG4/macros/QA",
244                              gROOT->GetMacroPath()));
245     CreateTaskAndSetCollisionCandidates("AddTaskCalorimeterQA.C(\"ESD\",20011,kFALSE,kFALSE)");
246     Long_t ret = gROOT->ProcessLine("AddTaskCalorimeterQA(\"ESD\",2011,kFALSE,kFALSE,\"\",\"EMC7\")");
247     if (!ret) return;
248     AliAnalysisTaskSE* task = reinterpret_cast<AliAnalysisTaskSE*>(ret);
249     task->SelectCollisionCandidates(fTriggerEMC);
250   }
251   void CreateMUONTRG(EMode mode, Bool_t par)
252   {
253     // Muon Trigger
254     LoadLibrary("PWG3base", mode, par, true);
255     LoadLibrary("PWG3muon", mode, par, true);
256     LoadLibrary("PWG3muondep", mode, par, true);
257     
258     gROOT->Macro("AddTaskMTRchamberEfficiency.C");
259   }
260   void CreateMUONEff()
261   {
262     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG3/muondep",
263                              gROOT->GetMacroPath()));
264     gROOT->Macro("AddTaskMUONTrackingEfficiency.C");
265   }
266   void CreateV0()
267   {
268     // V0-Decay Reconstruction (Ana Marin) (not used)
269     gROOT->Macro("AddTaskV0QA.C(kFALSE)");
270   }
271   void CreateBRes()
272   {
273     // Impact parameter resolution (xianbao.yuan@pd.infn.it,
274     // andrea.dainese@pd.infn.it) 
275     CreateTaskAndSetCollisionCandidates(Form("AddTaskImpParRes.C(%s)", 
276                                              fCollisionType == 0 ? 
277                                              "" : 
278                                              "kFALSE,-1,kFALSE,kFALSE"));
279   }
280   void CreateMUON(EMode mode, Bool_t par)
281   {
282     // MUON QA (Philippe Pillot)
283     LoadLibrary("PWG3base", mode, par, true);
284     LoadLibrary("PWG3muon", mode, par, true);
285     LoadLibrary("PWG3muondep", mode, par, true);
286     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG3/muon",
287                              gROOT->GetMacroPath()));
288     gROOT->Macro("AddTaskMuonQA.C");
289   }
290   void CreateTOF()
291   {
292     // TOF (Francesca Bellini)
293     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/TOF",
294                              gROOT->GetMacroPath()));
295     CreateTaskAndSetCollisionCandidates("AddTaskTOFQA.C");
296   }
297   void CreatePIDRes()
298   {
299     // PIDResponse (Jens)
300     CreateTaskAndSetCollisionCandidates("AddTaskPIDResponse.C");
301   }
302
303   void CreatePID()
304   {
305     // PIDqa (Jens)
306     CreateTaskAndSetCollisionCandidates("AddTaskPIDqa.C");
307   }
308   void CreateHMPID()
309   {
310     // HMPID QA (Giacomo Volpe)
311     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/HMPID",
312                              gROOT->GetMacroPath()));
313     CreateTaskAndSetCollisionCandidates("AddTaskHmpidQA.C");
314   }
315   void CreateT0()
316   {
317     // T0 QA (Alla Mayevskaya)
318     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/T0",
319                              gROOT->GetMacroPath()));
320     CreateTaskAndSetCollisionCandidates("AddTaskT0QA.C");
321   }
322   void CreateFMD(EMode mode, Bool_t par)
323   {
324     // FMD QA (Christian Holm Christiansen)
325     LoadLibrary("PWG2forward2", mode, par, true);
326     Bool_t mc = AliAnalysisManager::GetAnalysisManager()
327       ->GetMCtruthEventHandler() != 0;
328     gROOT->Macro(Form("AddTaskForwardQA.C(%d,%d)", mc, (fFlags & kCentrality)));
329   }
330   //__________________________________________________________________
331   /** 
332    * Create the tasks 
333    * 
334    * @param mode Processing mode
335    * @param par  Whether to use par files 
336    * @param mgr  Analysis manager 
337    */
338   void CreateTasks(EMode mode, Bool_t par, AliAnalysisManager* mgr)
339   {
340     // --- Output file name ------------------------------------------
341     AliAnalysisManager::SetCommonFileName("QAResults.root");
342
343     LoadLibrary("CORRFW", mode, par);
344     LoadLibrary("TENDER", mode, par);
345     LoadLibrary("PWG0base", mode, par);
346     LoadLibrary("PWG0dep", mode, par);
347     LoadLibrary("PWG0selectors", mode, par);
348     LoadLibrary("PWG1", mode, par);    
349
350     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/PilotTrain"
351                              ":$(ALICE_ROOT)/PWG1/macros",
352                              gROOT->GetMacroPath()));   
353  
354     mgr->AddStatisticsTask(fTriggerMask);
355     if (fFlags   & kCDBConnect) CreateCDBConnect();
356     if (fModules & kVertex)     CreateVertex();
357     if (fModules & kSymmetric)  CreateSymmetric();
358     if (fModules & kVZERO)      CreateVZERO();
359     if (fModules & kTPC)        CreateTPC();
360     if (fModules & kSPD)        CreateSPD();
361     if (fModules & kSDD)        CreateSDD();
362     if (fModules & kSSD)        CreateSSD();
363     if (fModules & kITS)        CreateITS();
364     if (fModules & kITSSA)      CreateITSSA();
365     if (fModules & kITSAlign)   CreateITSAlign();
366     if (fModules & kTRD)        CreateTRD(); 
367     if (fModules & kZDC)        CreateZDC(); 
368     if (fModules & kCALO)       CreateCALO(mode, par); 
369     if (fModules & kMUONTRG)    CreateMUONTRG(mode, par); 
370     if (fModules & kMUONEff)    CreateMUONEff(); 
371     if (fModules & kV0)         CreateV0(); 
372     if (fModules & kBRes)       CreateBRes(); 
373     if (fModules & kMUON)       CreateMUON(mode, par); 
374     if (fModules & kTOF)        CreateTOF(); 
375     if (fModules & kPIDRes)     CreatePIDRes(); 
376     if (fModules & kPID)        CreatePID(); 
377     if (fModules & kHMPID)      CreateHMPID(); 
378     if (fModules & kT0)         CreateT0(); 
379     if (fModules & kFMD)        CreateFMD(mode, par); 
380   }
381   /** 
382    * Crete output handler - we don't want one here. 
383    * 
384    * @return 0
385    */
386   AliVEventHandler* CreateOutputHandler(EType) { return 0; }
387   UInt_t   fRun; // Run number 
388   UShort_t fFlags; // Flags 
389   UInt_t   fModules; // Modules to load 
390   UInt_t   fTriggerMask; 
391   UInt_t   fTriggerHM;
392   UInt_t   fTriggerEMC;
393   UInt_t   fTriggerMUONBarrel;
394   UShort_t fCollisionType; // 0: pp, 1: PbPb 
395   
396   
397   Bool_t fUseCent; // Whether to use centrality or not 
398 };
399
400 //
401 // EOF
402 //