[u/mrichter/AliRoot.git] / MFT / AODtrain.C

// ### Settings that make sense when using the Alien plugin
//==============================================================================
Int_t       runOnData          = 0;       // Set to 1 if processing real data
Int_t       iCollision         = 0;       // 0=pp, 1=Pb-Pb
//==============================================================================
Bool_t      usePhysicsSelection = kTRUE; // use physics selection
Bool_t      useTender           = kFALSE; // use tender wagon
Bool_t      useCentrality       = kTRUE; // centrality
Bool_t      useV0tender         = kFALSE;  // use V0 correction in tender
Bool_t      useDBG              = kTRUE;  // activate debugging
Bool_t      useMC               = kTRUE;  // use MC info
Bool_t      useKFILTER          = kTRUE;  // use Kinematics filter
Bool_t      useTR               = kTRUE;  // use track references
Bool_t      useCORRFW           = kFALSE; // do not change
Bool_t      useAODTAGS          = kFALSE; // use AOD tags
Bool_t      useSysInfo          = kFALSE; // use sys info

// ### Analysis modules to be included. Some may not be yet fully implemented.
//==============================================================================
Int_t       iAODhandler        = 1;      // Analysis produces an AOD or dAOD's
Int_t       iESDMCLabelAddition= 0;
Int_t       iESDfilter         = 1;      // ESD to AOD filter (barrel + muon tracks)
Int_t       iMUONcopyAOD       = 1;      // Task that copies only muon events in a separate AOD (PWG3)
Int_t       iJETAN             = 0;      // Jet analysis (PWG4)
Int_t       iJETANdelta        = 0;      // Jet delta AODs
Int_t       iPWGHFvertexing     = 0;      // Vertexing HF task (PWG3)
Int_t       iPWGDQJPSIfilter    = 0;      // JPSI filtering (PWG3)
Int_t       iPWGHFd2h           = 0;      // D0->2 hadrons (PWG3)
Bool_t doPIDResponse  = 1;
Bool_t doPIDqa        = 1; //new

// ### Configuration macros used for each module
//==============================================================================
 TString configPWGHFd2h = (iCollision==0)?"$ALICE_ROOT/PWGHF/vertexingHF/ConfigVertexingHF.C"
                          :"$ALICE_ROOT/PWGHF/vertexingHF/ConfigVertexingHF_Pb_AllCent.C";
                                                 
// Temporaries.
class AliOADBPhysicsSelection;                                                                                                                  
AliOADBPhysicsSelection *CreateOADBphysicsSelection();
void AODmerge();
void AddAnalysisTasks(Int_t);
Bool_t LoadCommonLibraries();
Bool_t LoadAnalysisLibraries();
Bool_t LoadLibrary(const char *);
TChain *CreateChain();

//______________________________________________________________________________
void AODtrain(Int_t merge=0)
{
// Main analysis train macro.
   AliLog::SetGlobalDebugLevel(3);
  if (merge) {
    TGrid::Connect("alien://");
    if (!gGrid || !gGrid->IsConnected()) {
      ::Error("QAtrain", "No grid connection");
      return;
    }
  }
  // Set temporary merging directory to current one
  gSystem->Setenv("TMPDIR", gSystem->pwd());
  // Set temporary compilation directory to current one
  gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
   printf("==================================================================\n");
   printf("===========    RUNNING FILTERING TRAIN   ==========\n");
   printf("==================================================================\n");
   printf("=  Configuring analysis train for:                               =\n");
   if (usePhysicsSelection)   printf("=  Physics selection                                                =\n");
   if (useTender)    printf("=  TENDER                                                        =\n");
   if (iESDfilter)   printf("=  ESD filter                                                    =\n");
   if (iMUONcopyAOD) printf("=  MUON copy AOD                                                 =\n");
   if (iJETAN)       printf("=  Jet analysis                                                  =\n");
   if (iJETANdelta)  printf("=     Jet delta AODs                                             =\n");
   if (iPWGHFvertexing) printf("=  PWGHF vertexing                                                =\n");
   if (iPWGDQJPSIfilter) printf("=  PWGDQ j/psi filter                                             =\n");
   if (iPWGHFd2h) printf("=  PWGHF D0->2 hadrons QA                                     =\n");

   // Load common libraries and set include path
   if (!LoadCommonLibraries()) {
      ::Error("AnalysisTrain", "Could not load common libraries");
      return;
   }
    
   // Make the analysis manager and connect event handlers
   AliAnalysisManager *mgr  = new AliAnalysisManager("Analysis Train", "Production train");
   if (useSysInfo) mgr->SetNSysInfo(100);
   // Load analysis specific libraries
   if (!LoadAnalysisLibraries()) {
      ::Error("AnalysisTrain", "Could not load analysis libraries");
      return;
   }   

   // Create input handler (input container created automatically)
   // ESD input handler
   AliESDInputHandler *esdHandler = new AliESDInputHandler();
   mgr->SetInputEventHandler(esdHandler);       
   // Monte Carlo handler
   if (useMC) {
      AliMCEventHandler* mcHandler = new AliMCEventHandler();
      mgr->SetMCtruthEventHandler(mcHandler);
      mcHandler->SetReadTR(useTR); 
   }   
   // AOD output container, created automatically when setting an AOD handler
   if (iAODhandler) {
      // AOD output handler
      AliAODHandler* aodHandler   = new AliAODHandler();
      aodHandler->SetOutputFileName("AliAOD.root");
      mgr->SetOutputEventHandler(aodHandler);
   }
   // Debugging if needed
   if (useDBG) mgr->SetDebugLevel(3);

   AddAnalysisTasks(merge);
   if (merge) {
      AODmerge();
      mgr->InitAnalysis();
      mgr->SetGridHandler(new AliAnalysisAlien);
      mgr->StartAnalysis("gridterminate",0);
      return;
   }   
   // Run the analysis                                                                                                                     
   //
   TChain *chain = CreateChain();
   if (!chain) return;
                                                                                                                                                   
   TStopwatch timer;
   timer.Start();
   mgr->SetSkipTerminate(kTRUE);
   if (mgr->InitAnalysis()) {
      mgr->PrintStatus();
      mgr->StartAnalysis("local", chain);
   }
   timer.Print();
}                                                                                                                                          
                                                                                                                                            
