[u/mrichter/AliRoot.git] / PWG0 / multPbPb / run.C

// TODO:
// 1. Check cuts for 2010 (Jochen?)
// 2. Run with many centrality bins at once
#include <string.h>

enum { kMyRunModeLocal = 0, kMyRunModeCAF, kMyRunModeGRID};

TList * listToLoad = new TList();

TChain * GetAnalysisChain(const char * incollection);

void run(Char_t* data, Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 0, Bool_t isMC = 0, 
	 Int_t centrBin = 0, const char * centrEstimator = "VOM", Bool_t useTrackCentralityCut = kFALSE, Int_t trackMin=0, Int_t trackMax=10000, 
	 const char* option = "",TString customSuffix = "", Int_t workers = -1)
{
  // runMode:
  //
  // 0 local 
  // 1 proof

  if (nev < 0)
    nev = 1234567890;

  InitAndLoadLibs(runMode,workers,debug);

  // Create the analysis manager
  mgr = new AliAnalysisManager;

  // Add ESD handler
  AliESDInputHandler* esdH = new AliESDInputHandler;
  // Do I need any of this? 
  esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks");
  mgr->SetInputEventHandler(esdH);

  if(isMC) {
    AliMCEventHandler* handler = new AliMCEventHandler;
    handler->SetPreReadMode(AliMCEventHandler::kLmPreRead);
    mgr->SetMCtruthEventHandler(handler);
  }


  // If we are running on grid, we need the alien handler
  if (runMode == kMyRunModeGRID) {
    // Create and configure the alien handler plugin
    gROOT->LoadMacro("CreateAlienHandler.C");
    AliAnalysisGrid *alienHandler = CreateAlienHandler(data, listToLoad, "full", isMC);  
    if (!alienHandler) {
      cout << "Cannot create alien handler" << endl;    
      exit(1);
    }
    mgr->SetGridHandler(alienHandler);  
  }


  // physics selection
  gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
  physicsSelectionTask = AddTaskPhysicsSelection(isMC,0);//FIXME
  // FIXME!!
  if(!isMC) {
    AliPhysicsSelection * physSel = physicsSelectionTask->GetPhysicsSelection();
    //    physSel->AddCollisionTriggerClass("+CTRUE-B-NOPF-ALL");
    physSel->AddCollisionTriggerClass("+CMBAC-B-NOPF-ALL");
    physSel->AddCollisionTriggerClass("+CMBS1C-B-NOPF-ALL");
    physSel->AddCollisionTriggerClass("+CMBS1A-B-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBAC-C-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1C-C-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1A-C-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBAC-A-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1C-A-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1A-A-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBAC-E-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1C-E-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1A-E-NOPF-ALL");
    //    physSel->AddBGTriggerClass       ("+C0SM1-E-NOPF-ALL");
  }

  // Centrality
  AliCentralitySelectionTask *taskCentr = new AliCentralitySelectionTask("CentralitySelection");
  // const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root";
  // const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root";
  const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/AliCentralityBy1D_LHC10g2a_100.root";
  const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/AliCentralityByFunction_LHC10g2a_100.root";
  taskCentr->SetPercentileFile (file1);
  taskCentr->SetPercentileFile2(file2);
  mgr->AddTask(taskCentr);
  mgr->ConnectInput (taskCentr,0, mgr->GetCommonInputContainer());

  // Create my own centrality selector
  AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector();
  centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only
  centrSelector->SetCentralityBin(centrBin);
  centrSelector->SetCentralityEstimator(centrEstimator);
  // FIXME!!!

  //centrSelector->SetIsMC(isMC,1500,2300);
  if(useTrackCentralityCut){
    centrSelector->SetUseMultRange();
    centrSelector->SetMultRange(trackMin,trackMax);
  }

  // Parse option strings
  TString optionStr(option);
  
  // remove SAVE option if set
  // This  is copied from a macro by Jan. The reason I kept it is that I may want to pass textual options to the new task at some point
  Bool_t doSave = kFALSE;
  TString optionStr(option);
  if (optionStr.Contains("SAVE"))
  {
    optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length());
    doSave = kTRUE;
  }

  AliESDtrackCuts * cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE);
  TString pathsuffix = "";
  // cuts->SetPtRange(0.15,0.2);// FIXME pt cut
  // const char * pathsuffix = "_pt_015_020_nofakes";

  if (optionStr.Contains("ITSsa")) {
    delete cuts;
    cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
    cout << ">>>> USING ITS sa tracks" << endl;
    pathsuffix="ITSsa";
  }

  if (optionStr.Contains("TPC")) {
    delete cuts;
    cuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
    cout << ">>>> USING TPC only tracks" << endl;
    pathsuffix="TPC";
  }

  Bool_t useMCKinematics = isMC;
  if (optionStr.Contains("NOMCKIN")) {
    cout << ">>>> Ignoring MC kinematics" << endl;
    useMCKinematics=kFALSE;
  }
  
  
  // load my task
  gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C");
  AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector); // kTRUE enables DCA cut
  task->SetIsMC(useMCKinematics);
  if (isMC) {
    task->SetOfflineTrigger(AliVEvent::kMB);
  } else {
    task->SetOfflineTrigger(AliVEvent::kUserDefined);
  }
  if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC");
  if(customSuffix!=""){
    cout << "Setting custom suffix: " << customSuffix << endl;    
    task->GetHistoManager()->SetSuffix(customSuffix);
  }
  //  task->SelectCollisionCandidates(AliVEvent::kUserDefined);
  if (!mgr->InitAnalysis()) return;
  
  mgr->PrintStatus();
  
  if (runMode == kMyRunModeLocal ) {
    // If running in local mode, create chain of ESD files
    cout << "RUNNING LOCAL, CHAIN" << endl;    
    TChain * chain = GetAnalysisChain(data);
    //    chain->Print();
    mgr->StartAnalysis("local",chain,nev);
  } else if (runMode == kMyRunModeCAF) {
    mgr->StartAnalysis("proof",TString(data)+"#esdTree",nev);
  } else if (runMode == kMyRunModeGRID) {
    mgr->StartAnalysis("grid");
  } else {
    cout << "ERROR: unknown run mode" << endl;        
  }

  if (!useTrackCentralityCut) {
    pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin);
  } else {
    pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax);
  }
  pathsuffix += customSuffix;

  if (doSave) MoveOutput(data, pathsuffix.Data());

  
}


