PWGLF/FORWARD/trains/QATrain.C

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