//______________________________________________________________________________                                                           
void AddAnalysisTasks(Int_t merge){                                                                                                                                          
  // Add all analysis task wagons to the train                                                                                               
   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();                                                                     

  //
  // Tender and supplies. Needs to be called for every event.
  //
   AliAnalysisManager::SetCommonFileName("AODQA.root");
   if (useTender) {
      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/TenderSupplies/AddTaskTender.C");
      // IF V0 tender needed, put kTRUE below
      AliAnalysisTaskSE *tender = AddTaskTender(useV0tender);
//      tender->SetDebugLevel(2);
   }

   if (usePhysicsSelection) {
   // Physics selection task
      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
      mgr->RegisterExtraFile("event_stat.root");
      AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(kFALSE);
//      AliOADBPhysicsSelection * oadbDefaultPbPb = CreateOADBphysicsSelection();      
//      physSelTask->GetPhysicsSelection()->SetCustomOADBObjects(oadbDefaultPbPb,0,0);
//      if (!merge) mgr->AddStatisticsTask(AliVEvent::kAny);
   }
   // Centrality (only Pb-Pb)
   if (iCollision && useCentrality) {
      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
      AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
      taskCentrality->SelectCollisionCandidates(AliVEvent::kAny);
   }

	if(iESDMCLabelAddition) {
    		gROOT->LoadMacro("$ALICE_ROOT/PWG/muondep/AddTaskESDMCLabelAddition.C");
    		AliAnalysisTaskESDMCLabelAddition *esdmclabel = AddTaskESDMCLabelAddition(kFALSE);
	}
	
   if (iESDfilter) {
      //  ESD filter task configuration.
      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");	
      if (iMUONcopyAOD) {
         printf("Registering delta AOD file\n");
         mgr->RegisterExtraFile("AliAOD.Muons.root");
         mgr->RegisterExtraFile("AliAOD.Dimuons.root");
	 AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, kTRUE, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,kTRUE,kTRUE,kTRUE,1100,1);
      } else {
    AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, kFALSE, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,kTRUE,kTRUE,kTRUE,1100,1);
      }   
   }   

