[u/mrichter/AliRoot.git] / PWGPP / CalibMacros / CPass1 / QAtrain.C

#include "Riostream.h"
void LoadLibraries();
void AddAnalysisTasks(); 
void QAmerge(const char *, Int_t);

Int_t iCollisionType = 1; // 0=pp, 1=PbPb
// Trigger mask.

UInt_t kTriggerInt = AliVEvent::kAnyINT;
UInt_t kTriggerMuonAll = AliVEvent::kMUL7 | AliVEvent::kMUSH7 | AliVEvent::kMUU7 | AliVEvent::kMUS7
                       | AliVEvent::kMUSPB | AliVEvent::kMUSHPB | AliVEvent::kMuonLikePB | AliVEvent::kMuonUnlikePB;
UInt_t kTriggerMuonBarell = AliVEvent::kMUU7;
UInt_t kTriggerEMC   = AliVEvent::kEMC7 | AliVEvent::kEMCEJE | AliVEvent::kEMCEGA;
UInt_t kTriggerHM   = AliVEvent::kHighMult;
// Main trigger mask used:
UInt_t kTriggerMask = kTriggerInt;

Int_t runNumbers[5] = {158626};

Bool_t doCDBconnect   = 1;
Bool_t doEventStat    = 1;
Bool_t doCentrality   = 1;
Bool_t doQAsym        = 1;
Bool_t doVZERO        = 1;   // there is a 2nd file
Bool_t doVZEROPbPb    = 1; 
Bool_t doVertex       = 1;
Bool_t doSPD          = 1;   // needs RP   
Bool_t doTPC          = 1;
Bool_t doHLT          = 1;
Bool_t doSDD          = 1;   // needs RP
Bool_t doSSDdEdx      = 1;

Bool_t doTRD          = 1;
Bool_t doITS          = 1;
Bool_t doITSsaTracks  = 1; 
Bool_t doITSalign     = 1;  
Bool_t doCALO         = 1;
Bool_t doMUONTrig     = 0;
Bool_t doImpParRes    = 1;
Bool_t doMUON         = 0;
Bool_t doTOF          = 1;
Bool_t doHMPID        = 1;
Bool_t doT0           = 1;
Bool_t doZDC          = 1;
Bool_t doPIDResponse  = 1;
Bool_t doPIDqa        = 1; //new
Bool_t doFMD          = 1; // new
Bool_t doPHOS         = 1; // new
Bool_t doEMCAL        = 1;
Bool_t doFBFqa        = 1; // new - not ported yet to revision

               // Debug level
Int_t       debug_level        = 1;        // Debugging
Int_t       run_number = 0;

TString ocdbStorage("raw://");

void QAtrain(Int_t run = 0, 
             const char *xmlfile   = "wn.xml",
             Int_t  stage          = 0, /*0 = QA train, 1...n - merging stage*/
             const char* ocdb      = "raw://" )
{
  run_number = run;
  ocdbStorage = ocdb;

  if (ocdbStorage.EqualTo("raw://"))
  {
    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);
  // Load libraries
  LoadLibraries();
  printf("Include path: %s\n", gSystem->GetIncludePath());
  // Create manager
  AliAnalysisManager *mgr  = new AliAnalysisManager("PilotAnalysis", "Production train");
  mgr->SetRunFromPath(run_number);
  // Input handler
  AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP();
  esdHandler->SetReadFriends(kTRUE);
  esdHandler->SetActiveBranches("ESDfriend");
  mgr->SetInputEventHandler(esdHandler);
  mgr->SetDebugLevel(debug_level);
  
  // AnalysisTasks
  AddAnalysisTasks();
  if (stage>0) {
    QAmerge(xmlfile, stage);
    return;
  }   
  // Input chain
  TChain *chain = new TChain("esdTree");
  chain->Add("AliESDs.root");
  TStopwatch timer;
  timer.Start();
  if (mgr->InitAnalysis()) {                                                                                                              
    mgr->PrintStatus(); 
    mgr->SetSkipTerminate(kTRUE);
//    mgr->SetNSysInfo(1);
    mgr->StartAnalysis("local", chain);
  }
  timer.Print();
}

