[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / trains / QATrain.C

#include "TrainSetup.C"
#include <AliESDInputHandlerRP.h>
#include <AliCDBManager.h>

//====================================================================
/**
 * Analysis train to do energy loss fits
 * 
 * @ingroup pwg2_forward_trains
 */
class QATrain : public TrainSetup
{
public:
  enum { 
    kCDBConnect = 0x1, 
    kEventStats = 0x2,  // Event Statistics (Jan Fiete)
    kCentrality = 0x4,  // Centrality (A. Toia)
    kDefaultFlags = (kCDBConnect|kEventStats|kCentrality)
  };
  enum { 
    kVertex     = 0x000001,  // Vertexing (A. Dainese)
    kSymmetric  = 0x000002,  // TPC QA (E. Sicking)
    kVZERO      = 0x000004,  // VZERO QA  (C. Cheshkov)
    kTPC        = 0x000008,  // TPC (Jacek Otwinowski & Michael Knichel)
    kSPD        = 0x000010,  // SPD (A. Mastroserio) - Needs RP
    kSDD        = 0x000020,  // SDD (F. Prino) Needs RP
    kSSD        = 0x000040,  // SSD dEdx (Marek Chojnacki)
    kITS        = 0x000080,  // 
    kITSSA      = 0x000100,  // ITS saTracks (F.Prino)
    kITSAlign   = 0x000200,  // ITS align (F.Prino)
    kTRD        = 0x000400,  // TRD (Alex Bercuci, M. Fasel) 
    kZDC        = 0x000800,  // ZDC (Chiara Oppedisano) 
    kCALO       = 0x001000,  // Calorimetry (Gustavo Conesa)
    kMUONTRG    = 0x002000,  // Muon Trigger
    kMUONEff    = 0x004000,  // Muon Efficiency (not used) Need geo 
    kV0         = 0x008000,  // V0-Decay Reconstruction (Ana Marin)
			     // (not used) Need MC truth 
    kBRes       = 0x010000,  // Impact parameter resolution
			     // (xianbao.yuan@pd.infn.it,
			     // andrea.dainese@pd.infn.it) 
    kMUON       = 0x020000,  // MUON QA (Philippe Pillot)
    kTOF        = 0x040000,  // TOF (Francesca Bellini)
    kPIDRes     = 0x080000,  // PIDResponse (Jens)
    kPID        = 0x100000,  // PIDqa (Jens)
    kHMPID      = 0x200000,  // HMPID QA (Giacomo Volpe)
    kT0         = 0x400000,  // T0 QA (Alla Mayevskaya)
    kFMD        = 0x800000,  // FMD QA (Christian Holm Christiansen)
    kDefaultModules  = (kVertex|kSymmetric|kVZERO|kTPC|kSPD|kSDD|kSSD|kITS|
			kITSSA|kITSAlign|kTRD|kZDC|kCALO|kMUONTRG|kBRes|
			kMUON|kTOF|kPIDRes|kPID|kHMPID|kT0|kFMD)
  };
    
    

  /** 
   * Constructor.  Date and time must be specified when running this
   * in Termiante mode on Grid
   * 
   * @param name     Name of train 
   * @param useCent  Whether to use centrality or not 
   * @param dateTime Append date and time to name
   * @param year     Year
   * @param month    Month 
   * @param day      Day
   * @param hour     Hour 
   * @param min      Minutes
   */
  QATrain(UInt_t      run  = 0,
	  UShort_t    flags = kDefaultFlags, 
	  UInt_t      modules = kDefaultModules)
    : TrainSetup("PilotAnalysis", false, 0, 0, 0, 0, 0), 
      fRun(run),
      fFlags(flags), 
      fModules(modules), 
      fTriggerMask(AliVEvent::kAnyINT), 
      fTriggerHM(AliVEvent::kHighMult),
      fTriggerEMC(AliVEvent::kEMC7), 
      fTriggerMUONBarrel(AliVEvent::kMUU7),
      fCollisionType(0) // 0: pp, 1: PbPb
  {}
  //__________________________________________________________________
  /** 
   * Run this analysis 
   * 
   * @param mode     Mode
   * @param oper     Operation
   * @param nEvents  Number of events (negative means all)
   * @param mc       If true, assume simulated events 
   * @param par      IF true, use par files 
   */
  void Run(const char* oper, 
	   Int_t nEvents=-1, Bool_t mc=false, Bool_t par=false)
  {
    Exec("ESD", "Local", oper, nEvents, mc, par);
  }
  //__________________________________________________________________
  /** 
   * Run this analysis 
   * 
   * @param mode     Mode
   * @param oper     Operation
   * @param nEvents  Number of events (negative means all)
   * @param mc       If true, assume simulated events 
   * @param par      IF true, use par files 
   */
  void Run(EOper oper, Int_t nEvents=-1, Bool_t mc=false,
	   Bool_t par=false)
  {
    Exec(kESD, kLocal, oper, nEvents, mc, par);
  }
protected:
  AliVEventHandler* CreateInputHandler(EType type)
  {
    if (type != kESD) return 0;
    AliAnalysisManager::GetAnalysisManager()->SetRunFromPath(fRun);
    
    AliESDInputHandlerRP* ih = new AliESDInputHandlerRP();
    ih->SetReadFriends(kTRUE);
    ih->SetActiveBranches("ESDfriend");
    return ih;
  }
  AliAnalysisTaskSE* CreateTaskAndSetCollisionCandidates(const char* macro)
  {
    Long_t ret = gROOT->Macro(macro);
    if (!ret) return 0;
    AliAnalysisTaskSE* task = reinterpret_cast<AliAnalysisTaskSE*>(ret);
    task->SelectCollisionCandidates(fTriggerMask);
    return task;
  }
  void CreateCDBConnect()
  {                                 
    ::Info("CreateCDBConnect", "Loading CDB connect w/run=%d", fRun);
    Long_t ret = gROOT->Macro(Form("AddTaskCDBconnect.C(%d)", fRun));
    ::Info("CreateCDBConnect", "Loaded %p", fRun);
    if (!ret) return;
    AliCDBManager::Instance()->SetDefaultStorage("raw://");
  }
  void CreatePhysicsSelection(Bool_t mc,
			      AliAnalysisManager* mgr)
  {
    // Event Statistics (Jan Fiete)
    if (!(fFlags & kEventStats)) return;
    TrainSetup::CreatePhysicsSelection(mc, mgr);
  }
  void CreateCentralitySelection(Bool_t mc, AliAnalysisManager* mgr)
  {
    // Centrality (A. Toia)
    if (!(fFlags & kCentrality)) return;
    TrainSetup::CreateCentralitySelection(mc, mgr);
  } 
  void CreateVertex()
  {
    // Vertexing (A. Dainese)
    gROOT->Macro(Form("AddTaskVertexESD.C(kFALSE,0x%x)", fTriggerMask));
  }
  void CreateSymmetric()
  {
    // TPC QA (E. Sicking)
    gROOT->Macro(Form("AddTaskQAsym.C(0,0x%x,0x%x,0x%x,0x%x)",
		      fTriggerMask, fTriggerHM, fTriggerEMC, 
		      fTriggerMUONBarrel));
  }
  void CreateVZERO()
  {
    //  VZERO QA  (C. Cheshkov)
    gROOT->Macro("AddTaskVZEROQA.C(0)");
  }
  void CreateTPC()
  {
    // TPC (Jacek Otwinowski & Michael Knichel)
    //
    // Optionally MC information can be used by setting the 1st
    // argument to true 
    // 
    // Optionally friends information can be switched off by setting
    // the 2st argument to false
    // 
    // Optionally highMult axis can be used by setting the 3st
    // argument to true (for PbPb)
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TPC/macros",
			     gROOT->GetMacroPath()));
    CreateTaskAndSetCollisionCandidates("AddTaskPerformanceTPCdEdxQA.C(kFALSE,kTRUE,kFALSE)");
  }
  void CreateSPD()
  {
    // SPD (A. Mastroserio)
    CreateTaskAndSetCollisionCandidates("AddTaskSPDQA.C");
    // AliAnalysisTask* task = 
    //   CreateTaskAndSetCollisionCandidates("AddTaskSPDQA.C");
    // if (!task) return;
    // task->SetOCDBInfo(fRun, "raw://");
  }
  void CreateSDD()
  {
    // SDD (F. Prino)
    CreateTaskAndSetCollisionCandidates("AddSDDPoints.C");
  }
  void CreateSSD()
  {
    // SSD dEdx (Marek Chojnacki)
    CreateTaskAndSetCollisionCandidates("AddTaskdEdxSSDQA.C");
  }
  void CreateITS()
  {
    gROOT->Macro("AddTaskPerformanceITS.C(kFALSE)");
    if (fCollisionType == 0) return;

    gROOT->ProcessLine("AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,3500,10000)");
    gROOT->ProcessLine("AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,590,1570)");
    gROOT->ProcessLine("AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,70,310)");
  }
  void CreateITSSA() 
  {
    // ITS saTracks, align (F.Prino)
    CreateTaskAndSetCollisionCandidates("AddTaskITSsaTracks.C(kFALSE,kFALSE)");
  }
  void CreateITSAlign()
  {
    // ITS saTracks, align (F.Prino)
    gROOT->Macro("AddTaskITSAlign.C(0,2011");
  }
  void CreateTRD()
  {
    // TRD (Alex Bercuci, M. Fasel) 
    gSystem->AddIncludePath("-I${ALICE_ROOT}/PWGPP/TRD");
    gROOT->Macro("AddTrainPerformanceTRD.C(\"ESD DET EFF RES PID\")"); 
  }
  void CreateZDC()
  {
    // ZDC (Chiara Oppedisano)
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/ZDC",
			     gROOT->GetMacroPath()));
    CreateTaskAndSetCollisionCandidates("AddTaskZDCQA.C");
  }
  void CreateCALO(EMode mode, Bool_t par)
  {
    // Calorimetry (Gustavo Conesa)
    LoadLibrary("EMCALUtils", mode, par, true);
    LoadLibrary("PHOSUtils", mode, par, true);
    LoadLibrary("PWG4PartCorrBase", mode, par, true);
    LoadLibrary("PWG4PartCorrDep", mode, par, true);
    
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG4/macros/QA",
			     gROOT->GetMacroPath()));
    CreateTaskAndSetCollisionCandidates("AddTaskCalorimeterQA.C(\"ESD\",20011,kFALSE,kFALSE)");
    Long_t ret = gROOT->ProcessLine("AddTaskCalorimeterQA(\"ESD\",2011,kFALSE,kFALSE,\"\",\"EMC7\")");
    if (!ret) return;
    AliAnalysisTaskSE* task = reinterpret_cast<AliAnalysisTaskSE*>(ret);
    task->SelectCollisionCandidates(fTriggerEMC);
  }
  void CreateMUONTRG(EMode mode, Bool_t par)
  {
    // Muon Trigger
    LoadLibrary("PWG3base", mode, par, true);
    LoadLibrary("PWG3muon", mode, par, true);
    LoadLibrary("PWG3muondep", mode, par, true);
    
    gROOT->Macro("AddTaskMTRchamberEfficiency.C");
  }
  void CreateMUONEff()
  {
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG3/muondep",
			     gROOT->GetMacroPath()));
    gROOT->Macro("AddTaskMUONTrackingEfficiency.C");
  }
  void CreateV0()
  {
    // V0-Decay Reconstruction (Ana Marin) (not used)
    gROOT->Macro("AddTaskV0QA.C(kFALSE)");
  }
  void CreateBRes()
  {
    // Impact parameter resolution (xianbao.yuan@pd.infn.it,
    // andrea.dainese@pd.infn.it) 
    CreateTaskAndSetCollisionCandidates(Form("AddTaskImpParRes.C(%s)", 
					     fCollisionType == 0 ? 
					     "" : 
					     "kFALSE,-1,kFALSE,kFALSE"));
  }
  void CreateMUON(EMode mode, Bool_t par)
  {
    // MUON QA (Philippe Pillot)
    LoadLibrary("PWG3base", mode, par, true);
    LoadLibrary("PWG3muon", mode, par, true);
    LoadLibrary("PWG3muondep", mode, par, true);
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG3/muon",
			     gROOT->GetMacroPath()));
    gROOT->Macro("AddTaskMuonQA.C");
  }
  void CreateTOF()
  {
    // TOF (Francesca Bellini)
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TOF",
			     gROOT->GetMacroPath()));
    CreateTaskAndSetCollisionCandidates("AddTaskTOFQA.C");
  }
  void CreatePIDRes()
  {
    // PIDResponse (Jens)
    CreateTaskAndSetCollisionCandidates("AddTaskPIDResponse.C");
  }

  void CreatePID()
  {
    // PIDqa (Jens)
    CreateTaskAndSetCollisionCandidates("AddTaskPIDqa.C");
  }
  void CreateHMPID()
  {
    // HMPID QA (Giacomo Volpe)
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/HMPID",
			     gROOT->GetMacroPath()));
    CreateTaskAndSetCollisionCandidates("AddTaskHmpidQA.C");
  }
  void CreateT0()
  {
    // T0 QA (Alla Mayevskaya)
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/T0",
			     gROOT->GetMacroPath()));
    CreateTaskAndSetCollisionCandidates("AddTaskT0QA.C");
  }
  void CreateFMD(EMode mode, Bool_t par)
  {
    // FMD QA (Christian Holm Christiansen)
    LoadLibrary("PWG2forward2", mode, par, true);
    Bool_t mc = AliAnalysisManager::GetAnalysisManager()
      ->GetMCtruthEventHandler() != 0;
    gROOT->Macro(Form("AddTaskForwardQA.C(%d,%d)", mc, (fFlags & kCentrality)));
  }
  //__________________________________________________________________
  /** 
   * Create the tasks 
   * 
   * @param mode Processing mode
   * @param par  Whether to use par files 
   * @param mgr  Analysis manager 
   */
  void CreateTasks(EMode mode, Bool_t par, AliAnalysisManager* mgr)
  {
    // --- Output file name ------------------------------------------
    AliAnalysisManager::SetCommonFileName("QAResults.root");

    LoadLibrary("CORRFW", mode, par);
    LoadLibrary("TENDER", mode, par);
    LoadLibrary("PWG0base", mode, par);
    LoadLibrary("PWG0dep", mode, par);
    LoadLibrary("PWG0selectors", mode, par);
    LoadLibrary("PWGPP", mode, par);    

    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/PilotTrain"
			     ":$(ALICE_ROOT)/PWGPP/macros",
			     gROOT->GetMacroPath()));   
 
    mgr->AddStatisticsTask(fTriggerMask);
    if (fFlags   & kCDBConnect) CreateCDBConnect();
    if (fModules & kVertex)     CreateVertex();
    if (fModules & kSymmetric)  CreateSymmetric();
    if (fModules & kVZERO)      CreateVZERO();
    if (fModules & kTPC)        CreateTPC();
    if (fModules & kSPD)        CreateSPD();
    if (fModules & kSDD)        CreateSDD();
    if (fModules & kSSD)        CreateSSD();
    if (fModules & kITS)        CreateITS();
    if (fModules & kITSSA)      CreateITSSA();
    if (fModules & kITSAlign)   CreateITSAlign();
    if (fModules & kTRD)        CreateTRD(); 
    if (fModules & kZDC)        CreateZDC(); 
    if (fModules & kCALO)       CreateCALO(mode, par); 
    if (fModules & kMUONTRG)    CreateMUONTRG(mode, par); 
    if (fModules & kMUONEff)    CreateMUONEff(); 
    if (fModules & kV0)         CreateV0(); 
    if (fModules & kBRes)       CreateBRes(); 
    if (fModules & kMUON)       CreateMUON(mode, par); 
    if (fModules & kTOF)        CreateTOF(); 
    if (fModules & kPIDRes)     CreatePIDRes(); 
    if (fModules & kPID)        CreatePID(); 
    if (fModules & kHMPID)      CreateHMPID(); 
    if (fModules & kT0)         CreateT0(); 
    if (fModules & kFMD)        CreateFMD(mode, par); 
  }
  /** 
   * Crete output handler - we don't want one here. 
   * 
   * @return 0
   */
  AliVEventHandler* CreateOutputHandler(EType) { return 0; }
  UInt_t   fRun; // Run number 
  UShort_t fFlags; // Flags 
  UInt_t   fModules; // Modules to load 
  UInt_t   fTriggerMask; 
  UInt_t   fTriggerHM;
  UInt_t   fTriggerEMC;
  UInt_t   fTriggerMUONBarrel;
  UShort_t fCollisionType; // 0: pp, 1: PbPb 
  
  
  Bool_t fUseCent; // Whether to use centrality or not 
};

//
// EOF
//
Commit	Line	Data
37d558fc	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)
2bfe5463	180	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TPC/macros",
37d558fc	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)
2bfe5463	225	gSystem->AddIncludePath("-I${ALICE_ROOT}/PWGPP/TRD");
37d558fc	226	gROOT->Macro("AddTrainPerformanceTRD.C(\"ESD DET EFF RES PID\")");
	227	}
	228	void CreateZDC()
	229	{
	230	// ZDC (Chiara Oppedisano)
2bfe5463	231	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/ZDC",
37d558fc	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)
2bfe5463	293	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TOF",
37d558fc	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)
2bfe5463	311	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/HMPID",
37d558fc	312	gROOT->GetMacroPath()));
	313	CreateTaskAndSetCollisionCandidates("AddTaskHmpidQA.C");
	314	}
	315	void CreateT0()
	316	{
	317	// T0 QA (Alla Mayevskaya)
2bfe5463	318	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/T0",
37d558fc	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);
2bfe5463	348	LoadLibrary("PWGPP", mode, par);
37d558fc	349
2bfe5463	350	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/PilotTrain"
2bfe5463	351	":$(ALICE_ROOT)/PWGPP/macros",
37d558fc	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	//