// ********** PWG3 wagons ******************************************************           
   // PWGHF vertexing
   if (iPWGHFvertexing) {
      gROOT->LoadMacro("$ALICE_ROOT/PWGHF/vertexingHF/macros/AddTaskVertexingHF.C");
      if (!iPWGHFd2h) TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
      AliAnalysisTaskSEVertexingHF *taskvertexingHF = AddTaskVertexingHF();
      if (!taskvertexingHF) ::Warning("AnalysisTrainNew", "AliAnalysisTaskSEVertexingHF cannot run for this train conditions - EXCLUDED");
      else mgr->RegisterExtraFile("AliAOD.VertexingHF.root");
      taskvertexingHF->SelectCollisionCandidates(0);
   }   
      
   // PWGDQ JPSI filtering (only pp)
   if (iPWGDQJPSIfilter && (iCollision==0)) {
      gROOT->LoadMacro("$ALICE_ROOT/PWGDQ/dielectron/macros/AddTaskJPSIFilter.C");
      AliAnalysisTaskSE *taskJPSIfilter = AddTaskJPSIFilter();
      if (!taskJPSIfilter) ::Warning("AnalysisTrainNew", "AliAnalysisTaskDielectronFilter cannot run for this train conditions - EXCLUDED");
      else mgr->RegisterExtraFile("AliAOD.Dielectron.root");
      taskJPSIfilter->SelectCollisionCandidates(0);
   }   

   // PWGHF D2h
   if (iPWGHFd2h) {   
     gROOT->LoadMacro("$ALICE_ROOT/PWGHF/vertexingHF/AddD2HTrain.C");
     TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
     AddD2HTrain(kFALSE, 1,0,0,0,0,0,0,0,0,0,0);                                 
   }
   
   // ********** PWG4 wagons ******************************************************
   // Jet analysis

   // Configurations flags, move up?
   TString kDeltaAODJetName = "AliAOD.Jets.root"; //
   Bool_t  kIsPbPb = (iCollision==0)?false:true; // can be more intlligent checking the name of the data set
   TString kDefaultJetBackgroundBranch = "";
   TString kJetSubtractBranches = "";
   UInt_t kHighPtFilterMask = 128;// from esd filter
   UInt_t iPhysicsSelectionFlag = AliVEvent::kMB;
   if (iJETAN) {
     gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJets.C");
     // Default jet reconstructor running on ESD's
     AliAnalysisTaskJets *taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction     
     if (!taskjets) ::Fatal("AnalysisTrainNew", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
     if(kDeltaAODJetName.Length()>0) taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
     if (iJETANdelta) {
        //            AddTaskJetsDelta("AliAOD.Jets.root"); // need to modify this accordingly in the add task jets
        mgr->RegisterExtraFile(kDeltaAODJetName.Data());
        TString cTmp("");
        if(kIsPbPb){
          // UA1 intrinsic background subtraction
          taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
          if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
       }
       // SICONE 
       taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtration to be done later....                                                                                  
       if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
       cTmp = taskjets->GetNonStdBranch();
       if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data());
	 
       // Add the clusters..
       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCluster.C");
       AliAnalysisTaskJetCluster *taskCl = 0;
       Float_t fCenUp = 0;
       Float_t fCenLo = 0;
       Float_t fTrackEtaWindow = 0.9;
       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip                                                                                 
       taskCl->SetBackgroundCalc(kTRUE);
       taskCl->SetNRandomCones(10);
       taskCl->SetCentralityCut(fCenLo,fCenUp);
       taskCl->SetGhostEtamax(fTrackEtaWindow);
       kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());

       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
       taskCl->SetCentralityCut(fCenLo,fCenUp);
       if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
       taskCl->SetNRandomCones(10);
       kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());

       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
       taskCl->SetCentralityCut(fCenLo,fCenUp);
       if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
       kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
	 
       // DO THE BACKGROUND SUBTRACTION
       if(kIsPbPb&&kJetSubtractBranches.Length()){
         gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetBackgroundSubtract.C");
         AliAnalysisTaskJetBackgroundSubtract *taskSubtract = 0;
         taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,1,"B0","B%d");
         taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
         if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
       }
     } 
   }
}

//______________________________________________________________________________
Bool_t LoadCommonLibraries()
{
// Load common analysis libraries.
   if (!gSystem->Getenv("ALICE_ROOT")) {
      ::Error("AnalysisTrainNew.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot"); 
      return kFALSE;
   }   
   Bool_t success = kTRUE;
   // Load framework classes. Par option ignored here.
   success &= LoadLibrary("libSTEERBase.so");
   success &= LoadLibrary("libESD.so");
   success &= LoadLibrary("libAOD.so");
   success &= LoadLibrary("libANALYSIS.so");
   success &= LoadLibrary("libOADB.so");
   success &= LoadLibrary("libANALYSISalice.so");
   success &= LoadLibrary("libCORRFW.so");
   gROOT->ProcessLine(".include $ALICE_ROOT/include");
   if (success) {
      ::Info("AnalysisTrainNew.C::LoadCommodLibraries", "Load common libraries:    SUCCESS");
      ::Info("AnalysisTrainNew.C::LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
              gSystem->GetIncludePath());
   } else {           
      ::Info("AnalysisTrainNew.C::LoadCommodLibraries", "Load common libraries:    FAILED");
   }   
   return success;
}

