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

/**
 * @file   QATrain.C
 * @author Christian Holm Christensen <cholm@master.hehi.nbi.dk>
 * @date   Fri Jun  1 13:55:50 2012
 * 
 * @brief  
 * 
 * 
 * @ingroup pwglf_forward_trains_examples
 */

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

//====================================================================
/**
 * Analysis train to do full Quality Assurance train
 * 
 * @ingroup pwglf_forward_trains_examples
 */
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 
   */
  QATrain(const char* name="PilotAnalysis")
    : TrainSetup(name, false, 0, 0, 0, 0, 0), 
      fRun(0),
      fFlags(kDefaultFlags), 
      fModules(kDefaultModules), 
      fTriggerMask(AliVEvent::kAnyINT), 
      fTriggerHM(AliVEvent::kHighMult),
      fTriggerEMC(AliVEvent::kEMC7), 
      fTriggerMUONBarrel(AliVEvent::kMUU7),
      fCollisionType(0) // 0: pp, 1: PbPb
  {}
  void SetFlags(UShort_t flags) { fFlags = flags; }
  void SetRun(UInt_t run) { fRun = run; }
  void SetModules(UInt_t m) { fModules = m; }
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,
							 const char* args="")
  {
    AliAnalysisTaskSE* task = CoupleSECar(macro, args);
    if (task) task->SelectCollisionCandidates(fTriggerMask);
    return task;
  }
  void CreateCDBConnect()
  {                                 
    ::Info("CreateCDBConnect", "Loading CDB connect w/run=%d", fRun);
    AliAnalysisTask* task = CoupleCar("AddTaskCDBconnect.C", Form("%d", fRun));
    ::Info("CreateCDBConnect", "Loaded %p", task);
    if (!task) 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)
    CoupleCar("AddTaskVertexESD.C", Form("kFALSE,0x%x", fTriggerMask));
  }
  void CreateSymmetric()
  {
    // TPC QA (E. Sicking)
    CoupleCar("AddTaskQAsym.C", Form("0,0x%x,0x%x,0x%x,0x%x",
				     fTriggerMask, fTriggerHM, fTriggerEMC, 
				     fTriggerMUONBarrel));
  }
  void CreateVZERO()
  {
    //  VZERO QA  (C. Cheshkov)
    CoupleCar("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()
  {
    CoupleCar("AddTaskPerformanceITS.C","false");
    if (fCollisionType == 0) return;

    gROOT->ProcessLine("AddTaskPerformanceITS(false,false,false,3500,10000)");
    gROOT->ProcessLine("AddTaskPerformanceITS(false,false,false,590,1570)");
    gROOT->ProcessLine("AddTaskPerformanceITS(false,false,false,70,310)");
  }
  void CreateITSSA() 
  {
    // ITS saTracks, align (F.Prino)
    CreateTaskAndSetCollisionCandidates("AddTaskITSsaTracks.C",
					"false,false)");
  }
  void CreateITSAlign()
  {
    // ITS saTracks, align (F.Prino)
    CoupleCar("AddTaskITSAlign.C","0,2011");
  }
  void CreateTRD()
  {
    // TRD (Alex Bercuci, M. Fasel) 
    gSystem->AddIncludePath("-I${ALICE_ROOT}/PWGPP/TRD");
    CoupleCar("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,false,false)");
    Long_t ret = 
      gROOT->ProcessLine("AddTaskCalorimeterQA(\"ESD\",2011,false,false,\"\",\"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);
    
    CoupleCar("AddTaskMTRchamberEfficiency.C");
  }
  void CreateMUONEff()
  {
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG3/muondep",
			     gROOT->GetMacroPath()));
    CoupleCar("AddTaskMUONTrackingEfficiency.C");
  }
  void CreateV0()
  {
    // V0-Decay Reconstruction (Ana Marin) (not used)
    CoupleCar("AddTaskV0QA.C","false");
  }
  void CreateBRes()
  {
    // Impact parameter resolution (xianbao.yuan@pd.infn.it,
    // andrea.dainese@pd.infn.it) 
    CreateTaskAndSetCollisionCandidates(Form("AddTaskImpParRes.C", 
					     fCollisionType == 0 ? 
					     "" : 
					     "false,-1,false,false"));
  }
  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()));
    CoupleCar("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("PWGLFforward2", mode, par, true);
    Bool_t mc = AliAnalysisManager::GetAnalysisManager()
      ->GetMCtruthEventHandler() != 0;
    CoupleCar("AddTaskForwardQA.C", Form("(%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
fdfd93b4	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	*
33438b4c	9	* @ingroup pwglf_forward_trains_examples
fdfd93b4	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	*
33438b4c	20	* @ingroup pwglf_forward_trains_examples
fdfd93b4	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	}
ba144d92	97	AliAnalysisTaskSE* CreateTaskAndSetCollisionCandidates(const char* macro,
ba144d92	98	const char* args="")
fdfd93b4	99	{
ba144d92	100	AliAnalysisTaskSE* task = CoupleSECar(macro, args);
ba144d92	101	if (task) task->SelectCollisionCandidates(fTriggerMask);
fdfd93b4	102	return task;
	103	}
	104	void CreateCDBConnect()
	105	{
	106	::Info("CreateCDBConnect", "Loading CDB connect w/run=%d", fRun);
ba144d92	107	AliAnalysisTask* task = CoupleCar("AddTaskCDBconnect.C", Form("%d", fRun));
	108	::Info("CreateCDBConnect", "Loaded %p", task);
	109	if (!task) return;
fdfd93b4	110	AliCDBManager::Instance()->SetDefaultStorage("raw://");
	111	}
	112	void CreatePhysicsSelection(Bool_t mc,
	113	AliAnalysisManager* mgr)
	114	{
	115	// Event Statistics (Jan Fiete)
	116	if (!(fFlags & kEventStats)) return;
	117	TrainSetup::CreatePhysicsSelection(mc, mgr);
	118	}
	119	void CreateCentralitySelection(Bool_t mc, AliAnalysisManager* mgr)
	120	{
	121	// Centrality (A. Toia)
	122	if (!(fFlags & kCentrality)) return;
	123	TrainSetup::CreateCentralitySelection(mc, mgr);
	124	}
	125	void CreateVertex()
	126	{
	127	// Vertexing (A. Dainese)
ba144d92	128	CoupleCar("AddTaskVertexESD.C", Form("kFALSE,0x%x", fTriggerMask));
fdfd93b4	129	}
	130	void CreateSymmetric()
	131	{
	132	// TPC QA (E. Sicking)
ba144d92	133	CoupleCar("AddTaskQAsym.C", Form("0,0x%x,0x%x,0x%x,0x%x",
	134	fTriggerMask, fTriggerHM, fTriggerEMC,
	135	fTriggerMUONBarrel));
fdfd93b4	136	}
	137	void CreateVZERO()
	138	{
	139	// VZERO QA (C. Cheshkov)
ba144d92	140	CoupleCar("AddTaskVZEROQA.C", "0");
fdfd93b4	141	}
	142	void CreateTPC()
	143	{
	144	// TPC (Jacek Otwinowski & Michael Knichel)
	145	//
	146	// Optionally MC information can be used by setting the 1st
	147	// argument to true
	148	//
	149	// Optionally friends information can be switched off by setting
	150	// the 2st argument to false
	151	//
	152	// Optionally highMult axis can be used by setting the 3st
	153	// argument to true (for PbPb)
	154	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TPC/macros",
	155	gROOT->GetMacroPath()));
ba144d92	156	CreateTaskAndSetCollisionCandidates("AddTaskPerformanceTPCdEdxQA.C",
ba144d92	157	"kFALSE,kTRUE,kFALSE");
fdfd93b4	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	{
ba144d92	180	CoupleCar("AddTaskPerformanceITS.C","false");
fdfd93b4	181	if (fCollisionType == 0) return;
fdfd93b4	182
ba144d92	183	gROOT->ProcessLine("AddTaskPerformanceITS(false,false,false,3500,10000)");
	184	gROOT->ProcessLine("AddTaskPerformanceITS(false,false,false,590,1570)");
	185	gROOT->ProcessLine("AddTaskPerformanceITS(false,false,false,70,310)");
fdfd93b4	186	}
	187	void CreateITSSA()
	188	{
	189	// ITS saTracks, align (F.Prino)
ba144d92	190	CreateTaskAndSetCollisionCandidates("AddTaskITSsaTracks.C",
ba144d92	191	"false,false)");
fdfd93b4	192	}
	193	void CreateITSAlign()
	194	{
	195	// ITS saTracks, align (F.Prino)
ba144d92	196	CoupleCar("AddTaskITSAlign.C","0,2011");
fdfd93b4	197	}
	198	void CreateTRD()
	199	{
	200	// TRD (Alex Bercuci, M. Fasel)
	201	gSystem->AddIncludePath("-I${ALICE_ROOT}/PWGPP/TRD");
ba144d92	202	CoupleCar("AddTrainPerformanceTRD.C","\"ESD DET EFF RES PID\"");
fdfd93b4	203	}
	204	void CreateZDC()
	205	{
	206	// ZDC (Chiara Oppedisano)
	207	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/ZDC",
	208	gROOT->GetMacroPath()));
	209	CreateTaskAndSetCollisionCandidates("AddTaskZDCQA.C");
	210	}
	211	void CreateCALO(EMode mode, Bool_t par)
	212	{
	213	// Calorimetry (Gustavo Conesa)
	214	LoadLibrary("EMCALUtils", mode, par, true);
	215	LoadLibrary("PHOSUtils", mode, par, true);
	216	LoadLibrary("PWG4PartCorrBase", mode, par, true);
	217	LoadLibrary("PWG4PartCorrDep", mode, par, true);
	218
	219	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG4/macros/QA",
	220	gROOT->GetMacroPath()));