void MoveOutput(const char * data, const char * suffix = ""){

  TString path("output/");
  path = path + TString(data).Tokenize("/")->Last()->GetName() + suffix;
  
  TString fileName = "multPbPbtracks.root";
  gSystem->mkdir(path, kTRUE);
  gSystem->Rename(fileName, path + "/" + fileName);
  gSystem->Rename("event_stat.root", path + "/event_stat.root");      
  Printf(">>>>> Moved files to %s", path.Data());
}  


TChain * GetAnalysisChain(const char * incollection){
  // Builds a chain of esd files
  // incollection can be
  // - a single root file
  // - an xml collection of files on alien
  // - a ASCII containing a list of local root files
  TChain* analysisChain = 0;
  // chain
  analysisChain = new TChain("esdTree");
  if (TString(incollection).Contains(".root")){
    analysisChain->Add(incollection);
  }
  else if (TString(incollection).Contains("xml")){
    TGrid::Connect("alien://");
    TAlienCollection * coll = TAlienCollection::Open (incollection);
    while(coll->Next()){
      analysisChain->Add(TString("alien://")+coll->GetLFN());
    }
  } else {
    ifstream file_collect(incollection);
    TString line;
    while (line.ReadLine(file_collect) ) {
      analysisChain->Add(line.Data());
    }
  }
  analysisChain->GetListOfFiles()->Print();

  return analysisChain;
}