//______________________________________________________________________________
Bool_t LoadAnalysisLibraries()
{
// Load common analysis libraries.
   if (useTender) {
      if (!LoadLibrary("TENDER") ||
          !LoadLibrary("TENDERSupplies")) return kFALSE;
   }       
   if (iESDfilter || iPWGMuonTrain) {
      if (!LoadLibrary("PWGmuon")) return kFALSE;
   }   
   if (iESDMCLabelAddition) {
     if (!LoadLibrary("PWGmuondep")) return kFALSE;
   }
   // JETAN
   if (iJETAN) {
      if (!LoadLibrary("JETAN")) return kFALSE;
   }
   if (iJETANdelta) {
      if (!LoadLibrary("JETAN") ||
          !LoadLibrary("CGAL") ||
          !LoadLibrary("fastjet") ||
          !LoadLibrary("siscone") ||
          !LoadLibrary("SISConePlugin") ||
          !LoadLibrary("FASTJETAN")) return kFALSE;
   }     
   // PWG3 Vertexing HF
   if (iPWGHFvertexing || iPWGHFd2h) {
      if (!LoadLibrary("PWGflowBase") ||
          !LoadLibrary("PWGflowTasks") ||
          !LoadLibrary("PWGHFvertexingHF")) return kFALSE;
   }    
 //    if (iPWGHFvertexing || iPWG3d2h) {
 //     if (!LoadLibrary("PWG3base") ||
 //         !LoadLibrary("PWGHFvertexingHF")) return kFALSE;
 //  }   
   // PWG3 dielectron
   if (iPWGDQJPSIfilter) {
      if (!LoadLibrary("PWGDQdielectron")) return kFALSE;
   }   
   
   ::Info("AnalysisTrainNew.C::LoadAnalysisLibraries", "Load other libraries:   SUCCESS");
   return kTRUE;
}

//______________________________________________________________________________
Bool_t LoadLibrary(const char *module)
{
// Load a module library in a given mode. Reports success.
   Int_t result;
   TString mod(module);
   if (!mod.Length()) {
      ::Error("AnalysisTrainNew.C::LoadLibrary", "Empty module name");
      return kFALSE;
   }   
   // If a library is specified, just load it
   if (mod.EndsWith(".so")) {
      mod.Remove(mod.Index(".so"));
      result = gSystem->Load(mod);
      if (result < 0) {
         ::Error("AnalysisTrainNew.C::LoadLibrary", "Could not load library %s", module);
         return kFALSE;
      }
      return kTRUE;
   } 
   // Check if the library is already loaded
   if (strlen(gSystem->GetLibraries(Form("%s.so", module), "", kFALSE)) > 0) return kTRUE;    
   result = gSystem->Load(Form("lib%s.so", module));
   if (result < 0) {
      ::Error("AnalysisTrainNew.C::LoadLibrary", "Could not load module %s", module);
      return kFALSE;
   }
   return kTRUE;
}           


//______________________________________________________________________________
TChain *CreateChain()
{
// Create the input chain
   chain = new TChain("esdTree");
   if (gSystem->AccessPathName("AliESDs.root")) 
      ::Error("AnalysisTrainNew.C::CreateChain", "File: AliESDs.root not in ./data dir");
   else 
       chain->Add("AliESDs.root");
   if (chain->GetNtrees()) return chain;
   return NULL;
}   

