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

// Steer TRD QA train for Reconstruction (Clusterizer, Tracking and PID).
// 
// Usage:
//   run.C(tasks, files, entries)
//   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
//     "RES"  : TRD tracking Resolution
//     "CLRES": clusters Resolution
//     "CAL"  : TRD calibration
//     "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")
//
// 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 "AliMagFMaps.h"
#include "AliTracker.h"
#include "AliLog.h"
#include "AliCDBManager.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/AliTRDtrackInfoGen.h"
#include "TRD/qaRec/AliTRDtrackingEfficiency.h"
#include "TRD/qaRec/AliTRDtrackingEfficiencyCombined.h"
#include "TRD/qaRec/AliTRDtrackingResolution.h"
#include "TRD/qaRec/AliTRDcalibration.h"
#include "TRD/qaRec/AliTRDpidChecker.h"
#include "TRD/qaRec/AliTRDpidRefMaker.h"
#include "TRD/qaRec/AliTRDcheckDetector.h"
#include "TRD/qaRec/AliTRDclusterResolution.h"
#endif

#include "run.h"

Bool_t MEM = kFALSE;

TChain* CreateESDChain(const char* filename = 0x0, Int_t nfiles=-1 );
void run(Char_t *tasks="ALL", const Char_t *files=0x0, Int_t nmax=-1)
{
  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;
  
  Bool_t fHasMCdata = kTRUE;
  Bool_t fHasFriends = kTRUE;
  TObjArray *tasksArray = TString(tasks).Tokenize(" ");

  Int_t fSteerTask = 0; SETBIT(fSteerTask, kInfoGen);
  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 = 1; itask <= NTRDTASKS; 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);
        foundOpt = kTRUE;
        break;
      }
      if(!foundOpt) Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
    }
  }
  // extra rules for calibration tasks
  if(TSTBIT(fSteerTask, kClusterErrorParam)) SETBIT(fSteerTask, kTrackingResolution);

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

  //____________________________________________//
  //gROOT->LoadMacro(Form("%s/TRD/qaRec/CreateESDChain.C", gSystem->ExpandPathName("$ALICE_ROOT")));
  TChain *chain = CreateESDChain(files, nmax);
  //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 QA Reconstruction Manager");
  //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 track summary generator
  mgr->AddTask(task = new AliTRDtrackInfoGen());
  taskPtr[(Int_t)kInfoGen] = task;
  task->SetDebugLevel(1);
  task->SetMCdata(fHasMCdata);
  // Create containers for input/output
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("data", TChain::Class(), AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("trackInfo", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
  AliAnalysisDataContainer *coutput1a = mgr->CreateContainer("eventInfo", AliTRDeventInfo::Class(), AliAnalysisManager::kExchangeContainer);
  mgr->ConnectInput( task, 0, cinput1);
  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(4);
    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, kTrackingEfficiency)){
    mgr->AddTask(task = new AliTRDtrackingEfficiency());
    taskPtr[(Int_t)kTrackingEfficiency] = 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, kTrackingCombinedEfficiency)){
    mgr->AddTask(task = new AliTRDtrackingEfficiencyCombined());
    taskPtr[(Int_t)kTrackingCombinedEfficiency] = 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, kTrackingResolution)){
    mgr->AddTask(task = new AliTRDtrackingResolution());
    taskPtr[(Int_t)kTrackingResolution] = task;
    task->SetMCdata(fHasMCdata);
    task->SetPostProcess(kFALSE);
    task->SetDebugLevel(1);
    
    // 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 = 5;
    const Char_t *cn[nc] = {"ClRez", "TrkltRez", "TrkltPhiRez", "ClRes", "TrkltRes"}; 
    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, kClusterErrorParam)){
      mgr->AddTask(task = new AliTRDclusterResolution());
      taskPtr[(Int_t)kClusterErrorParam] = task;
      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());
      mgr->ConnectInput(task, 0, co[1]);
      mgr->ConnectOutput(task, 0, mgr->CreateContainer(Form("%sMC", task->GetName()), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sMC.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 pid checker
  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]->GetTitle(), taskPtr[itask]->GetName());
  }
  printf("\n\n");
  //mgr->PrintStatus();


  AliCDBManager *cdbManager = AliCDBManager::Instance();
  cdbManager->SetDefaultStorage("local://$ALICE_ROOT");
  //cdbManager->SetSpecificStorage("TRD/Calib/FEE","local:///u/bailhach/aliroot/database30head/database");
  cdbManager->SetRun(0);
  cdbManager->SetCacheFlag(kFALSE);
 
  // initialize TRD settings
  AliMagFMaps *field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
  AliTracker::SetFieldMap(field, kTRUE);
  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
  AliTRDtrackerV1::SetNTimeBins(cal->GetNumberOfTimeBins());
  AliGeomManager::LoadGeometry();


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

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

  cal->Terminate();
  delete field;
  delete cdbManager;
  for(Int_t it=NTRDTASKS-1; it>=0; it--) if(taskPtr[it]) delete taskPtr[it];
  if(mcH) delete mcH;
  delete esdH;
  delete mgr;
  delete chain;
  if(MEM) delete mem;
  if(MEM) TMemStatViewerGUI::ShowGUI();
}