ba144d92	221	CreateTaskAndSetCollisionCandidates("AddTaskCalorimeterQA.C",
	222	"\"ESD\",20011,false,false)");
	223	Long_t ret =
	224	gROOT->ProcessLine("AddTaskCalorimeterQA(\"ESD\",2011,false,false,\"\",\"EMC7\")");
fdfd93b4	225	if (!ret) return;
	226	AliAnalysisTaskSE* task = reinterpret_cast<AliAnalysisTaskSE*>(ret);
	227	task->SelectCollisionCandidates(fTriggerEMC);
	228	}
	229	void CreateMUONTRG(EMode mode, Bool_t par)
	230	{
	231	// Muon Trigger
	232	LoadLibrary("PWG3base", mode, par, true);
	233	LoadLibrary("PWG3muon", mode, par, true);
	234	LoadLibrary("PWG3muondep", mode, par, true);
	235
ba144d92	236	CoupleCar("AddTaskMTRchamberEfficiency.C");
fdfd93b4	237	}
	238	void CreateMUONEff()
	239	{
	240	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG3/muondep",
	241	gROOT->GetMacroPath()));
ba144d92	242	CoupleCar("AddTaskMUONTrackingEfficiency.C");
fdfd93b4	243	}
	244	void CreateV0()
	245	{
	246	// V0-Decay Reconstruction (Ana Marin) (not used)
ba144d92	247	CoupleCar("AddTaskV0QA.C","false");
fdfd93b4	248	}
	249	void CreateBRes()
	250	{
	251	// Impact parameter resolution (xianbao.yuan@pd.infn.it,
	252	// andrea.dainese@pd.infn.it)
ba144d92	253	CreateTaskAndSetCollisionCandidates(Form("AddTaskImpParRes.C",
fdfd93b4	254	fCollisionType == 0 ?
fdfd93b4	255	"" :
ba144d92	256	"false,-1,false,false"));
fdfd93b4	257	}
	258	void CreateMUON(EMode mode, Bool_t par)
	259	{
	260	// MUON QA (Philippe Pillot)
	261	LoadLibrary("PWG3base", mode, par, true);
	262	LoadLibrary("PWG3muon", mode, par, true);
	263	LoadLibrary("PWG3muondep", mode, par, true);
	264	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG3/muon",
	265	gROOT->GetMacroPath()));