//______________________________________________________________________________
void AODmerge()
{
// Merging method. No staging and no terminate phase.
  TStopwatch timer;
  timer.Start();
  TString outputDir = "wn.xml";
  TString outputFiles = "EventStat_temp.root,AliAOD.root,AliAOD.Muons.root";
  TString mergeExcludes = "";
  TObjArray *list = outputFiles.Tokenize(",");
  TIter *iter = new TIter(list);
  TObjString *str;
  TString outputFile;
  Bool_t merged = kTRUE;
  while((str=(TObjString*)iter->Next())) {
    outputFile = str->GetString();
    // Skip already merged outputs
    if (!gSystem->AccessPathName(outputFile)) {
       printf("Output file <%s> found. Not merging again.",outputFile.Data());
       continue;
    }
    if (mergeExcludes.Contains(outputFile.Data())) continue;
    merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, 0);
    if (!merged) {
       printf("ERROR: Cannot merge %s\n", outputFile.Data());
       return;
    }
  }
  // all outputs merged, validate
  ofstream out;
  out.open("outputs_valid", ios::out);
  out.close();
  timer.Print();
}
Commit	Line	Data
e21f8bf5	1	// ### Settings that make sense when using the Alien plugin
	2	//==============================================================================
	3	Int_t runOnData = 0; // Set to 1 if processing real data
	4	Int_t iCollision = 0; // 0=pp, 1=Pb-Pb
	5	//==============================================================================
	6	Bool_t usePhysicsSelection = kTRUE; // use physics selection
	7	Bool_t useTender = kFALSE; // use tender wagon
	8	Bool_t useCentrality = kTRUE; // centrality
	9	Bool_t useV0tender = kFALSE; // use V0 correction in tender
	10	Bool_t useDBG = kTRUE; // activate debugging
	11	Bool_t useMC = kTRUE; // use MC info
	12	Bool_t useKFILTER = kTRUE; // use Kinematics filter
	13	Bool_t useTR = kTRUE; // use track references
	14	Bool_t useCORRFW = kFALSE; // do not change
	15	Bool_t useAODTAGS = kFALSE; // use AOD tags
	16	Bool_t useSysInfo = kFALSE; // use sys info
	17
	18	// ### Analysis modules to be included. Some may not be yet fully implemented.
	19	//==============================================================================
	20	Int_t iAODhandler = 1; // Analysis produces an AOD or dAOD's
	21	Int_t iESDMCLabelAddition= 0;
	22	Int_t iESDfilter = 1; // ESD to AOD filter (barrel + muon tracks)
	23	Int_t iMUONcopyAOD = 1; // Task that copies only muon events in a separate AOD (PWG3)
	24	Int_t iJETAN = 0; // Jet analysis (PWG4)
	25	Int_t iJETANdelta = 0; // Jet delta AODs
	26	Int_t iPWGHFvertexing = 0; // Vertexing HF task (PWG3)
	27	Int_t iPWGDQJPSIfilter = 0; // JPSI filtering (PWG3)
	28	Int_t iPWGHFd2h = 0; // D0->2 hadrons (PWG3)
	29	Bool_t doPIDResponse = 1;
	30	Bool_t doPIDqa = 1; //new
	31
	32	// ### Configuration macros used for each module
	33	//==============================================================================
	34	TString configPWGHFd2h = (iCollision==0)?"$ALICE_ROOT/PWGHF/vertexingHF/ConfigVertexingHF.C"
	35	:"$ALICE_ROOT/PWGHF/vertexingHF/ConfigVertexingHF_Pb_AllCent.C";
	36
	37	// Temporaries.
	38	class AliOADBPhysicsSelection;
	39	AliOADBPhysicsSelection *CreateOADBphysicsSelection();
	40	void AODmerge();
	41	void AddAnalysisTasks(Int_t);
	42	Bool_t LoadCommonLibraries();
	43	Bool_t LoadAnalysisLibraries();
	44	Bool_t LoadLibrary(const char *);
	45	TChain *CreateChain();
	46
	47	//______________________________________________________________________________
	48	void AODtrain(Int_t merge=0)
	49	{
	50	// Main analysis train macro.
	51	AliLog::SetGlobalDebugLevel(3);
	52	if (merge) {
	53	TGrid::Connect("alien://");
	54	if (!gGrid \|\| !gGrid->IsConnected()) {
	55	::Error("QAtrain", "No grid connection");
	56	return;
	57	}
	58	}
	59	// Set temporary merging directory to current one
	60	gSystem->Setenv("TMPDIR", gSystem->pwd());
	61	// Set temporary compilation directory to current one
	62	gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
	63	printf("==================================================================\n");
	64	printf("=========== RUNNING FILTERING TRAIN ==========\n");
65	printf("==================================================================\n");
66	printf("= Configuring analysis train for: =\n");
67	if (usePhysicsSelection) printf("= Physics selection =\n");
68	if (useTender) printf("= TENDER =\n");
69	if (iESDfilter) printf("= ESD filter =\n");
70	if (iMUONcopyAOD) printf("= MUON copy AOD =\n");
71	if (iJETAN) printf("= Jet analysis =\n");
72	if (iJETANdelta) printf("= Jet delta AODs =\n");
73	if (iPWGHFvertexing) printf("= PWGHF vertexing =\n");
74	if (iPWGDQJPSIfilter) printf("= PWGDQ j/psi filter =\n");
75	if (iPWGHFd2h) printf("= PWGHF D0->2 hadrons QA =\n");
76
77	// Load common libraries and set include path
78	if (!LoadCommonLibraries()) {
79	::Error("AnalysisTrain", "Could not load common libraries");
80	return;
81	}
82
83	// Make the analysis manager and connect event handlers
84	AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train");
85	if (useSysInfo) mgr->SetNSysInfo(100);
86	// Load analysis specific libraries
87	if (!LoadAnalysisLibraries()) {
88	::Error("AnalysisTrain", "Could not load analysis libraries");
89	return;
90	}
91
92	// Create input handler (input container created automatically)
93	// ESD input handler
94	AliESDInputHandler *esdHandler = new AliESDInputHandler();
95	mgr->SetInputEventHandler(esdHandler);
96	// Monte Carlo handler
97	if (useMC) {
98	AliMCEventHandler* mcHandler = new AliMCEventHandler();
99	mgr->SetMCtruthEventHandler(mcHandler);
100	mcHandler->SetReadTR(useTR);
101	}
102	// AOD output container, created automatically when setting an AOD handler
103	if (iAODhandler) {
104	// AOD output handler
105	AliAODHandler* aodHandler = new AliAODHandler();
106	aodHandler->SetOutputFileName("AliAOD.root");
107	mgr->SetOutputEventHandler(aodHandler);
108	}
109	// Debugging if needed
110	if (useDBG) mgr->SetDebugLevel(3);
111
112	AddAnalysisTasks(merge);
113	if (merge) {
114	AODmerge();
115	mgr->InitAnalysis();
116	mgr->SetGridHandler(new AliAnalysisAlien);
117	mgr->StartAnalysis("gridterminate",0);
118	return;
119	}
120	// Run the analysis
121	//
122	TChain *chain = CreateChain();
123	if (!chain) return;
124
125	TStopwatch timer;
126	timer.Start();
127	mgr->SetSkipTerminate(kTRUE);
128	if (mgr->InitAnalysis()) {
129	mgr->PrintStatus();
130	mgr->StartAnalysis("local", chain);
131	}
132	timer.Print();
133	}
134
135	//______________________________________________________________________________
136	void AddAnalysisTasks(Int_t merge){
137	// Add all analysis task wagons to the train
138	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
139
140	//
141	// Tender and supplies. Needs to be called for every event.
142	//
143	AliAnalysisManager::SetCommonFileName("AODQA.root");
144	if (useTender) {
145	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/TenderSupplies/AddTaskTender.C");
146	// IF V0 tender needed, put kTRUE below
147	AliAnalysisTaskSE *tender = AddTaskTender(useV0tender);
148	// tender->SetDebugLevel(2);
149	}
150
151	if (usePhysicsSelection) {
152	// Physics selection task
153	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
154	mgr->RegisterExtraFile("event_stat.root");
155	AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(kFALSE);
156	// AliOADBPhysicsSelection * oadbDefaultPbPb = CreateOADBphysicsSelection();
157	// physSelTask->GetPhysicsSelection()->SetCustomOADBObjects(oadbDefaultPbPb,0,0);
158	// if (!merge) mgr->AddStatisticsTask(AliVEvent::kAny);
159	}
160	// Centrality (only Pb-Pb)
161	if (iCollision && useCentrality) {
162	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
163	AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
164	taskCentrality->SelectCollisionCandidates(AliVEvent::kAny);
165	}
166
167	if(iESDMCLabelAddition) {
168	gROOT->LoadMacro("$ALICE_ROOT/PWG/muondep/AddTaskESDMCLabelAddition.C");
169	AliAnalysisTaskESDMCLabelAddition *esdmclabel = AddTaskESDMCLabelAddition(kFALSE);
170	}
171
172	if (iESDfilter) {
173	// ESD filter task configuration.
174	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
175	if (iMUONcopyAOD) {
176	printf("Registering delta AOD file\n");
177	mgr->RegisterExtraFile("AliAOD.Muons.root");
178	mgr->RegisterExtraFile("AliAOD.Dimuons.root");
179	AliAnalysisTaskESDfilter taskesdfilter = AddTaskESDFilter(useKFILTER, kTRUE, kFALSE, kFALSE /usePhysicsSelection*/,kFALSE,kTRUE,kTRUE,kTRUE,1100,1);
180	} else {
181	AliAnalysisTaskESDfilter taskesdfilter = AddTaskESDFilter(useKFILTER, kFALSE, kFALSE, kFALSE /usePhysicsSelection*/,kFALSE,kTRUE,kTRUE,kTRUE,1100,1);
182	}
183	}
184
185	// ******** PWG3 wagons ****************************************************
186	// PWGHF vertexing
187	if (iPWGHFvertexing) {
188	gROOT->LoadMacro("$ALICE_ROOT/PWGHF/vertexingHF/macros/AddTaskVertexingHF.C");
189	if (!iPWGHFd2h) TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
190	AliAnalysisTaskSEVertexingHF *taskvertexingHF = AddTaskVertexingHF();
191	if (!taskvertexingHF) ::Warning("AnalysisTrainNew", "AliAnalysisTaskSEVertexingHF cannot run for this train conditions - EXCLUDED");
192	else mgr->RegisterExtraFile("AliAOD.VertexingHF.root");
193	taskvertexingHF->SelectCollisionCandidates(0);
194	}
195
196	// PWGDQ JPSI filtering (only pp)
197	if (iPWGDQJPSIfilter && (iCollision==0)) {
198	gROOT->LoadMacro("$ALICE_ROOT/PWGDQ/dielectron/macros/AddTaskJPSIFilter.C");
199	AliAnalysisTaskSE *taskJPSIfilter = AddTaskJPSIFilter();
200	if (!taskJPSIfilter) ::Warning("AnalysisTrainNew", "AliAnalysisTaskDielectronFilter cannot run for this train conditions - EXCLUDED");
201	else mgr->RegisterExtraFile("AliAOD.Dielectron.root");
202	taskJPSIfilter->SelectCollisionCandidates(0);
203	}
204
205	// PWGHF D2h
206	if (iPWGHFd2h) {
207	gROOT->LoadMacro("$ALICE_ROOT/PWGHF/vertexingHF/AddD2HTrain.C");
208	TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
209	AddD2HTrain(kFALSE, 1,0,0,0,0,0,0,0,0,0,0);
210	}
211
212	// ******** PWG4 wagons ****************************************************
213	// Jet analysis
214
215	// Configurations flags, move up?
216	TString kDeltaAODJetName = "AliAOD.Jets.root"; //
217	Bool_t kIsPbPb = (iCollision==0)?false:true; // can be more intlligent checking the name of the data set
218	TString kDefaultJetBackgroundBranch = "";
219	TString kJetSubtractBranches = "";
220	UInt_t kHighPtFilterMask = 128;// from esd filter
221	UInt_t iPhysicsSelectionFlag = AliVEvent::kMB;
222	if (iJETAN) {
223	gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJets.C");
224	// Default jet reconstructor running on ESD's
225	AliAnalysisTaskJets *taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
226	if (!taskjets) ::Fatal("AnalysisTrainNew", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
227	if(kDeltaAODJetName.Length()>0) taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
228	if (iJETANdelta) {
229	// AddTaskJetsDelta("AliAOD.Jets.root"); // need to modify this accordingly in the add task jets
230	mgr->RegisterExtraFile(kDeltaAODJetName.Data());
231	TString cTmp("");
232	if(kIsPbPb){
233	// UA1 intrinsic background subtraction
234	taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
235	if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
236	}
237	// SICONE
238	taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtration to be done later....
239	if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
240	cTmp = taskjets->GetNonStdBranch();
241	if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data());
242
243	// Add the clusters..
244	gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCluster.C");
245	AliAnalysisTaskJetCluster *taskCl = 0;
246	Float_t fCenUp = 0;
247	Float_t fCenLo = 0;
248	Float_t fTrackEtaWindow = 0.9;
249	taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip
250	taskCl->SetBackgroundCalc(kTRUE);
251	taskCl->SetNRandomCones(10);
252	taskCl->SetCentralityCut(fCenLo,fCenUp);
253	taskCl->SetGhostEtamax(fTrackEtaWindow);
254	kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
255
256	taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
257	taskCl->SetCentralityCut(fCenLo,fCenUp);
258	if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
259	taskCl->SetNRandomCones(10);
260	kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
261
262	taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
263	taskCl->SetCentralityCut(fCenLo,fCenUp);
264	if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
265	kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
266
267	// DO THE BACKGROUND SUBTRACTION
268	if(kIsPbPb&&kJetSubtractBranches.Length()){
269	gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetBackgroundSubtract.C");
270	AliAnalysisTaskJetBackgroundSubtract *taskSubtract = 0;
271	taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,1,"B0","B%d");
272	taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
273	if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
274	}
275	}
276	}
277	}
278
279	//______________________________________________________________________________
280	Bool_t LoadCommonLibraries()
281	{
282	// Load common analysis libraries.
283	if (!gSystem->Getenv("ALICE_ROOT")) {
284	::Error("AnalysisTrainNew.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot");
285	return kFALSE;
286	}
287	Bool_t success = kTRUE;
288	// Load framework classes. Par option ignored here.
289	success &= LoadLibrary("libSTEERBase.so");
290	success &= LoadLibrary("libESD.so");
291	success &= LoadLibrary("libAOD.so");
292	success &= LoadLibrary("libANALYSIS.so");
293	success &= LoadLibrary("libOADB.so");
294	success &= LoadLibrary("libANALYSISalice.so");
295	success &= LoadLibrary("libCORRFW.so");
296	gROOT->ProcessLine(".include $ALICE_ROOT/include");
297	if (success) {
298	::Info("AnalysisTrainNew.C::LoadCommodLibraries", "Load common libraries: SUCCESS");
299	::Info("AnalysisTrainNew.C::LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
300	gSystem->GetIncludePath());
301	} else {
302	::Info("AnalysisTrainNew.C::LoadCommodLibraries", "Load common libraries: FAILED");
303	}
304	return success;
305	}
306
307	//______________________________________________________________________________
308	Bool_t LoadAnalysisLibraries()
309	{
310	// Load common analysis libraries.
311	if (useTender) {
312	if (!LoadLibrary("TENDER") \|\|
313	!LoadLibrary("TENDERSupplies")) return kFALSE;
314	}
315	if (iESDfilter \|\| iPWGMuonTrain) {
316	if (!LoadLibrary("PWGmuon")) return kFALSE;
317	}
318	if (iESDMCLabelAddition) {
319	if (!LoadLibrary("PWGmuondep")) return kFALSE;
320	}
321	// JETAN
322	if (iJETAN) {
323	if (!LoadLibrary("JETAN")) return kFALSE;
324	}
325	if (iJETANdelta) {
326	if (!LoadLibrary("JETAN") \|\|
327	!LoadLibrary("CGAL") \|\|
328	!LoadLibrary("fastjet") \|\|
329	!LoadLibrary("siscone") \|\|
330	!LoadLibrary("SISConePlugin") \|\|
331	!LoadLibrary("FASTJETAN")) return kFALSE;
332	}
333	// PWG3 Vertexing HF
334	if (iPWGHFvertexing \|\| iPWGHFd2h) {
335	if (!LoadLibrary("PWGflowBase") \|\|
336	!LoadLibrary("PWGflowTasks") \|\|
337	!LoadLibrary("PWGHFvertexingHF")) return kFALSE;
338	}
339	// if (iPWGHFvertexing \|\| iPWG3d2h) {
340	// if (!LoadLibrary("PWG3base") \|\|
341	// !LoadLibrary("PWGHFvertexingHF")) return kFALSE;
342	// }
343	// PWG3 dielectron
344	if (iPWGDQJPSIfilter) {
345	if (!LoadLibrary("PWGDQdielectron")) return kFALSE;
346	}
347
348	::Info("AnalysisTrainNew.C::LoadAnalysisLibraries", "Load other libraries: SUCCESS");
349	return kTRUE;
350	}
351
352	//______________________________________________________________________________
353	Bool_t LoadLibrary(const char *module)
354	{
355	// Load a module library in a given mode. Reports success.
356	Int_t result;
357	TString mod(module);
358	if (!mod.Length()) {
359	::Error("AnalysisTrainNew.C::LoadLibrary", "Empty module name");
360	return kFALSE;
361	}
362	// If a library is specified, just load it
363	if (mod.EndsWith(".so")) {
364	mod.Remove(mod.Index(".so"));
365	result = gSystem->Load(mod);
366	if (result < 0) {
367	::Error("AnalysisTrainNew.C::LoadLibrary", "Could not load library %s", module);
368	return kFALSE;
369	}
370	return kTRUE;
371	}
372	// Check if the library is already loaded
373	if (strlen(gSystem->GetLibraries(Form("%s.so", module), "", kFALSE)) > 0) return kTRUE;
374	result = gSystem->Load(Form("lib%s.so", module));
375	if (result < 0) {
376	::Error("AnalysisTrainNew.C::LoadLibrary", "Could not load module %s", module);
377	return kFALSE;
378	}
379	return kTRUE;
380	}
381
382
383	//______________________________________________________________________________
384	TChain *CreateChain()
385	{
386	// Create the input chain
387	chain = new TChain("esdTree");
388	if (gSystem->AccessPathName("AliESDs.root"))
389	::Error("AnalysisTrainNew.C::CreateChain", "File: AliESDs.root not in ./data dir");
390	else
391	chain->Add("AliESDs.root");
392	if (chain->GetNtrees()) return chain;
393	return NULL;
394	}
395
396	//______________________________________________________________________________
397	void AODmerge()
398	{
399	// Merging method. No staging and no terminate phase.
400	TStopwatch timer;
401	timer.Start();
402	TString outputDir = "wn.xml";
403	TString outputFiles = "EventStat_temp.root,AliAOD.root,AliAOD.Muons.root";
404	TString mergeExcludes = "";
405	TObjArray *list = outputFiles.Tokenize(",");
406	TIter *iter = new TIter(list);
407	TObjString *str;
408	TString outputFile;
409	Bool_t merged = kTRUE;
410	while((str=(TObjString*)iter->Next())) {
411	outputFile = str->GetString();
412	// Skip already merged outputs
413	if (!gSystem->AccessPathName(outputFile)) {
414	printf("Output file <%s> found. Not merging again.",outputFile.Data());
415	continue;
416	}
417	if (mergeExcludes.Contains(outputFile.Data())) continue;
418	merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, 0);
419	if (!merged) {
420	printf("ERROR: Cannot merge %s\n", outputFile.Data());
421	return;
422	}
423	}
424	// all outputs merged, validate
425	ofstream out;
426	out.open("outputs_valid", ios::out);
427	out.close();
428	timer.Print();
429	}