void InitAndLoadLibs(Int_t runMode=kMyRunModeLocal, Int_t workers=0,Bool_t debug=0) {
  // Loads libs and par files + custom task and classes

  // Custom stuff to be loaded
  listToLoad->Add(new TObjString("$ALICE_ROOT/ANALYSIS/AliCentralitySelectionTask.cxx+"));
  listToLoad->Add(new TObjString("$ALICE_ROOT/PWG1/background/AliHistoListWrapper.cxx+"));
  listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbTrackHistoManager.cxx+"));
  listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbCentralitySelector.cxx+"));
  listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisTaskMultPbTracks.cxx+"));


  if (runMode == kMyRunModeCAF)
  {
    cout << "Init in CAF mode" << endl;
    
    gEnv->SetValue("XSec.GSI.DelegProxy", "2");
    TProof::Open("alice-caf.cern.ch", workers>0 ? Form("workers=%d",workers) : "");
    //    TProof::Open("skaf.saske.sk", workers>0 ? Form("workers=%d",workers) : "");
    
    // Enable the needed package
    gProof->UploadPackage("$ALICE_ROOT/STEERBase");
    gProof->EnablePackage("$ALICE_ROOT/STEERBase");
    gProof->UploadPackage("$ALICE_ROOT/ESD");
    gProof->EnablePackage("$ALICE_ROOT/ESD");
    gProof->UploadPackage("$ALICE_ROOT/AOD");
    gProof->EnablePackage("$ALICE_ROOT/AOD");
    gProof->UploadPackage("$ALICE_ROOT/ANALYSIS");
    gProof->EnablePackage("$ALICE_ROOT/ANALYSIS");
    gProof->UploadPackage("$ALICE_ROOT/ANALYSISalice");
    gProof->EnablePackage("$ALICE_ROOT/ANALYSISalice");
    gProof->UploadPackage("$ALICE_ROOT/PWG0base");
    gProof->EnablePackage("$ALICE_ROOT/PWG0base");
    gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
    gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
  }
  else
  {
    cout << "Init in Local or Grid mode" << endl;
    gSystem->Load("libCore.so");  
    gSystem->Load("libTree.so");
    gSystem->Load("libGeom.so");
    gSystem->Load("libVMC.so");
    gSystem->Load("libPhysics.so");
    gSystem->Load("libSTEERBase");
    gSystem->Load("libESD");
    gSystem->Load("libAOD");
    gSystem->Load("libANALYSIS");
    gSystem->Load("libANALYSISalice");   
  // Use AliRoot includes to compile our task
    gROOT->ProcessLine(".include $ALICE_ROOT/include");

    // gSystem->Load("libVMC");
    // gSystem->Load("libTree");
    // gSystem->Load("libSTEERBase");
    // gSystem->Load("libESD");
    // gSystem->Load("libAOD");
    // gSystem->Load("libANALYSIS");
    // gSystem->Load("libANALYSISalice");
    // gSystem->Load("libPWG0base");
    
    gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
    gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
    //    gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background/"));
  }
  // Load helper classes
  TIterator * iter = listToLoad->MakeIterator();
  TObjString * name = 0;
  while (name = (TObjString *)iter->Next()) {
    gSystem->ExpandPathName(name->String());
    cout << name->String().Data();
    if (runMode == kMyRunModeCAF) {
      gProof->Load(name->String()+(debug?"+g":""));   
    } else {
      gROOT->LoadMacro(name->String()+(debug?"+g":""));   
    }
  }

}
Commit	Line	Data
a23f7c97	1	// TODO:
a23f7c97	2	// 1. Check cuts for 2010 (Jochen?)
54b31d6a	3	// 2. Run with many centrality bins at once
e0376287	4	#include <string.h>
a23f7c97	5
e0376287	6	enum { kMyRunModeLocal = 0, kMyRunModeCAF, kMyRunModeGRID};
	7
	8	TList * listToLoad = new TList();
a23f7c97	9
	10	TChain * GetAnalysisChain(const char * incollection);
	11
eef42d18	12	void run(Char_t* data, Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 0, Bool_t isMC = 0,
	13	Int_t centrBin = 0, const char * centrEstimator = "VOM", Bool_t useTrackCentralityCut = kFALSE, Int_t trackMin=0, Int_t trackMax=10000,
	14	const char* option = "",TString customSuffix = "", Int_t workers = -1)