TChain* CreateESDChain(const char* filename, Int_t nfiles)
{
  // 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() && (nfiles--) ) {
    in >> esdfile;
    if (!esdfile.Contains("root")) continue; // protection
    chain->Add(esdfile.Data());
  }

  in.close();

  return chain;
}
Commit	Line	Data
77203477	1	// Steer TRD QA train for Reconstruction (Clusterizer, Tracking and PID).
	2	//
	3	// Usage:
	4	// run.C(tasks, files, entries)
	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
	8	// "RES" : TRD tracking Resolution
5198d8c6	9	// "CLRES": clusters Resolution
ba2773d0	10	// "CAL" : TRD calibration
77203477	11	// "PID" : TRD PID - pion efficiency
77203477	12	// "PIDR" : TRD PID - reference data
2b468513	13	// "DET" : Basic TRD Detector checks
28efdace	14	// "NOFR" : Data set does not have AliESDfriends.root
4b8f8a35	15	// "NOMC" : Data set does not have Monte Carlo Informations (real data), so all tasks which rely
4b8f8a35	16	// on MC information are switched off
2c0cf367	17	//
	18	// In compiled mode :
	19	// Don't forget to load first the libraries
	20	// gSystem->Load("libMemStat.so")
	21	// gSystem->Load("libMemStatGui.so")
	22	// gSystem->Load("libANALYSIS.so")
	23	// gSystem->Load("libTRDqaRec.so")
	24	//
77203477	25	// Authors:
	26	// Alex Bercuci (A.Bercuci@gsi.de)
	27	// Markus Fasel (m.Fasel@gsi.de)
	28
819f5b0f	29	#ifndef __CINT__
8cc0ed91	30	#include <Riostream.h>
8cc0ed91	31
819f5b0f	32	#include "TStopwatch.h"
	33	#include "TMemStat.h"
	34	#include "TMemStatViewerGUI.h"
	35
	36	#include "TROOT.h"
	37	#include "TSystem.h"
8cc0ed91	38	#include "TError.h"
819f5b0f	39	#include "TChain.h"
819f5b0f	40
8cc0ed91	41	#include "AliMagFMaps.h"
8cc0ed91	42	#include "AliTracker.h"
819f5b0f	43	#include "AliLog.h"
	44	#include "AliCDBManager.h"
	45	#include "AliAnalysisManager.h"
	46	#include "AliAnalysisDataContainer.h"
