[u/mrichter/AliRoot.git] / TRD / qaRec / run.C

// Steer TRD QA train for Reconstruction (Clusterizer, Tracking and PID).
// 
// Usage:
//   run.C(tasks, files)
//   tasks : "ALL" or one/more of the following:
//     "EFF"  : TRD Tracking Efficiency 
//     "EFFC" : TRD Tracking Efficiency Combined (barrel + stand alone) - only in case of simulations
//     "MULT"  : TRD single track selection
//     "RES"  : TRD tracking Resolution
//     "CLRES": clusters Resolution
//     "CAL"  : TRD calibration
//     "ALGN" : TRD alignment
//     "PID"  : TRD PID - pion efficiency 
//     "PIDR" : TRD PID - reference data
//     "DET"  : Basic TRD Detector checks
//     "NOFR" : Data set does not have AliESDfriends.root 
//     "NOMC" : Data set does not have Monte Carlo Informations (real data), so all tasks which rely
//              on MC information are switched off
//
// In compiled mode : 
// Don't forget to load first the libraries
// gSystem->Load("libMemStat.so")
// gSystem->Load("libMemStatGui.so")
// gSystem->Load("libANALYSIS.so")
// gSystem->Load("libTRDqaRec.so")
// gSystem->Load("libNetx.so") ;
// gSystem->Load("libRAliEn.so");
//
// Authors:
//   Alex Bercuci (A.Bercuci@gsi.de) 
//   Markus Fasel (m.Fasel@gsi.de) 

#ifndef __CINT__
#include <Riostream.h>

#include "TStopwatch.h"
#include "TMemStat.h"
#include "TMemStatViewerGUI.h"

#include "TROOT.h"
#include "TSystem.h"
#include "TError.h"
#include "TChain.h"
#include "TGrid.h"
#include "TAlienCollection.h"
#include "TGridCollection.h"
#include "TGridResult.h"
#include "TGeoGlobalMagField.h"

#include "AliMagF.h"
#include "AliTracker.h"
#include "AliLog.h"
#include "AliCDBManager.h"
#include "AliGeomManager.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
#include "AliMCEventHandler.h"
#include "AliESDInputHandler.h"

#include "TRD/AliTRDtrackerV1.h"
#include "TRD/AliTRDcalibDB.h"
#include "TRD/qaRec/AliTRDtrackInfo/AliTRDeventInfo.h"
#include "TRD/qaRec/AliTRDcheckESD.h"
#include "TRD/qaRec/AliTRDtrackInfoGen.h"
#include "TRD/qaRec/AliTRDtrackingEfficiency.h"
#include "TRD/qaRec/AliTRDtrackingEfficiencyCombined.h"
#include "TRD/qaRec/AliTRDresolution.h"
#include "TRD/qaRec/AliTRDcalibration.h"
#include "TRD/qaRec/AliTRDalignmentTask.h"
#include "TRD/qaRec/AliTRDpidChecker.h"
#include "TRD/qaRec/AliTRDpidRefMaker.h"
#include "TRD/qaRec/AliTRDcheckDetector.h"
#include "TRD/qaRec/AliTRDclusterResolution.h"
#include "TRD/qaRec/AliTRDmultiplicity.h"
#endif

#include "run.h"

Bool_t MEM = kFALSE;