a23f7c97	15	{
	16	// runMode:
	17	//
	18	// 0 local
	19	// 1 proof
	20
	21	if (nev < 0)
	22	nev = 1234567890;
	23
	24	InitAndLoadLibs(runMode,workers,debug);
	25
	26	// Create the analysis manager
	27	mgr = new AliAnalysisManager;
	28
	29	// Add ESD handler
	30	AliESDInputHandler* esdH = new AliESDInputHandler;
	31	// Do I need any of this?
eef42d18	32	esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks");
a23f7c97	33	mgr->SetInputEventHandler(esdH);
	34
	35	if(isMC) {
	36	AliMCEventHandler* handler = new AliMCEventHandler;
b00e8ba9	37	handler->SetPreReadMode(AliMCEventHandler::kLmPreRead);
a23f7c97	38	mgr->SetMCtruthEventHandler(handler);
	39	}
	40
e0376287	41
	42	// If we are running on grid, we need the alien handler
	43	if (runMode == kMyRunModeGRID) {
	44	// Create and configure the alien handler plugin
	45	gROOT->LoadMacro("CreateAlienHandler.C");
8b7362ee	46	AliAnalysisGrid *alienHandler = CreateAlienHandler(data, listToLoad, "full", isMC);
e0376287	47	if (!alienHandler) {
	48	cout << "Cannot create alien handler" << endl;
	49	exit(1);
	50	}
	51	mgr->SetGridHandler(alienHandler);
	52	}
	53
	54
	55
a23f7c97	56	// physics selection
a23f7c97	57	gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
eef42d18	58	physicsSelectionTask = AddTaskPhysicsSelection(isMC,0);//FIXME
5ec1c2f5	59	// FIXME!!
8b628a20	60	if(!isMC) {
	61	AliPhysicsSelection * physSel = physicsSelectionTask->GetPhysicsSelection();
	62	// physSel->AddCollisionTriggerClass("+CTRUE-B-NOPF-ALL");
eef42d18	63	physSel->AddCollisionTriggerClass("+CMBAC-B-NOPF-ALL");
	64	physSel->AddCollisionTriggerClass("+CMBS1C-B-NOPF-ALL");
	65	physSel->AddCollisionTriggerClass("+CMBS1A-B-NOPF-ALL");
	66	physSel->AddBGTriggerClass("+CMBAC-C-NOPF-ALL");
	67	physSel->AddBGTriggerClass("+CMBS1C-C-NOPF-ALL");
	68	physSel->AddBGTriggerClass("+CMBS1A-C-NOPF-ALL");
	69	physSel->AddBGTriggerClass("+CMBAC-A-NOPF-ALL");
	70	physSel->AddBGTriggerClass("+CMBS1C-A-NOPF-ALL");
	71	physSel->AddBGTriggerClass("+CMBS1A-A-NOPF-ALL");
	72	physSel->AddBGTriggerClass("+CMBAC-E-NOPF-ALL");
	73	physSel->AddBGTriggerClass("+CMBS1C-E-NOPF-ALL");
	74	physSel->AddBGTriggerClass("+CMBS1A-E-NOPF-ALL");
	75	// physSel->AddBGTriggerClass ("+C0SM1-E-NOPF-ALL");
8b628a20	76	}
8b628a20	77
54b31d6a	78	// Centrality
54b31d6a	79	AliCentralitySelectionTask *taskCentr = new AliCentralitySelectionTask("CentralitySelection");
7f5f2e0c	80	// const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root";
	81	// const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root";
	82	const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/AliCentralityBy1D_LHC10g2a_100.root";
	83	const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/AliCentralityByFunction_LHC10g2a_100.root";
2bbfd8c6	84	taskCentr->SetPercentileFile (file1);
2bbfd8c6	85	taskCentr->SetPercentileFile2(file2);
54b31d6a	86	mgr->AddTask(taskCentr);
54b31d6a	87	mgr->ConnectInput (taskCentr,0, mgr->GetCommonInputContainer());
a23f7c97	88
2bbfd8c6	89	// Create my own centrality selector
2bbfd8c6	90	AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector();
8b628a20	91	centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only
2bbfd8c6	92	centrSelector->SetCentralityBin(centrBin);
	93	centrSelector->SetCentralityEstimator(centrEstimator);
	94	// FIXME!!!
eef42d18	95
	96	//centrSelector->SetIsMC(isMC,1500,2300);
	97	if(useTrackCentralityCut){
	98	centrSelector->SetUseMultRange();
	99	centrSelector->SetMultRange(trackMin,trackMax);
	100	}
a23f7c97	101
	102	// Parse option strings
	103	TString optionStr(option);
	104
	105	// remove SAVE option if set
	106	// This is copied from a macro by Jan. The reason I kept it is that I may want to pass textual options to the new task at some point
	107	Bool_t doSave = kFALSE;
	108	TString optionStr(option);
	109	if (optionStr.Contains("SAVE"))
	110	{
	111	optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length());
	112	doSave = kTRUE;
	113	}
	114