void LoadLibraries()
{
  gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWGPP/TRD");
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice");
  gSystem->Load("libCORRFW");
  gSystem->Load("libTENDER");
  gSystem->Load("libPWGPP.so");
  gSystem->Load("libAliHLTTrigger.so");

  if (doEMCAL || doPHOS || doCALO) {
     gSystem->Load("libEMCALUtils");
     gSystem->Load("libPHOSUtils");
     gSystem->Load("libPWGCaloTrackCorrBase");
     gSystem->Load("libPWGGACaloTrackCorrelations");
     gSystem->Load("libPWGGACaloTasks");
     gSystem->Load("libPWGGAPHOSTasks");
     gSystem->Load("libPWGGAEMCALTasks");
  }  
  if(doMUON || doMUONTrig) {
     gSystem->Load("libPWGmuon");
     gSystem->Load("libPWGPPMUONlite");
     gSystem->Load("libPWGmuondep");
  }
  if (doFMD) {
     gSystem->Load("libPWGLFforward2");
  }      
}

void AddAnalysisTasks()
{
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  mgr->SetCommonFileName("QAresults.root");
  // Statistics task
  mgr->AddStatisticsTask(kTriggerMask);
  //
  // CDB connection
  //
  if (doCDBconnect && ocdbStorage.EqualTo("raw://")) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C");
    AliTaskCDBconnect *taskCDB = AddTaskCDBconnect();
    if (!taskCDB) return;
    AliCDBManager *cdb = AliCDBManager::Instance();
    cdb->SetDefaultStorage("raw://");
    taskCDB->SetRunNumber(run_number);
  } else {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/CalibMacros/CPass1/ConfigCalibTrain.C");
    ConfigCalibTrain(run_number, ocdbStorage);
  }
  
  //
  // Event Statistics (Jan Fiete)
  //
  if (doEventStat) {
      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
      AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE /*MC*/);
  }
  
  //
  // Centrality (A. Toia)
  //
  if (doCentrality) {
     if (!iCollisionType) {
        printf("Disabling centrality task for p-p\n");
        doCentrality = kFALSE;
     } else {           
        gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
        AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
     }   
  }   
  
  // Vertexing (A. Dainese)
  // 
  if (doVertex) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
    AliAnalysisTaskVertexESD* taskvertexesd =  AddTaskVertexESD(kFALSE, kTriggerMask);
    taskvertexesd->SelectCollisionCandidates(kTriggerMask);
  }  

  // TPC QA (E. Sicking)
  //
  if (doQAsym) {
  // offline trigger in AddTask
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
    AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell);
  }  
  //
  // VZERO QA  (C. Cheshkov)
  //
  if (doVZERO) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
    AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
//  taskv0qa->SelectCollisionCandidates();
  }
  if (doVZEROPbPb && iCollisionType==1) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/VZERO/AddTaskVZEROPbPb.C");
    AliAnaVZEROPbPb* taskV0PbPb = (AliAnaVZEROPbPb*)AddTaskVZEROPbPb(0);