8cc0ed91	47	#include "AliMCEventHandler.h"
8cc0ed91	48	#include "AliESDInputHandler.h"
819f5b0f	49
8cc0ed91	50	#include "TRD/AliTRDtrackerV1.h"
8cc0ed91	51	#include "TRD/AliTRDcalibDB.h"
4c0f3c82	52	#include "TRD/qaRec/AliTRDtrackInfo/AliTRDeventInfo.h"
819f5b0f	53	#include "TRD/qaRec/AliTRDtrackInfoGen.h"
8cc0ed91	54	#include "TRD/qaRec/AliTRDtrackingEfficiency.h"
	55	#include "TRD/qaRec/AliTRDtrackingEfficiencyCombined.h"
	56	#include "TRD/qaRec/AliTRDtrackingResolution.h"
	57	#include "TRD/qaRec/AliTRDcalibration.h"
3d86166d	58	#include "TRD/qaRec/AliTRDpidChecker.h"
28efdace	59	#include "TRD/qaRec/AliTRDpidRefMaker.h"
2b468513	60	#include "TRD/qaRec/AliTRDcheckDetector.h"
5198d8c6	61	#include "TRD/qaRec/AliTRDclusterResolution.h"
819f5b0f	62	#endif
819f5b0f	63
3d86166d	64	#include "run.h"
3d86166d	65
819f5b0f	66	Bool_t MEM = kFALSE;
8cc0ed91	67
8cc0ed91	68	TChain* CreateESDChain(const char* filename = 0x0, Int_t nfiles=-1 );
0ddce9c3	69	void run(Char_t tasks="ALL", const Char_t files=0x0, Int_t nmax=-1)
77203477	70	{
819f5b0f	71	TMemStat *mem = 0x0;
8cc0ed91	72	if(MEM){
	73	gSystem->Load("libMemStat.so");
	74	gSystem->Load("libMemStatGui.so");
	75	mem = new TMemStat("new, gnubuildin");
	76	mem->AddStamp("Start");
	77	}
77203477	78
814ecea4	79	TStopwatch timer;
814ecea4	80	timer.Start();
814ecea4	81
107fde80	82	if(gSystem->Load("libANALYSIS.so")<0) return;
107fde80	83	if(gSystem->Load("libTRDqaRec.so")<0) return;
77203477	84
d2381af5	85	Bool_t fHasMCdata = kTRUE;
28efdace	86	Bool_t fHasFriends = kTRUE;
773d3f8c	87	TObjArray *tasksArray = TString(tasks).Tokenize(" ");
28efdace	88
28efdace	89	Int_t fSteerTask = 0; SETBIT(fSteerTask, kInfoGen);
773d3f8c	90	for(Int_t isel = 0; isel < tasksArray->GetEntriesFast(); isel++){
773d3f8c	91	TString s = (dynamic_cast<TObjString *>(tasksArray->UncheckedAt(isel)))->String();
77203477	92	if(s.CompareTo("ALL") == 0){
dec291b0	93	for(Int_t itask = 1; itask <= NTRDTASKS; itask++) SETBIT(fSteerTask, itask);
77203477	94	continue;
28efdace	95	} else if(s.CompareTo("NOFR") == 0){
	96	fHasFriends = kFALSE;
	97	} else if(s.CompareTo("NOMC") == 0){
d2381af5	98	fHasMCdata = kFALSE;
28efdace	99	} else {
28efdace	100	Bool_t foundOpt = kFALSE;
5198d8c6	101	for(Int_t itask = 1; itask <= NTRDTASKS; itask++){
4c0f3c82	102	if(s.CompareTo(fgkTRDtaskOpt[itask]) != 0) continue;
28efdace	103	SETBIT(fSteerTask, itask);
	104	foundOpt = kTRUE;
	105	break;
	106	}
	107	if(!foundOpt) Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
77203477	108	}
77203477	109	}
5198d8c6	110	// extra rules for calibration tasks
	111	if(TSTBIT(fSteerTask, kClusterErrorParam)) SETBIT(fSteerTask, kTrackingResolution);
	112
8cc0ed91	113	// define task list pointers;
107fde80	114	AliTRDrecoTask taskPtr[NTRDTASKS], task = 0x0;
107fde80	115	memset(taskPtr, 0, NTRDTASKSsizeof(AliAnalysisTask));
8cc0ed91	116
814ecea4	117	//____________________________________________//
8cc0ed91	118	//gROOT->LoadMacro(Form("%s/TRD/qaRec/CreateESDChain.C", gSystem->ExpandPathName("$ALICE_ROOT")));
77203477	119	TChain *chain = CreateESDChain(files, nmax);
814ecea4	120	//chain->SetBranchStatus("*", 0);
	121	chain->SetBranchStatus("FMD",0);
	122	chain->SetBranchStatus("Calo",0);
	123	chain->SetBranchStatus("Tracks", 1);
	124	chain->SetBranchStatus("ESDfriend*",1);
	125	chain->Lookup();
	126	chain->GetListOfFiles()->Print();
	127	printf("\n ----> CHAIN HAS %d ENTRIES <----\n\n", (Int_t)chain->GetEntries());
	128
	129	AliLog::SetGlobalLogLevel(AliLog::kError);
	130
	131	//____________________________________________
	132	// Make the analysis manager
3d86166d	133	AliAnalysisManager *mgr = new AliAnalysisManager("TRD QA Reconstruction Manager");
814ecea4	134	//mgr->SetSpecialOutputLocation(source); // To Be Changed
8cc0ed91	135	AliVEventHandler esdH = 0x0, mcH = 0x0;
	136	mgr->SetInputEventHandler(esdH = new AliESDInputHandler);
	137	if(fHasMCdata) mgr->SetMCtruthEventHandler(mcH = new AliMCEventHandler());
814ecea4	138	//mgr->SetDebugLevel(10);
	139
	140	//____________________________________________
	141	// TRD track summary generator
773d3f8c	142	mgr->AddTask(task = new AliTRDtrackInfoGen());
3d86166d	143	taskPtr[(Int_t)kInfoGen] = task;
b718144c	144	task->SetDebugLevel(1);
3d86166d	145	task->SetMCdata(fHasMCdata);
814ecea4	146	// Create containers for input/output
814ecea4	147	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("data", TChain::Class(), AliAnalysisManager::kInputContainer);
421fb961	148	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("trackInfo", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
421fb961	149	AliAnalysisDataContainer *coutput1a = mgr->CreateContainer("eventInfo", AliTRDeventInfo::Class(), AliAnalysisManager::kExchangeContainer);
773d3f8c	150	mgr->ConnectInput( task, 0, cinput1);
773d3f8c	151	mgr->ConnectOutput(task, 0, coutput1);
421fb961	152	mgr->ConnectOutput(task, 1, coutput1a);
814ecea4	153
28efdace	154	//____________________________________________
28efdace	155	// TRD detector checker
10557e39	156	if(TSTBIT(fSteerTask, kCheckDetector)){
28efdace	157	mgr->AddTask(task = new AliTRDcheckDetector());
28efdace	158	taskPtr[(Int_t)kCheckDetector] = task;
9e548ae7	159	task->SetDebugLevel(4);
28efdace	160	task->SetMCdata(fHasMCdata);
	161
	162	// Create containers for input/output
	163	mgr->ConnectInput( task, 0, coutput1);
421fb961	164	mgr->ConnectInput( task, 1, coutput1a);
28efdace	165	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
	166	}
	167
814ecea4	168	//____________________________________________
814ecea4	169	// TRD barrel tracking efficiency
10557e39	170	if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEfficiency)){
773d3f8c	171	mgr->AddTask(task = new AliTRDtrackingEfficiency());
3d86166d	172	taskPtr[(Int_t)kTrackingEfficiency] = task;
	173	task->SetDebugLevel(0);
	174
77203477	175	//Create containers for input/output
773d3f8c	176	mgr->ConnectInput( task, 0, coutput1);
28efdace	177	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
77203477	178	}
814ecea4	179
	180	//____________________________________________
	181	// TRD combined tracking efficiency