e0376287	115	AliESDtrackCuts * cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE);
a23f7c97	116	TString pathsuffix = "";
	117	// cuts->SetPtRange(0.15,0.2);// FIXME pt cut
	118	// const char * pathsuffix = "_pt_015_020_nofakes";
	119
	120	if (optionStr.Contains("ITSsa")) {
	121	delete cuts;
	122	cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
	123	cout << ">>>> USING ITS sa tracks" << endl;
	124	pathsuffix="ITSsa";
	125	}
	126
	127	if (optionStr.Contains("TPC")) {
	128	delete cuts;
	129	cuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	130	cout << ">>>> USING TPC only tracks" << endl;
	131	pathsuffix="TPC";
	132	}
54b31d6a	133
	134	Bool_t useMCKinematics = isMC;
	135	if (optionStr.Contains("NOMCKIN")) {
	136	cout << ">>>> Ignoring MC kinematics" << endl;
	137	useMCKinematics=kFALSE;
	138	}
a23f7c97	139
	140
	141	// load my task
	142	gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C");
2bbfd8c6	143	AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector); // kTRUE enables DCA cut
54b31d6a	144	task->SetIsMC(useMCKinematics);
8b628a20	145	if (isMC) {
	146	task->SetOfflineTrigger(AliVEvent::kMB);
	147	} else {
	148	task->SetOfflineTrigger(AliVEvent::kUserDefined);
	149	}
e0376287	150	if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC");
	151	if(customSuffix!=""){
	152	cout << "Setting custom suffix: " << customSuffix << endl;
	153	task->GetHistoManager()->SetSuffix(customSuffix);
	154	}
7f5f2e0c	155	// task->SelectCollisionCandidates(AliVEvent::kUserDefined);
a23f7c97	156	if (!mgr->InitAnalysis()) return;
7f5f2e0c	157
a23f7c97	158	mgr->PrintStatus();
	159
	160	if (runMode == kMyRunModeLocal ) {
	161	// If running in local mode, create chain of ESD files
54b31d6a	162	cout << "RUNNING LOCAL, CHAIN" << endl;
a23f7c97	163	TChain * chain = GetAnalysisChain(data);
5ec1c2f5	164	// chain->Print();
a23f7c97	165	mgr->StartAnalysis("local",chain,nev);
	166	} else if (runMode == kMyRunModeCAF) {
	167	mgr->StartAnalysis("proof",TString(data)+"#esdTree",nev);
e0376287	168	} else if (runMode == kMyRunModeGRID) {
e0376287	169	mgr->StartAnalysis("grid");
a23f7c97	170	} else {
	171	cout << "ERROR: unknown run mode" << endl;
	172	}
	173
eef42d18	174	if (!useTrackCentralityCut) {
	175	pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin);
	176	} else {
	177	pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax);
	178	}