//    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-");
//    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN");
//    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-");
//    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-");
    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-");
  }
  //
  // 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)
  if (doTPC) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
    AliPerformanceTask *tpcQA = 0;
    if (iCollisionType) {
       // High multiplicity Pb-Pb
       tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kTRUE);
    } else {
      // Low multiplicity (pp)
       tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE);
    }
    tpcQA->SelectCollisionCandidates(kTriggerMask);
  }  

  // HLT (Alberica Toia)
  if (doHLT) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
    AliPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE,0,kTRUE);
    hltQA->SelectCollisionCandidates(kTriggerMask);
  }  
  //
  // SPD (A. Mastroserio)
  //
  if (doSPD) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
    AliAnalysisTaskSPD* taskspdqa = (AliAnalysisTaskSPD*)AddTaskSPDQA();
    // Request from Annalisa
    if (iCollisionType) taskspdqa->SetHeavyIonMode();
    taskspdqa->SelectCollisionCandidates(kTriggerMask);
    taskspdqa->SetOCDBInfo(run_number, "raw://");
  }  
  //
  // SDD (F. Prino)
  //
  if (doSDD) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
    AliAnalysisTaskSE* tasksdd = AddSDDPoints();
    tasksdd->SelectCollisionCandidates(kTriggerMask);
  }
  //
  // SSD dEdx (Marek Chojnacki)
  //
  if (doSSDdEdx) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
    AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
    taskssddedx->SelectCollisionCandidates(kTriggerMask);
  }

  //
  // ITS
  //
  if (doITS) {
  // hardcoded non-zero trigger mask
      gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
      AliAnalysisTaskITSTrackingCheck *itsQA = 0;
      AliAnalysisTaskITSTrackingCheck *itsQACent0010 = 0;
      AliAnalysisTaskITSTrackingCheck *itsQACent3050 = 0;
      AliAnalysisTaskITSTrackingCheck *itsQACent6080 = 0;
      if(iCollisionType==0) {
        itsQA = AddTaskPerformanceITS(kFALSE);
      } else {
        itsQA = AddTaskPerformanceITS(kFALSE);
        itsQACent0010 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,3500,10000);
        itsQACent3050 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,590,1570);
        itsQACent6080 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,70,310);
      }
  }
  //
  // ITS saTracks, align (F.Prino)
  //
  if (doITSsaTracks) {
  // offline trigger in AddTask
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSsaTracks.C");
     AliAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kFALSE,kFALSE);
     itssaTracks->SelectCollisionCandidates(kTriggerMask);
  }   
  if (doITSalign) {
  // no offline trigger selection
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSAlign.C");
     AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011);
  }   
  //
  // TRD (Alex Bercuci, M. Fasel) 
  //
  if(doTRD) {
  // no offline trigger selection
      gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
      // steer individual TRD tasks
      Bool_t 
      doCheckESD(kTRUE),  // AliTRDcheckESD
      doCheckDET(kTRUE),  // AliTRDcheckDET
      doEffic(kTRUE),     // AliTRDefficiency
      doResolution(kTRUE),// AliTRDresolution
      doCheckPID(kTRUE),  // AliTRDcheckPID
      doV0Monitor(kFALSE);// AliTRDv0Monitor
      AddTrainPerformanceTRD(Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor));
  }

  //
  // ZDC (Chiara Oppedisano) 
  //
  if(doZDC) {
  // hardcoded kMB trigger mask
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/ZDC/AddTaskZDCQA.C");
     AliAnalysisTaskSE *taskZDC = AddTaskZDCQA();
     taskZDC->SelectCollisionCandidates(kTriggerMask);
  }   
  //
  // Calorimetry (Gustavo Conesa)
  //

  if(doCALO) {
      gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
      AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE);
      taskCaloQA->SetDebugLevel(0);
      // offline mask set in AddTask to kMB
      taskCaloQA->SelectCollisionCandidates(kTriggerMask);
      // Add a new calo task with EMC1 trigger only
      taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE, "", "EMC7");
      taskCaloQA->SetDebugLevel(0);
      taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
  }

  //
  // Muon Trigger
  //
  
  if(doMUONTrig) {
  // no offline trigger selection
      gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
      AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
  }

  //
  // Impact parameter resolution (xianbao.yuan@pd.infn.it, andrea.dainese@pd.infn.it)
  //
  if (doImpParRes) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskImpParRes.C");
    AliAnalysisTaskSE* taskimpparres=0;
    if(iCollisionType==0) {
       taskimpparres= AddTaskImpParRes();
    } else {
       taskimpparres= AddTaskImpParRes(kFALSE,-1,kFALSE,kFALSE);
    }
    taskimpparres->SelectCollisionCandidates(kTriggerMask);
  }  
  //
  // MUON QA (Philippe Pillot)
  //
  if (doMUON) {
  // trigger analysis internal
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskMuonQA.C");
    AliAnalysisTaskSE* taskmuonqa= AddTaskMuonQA();
  }  
  //
  // TOF (Francesca Bellini)
  //
  if (doTOF) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
    AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA();
    tofQA->SelectCollisionCandidates(kTriggerMask);
  } 
   //
  // PIDResponse(JENS)
  //
  if (doPIDResponse) {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); 
    AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse();
    PIDResponse->SelectCollisionCandidates(kTriggerMask);
  }  

  //
  // PIDqa(JENS)
  //
  if (doPIDqa) {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
    AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
    PIDQA->SelectCollisionCandidates(kTriggerMask);
  }  
 
  //
  // HMPID QA (Giacomo Volpe)
  //
  if (doHMPID) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/HMPID/AddTaskHmpidQA.C");
    AliAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kFALSE);
      // offline mask set in AddTask to kMB
    taskhmpidqa->SelectCollisionCandidates(kTriggerMask);
  }      
  
  
  // T0 QA (Alla Mayevskaya)
  if (doT0) {
  // no offline trigger selection
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/T0/AddTaskT0QA.C");
    AliT0AnalysisTaskQA* taskt0qa= AddTaskT0QA();
    taskt0qa->SelectCollisionCandidates(kTriggerMask);
  }      
  // FMD QA (Christian Holm Christiansen)
  if (doFMD) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C");
    // Parameters: usemc, usecentrality
    AliAnalysisTaskSE *forwardQA = (AliAnalysisTaskSE *)AddTaskForwardQA(kFALSE, kFALSE);
    // No offline trigger config. needed (see #84077)
  }
   //     
  // PHOS QA (Boris Polishchuk)
  //
  if (doPHOS) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/CaloCellQA/macros/AddTaskCaloCellsQA.C");
    AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_AnyInt"); 
    taskPHOSCellQA1->SelectCollisionCandidates(kTriggerMask);
    taskPHOSCellQA1->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
    AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_PHI7"); 
    taskPHOSCellQA2->SelectCollisionCandidates(AliVEvent::kPHI7);
    taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
    // Pi0 QA fo PbPb
    if (iCollisionType) {
      gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C");
      AliAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0);
    }
  }    
  //
  // EMCAL QA (Gustavo Conesa)
  //
  if (doEMCAL) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C");
     AliAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA();
  }   
  //     
  // FLOW and BF QA (C.Perez && A.Rodriguez)
  //
  if (doFBFqa) {
    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskFBFqa.C");
    AliAnalysisTaskSE *qaFBFMB = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFmb",kFALSE);
    qaFBFMB->SelectCollisionCandidates(AliVEvent::kMB);
    AliAnalysisTaskSE *qaFBFSC = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFsc",kFALSE);
    qaFBFSC->SelectCollisionCandidates(AliVEvent::kSemiCentral);
    AliAnalysisTaskSE *qaFBFCE = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFce",kFALSE);
    qaFBFCE->SelectCollisionCandidates(AliVEvent::kCentral);
  }
}