10557e39	182	if(fHasMCdata && TSTBIT(fSteerTask, kTrackingCombinedEfficiency)){
773d3f8c	183	mgr->AddTask(task = new AliTRDtrackingEfficiencyCombined());
3d86166d	184	taskPtr[(Int_t)kTrackingCombinedEfficiency] = task;
3d86166d	185	task->SetDebugLevel(0);
773d3f8c	186
77203477	187	// Create containers for input/output
773d3f8c	188	mgr->ConnectInput( task, 0, coutput1);
28efdace	189	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
77203477	190	}
814ecea4	191
77203477	192	//____________________________________________
e26505aa	193	// TRD tracking resolution
10557e39	194	if(TSTBIT(fSteerTask, kTrackingResolution)){
773d3f8c	195	mgr->AddTask(task = new AliTRDtrackingResolution());
3d86166d	196	taskPtr[(Int_t)kTrackingResolution] = task;
3d86166d	197	task->SetMCdata(fHasMCdata);
2b468513	198	task->SetPostProcess(kFALSE);
b718144c	199	task->SetDebugLevel(1);
3d86166d	200
77203477	201	// Create containers for input/output
773d3f8c	202	mgr->ConnectInput( task, 0, coutput1);
28efdace	203	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
b2dc316d	204
5198d8c6	205	// Create output containers for calibration tasks
dec291b0	206	const Int_t nc = 5;
dec291b0	207	const Char_t *cn[nc] = {"ClRez", "TrkltRez", "TrkltPhiRez", "ClRes", "TrkltRes"};
5198d8c6	208	AliAnalysisDataContainer *co[nc];
	209	for(Int_t ic = 0; ic<nc; ic++){
	210	co[ic] = mgr->CreateContainer(Form("%s%s", task->GetName(), cn[ic]), TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
	211	mgr->ConnectOutput(task, 1+ic, co[ic]);
	212	}
b2dc316d	213
b2dc316d	214	// test reconstruction calibration plugin
5198d8c6	215	if(TSTBIT(fSteerTask, kClusterErrorParam)){
	216	mgr->AddTask(task = new AliTRDclusterResolution());
	217	taskPtr[(Int_t)kClusterErrorParam] = task;
	218	mgr->ConnectInput(task, 0, co[0]);
	219	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
	220
	221	mgr->AddTask(task = new AliTRDclusterResolution());
	222	mgr->ConnectInput(task, 0, co[1]);
	223	mgr->ConnectOutput(task, 0, mgr->CreateContainer(Form("%sMC", task->GetName()), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sMC.root", task->GetName())));
	224	}
77203477	225	}
814ecea4	226
ba2773d0	227	//____________________________________________
ba2773d0	228	// TRD calibration
10557e39	229	if(TSTBIT(fSteerTask, kCalibration)){
773d3f8c	230	mgr->AddTask(task = new AliTRDcalibration());
3d86166d	231	taskPtr[(Int_t)kCalibration] = task;
773d3f8c	232	((AliTRDcalibration*)task)->SetLow(0);
773d3f8c	233	((AliTRDcalibration*)task)->SetHigh(30);
773d3f8c	234	((AliTRDcalibration*)task)->SetFillZero(kFALSE);
3d86166d	235	task->SetDebugLevel(0);
3d86166d	236
ba2773d0	237	// Create containers for input/output
773d3f8c	238	mgr->ConnectInput(task, 0, coutput1);
28efdace	239	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
ba2773d0	240	}
ba2773d0	241
773d3f8c	242	//____________________________________________
773d3f8c	243	// TRD pid checker
10557e39	244	if(TSTBIT(fSteerTask, kPIDChecker)){
773d3f8c	245	mgr->AddTask(task = new AliTRDpidChecker());
3d86166d	246	taskPtr[(Int_t)kPIDChecker] = task;
3d86166d	247	task->SetDebugLevel(0);
c7cf2032	248	task->SetMCdata(fHasMCdata);
3d86166d	249
773d3f8c	250	// Create containers for input/output
773d3f8c	251	mgr->ConnectInput( task, 0, coutput1);
28efdace	252	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
773d3f8c	253	}
773d3f8c	254
28efdace	255
2b468513	256	//____________________________________________
93e41bce	257	// TRD pid reference
10557e39	258	if(TSTBIT(fSteerTask, kPIDRefMaker)){
28efdace	259	mgr->AddTask(task = new AliTRDpidRefMaker());
28efdace	260	taskPtr[(Int_t)kPIDRefMaker] = task;
2b468513	261	task->SetDebugLevel(0);
d85cd79c	262	task->SetMCdata(fHasMCdata);
2b468513	263
2b468513	264	// Create containers for input/output
2b468513	265	mgr->ConnectInput( task, 0, coutput1);
28efdace	266	mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
93e41bce	267	mgr->ConnectOutput(task, 1, mgr->CreateContainer(Form("%sNN", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sNN.root", task->GetName())));
93e41bce	268	mgr->ConnectOutput(task, 2, mgr->CreateContainer(Form("%sLQ", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sLQ.root", task->GetName())));
2b468513	269	}
2b468513	270
28efdace	271
814ecea4	272	if (!mgr->InitAnalysis()) return;
3d86166d	273	printf("\n\tRUNNING TRAIN FOR TASKS:\n");
5198d8c6	274	for(Int_t itask = 1; itask <= NTRDTASKS; itask++){
10557e39	275	if(TSTBIT(fSteerTask, itask)) printf("\t %s [%s]\n", taskPtr[itask]->GetTitle(), taskPtr[itask]->GetName());
3d86166d	276	}
3d86166d	277	printf("\n\n");
d85cd79c	278	//mgr->PrintStatus();
819f5b0f	279
	280
	281	AliCDBManager *cdbManager = AliCDBManager::Instance();
	282	cdbManager->SetDefaultStorage("local://$ALICE_ROOT");
	283	//cdbManager->SetSpecificStorage("TRD/Calib/FEE","local:///u/bailhach/aliroot/database30head/database");
	284	cdbManager->SetRun(0);
2c0cf367	285	cdbManager->SetCacheFlag(kFALSE);
819f5b0f	286
d2381af5	287	// initialize TRD settings
8cc0ed91	288	AliMagFMaps *field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
8cc0ed91	289	AliTracker::SetFieldMap(field, kTRUE);
2c0cf367	290	AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
2c0cf367	291	AliTRDtrackerV1::SetNTimeBins(cal->GetNumberOfTimeBins());
7dc3c50c	292	AliGeomManager::LoadGeometry();
8cc0ed91	293
8cc0ed91	294
814ecea4	295	mgr->StartAnalysis("local",chain);
	296
	297	timer.Stop();
819f5b0f	298	timer.Print();
819f5b0f	299
2c0cf367	300	cal->Terminate();
8cc0ed91	301	delete field;
8cc0ed91	302	delete cdbManager;
107fde80	303	for(Int_t it=NTRDTASKS-1; it>=0; it--) if(taskPtr[it]) delete taskPtr[it];
8cc0ed91	304	if(mcH) delete mcH;
	305	delete esdH;
	306	delete mgr;
	307	delete chain;
819f5b0f	308	if(MEM) delete mem;
819f5b0f	309	if(MEM) TMemStatViewerGUI::ShowGUI();
814ecea4	310	}
8cc0ed91	311
	312
	313	TChain* CreateESDChain(const char* filename, Int_t nfiles)
	314	{
	315	// Create the chain
	316	TChain* chain = new TChain("esdTree");
	317
	318	if(!filename){
	319	chain->Add(Form("%s/AliESDs.root", gSystem->pwd()));
	320	return chain;
	321	}
	322
	323
	324	// read ESD files from the input list.
	325	ifstream in;
	326	in.open(filename);
	327	TString esdfile;
	328	while(in.good() && (nfiles--) ) {
	329	in >> esdfile;
	330	if (!esdfile.Contains("root")) continue; // protection
	331	chain->Add(esdfile.Data());
	332	}
	333
	334	in.close();
	335
	336	return chain;
	337	}