TChain* MakeChainLST(const char* filename = 0x0);
TChain* MakeChainXML(const char* filename = 0x0);
void run(Char_t *tasks="ALL", const Char_t *files=0x0)
{
  TMemStat *mem = 0x0;
  if(MEM){ 
    gSystem->Load("libMemStat.so");
    gSystem->Load("libMemStatGui.so");
    mem = new TMemStat("new, gnubuildin");
    mem->AddStamp("Start");
  }

  TStopwatch timer;
  timer.Start();

  if(gSystem->Load("libANALYSIS.so")<0) return;
  if(gSystem->Load("libTRDqaRec.so")<0) return;
  
  // DB INITIALIZATION
  //TODO We should use the GRP if available similar to AliReconstruction::InitGRP()!
  // initialize OCDB manager
  AliCDBManager *cdbManager = AliCDBManager::Instance();
  cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  cdbManager->SetRun(0);
  cdbManager->SetCacheFlag(kFALSE);
  // initialize magnetic field.
  AliMagF *field = 0x0;
  field = new AliMagF("Maps","Maps", 2, 1., 10., AliMagF::k5kG);
  //field = new AliMagF("Maps","Maps", 2, 0., 10., AliMagF::k2kG);
  TGeoGlobalMagField::Instance()->SetField(field);

  // initialize TRD settings
  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
  AliTRDtrackerV1::SetNTimeBins(cal->GetNumberOfTimeBins());
  AliGeomManager::LoadGeometry();

  Bool_t fHasMCdata = kTRUE;
  Bool_t fHasFriends = kTRUE;
  TObjArray *tasksArray = TString(tasks).Tokenize(" ");

  Int_t fSteerTask = 0;
  for(Int_t isel = 0; isel < tasksArray->GetEntriesFast(); isel++){
    TString s = (dynamic_cast<TObjString *>(tasksArray->UncheckedAt(isel)))->String();
    if(s.CompareTo("ALL") == 0){
      for(Int_t itask = 0; itask < NQATASKS; itask++) SETBIT(fSteerTask, itask);
      continue;
    } else if(s.CompareTo("NOFR") == 0){ 
      fHasFriends = kFALSE;
    } else if(s.CompareTo("NOMC") == 0){ 
      fHasMCdata = kFALSE;
    } else { 
      Bool_t foundOpt = kFALSE;  
      for(Int_t itask = 1; itask < NTRDTASKS; itask++){
        if(s.CompareTo(fgkTRDtaskOpt[itask]) != 0) continue;
        SETBIT(fSteerTask, itask); SETBIT(fSteerTask, 0);
        foundOpt = kTRUE;
        break;
      }
      if(!foundOpt) Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
    }
  }
  // extra rules for calibration tasks
  if(TSTBIT(fSteerTask, kClErrParam)) SETBIT(fSteerTask, kResolution);
  if(TSTBIT(fSteerTask, kMultiplicity)) SETBIT(fSteerTask, kTrackingEff);
  if(TSTBIT(fSteerTask, kPIDRefMaker)) SETBIT(fSteerTask, kPIDChecker);
  if(TSTBIT(fSteerTask, kAlignment)) SETBIT(fSteerTask, kResolution);

  // define task list pointers;
  AliTRDrecoTask *taskPtr[NTRDTASKS], *task = 0x0;
  memset(taskPtr, 0, NTRDTASKS*sizeof(AliAnalysisTask*));

  //____________________________________________//
  // DEFINE DATA CHAIN
  TChain *chain = 0x0;
  if(!files) chain = MakeChainLST();
  else{
    TString fn(files);
    if(fn.EndsWith("xml")) chain = MakeChainXML(files);
    else chain = MakeChainLST(files);
  }
  if(!chain) return;

  //chain->SetBranchStatus("*", 0);
  chain->SetBranchStatus("*FMD*",0);
  chain->SetBranchStatus("*Calo*",0);
  chain->SetBranchStatus("Tracks", 1);
  chain->SetBranchStatus("ESDfriend*",1);
  chain->Lookup();
  chain->GetListOfFiles()->Print();
  printf("\n ----> CHAIN HAS %d ENTRIES <----\n\n", (Int_t)chain->GetEntries());
  
  AliLog::SetGlobalLogLevel(AliLog::kError);

  //____________________________________________
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("TRD Reconstruction QA");
  //mgr->SetSpecialOutputLocation(source); // To Be Changed
  AliVEventHandler *esdH = 0x0, *mcH = 0x0;
  mgr->SetInputEventHandler(esdH = new AliESDInputHandler);
  if(fHasMCdata) mgr->SetMCtruthEventHandler(mcH = new AliMCEventHandler());
  //mgr->SetDebugLevel(10);

  //____________________________________________
  // TRD check ESD
  AliTRDcheckESD *checkESD = new AliTRDcheckESD();
  mgr->AddTask(checkESD);
  checkESD->SetMC(fHasMCdata);
  mgr->ConnectInput(checkESD, 0, mgr->GetCommonInputContainer());  mgr->ConnectOutput(checkESD, 0, mgr->CreateContainer(checkESD->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", checkESD->GetName())));

  //____________________________________________
  // TRD track summary generator
  AliAnalysisDataContainer *coutput1 = 0x0, *coutput1a = 0x0;
	if(TSTBIT(fSteerTask, kInfoGen)){
    mgr->AddTask(task = new AliTRDtrackInfoGen());
    taskPtr[(Int_t)kInfoGen] = task;
    task->SetDebugLevel(0);
    task->SetMCdata(fHasMCdata);
    mgr->ConnectInput( task, 0, mgr->GetCommonInputContainer());
    coutput1 = mgr->CreateContainer("trackInfo", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
    coutput1a = mgr->CreateContainer("eventInfo", AliTRDeventInfo::Class(), AliAnalysisManager::kExchangeContainer);
    mgr->ConnectOutput(task, 0, coutput1);
    mgr->ConnectOutput(task, 1, coutput1a);
  }

  //____________________________________________
  // TRD detector checker
	if(TSTBIT(fSteerTask, kCheckDetector)){
    mgr->AddTask(task = new AliTRDcheckDetector());
    taskPtr[(Int_t)kCheckDetector] = task;
    task->SetDebugLevel(0);
    task->SetMCdata(fHasMCdata);
    
    // Create containers for input/output
    mgr->ConnectInput( task, 0, coutput1);
    mgr->ConnectInput( task, 1, coutput1a);
    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
  }

  //____________________________________________
  // TRD barrel tracking efficiency
  if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEff)){
    mgr->AddTask(task = new AliTRDtrackingEfficiency());
    taskPtr[(Int_t)kTrackingEff] = task;
    task->SetDebugLevel(0);

    //Create containers for input/output
    mgr->ConnectInput( task, 0, coutput1);
    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
    
    // TRD single track selection
    if(TSTBIT(fSteerTask, kMultiplicity)){
      mgr->AddTask(task = new AliTRDmultiplicity());
      taskPtr[(Int_t)kMultiplicity] = task;
      task->SetDebugLevel(0);
      // Create containers for input/output
      mgr->ConnectInput( task, 0, coutput1);
      mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
    }
  }

  //____________________________________________
  // TRD combined tracking efficiency
  if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEffMC)){
    mgr->AddTask(task = new AliTRDtrackingEfficiencyCombined());
    taskPtr[(Int_t)kTrackingEffMC] = task;
    task->SetDebugLevel(0);

    // Create containers for input/output
    mgr->ConnectInput( task, 0, coutput1);
    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
  }

  //____________________________________________
  // TRD tracking resolution
  if(TSTBIT(fSteerTask, kResolution)){
    mgr->AddTask(task = new AliTRDresolution());
    taskPtr[(Int_t)kResolution] = task;
    task->SetMCdata(fHasMCdata);
    task->SetPostProcess(kFALSE);
    task->SetDebugLevel(0);
    
    // Create containers for input/output
    mgr->ConnectInput( task, 0, coutput1);
    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));

    // Create output containers for calibration tasks
    const Int_t nc = 4;
    const Char_t *cn[nc] = {"Cl", "Trklt", "MC_Cl", "MC_Trklt"}; 
    AliAnalysisDataContainer *co[nc]; 
    for(Int_t ic = 0; ic<nc; ic++){
      co[ic] = mgr->CreateContainer(Form("%s%s", task->GetName(), cn[ic]), TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
      mgr->ConnectOutput(task, 1+ic, co[ic]);
    }
    
    // test reconstruction calibration plugin
    if(TSTBIT(fSteerTask, kClErrParam)){
      mgr->AddTask(task = new AliTRDclusterResolution());
      taskPtr[(Int_t)kClErrParam] = task;
      ((AliTRDclusterResolution*)task)->SetExB();
      mgr->ConnectInput(task, 0, co[0]);
      mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
  
      mgr->AddTask(task = new AliTRDclusterResolution("ClErrParamMC"));
      taskPtr[(Int_t)kClErrParam+1] = task;
      ((AliTRDclusterResolution*)task)->SetExB();
      mgr->ConnectInput(task, 0, co[2]);
      mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
    }
  }

  //____________________________________________
  // TRD calibration
  if(TSTBIT(fSteerTask, kCalibration)){
    mgr->AddTask(task = new AliTRDcalibration());
    taskPtr[(Int_t)kCalibration] = task;
    ((AliTRDcalibration*)task)->SetLow(0);
    ((AliTRDcalibration*)task)->SetHigh(30);
    ((AliTRDcalibration*)task)->SetFillZero(kFALSE);
    task->SetDebugLevel(0);

    // Create containers for input/output
    mgr->ConnectInput(task, 0, coutput1);
    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
  }
  
  //____________________________________________
  // TRD alignment
  if(TSTBIT(fSteerTask, kAlignment)){
    mgr->AddTask(task = new AliTRDalignmentTask());
    taskPtr[(Int_t)kAlignment] = task;
    task->SetDebugLevel(0);

    // Create containers for input/output
    mgr->ConnectInput(task, 0, coutput1);
    mgr->ConnectOutput(task, 0, mgr->CreateContainer(Form("h%s", task->GetName()), TObjArray::Class(), AliAnalysisManager::kExchangeContainer));

    mgr->ConnectOutput(task, 1, mgr->CreateContainer(task->GetName(), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
  }
  
  //____________________________________________
  // TRD PID
  if(TSTBIT(fSteerTask, kPIDChecker)){
    mgr->AddTask(task = new AliTRDpidChecker());
    taskPtr[(Int_t)kPIDChecker] = task;
    task->SetDebugLevel(0);
    task->SetMCdata(fHasMCdata);
    
    // Create containers for input/output
    mgr->ConnectInput( task, 0, coutput1);
    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));

    //____________________________________________
    // TRD pid reference 
    if(TSTBIT(fSteerTask, kPIDRefMaker)){
      mgr->AddTask(task = new AliTRDpidRefMaker());
      taskPtr[(Int_t)kPIDRefMaker] = task;
      task->SetDebugLevel(0);
      task->SetMCdata(fHasMCdata);
      
      // Create containers for input/output
      mgr->ConnectInput( task, 0, coutput1);
      mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
      mgr->ConnectOutput(task, 1, mgr->CreateContainer(Form("%sNN", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sNN.root", task->GetName())));
      mgr->ConnectOutput(task, 2, mgr->CreateContainer(Form("%sLQ", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sLQ.root", task->GetName())));
    }
  }


  if (!mgr->InitAnalysis()) return;
  printf("\n\tRUNNING TRAIN FOR TASKS:\n");
  for(Int_t itask = 1; itask < NTRDTASKS; itask++){
    if(TSTBIT(fSteerTask, itask)) printf("\t   %s [%s]\n",  taskPtr[itask]->GetName(), taskPtr[itask]->GetTitle());
  }
  printf("\n\n");
  //mgr->PrintStatus();

  mgr->StartAnalysis("local", chain);

  timer.Stop();
  timer.Print();  

  cal->Terminate();
  TGeoGlobalMagField::Instance()->SetField(NULL);
  delete cdbManager;
  for(Int_t it=NTRDTASKS; it--; ){ 
    if(taskPtr[it]){ 
      printf("Cleaning %s [%s] ...\n", fgkTRDtaskClassName[it], taskPtr[it]->GetTitle());
      delete taskPtr[it];
    }
  }
  delete checkESD;

  if(mcH) delete mcH;
  delete esdH;
  delete mgr;
  delete chain;
  if(MEM) delete mem;
  if(MEM) TMemStatViewerGUI::ShowGUI();
}

//____________________________________________
TChain* MakeChainLST(const char* filename)
{
  // Create the chain
  TChain* chain = new TChain("esdTree");

  if(!filename){
    chain->Add(Form("%s/AliESDs.root", gSystem->pwd()));
    return chain;
  }


  // read ESD files from the input list.
  ifstream in;
  in.open(filename);
  TString esdfile;
  while(in.good()) {
    in >> esdfile;
    if (!esdfile.Contains("root")) continue; // protection
    chain->Add(esdfile.Data());
  }

  in.close();

  return chain;
}

//____________________________________________
TChain* MakeChainXML(const char* xmlfile)
{
  if (!TFile::Open(xmlfile)) {
    Error("MakeChainXML", Form("No file %s was found", xmlfile));
    return 0x0;
  }

  if(gSystem->Load("libNetx.so")<0) return 0x0;
  if(gSystem->Load("libRAliEn.so")<0) return 0x0;
  TGrid::Connect("alien://") ;

  TGridCollection *collection = (TGridCollection*) TAlienCollection::Open(xmlfile);
  if (!collection) {
    Error("MakeChainXML", Form("No collection found in %s", xmlfile)) ; 
    return 0x0; 
  }
  //collection->CheckIfOnline();

  TGridResult* result = collection->GetGridResult("",0 ,0);
  if(!result->GetEntries()){
    Error("MakeChainXML", Form("No entries found in %s", xmlfile)) ; 
    return 0x0; 
  }
  // Makes the ESD chain 
  TChain* chain = new TChain("esdTree");
  for (Int_t idx = 0; idx < result->GetEntries(); idx++) {
    chain->Add(result->GetKey(idx, "turl")); 
  }
  return chain;
}
Commit	Line	Data
77203477	1	// Steer TRD QA train for Reconstruction (Clusterizer, Tracking and PID).
	2	//
	3	// Usage:
e15179be	4	// run.C(tasks, files)
77203477	5	// tasks : "ALL" or one/more of the following:
	6	// "EFF" : TRD Tracking Efficiency
	7	// "EFFC" : TRD Tracking Efficiency Combined (barrel + stand alone) - only in case of simulations
c792ca2e	8	// "MULT" : TRD single track selection
77203477	9	// "RES" : TRD tracking Resolution
5198d8c6	10	// "CLRES": clusters Resolution
ba2773d0	11	// "CAL" : TRD calibration
56bb0e8e	12	// "ALGN" : TRD alignment
77203477	13	// "PID" : TRD PID - pion efficiency
77203477	14	// "PIDR" : TRD PID - reference data
2b468513	15	// "DET" : Basic TRD Detector checks
28efdace	16	// "NOFR" : Data set does not have AliESDfriends.root
4b8f8a35	17	// "NOMC" : Data set does not have Monte Carlo Informations (real data), so all tasks which rely
4b8f8a35	18	// on MC information are switched off
2c0cf367	19	//
	20	// In compiled mode :
	21	// Don't forget to load first the libraries
	22	// gSystem->Load("libMemStat.so")
	23	// gSystem->Load("libMemStatGui.so")
	24	// gSystem->Load("libANALYSIS.so")
	25	// gSystem->Load("libTRDqaRec.so")
e15179be	26	// gSystem->Load("libNetx.so") ;
e15179be	27	// gSystem->Load("libRAliEn.so");
2c0cf367	28	//
77203477	29	// Authors:
	30	// Alex Bercuci (A.Bercuci@gsi.de)
	31	// Markus Fasel (m.Fasel@gsi.de)
	32
819f5b0f	33	#ifndef __CINT__
8cc0ed91	34	#include <Riostream.h>
8cc0ed91	35
819f5b0f	36	#include "TStopwatch.h"
	37	#include "TMemStat.h"
	38	#include "TMemStatViewerGUI.h"
	39
	40	#include "TROOT.h"
	41	#include "TSystem.h"
8cc0ed91	42	#include "TError.h"
819f5b0f	43	#include "TChain.h"
e15179be	44	#include "TGrid.h"
	45	#include "TAlienCollection.h"
	46	#include "TGridCollection.h"
	47	#include "TGridResult.h"
af735a05	48	#include "TGeoGlobalMagField.h"
819f5b0f	49
f7a1cc68	50	#include "AliMagF.h"
8cc0ed91	51	#include "AliTracker.h"
819f5b0f	52	#include "AliLog.h"
819f5b0f	53	#include "AliCDBManager.h"
e15179be	54	#include "AliGeomManager.h"
819f5b0f	55	#include "AliAnalysisManager.h"
819f5b0f	56	#include "AliAnalysisDataContainer.h"
8cc0ed91	57	#include "AliMCEventHandler.h"
8cc0ed91	58	#include "AliESDInputHandler.h"
819f5b0f	59
8cc0ed91	60	#include "TRD/AliTRDtrackerV1.h"
8cc0ed91	61	#include "TRD/AliTRDcalibDB.h"
4c0f3c82	62	#include "TRD/qaRec/AliTRDtrackInfo/AliTRDeventInfo.h"
9a281e83	63	#include "TRD/qaRec/AliTRDcheckESD.h"
819f5b0f	64	#include "TRD/qaRec/AliTRDtrackInfoGen.h"
8cc0ed91	65	#include "TRD/qaRec/AliTRDtrackingEfficiency.h"
8cc0ed91	66	#include "TRD/qaRec/AliTRDtrackingEfficiencyCombined.h"
e3cf3d02	67	#include "TRD/qaRec/AliTRDresolution.h"
8cc0ed91	68	#include "TRD/qaRec/AliTRDcalibration.h"
e15179be	69	#include "TRD/qaRec/AliTRDalignmentTask.h"
3d86166d	70	#include "TRD/qaRec/AliTRDpidChecker.h"
28efdace	71	#include "TRD/qaRec/AliTRDpidRefMaker.h"
2b468513	72	#include "TRD/qaRec/AliTRDcheckDetector.h"
5198d8c6	73	#include "TRD/qaRec/AliTRDclusterResolution.h"
c792ca2e	74	#include "TRD/qaRec/AliTRDmultiplicity.h"
819f5b0f	75	#endif
819f5b0f	76
3d86166d	77	#include "run.h"
3d86166d	78
819f5b0f	79	Bool_t MEM = kFALSE;
8cc0ed91	80
e15179be	81	TChain* MakeChainLST(const char* filename = 0x0);
	82	TChain* MakeChainXML(const char* filename = 0x0);
	83	void run(Char_t tasks="ALL", const Char_t files=0x0)
77203477	84	{
819f5b0f	85	TMemStat *mem = 0x0;
8cc0ed91	86	if(MEM){
	87	gSystem->Load("libMemStat.so");
	88	gSystem->Load("libMemStatGui.so");
	89	mem = new TMemStat("new, gnubuildin");
	90	mem->AddStamp("Start");
	91	}
77203477	92
814ecea4	93	TStopwatch timer;
814ecea4	94	timer.Start();
814ecea4	95
107fde80	96	if(gSystem->Load("libANALYSIS.so")<0) return;
107fde80	97	if(gSystem->Load("libTRDqaRec.so")<0) return;
77203477	98
6bc4a8f4	99	// DB INITIALIZATION
af735a05	100	//TODO We should use the GRP if available similar to AliReconstruction::InitGRP()!
6bc4a8f4	101	// initialize OCDB manager
6bc4a8f4	102	AliCDBManager *cdbManager = AliCDBManager::Instance();
162637e4	103	cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
6bc4a8f4	104	cdbManager->SetRun(0);
6bc4a8f4	105	cdbManager->SetCacheFlag(kFALSE);
af735a05	106	// initialize magnetic field.
	107	AliMagF *field = 0x0;
	108	field = new AliMagF("Maps","Maps", 2, 1., 10., AliMagF::k5kG);
	109	//field = new AliMagF("Maps","Maps", 2, 0., 10., AliMagF::k2kG);
	110	TGeoGlobalMagField::Instance()->SetField(field);
6fc46cba	111
6bc4a8f4	112	// initialize TRD settings
	113	AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
	114	AliTRDtrackerV1::SetNTimeBins(cal->GetNumberOfTimeBins());
	115	AliGeomManager::LoadGeometry();
	116
d2381af5	117	Bool_t fHasMCdata = kTRUE;
28efdace	118	Bool_t fHasFriends = kTRUE;
773d3f8c	119	TObjArray *tasksArray = TString(tasks).Tokenize(" ");
28efdace	120
48797466	121	Int_t fSteerTask = 0;
773d3f8c	122	for(Int_t isel = 0; isel < tasksArray->GetEntriesFast(); isel++){
773d3f8c	123	TString s = (dynamic_cast<TObjString *>(tasksArray->UncheckedAt(isel)))->String();
77203477	124	if(s.CompareTo("ALL") == 0){
48797466	125	for(Int_t itask = 0; itask < NQATASKS; itask++) SETBIT(fSteerTask, itask);
77203477	126	continue;
28efdace	127	} else if(s.CompareTo("NOFR") == 0){
	128	fHasFriends = kFALSE;
	129	} else if(s.CompareTo("NOMC") == 0){
d2381af5	130	fHasMCdata = kFALSE;
28efdace	131	} else {
28efdace	132	Bool_t foundOpt = kFALSE;
e15179be	133	for(Int_t itask = 1; itask < NTRDTASKS; itask++){
4c0f3c82	134	if(s.CompareTo(fgkTRDtaskOpt[itask]) != 0) continue;
48797466	135	SETBIT(fSteerTask, itask); SETBIT(fSteerTask, 0);
28efdace	136	foundOpt = kTRUE;
	137	break;
	138	}
	139	if(!foundOpt) Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
77203477	140	}
77203477	141	}
5198d8c6	142	// extra rules for calibration tasks
e15179be	143	if(TSTBIT(fSteerTask, kClErrParam)) SETBIT(fSteerTask, kResolution);
c792ca2e	144	if(TSTBIT(fSteerTask, kMultiplicity)) SETBIT(fSteerTask, kTrackingEff);
e15179be	145	if(TSTBIT(fSteerTask, kPIDRefMaker)) SETBIT(fSteerTask, kPIDChecker);
e15179be	146	if(TSTBIT(fSteerTask, kAlignment)) SETBIT(fSteerTask, kResolution);
5198d8c6	147
8cc0ed91	148	// define task list pointers;
e15179be	149	AliTRDrecoTask taskPtr[NTRDTASKS], task = 0x0;
e15179be	150	memset(taskPtr, 0, NTRDTASKSsizeof(AliAnalysisTask));
8cc0ed91	151
814ecea4	152	//____________________________________________//
e15179be	153	// DEFINE DATA CHAIN
	154	TChain *chain = 0x0;
	155	if(!files) chain = MakeChainLST();
	156	else{
	157	TString fn(files);
	158	if(fn.EndsWith("xml")) chain = MakeChainXML(files);
	159	else chain = MakeChainLST(files);
	160	}
	161	if(!chain) return;
	162
814ecea4	163	//chain->SetBranchStatus("*", 0);
	164	chain->SetBranchStatus("FMD",0);
	165	chain->SetBranchStatus("Calo",0);
	166	chain->SetBranchStatus("Tracks", 1);
	167	chain->SetBranchStatus("ESDfriend*",1);
	168	chain->Lookup();
	169	chain->GetListOfFiles()->Print();
	170	printf("\n ----> CHAIN HAS %d ENTRIES <----\n\n", (Int_t)chain->GetEntries());
	171
	172	AliLog::SetGlobalLogLevel(AliLog::kError);
	173
	174	//____________________________________________
	175	// Make the analysis manager
af735a05	176	AliAnalysisManager *mgr = new AliAnalysisManager("TRD Reconstruction QA");
814ecea4	177	//mgr->SetSpecialOutputLocation(source); // To Be Changed
8cc0ed91	178	AliVEventHandler esdH = 0x0, mcH = 0x0;
	179	mgr->SetInputEventHandler(esdH = new AliESDInputHandler);
	180	if(fHasMCdata) mgr->SetMCtruthEventHandler(mcH = new AliMCEventHandler());
814ecea4	181	//mgr->SetDebugLevel(10);
814ecea4	182
9a281e83	183	//____________________________________________
	184	// TRD check ESD
	185	AliTRDcheckESD *checkESD = new AliTRDcheckESD();
	186	mgr->AddTask(checkESD);
	187	checkESD->SetMC(fHasMCdata);
	188	mgr->ConnectInput(checkESD, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(checkESD, 0, mgr->CreateContainer(checkESD->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", checkESD->GetName())));
	189
814ecea4	190	//____________________________________________
814ecea4	191	// TRD track summary generator
e3cf3d02	192	AliAnalysisDataContainer coutput1 = 0x0, coutput1a = 0x0;
48797466	193	if(TSTBIT(fSteerTask, kInfoGen)){
	194	mgr->AddTask(task = new AliTRDtrackInfoGen());
	195	taskPtr[(Int_t)kInfoGen] = task;
	196	task->SetDebugLevel(0);
	197	task->SetMCdata(fHasMCdata);
	198	mgr->ConnectInput( task, 0, mgr->GetCommonInputContainer());
e3cf3d02	199	coutput1 = mgr->CreateContainer("trackInfo", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
e3cf3d02	200	coutput1a = mgr->CreateContainer("eventInfo", AliTRDeventInfo::Class(), AliAnalysisManager::kExchangeContainer);
48797466	201	mgr->ConnectOutput(task, 0, coutput1);
	202	mgr->ConnectOutput(task, 1, coutput1a);
	203	}
814ecea4	204
28efdace	205	//____________________________________________
28efdace	206	// TRD detector checker
10557e39	207	if(TSTBIT(fSteerTask, kCheckDetector)){
28efdace	208	mgr->AddTask(task = new AliTRDcheckDetector());
28efdace	209	taskPtr[(Int_t)kCheckDetector] = task;
af735a05	210	task->SetDebugLevel(0);
28efdace	211	task->SetMCdata(fHasMCdata);
	212
	213	// Create containers for input/output
	214	mgr->ConnectInput( task, 0, coutput1);
421fb961	215	mgr->ConnectInput( task, 1, coutput1a);
28efdace	216	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
	217	}
	218
814ecea4	219	//____________________________________________
814ecea4	220	// TRD barrel tracking efficiency
e15179be	221	if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEff)){
773d3f8c	222	mgr->AddTask(task = new AliTRDtrackingEfficiency());
e15179be	223	taskPtr[(Int_t)kTrackingEff] = task;
3d86166d	224	task->SetDebugLevel(0);
3d86166d	225
77203477	226	//Create containers for input/output
773d3f8c	227	mgr->ConnectInput( task, 0, coutput1);
28efdace	228	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
c792ca2e	229
	230	// TRD single track selection
	231	if(TSTBIT(fSteerTask, kMultiplicity)){
	232	mgr->AddTask(task = new AliTRDmultiplicity());
	233	taskPtr[(Int_t)kMultiplicity] = task;
	234	task->SetDebugLevel(0);
	235	// Create containers for input/output
	236	mgr->ConnectInput( task, 0, coutput1);
	237	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
	238	}
77203477	239	}
814ecea4	240
	241	//____________________________________________
	242	// TRD combined tracking efficiency
e15179be	243	if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEffMC)){
773d3f8c	244	mgr->AddTask(task = new AliTRDtrackingEfficiencyCombined());
e15179be	245	taskPtr[(Int_t)kTrackingEffMC] = task;
3d86166d	246	task->SetDebugLevel(0);
773d3f8c	247
77203477	248	// Create containers for input/output
773d3f8c	249	mgr->ConnectInput( task, 0, coutput1);
28efdace	250	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
77203477	251	}
814ecea4	252
77203477	253	//____________________________________________
e26505aa	254	// TRD tracking resolution
e15179be	255	if(TSTBIT(fSteerTask, kResolution)){
e3cf3d02	256	mgr->AddTask(task = new AliTRDresolution());
e15179be	257	taskPtr[(Int_t)kResolution] = task;
3d86166d	258	task->SetMCdata(fHasMCdata);
2b468513	259	task->SetPostProcess(kFALSE);
af735a05	260	task->SetDebugLevel(0);
3d86166d	261
77203477	262	// Create containers for input/output
773d3f8c	263	mgr->ConnectInput( task, 0, coutput1);
28efdace	264	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
b2dc316d	265
5198d8c6	266	// Create output containers for calibration tasks
6fc46cba	267	const Int_t nc = 4;
6fc46cba	268	const Char_t *cn[nc] = {"Cl", "Trklt", "MC_Cl", "MC_Trklt"};
5198d8c6	269	AliAnalysisDataContainer *co[nc];
	270	for(Int_t ic = 0; ic<nc; ic++){
	271	co[ic] = mgr->CreateContainer(Form("%s%s", task->GetName(), cn[ic]), TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
	272	mgr->ConnectOutput(task, 1+ic, co[ic]);
	273	}
b2dc316d	274
b2dc316d	275	// test reconstruction calibration plugin
e15179be	276	if(TSTBIT(fSteerTask, kClErrParam)){
5198d8c6	277	mgr->AddTask(task = new AliTRDclusterResolution());
e15179be	278	taskPtr[(Int_t)kClErrParam] = task;
6bc4a8f4	279	((AliTRDclusterResolution*)task)->SetExB();
5198d8c6	280	mgr->ConnectInput(task, 0, co[0]);
	281	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
	282
6fc46cba	283	mgr->AddTask(task = new AliTRDclusterResolution("ClErrParamMC"));
e15179be	284	taskPtr[(Int_t)kClErrParam+1] = task;
6bc4a8f4	285	((AliTRDclusterResolution*)task)->SetExB();
6fc46cba	286	mgr->ConnectInput(task, 0, co[2]);
6fc46cba	287	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
5198d8c6	288	}
77203477	289	}
814ecea4	290
ba2773d0	291	//____________________________________________
ba2773d0	292	// TRD calibration
10557e39	293	if(TSTBIT(fSteerTask, kCalibration)){
773d3f8c	294	mgr->AddTask(task = new AliTRDcalibration());
3d86166d	295	taskPtr[(Int_t)kCalibration] = task;
773d3f8c	296	((AliTRDcalibration*)task)->SetLow(0);
773d3f8c	297	((AliTRDcalibration*)task)->SetHigh(30);
773d3f8c	298	((AliTRDcalibration*)task)->SetFillZero(kFALSE);
3d86166d	299	task->SetDebugLevel(0);
3d86166d	300
ba2773d0	301	// Create containers for input/output
773d3f8c	302	mgr->ConnectInput(task, 0, coutput1);
28efdace	303	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
ba2773d0	304	}
ba2773d0	305
56bb0e8e	306	//____________________________________________
	307	// TRD alignment
	308	if(TSTBIT(fSteerTask, kAlignment)){
	309	mgr->AddTask(task = new AliTRDalignmentTask());
	310	taskPtr[(Int_t)kAlignment] = task;
	311	task->SetDebugLevel(0);
	312
	313	// Create containers for input/output
	314	mgr->ConnectInput(task, 0, coutput1);
	315	mgr->ConnectOutput(task, 0, mgr->CreateContainer(Form("h%s", task->GetName()), TObjArray::Class(), AliAnalysisManager::kExchangeContainer));
	316
	317	mgr->ConnectOutput(task, 1, mgr->CreateContainer(task->GetName(), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
	318	}
	319
773d3f8c	320	//____________________________________________
e15179be	321	// TRD PID
10557e39	322	if(TSTBIT(fSteerTask, kPIDChecker)){
773d3f8c	323	mgr->AddTask(task = new AliTRDpidChecker());
3d86166d	324	taskPtr[(Int_t)kPIDChecker] = task;
3d86166d	325	task->SetDebugLevel(0);
c7cf2032	326	task->SetMCdata(fHasMCdata);
3d86166d	327
773d3f8c	328	// Create containers for input/output
773d3f8c	329	mgr->ConnectInput( task, 0, coutput1);
28efdace	330	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
28efdace	331
e15179be	332	//____________________________________________
	333	// TRD pid reference
	334	if(TSTBIT(fSteerTask, kPIDRefMaker)){
	335	mgr->AddTask(task = new AliTRDpidRefMaker());
	336	taskPtr[(Int_t)kPIDRefMaker] = task;
	337	task->SetDebugLevel(0);
	338	task->SetMCdata(fHasMCdata);
	339
	340	// Create containers for input/output
	341	mgr->ConnectInput( task, 0, coutput1);
	342	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
	343	mgr->ConnectOutput(task, 1, mgr->CreateContainer(Form("%sNN", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sNN.root", task->GetName())));
	344	mgr->ConnectOutput(task, 2, mgr->CreateContainer(Form("%sLQ", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sLQ.root", task->GetName())));
	345	}
2b468513	346	}
2b468513	347
28efdace	348
814ecea4	349	if (!mgr->InitAnalysis()) return;
3d86166d	350	printf("\n\tRUNNING TRAIN FOR TASKS:\n");
e15179be	351	for(Int_t itask = 1; itask < NTRDTASKS; itask++){
e15179be	352	if(TSTBIT(fSteerTask, itask)) printf("\t %s [%s]\n", taskPtr[itask]->GetName(), taskPtr[itask]->GetTitle());
3d86166d	353	}
3d86166d	354	printf("\n\n");
d85cd79c	355	//mgr->PrintStatus();
819f5b0f	356
af735a05	357	mgr->StartAnalysis("local", chain);
814ecea4	358
814ecea4	359	timer.Stop();
819f5b0f	360	timer.Print();
819f5b0f	361
2c0cf367	362	cal->Terminate();
af735a05	363	TGeoGlobalMagField::Instance()->SetField(NULL);
8cc0ed91	364	delete cdbManager;
e15179be	365	for(Int_t it=NTRDTASKS; it--; ){
	366	if(taskPtr[it]){
	367	printf("Cleaning %s [%s] ...\n", fgkTRDtaskClassName[it], taskPtr[it]->GetTitle());
	368	delete taskPtr[it];
	369	}
94f34623	370	}
d12237d6	371	delete checkESD;
d12237d6	372
8cc0ed91	373	if(mcH) delete mcH;
	374	delete esdH;
	375	delete mgr;
	376	delete chain;
819f5b0f	377	if(MEM) delete mem;
819f5b0f	378	if(MEM) TMemStatViewerGUI::ShowGUI();
814ecea4	379	}
8cc0ed91	380
e15179be	381	//____________________________________________
e15179be	382	TChain* MakeChainLST(const char* filename)
8cc0ed91	383	{
	384	// Create the chain
	385	TChain* chain = new TChain("esdTree");
	386
	387	if(!filename){
	388	chain->Add(Form("%s/AliESDs.root", gSystem->pwd()));
	389	return chain;
	390	}
	391
	392
	393	// read ESD files from the input list.
	394	ifstream in;
	395	in.open(filename);
	396	TString esdfile;
e15179be	397	while(in.good()) {
8cc0ed91	398	in >> esdfile;
	399	if (!esdfile.Contains("root")) continue; // protection
	400	chain->Add(esdfile.Data());
	401	}
	402
	403	in.close();
	404
	405	return chain;
	406	}
e15179be	407
	408	//____________________________________________
	409	TChain* MakeChainXML(const char* xmlfile)
	410	{
	411	if (!TFile::Open(xmlfile)) {
	412	Error("MakeChainXML", Form("No file %s was found", xmlfile));
	413	return 0x0;
	414	}
	415
	416	if(gSystem->Load("libNetx.so")<0) return 0x0;
	417	if(gSystem->Load("libRAliEn.so")<0) return 0x0;
	418	TGrid::Connect("alien://") ;
	419
	420	TGridCollection collection = (TGridCollection) TAlienCollection::Open(xmlfile);
	421	if (!collection) {
	422	Error("MakeChainXML", Form("No collection found in %s", xmlfile)) ;
	423	return 0x0;
	424	}
	425	//collection->CheckIfOnline();
	426
	427	TGridResult* result = collection->GetGridResult("",0 ,0);
	428	if(!result->GetEntries()){
	429	Error("MakeChainXML", Form("No entries found in %s", xmlfile)) ;
	430	return 0x0;
	431	}
	432	// Makes the ESD chain
	433	TChain* chain = new TChain("esdTree");
	434	for (Int_t idx = 0; idx < result->GetEntries(); idx++) {
	435	chain->Add(result->GetKey(idx, "turl"));
	436	}
	437	return chain;
	438	}