void QAmerge(const char *dir, Int_t stage)
{
// Merging method
  TStopwatch timer;
  timer.Start();
  TString outputDir = dir;
  TString outputFiles = "QAresults.root,EventStat_temp.root,RecoQAresults.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, stage);
    if (!merged) {
       printf("ERROR: Cannot merge %s\n", outputFile.Data());
       return;
    }
  }
  // read the analysis manager from file
  if (!outputDir.Contains("Stage")) {
    ofstream out;
    out.open("outputs_valid", ios::out);
    out.close();    
    return;
  }
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  mgr->SetRunFromPath(mgr->GetRunFromAlienPath(dir));
  mgr->SetSkipTerminate(kFALSE);
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  AliLog::SetGlobalLogLevel(AliLog::kError);
  TTree *tree = NULL;
  mgr->StartAnalysis("gridterminate", tree);
  ofstream out;
  out.open("outputs_valid", ios::out);
  out.close();
  timer.Print();
}
Commit	Line	Data
d74ff87e	1	#include "Riostream.h"
	2	void LoadLibraries();
	3	void AddAnalysisTasks();
	4	void QAmerge(const char *, Int_t);
	5
	6	Int_t iCollisionType = 1; // 0=pp, 1=PbPb
	7	// Trigger mask.
	8
	9	UInt_t kTriggerInt = AliVEvent::kAnyINT;
	10	UInt_t kTriggerMuonAll = AliVEvent::kMUL7 \| AliVEvent::kMUSH7 \| AliVEvent::kMUU7 \| AliVEvent::kMUS7
	11	\| AliVEvent::kMUSPB \| AliVEvent::kMUSHPB \| AliVEvent::kMuonLikePB \| AliVEvent::kMuonUnlikePB;
	12	UInt_t kTriggerMuonBarell = AliVEvent::kMUU7;
	13	UInt_t kTriggerEMC = AliVEvent::kEMC7 \| AliVEvent::kEMCEJE \| AliVEvent::kEMCEGA;
	14	UInt_t kTriggerHM = AliVEvent::kHighMult;
	15	// Main trigger mask used:
	16	UInt_t kTriggerMask = kTriggerInt;
	17
	18	Int_t runNumbers[5] = {158626};
	19
	20	Bool_t doCDBconnect = 1;
	21	Bool_t doEventStat = 1;
	22	Bool_t doCentrality = 1;
	23	Bool_t doQAsym = 1;
	24	Bool_t doVZERO = 1; // there is a 2nd file
	25	Bool_t doVZEROPbPb = 1;
	26	Bool_t doVertex = 1;
	27	Bool_t doSPD = 1; // needs RP
	28	Bool_t doTPC = 1;
	29	Bool_t doHLT = 1;
	30	Bool_t doSDD = 1; // needs RP
	31	Bool_t doSSDdEdx = 1;
	32
	33	Bool_t doTRD = 1;
	34	Bool_t doITS = 1;
	35	Bool_t doITSsaTracks = 1;
	36	Bool_t doITSalign = 1;
	37	Bool_t doCALO = 1;
