PWGLF/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)/PWGPP/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}/PWGPP/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)/PWGPP/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)/PWGPP/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)/PWGPP/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)/PWGPP/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("PWGPP", mode, par);
 349
 350     gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/PilotTrain"
 351                              ":$(ALICE_ROOT)/PWGPP/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 //