7f5f2e0c	179	pathsuffix += customSuffix;
7f5f2e0c	180
a23f7c97	181	if (doSave) MoveOutput(data, pathsuffix.Data());
	182
	183
	184	}
	185
	186
	187	void MoveOutput(const char * data, const char * suffix = ""){
	188
	189	TString path("output/");
	190	path = path + TString(data).Tokenize("/")->Last()->GetName() + suffix;
	191
	192	TString fileName = "multPbPbtracks.root";
	193	gSystem->mkdir(path, kTRUE);
	194	gSystem->Rename(fileName, path + "/" + fileName);
	195	gSystem->Rename("event_stat.root", path + "/event_stat.root");
	196	Printf(">>>>> Moved files to %s", path.Data());
	197	}
	198
	199
	200
	201	TChain * GetAnalysisChain(const char * incollection){
	202	// Builds a chain of esd files
	203	// incollection can be
	204	// - a single root file
	205	// - an xml collection of files on alien
	206	// - a ASCII containing a list of local root files
	207	TChain* analysisChain = 0;
	208	// chain
	209	analysisChain = new TChain("esdTree");
	210	if (TString(incollection).Contains(".root")){
	211	analysisChain->Add(incollection);
	212	}
	213	else if (TString(incollection).Contains("xml")){
	214	TGrid::Connect("alien://");
	215	TAlienCollection * coll = TAlienCollection::Open (incollection);
	216	while(coll->Next()){
	217	analysisChain->Add(TString("alien://")+coll->GetLFN());
	218	}
	219	} else {
	220	ifstream file_collect(incollection);
	221	TString line;
	222	while (line.ReadLine(file_collect) ) {
	223	analysisChain->Add(line.Data());
	224	}
	225	}
	226	analysisChain->GetListOfFiles()->Print();
	227
	228	return analysisChain;
	229	}
	230
	231
	232	void InitAndLoadLibs(Int_t runMode=kMyRunModeLocal, Int_t workers=0,Bool_t debug=0) {
e0376287	233	// Loads libs and par files + custom task and classes
	234
	235	// Custom stuff to be loaded
	236	listToLoad->Add(new TObjString("$ALICE_ROOT/ANALYSIS/AliCentralitySelectionTask.cxx+"));
	237	listToLoad->Add(new TObjString("$ALICE_ROOT/PWG1/background/AliHistoListWrapper.cxx+"));
	238	listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbTrackHistoManager.cxx+"));
2bbfd8c6	239	listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbCentralitySelector.cxx+"));
e0376287	240	listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisTaskMultPbTracks.cxx+"));
e0376287	241
a23f7c97	242
	243	if (runMode == kMyRunModeCAF)
	244	{
	245	cout << "Init in CAF mode" << endl;
	246
	247	gEnv->SetValue("XSec.GSI.DelegProxy", "2");
	248	TProof::Open("alice-caf.cern.ch", workers>0 ? Form("workers=%d",workers) : "");
eef42d18	249	// TProof::Open("skaf.saske.sk", workers>0 ? Form("workers=%d",workers) : "");
a23f7c97	250
	251	// Enable the needed package
	252	gProof->UploadPackage("$ALICE_ROOT/STEERBase");
	253	gProof->EnablePackage("$ALICE_ROOT/STEERBase");
	254	gProof->UploadPackage("$ALICE_ROOT/ESD");
	255	gProof->EnablePackage("$ALICE_ROOT/ESD");
	256	gProof->UploadPackage("$ALICE_ROOT/AOD");
	257	gProof->EnablePackage("$ALICE_ROOT/AOD");
	258	gProof->UploadPackage("$ALICE_ROOT/ANALYSIS");
	259	gProof->EnablePackage("$ALICE_ROOT/ANALYSIS");
	260	gProof->UploadPackage("$ALICE_ROOT/ANALYSISalice");
	261	gProof->EnablePackage("$ALICE_ROOT/ANALYSISalice");
	262	gProof->UploadPackage("$ALICE_ROOT/PWG0base");
	263	gProof->EnablePackage("$ALICE_ROOT/PWG0base");
a28a49f6	264	gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
a28a49f6	265	gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
a23f7c97	266	}
	267	else
	268	{
e0376287	269	cout << "Init in Local or Grid mode" << endl;
8b7362ee	270	gSystem->Load("libCore.so");
	271	gSystem->Load("libTree.so");
	272	gSystem->Load("libGeom.so");
	273	gSystem->Load("libVMC.so");
	274	gSystem->Load("libPhysics.so");
a23f7c97	275	gSystem->Load("libSTEERBase");
	276	gSystem->Load("libESD");
	277	gSystem->Load("libAOD");
	278	gSystem->Load("libANALYSIS");
8b7362ee	279	gSystem->Load("libANALYSISalice");
	280	// Use AliRoot includes to compile our task
	281	gROOT->ProcessLine(".include $ALICE_ROOT/include");
	282
	283	// gSystem->Load("libVMC");
	284	// gSystem->Load("libTree");
	285	// gSystem->Load("libSTEERBase");
	286	// gSystem->Load("libESD");
	287	// gSystem->Load("libAOD");
	288	// gSystem->Load("libANALYSIS");
	289	// gSystem->Load("libANALYSISalice");
	290	// gSystem->Load("libPWG0base");
a23f7c97	291
a28a49f6	292	gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
a28a49f6	293	gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
54b31d6a	294	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background/"));
a23f7c97	295	}
a23f7c97	296	// Load helper classes
e0376287	297	TIterator * iter = listToLoad->MakeIterator();
	298	TObjString * name = 0;
	299	while (name = (TObjString *)iter->Next()) {
	300	gSystem->ExpandPathName(name->String());
	301	cout << name->String().Data();
	302	if (runMode == kMyRunModeCAF) {
	303	gProof->Load(name->String()+(debug?"+g":""));
	304	} else {
	305	gROOT->LoadMacro(name->String()+(debug?"+g":""));
	306	}
a23f7c97	307	}
a23f7c97	308
a23f7c97	309	}