9e160db9	38	Bool_t doMUONTrig = 0;
d74ff87e	39	Bool_t doImpParRes = 1;
9e160db9	40	Bool_t doMUON = 0;
d74ff87e	41	Bool_t doTOF = 1;
	42	Bool_t doHMPID = 1;
	43	Bool_t doT0 = 1;
	44	Bool_t doZDC = 1;
	45	Bool_t doPIDResponse = 1;
	46	Bool_t doPIDqa = 1; //new
	47	Bool_t doFMD = 1; // new
	48	Bool_t doPHOS = 1; // new
	49	Bool_t doEMCAL = 1;
	50	Bool_t doFBFqa = 1; // new - not ported yet to revision
	51
	52	// Debug level
	53	Int_t debug_level = 1; // Debugging
	54	Int_t run_number = 0;
	55
9e160db9	56	TString ocdbStorage("raw://");
9e160db9	57
d74ff87e	58	void QAtrain(Int_t run = 0,
d74ff87e	59	const char *xmlfile = "wn.xml",
9e160db9	60	Int_t stage = 0, /0 = QA train, 1...n - merging stage/
9e160db9	61	const char* ocdb = "raw://" )
d74ff87e	62	{
d74ff87e	63	run_number = run;
9e160db9	64	ocdbStorage = ocdb;
d74ff87e	65
9e160db9	66	if (ocdbStorage.EqualTo("raw://"))
	67	{
	68	TGrid::Connect("alien://");
	69	if (!gGrid \|\| !gGrid->IsConnected()) {
	70	::Error("QAtrain", "No grid connection");
	71	return;
	72	}
	73	}
d74ff87e	74	// Set temporary merging directory to current one
	75	gSystem->Setenv("TMPDIR", gSystem->pwd());
	76	// Set temporary compilation directory to current one
	77	gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
	78	// Load libraries
	79	LoadLibraries();
	80	printf("Include path: %s\n", gSystem->GetIncludePath());
	81	// Create manager
	82	AliAnalysisManager *mgr = new AliAnalysisManager("PilotAnalysis", "Production train");
	83	mgr->SetRunFromPath(run_number);
	84	// Input handler
	85	AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP();
	86	esdHandler->SetReadFriends(kTRUE);
	87	esdHandler->SetActiveBranches("ESDfriend");
	88	mgr->SetInputEventHandler(esdHandler);
	89	mgr->SetDebugLevel(debug_level);
	90
	91	// AnalysisTasks
	92	AddAnalysisTasks();
	93	if (stage>0) {
	94	QAmerge(xmlfile, stage);
	95	return;
	96	}
	97	// Input chain
	98	TChain *chain = new TChain("esdTree");
	99	chain->Add("AliESDs.root");
	100	TStopwatch timer;
	101	timer.Start();
	102	if (mgr->InitAnalysis()) {
	103	mgr->PrintStatus();
	104	mgr->SetSkipTerminate(kTRUE);
	105	// mgr->SetNSysInfo(1);
	106	mgr->StartAnalysis("local", chain);
	107	}
	108	timer.Print();
	109	}
	110
	111	void LoadLibraries()
	112	{
	113	gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWGPP/TRD");
	114	gSystem->Load("libANALYSIS");
	115	gSystem->Load("libANALYSISalice");
	116	gSystem->Load("libCORRFW");
	117	gSystem->Load("libTENDER");
	118	gSystem->Load("libPWGPP.so");
	119	gSystem->Load("libAliHLTTrigger.so");
	120
	121	if (doEMCAL \|\| doPHOS \|\| doCALO) {
	122	gSystem->Load("libEMCALUtils");
	123	gSystem->Load("libPHOSUtils");
	124	gSystem->Load("libPWGCaloTrackCorrBase");
	125	gSystem->Load("libPWGGACaloTrackCorrelations");
	126	gSystem->Load("libPWGGACaloTasks");
	127	gSystem->Load("libPWGGAPHOSTasks");
	128	gSystem->Load("libPWGGAEMCALTasks");
	129	}
	130	if(doMUON \|\| doMUONTrig) {
	131	gSystem->Load("libPWGmuon");
	132	gSystem->Load("libPWGPPMUONlite");
	133	gSystem->Load("libPWGmuondep");
	134	}
	135	if (doFMD) {
	136	gSystem->Load("libPWGLFforward2");
	137	}
138	}
139
140	void AddAnalysisTasks()
141	{
142	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
143	mgr->SetCommonFileName("QAresults.root");
144	// Statistics task
145	mgr->AddStatisticsTask(kTriggerMask);
146	//
147	// CDB connection
148	//
9e160db9	149	if (doCDBconnect && ocdbStorage.EqualTo("raw://")) {
d74ff87e	150	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C");
	151	AliTaskCDBconnect *taskCDB = AddTaskCDBconnect();
	152	if (!taskCDB) return;
	153	AliCDBManager *cdb = AliCDBManager::Instance();
	154	cdb->SetDefaultStorage("raw://");
	155	taskCDB->SetRunNumber(run_number);
9e160db9	156	} else {
	157	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/CalibMacros/CPass1/ConfigCalibTrain.C");
	158	ConfigCalibTrain(run_number, ocdbStorage);
	159	}
d74ff87e	160
	161	//
	162	// Event Statistics (Jan Fiete)
	163	//
	164	if (doEventStat) {
	165	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
	166	AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE /MC/);
	167	}
	168
	169	//
	170	// Centrality (A. Toia)
	171	//
	172	if (doCentrality) {
	173	if (!iCollisionType) {
	174	printf("Disabling centrality task for p-p\n");
	175	doCentrality = kFALSE;
	176	} else {
	177	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
	178	AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
	179	}
	180	}
	181
	182	// Vertexing (A. Dainese)
	183	//
	184	if (doVertex) {
	185	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
	186	AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD(kFALSE, kTriggerMask);
	187	taskvertexesd->SelectCollisionCandidates(kTriggerMask);
	188	}
	189
	190	// TPC QA (E. Sicking)
	191	//
	192	if (doQAsym) {
	193	// offline trigger in AddTask
	194	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
	195	AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell);
	196	}
	197	//
	198	// VZERO QA (C. Cheshkov)
	199	//
	200	if (doVZERO) {
	201	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
	202	AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
	203	// taskv0qa->SelectCollisionCandidates();
	204	}
	205	if (doVZEROPbPb && iCollisionType==1) {
	206	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/VZERO/AddTaskVZEROPbPb.C");
	207	AliAnaVZEROPbPb* taskV0PbPb = (AliAnaVZEROPbPb*)AddTaskVZEROPbPb(0);
	208	// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-");
	209	// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN");
	210	// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-");
	211	// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-");
	212	taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-");
	213	}
	214	//
	215	// TPC (Jacek Otwinowski & Michael Knichel)
	216	//
	217	//
	218	// Optionally MC information can be used by setting the 1st argument to true
	219	// Optionally friends information can be switched off by setting the 2st argument
	220	// to false
	221	// Optionally highMult axis can be used by setting the 3st argument to true (for PbPb)
	222	if (doTPC) {
	223	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
224	AliPerformanceTask *tpcQA = 0;
225	if (iCollisionType) {
226	// High multiplicity Pb-Pb
227	tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kTRUE);
228	} else {
229	// Low multiplicity (pp)
230	tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE);
231	}
232	tpcQA->SelectCollisionCandidates(kTriggerMask);
233	}
234
235	// HLT (Alberica Toia)
236	if (doHLT) {
237	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
238	AliPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE,0,kTRUE);
239	hltQA->SelectCollisionCandidates(kTriggerMask);
240	}
241	//
242	// SPD (A. Mastroserio)
243	//
244	if (doSPD) {
245	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
246	AliAnalysisTaskSPD* taskspdqa = (AliAnalysisTaskSPD*)AddTaskSPDQA();
247	// Request from Annalisa
248	if (iCollisionType) taskspdqa->SetHeavyIonMode();
249	taskspdqa->SelectCollisionCandidates(kTriggerMask);
250	taskspdqa->SetOCDBInfo(run_number, "raw://");
251	}
252	//
253	// SDD (F. Prino)
254	//
255	if (doSDD) {
256	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
257	AliAnalysisTaskSE* tasksdd = AddSDDPoints();
258	tasksdd->SelectCollisionCandidates(kTriggerMask);
259	}
260	//
261	// SSD dEdx (Marek Chojnacki)
262	//
263	if (doSSDdEdx) {
264	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
265	AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
266	taskssddedx->SelectCollisionCandidates(kTriggerMask);
267	}
268
269	//
270	// ITS
271	//
272	if (doITS) {
273	// hardcoded non-zero trigger mask
274	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
275	AliAnalysisTaskITSTrackingCheck *itsQA = 0;
276	AliAnalysisTaskITSTrackingCheck *itsQACent0010 = 0;
277	AliAnalysisTaskITSTrackingCheck *itsQACent3050 = 0;
278	AliAnalysisTaskITSTrackingCheck *itsQACent6080 = 0;
279	if(iCollisionType==0) {
280	itsQA = AddTaskPerformanceITS(kFALSE);
281	} else {
282	itsQA = AddTaskPerformanceITS(kFALSE);
283	itsQACent0010 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,3500,10000);
284	itsQACent3050 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,590,1570);
285	itsQACent6080 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,70,310);
286	}
287	}
288	//
289	// ITS saTracks, align (F.Prino)
290	//
291	if (doITSsaTracks) {
292	// offline trigger in AddTask
293	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSsaTracks.C");
294	AliAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kFALSE,kFALSE);
295	itssaTracks->SelectCollisionCandidates(kTriggerMask);
296	}
297	if (doITSalign) {
298	// no offline trigger selection
299	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSAlign.C");
300	AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011);
301	}
302	//
303	// TRD (Alex Bercuci, M. Fasel)
304	//
305	if(doTRD) {
306	// no offline trigger selection
307	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
308	// steer individual TRD tasks
309	Bool_t
310	doCheckESD(kTRUE), // AliTRDcheckESD
311	doCheckDET(kTRUE), // AliTRDcheckDET
312	doEffic(kTRUE), // AliTRDefficiency
313	doResolution(kTRUE),// AliTRDresolution
314	doCheckPID(kTRUE), // AliTRDcheckPID
315	doV0Monitor(kFALSE);// AliTRDv0Monitor
316	AddTrainPerformanceTRD(Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor));
317	}
318
319	//
320	// ZDC (Chiara Oppedisano)
321	//
322	if(doZDC) {
323	// hardcoded kMB trigger mask
324	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/ZDC/AddTaskZDCQA.C");
325	AliAnalysisTaskSE *taskZDC = AddTaskZDCQA();
326	taskZDC->SelectCollisionCandidates(kTriggerMask);
327	}
328	//
329	// Calorimetry (Gustavo Conesa)
330	//
331
332	if(doCALO) {
333	gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
334	AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE);
335	taskCaloQA->SetDebugLevel(0);
336	// offline mask set in AddTask to kMB
337	taskCaloQA->SelectCollisionCandidates(kTriggerMask);
338	// Add a new calo task with EMC1 trigger only
339	taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE, "", "EMC7");
340	taskCaloQA->SetDebugLevel(0);
341	taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
342	}
343
344	//
345	// Muon Trigger
346	//
347
348	if(doMUONTrig) {
349	// no offline trigger selection
350	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
351	AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
352	}
353
354	//
355	// Impact parameter resolution (xianbao.yuan@pd.infn.it, andrea.dainese@pd.infn.it)
356	//
357	if (doImpParRes) {
358	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskImpParRes.C");
359	AliAnalysisTaskSE* taskimpparres=0;
360	if(iCollisionType==0) {
361	taskimpparres= AddTaskImpParRes();
362	} else {
363	taskimpparres= AddTaskImpParRes(kFALSE,-1,kFALSE,kFALSE);
364	}
365	taskimpparres->SelectCollisionCandidates(kTriggerMask);
366	}
367	//
368	// MUON QA (Philippe Pillot)
369	//
370	if (doMUON) {
371	// trigger analysis internal
372	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskMuonQA.C");
373	AliAnalysisTaskSE* taskmuonqa= AddTaskMuonQA();
374	}
375	//
376	// TOF (Francesca Bellini)
377	//
378	if (doTOF) {
379	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
380	AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA();
381	tofQA->SelectCollisionCandidates(kTriggerMask);
382	}
383	//
384	// PIDResponse(JENS)
385	//
386	if (doPIDResponse) {
387	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
388	AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse();
389	PIDResponse->SelectCollisionCandidates(kTriggerMask);
390	}
391
392	//
393	// PIDqa(JENS)
394	//
395	if (doPIDqa) {
396	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
397	AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
398	PIDQA->SelectCollisionCandidates(kTriggerMask);
399	}
400
401	//
402	// HMPID QA (Giacomo Volpe)
403	//
404	if (doHMPID) {
405	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/HMPID/AddTaskHmpidQA.C");
406	AliAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kFALSE);
407	// offline mask set in AddTask to kMB
408	taskhmpidqa->SelectCollisionCandidates(kTriggerMask);
409	}
410
411
412	// T0 QA (Alla Mayevskaya)
413	if (doT0) {
414	// no offline trigger selection
415	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/T0/AddTaskT0QA.C");
416	AliT0AnalysisTaskQA* taskt0qa= AddTaskT0QA();
417	taskt0qa->SelectCollisionCandidates(kTriggerMask);
418	}
419	// FMD QA (Christian Holm Christiansen)
420	if (doFMD) {
421	gROOT->LoadMacro("$ALICE_ROOT/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C");
422	// Parameters: usemc, usecentrality
423	AliAnalysisTaskSE forwardQA = (AliAnalysisTaskSE )AddTaskForwardQA(kFALSE, kFALSE);
424	// No offline trigger config. needed (see #84077)
425	}
426	//
427	// PHOS QA (Boris Polishchuk)
428	//
429	if (doPHOS) {
430	gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/CaloCellQA/macros/AddTaskCaloCellsQA.C");
431	AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_AnyInt");
432	taskPHOSCellQA1->SelectCollisionCandidates(kTriggerMask);
433	taskPHOSCellQA1->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
434	AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_PHI7");
435	taskPHOSCellQA2->SelectCollisionCandidates(AliVEvent::kPHI7);
436	taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
437	// Pi0 QA fo PbPb
438	if (iCollisionType) {
439	gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C");
440	AliAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0);
441	}
442	}
443	//
444	// EMCAL QA (Gustavo Conesa)
445	//
446	if (doEMCAL) {
447	gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C");
448	AliAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA();
449	}
450	//
451	// FLOW and BF QA (C.Perez && A.Rodriguez)
452	//
453	if (doFBFqa) {
454	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskFBFqa.C");
455	AliAnalysisTaskSE qaFBFMB = (AliAnalysisTaskSE) AddTaskFBFqa("qaFBFmb",kFALSE);
456	qaFBFMB->SelectCollisionCandidates(AliVEvent::kMB);
457	AliAnalysisTaskSE qaFBFSC = (AliAnalysisTaskSE) AddTaskFBFqa("qaFBFsc",kFALSE);
458	qaFBFSC->SelectCollisionCandidates(AliVEvent::kSemiCentral);
459	AliAnalysisTaskSE qaFBFCE = (AliAnalysisTaskSE) AddTaskFBFqa("qaFBFce",kFALSE);
460	qaFBFCE->SelectCollisionCandidates(AliVEvent::kCentral);
461	}
462	}
463
464	void QAmerge(const char *dir, Int_t stage)
465	{
466	// Merging method
467	TStopwatch timer;
468	timer.Start();
469	TString outputDir = dir;
470	TString outputFiles = "QAresults.root,EventStat_temp.root,RecoQAresults.root";
471	TString mergeExcludes = "";
472	TObjArray *list = outputFiles.Tokenize(",");
473	TIter *iter = new TIter(list);
474	TObjString *str;
475	TString outputFile;
476	Bool_t merged = kTRUE;
477	while((str=(TObjString*)iter->Next())) {
478	outputFile = str->GetString();
479	// Skip already merged outputs
480	if (!gSystem->AccessPathName(outputFile)) {
481	printf("Output file <%s> found. Not merging again.",outputFile.Data());
482	continue;
483	}
484	if (mergeExcludes.Contains(outputFile.Data())) continue;
485	merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, stage);
486	if (!merged) {
487	printf("ERROR: Cannot merge %s\n", outputFile.Data());
488	return;
489	}
490	}
491	// read the analysis manager from file
492	if (!outputDir.Contains("Stage")) {
493	ofstream out;
494	out.open("outputs_valid", ios::out);
495	out.close();
496	return;
497	}
498	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
499	mgr->SetRunFromPath(mgr->GetRunFromAlienPath(dir));
500	mgr->SetSkipTerminate(kFALSE);
501	if (!mgr->InitAnalysis()) return;
502	mgr->PrintStatus();
503	AliLog::SetGlobalLogLevel(AliLog::kError);
504	TTree *tree = NULL;
505	mgr->StartAnalysis("gridterminate", tree);
506	ofstream out;
507	out.open("outputs_valid", ios::out);
508	out.close();
509	timer.Print();
510	}