ba144d92	266	CoupleCar("AddTaskMuonQA.C");
fdfd93b4	267	}
	268	void CreateTOF()
	269	{
	270	// TOF (Francesca Bellini)
	271	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TOF",
	272	gROOT->GetMacroPath()));
	273	CreateTaskAndSetCollisionCandidates("AddTaskTOFQA.C");
	274	}
	275	void CreatePIDRes()
	276	{
	277	// PIDResponse (Jens)
	278	CreateTaskAndSetCollisionCandidates("AddTaskPIDResponse.C");
	279	}
	280
	281	void CreatePID()
	282	{
	283	// PIDqa (Jens)
	284	CreateTaskAndSetCollisionCandidates("AddTaskPIDqa.C");
	285	}
	286	void CreateHMPID()
	287	{
	288	// HMPID QA (Giacomo Volpe)
	289	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/HMPID",
	290	gROOT->GetMacroPath()));
	291	CreateTaskAndSetCollisionCandidates("AddTaskHmpidQA.C");
	292	}
	293	void CreateT0()
	294	{
	295	// T0 QA (Alla Mayevskaya)
	296	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/T0",
	297	gROOT->GetMacroPath()));
	298	CreateTaskAndSetCollisionCandidates("AddTaskT0QA.C");
	299	}
	300	void CreateFMD(EMode mode, Bool_t par)
	301	{
	302	// FMD QA (Christian Holm Christiansen)
	303	LoadLibrary("PWGLFforward2", mode, par, true);
	304	Bool_t mc = AliAnalysisManager::GetAnalysisManager()
	305	->GetMCtruthEventHandler() != 0;
ba144d92	306	CoupleCar("AddTaskForwardQA.C", Form("(%d,%d)",mc,(fFlags & kCentrality)));
fdfd93b4	307	}
	308	//__________________________________________________________________
	309	/**
	310	* Create the tasks
	311	*
	312	* @param mode Processing mode
	313	* @param par Whether to use par files
	314	* @param mgr Analysis manager
	315	*/
	316	void CreateTasks(EMode mode, Bool_t par, AliAnalysisManager* mgr)
	317	{
	318	// --- Output file name ------------------------------------------
	319	AliAnalysisManager::SetCommonFileName("QAResults.root");
	320
	321	LoadLibrary("CORRFW", mode, par);
	322	LoadLibrary("TENDER", mode, par);
	323	LoadLibrary("PWG0base", mode, par);
	324	LoadLibrary("PWG0dep", mode, par);
	325	LoadLibrary("PWG0selectors", mode, par);
	326	LoadLibrary("PWGPP", mode, par);
	327
	328	gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/PilotTrain"
	329	":$(ALICE_ROOT)/PWGPP/macros",
	330	gROOT->GetMacroPath()));
	331
	332	mgr->AddStatisticsTask(fTriggerMask);
	333	if (fFlags & kCDBConnect) CreateCDBConnect();
	334	if (fModules & kVertex) CreateVertex();
	335	if (fModules & kSymmetric) CreateSymmetric();
	336	if (fModules & kVZERO) CreateVZERO();
	337	if (fModules & kTPC) CreateTPC();
	338	if (fModules & kSPD) CreateSPD();
	339	if (fModules & kSDD) CreateSDD();
	340	if (fModules & kSSD) CreateSSD();
	341	if (fModules & kITS) CreateITS();
	342	if (fModules & kITSSA) CreateITSSA();
	343	if (fModules & kITSAlign) CreateITSAlign();
	344	if (fModules & kTRD) CreateTRD();
	345	if (fModules & kZDC) CreateZDC();
	346	if (fModules & kCALO) CreateCALO(mode, par);
	347	if (fModules & kMUONTRG) CreateMUONTRG(mode, par);
	348	if (fModules & kMUONEff) CreateMUONEff();
	349	if (fModules & kV0) CreateV0();
	350	if (fModules & kBRes) CreateBRes();
	351	if (fModules & kMUON) CreateMUON(mode, par);
	352	if (fModules & kTOF) CreateTOF();
	353	if (fModules & kPIDRes) CreatePIDRes();
	354	if (fModules & kPID) CreatePID();
	355	if (fModules & kHMPID) CreateHMPID();
	356	if (fModules & kT0) CreateT0();
	357	if (fModules & kFMD) CreateFMD(mode, par);
	358	}
	359	/**
	360	* Crete output handler - we don't want one here.
	361	*
	362	* @return 0
	363	*/
	364	AliVEventHandler* CreateOutputHandler(EType) { return 0; }
	365	UInt_t fRun; // Run number
	366	UShort_t fFlags; // Flags
	367	UInt_t fModules; // Modules to load
	368	UInt_t fTriggerMask;
	369	UInt_t fTriggerHM;
	370	UInt_t fTriggerEMC;
371	UInt_t fTriggerMUONBarrel;
372	UShort_t fCollisionType; // 0: pp, 1: PbPb
373
374
375	Bool_t fUseCent; // Whether to use centrality or not
376	};
377
378	//
379	// EOF
380	//