[u/mrichter/AliRoot.git] / PWGLF / SPECTRA / ChargedHadrons / 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, kMyRunModeProofLite};

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", Int_t useOtherCentralityCut = 0, Int_t trackMin=0, Int_t trackMax=10000, 
	 const char* option = "",TString customSuffix = "", Int_t workers = -1, Bool_t useSingleBin=kTRUE, const char * runList = 0)
{
  // 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);
  }


  // 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(kFALSE);  
  TString pathsuffix = "";

  if(!useSingleBin) pathsuffix += "_AllCentr";

  if (optionStr.Contains("DCA")) {
    delete cuts;
    //    cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
    cout << ">>>> USING DCA cut" << endl;
    cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();  
    cuts->SetMaxChi2TPCConstrainedGlobal(); // remove golden cut
    pathsuffix+="_DCAcut";
  }

  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";
  }

  if(optionStr.Contains("NoElectrons")) pathsuffix +="_NoElectrons";


  Bool_t useMCKinematics = isMC;
  if (optionStr.Contains("NOMCKIN")) {
    cout << ">>>> Ignoring MC kinematics" << endl;
    useMCKinematics=kFALSE;
    pathsuffix+="_NOMCKIN";
  }
  
  // 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, runList, pathsuffix.Data(), listToLoad, "full", isMC);  // full
    if (!alienHandler) {
      cout << "Cannot create alien handler" << endl;    
      exit(1);
    }
    mgr->SetGridHandler(alienHandler);  
  }


  // Add tasks
  // physics selection
  gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
  physicsSelectionTask = AddTaskPhysicsSelection(isMC);

  //PID
  gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
  AddTaskPIDResponse(isMC); 

  // // PID QA:
  // gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
  // AddTaskPIDqa();


  // Centrality
  gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
  AliCentralitySelectionTask *taskCentr = AddTaskCentrality();
  // OBSOLETE
  const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root";
  const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root";
  // END of OBSOLETE
  if(isMC) taskCentr-> SetMCInput();
  taskCentr->SetPass(2);

  // Create my own centrality selector
  AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector();
  centrSelector->SetIsMC(isMC);
  centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only
  centrSelector->SetCentralityBin(centrBin);
  if (!useSingleBin) centrSelector->SetCentralityBin(0); // FIXME: ok?
  centrSelector->SetCentralityEstimator(centrEstimator);

  if(useOtherCentralityCut == 1){
    cout << "Setting centrality by MULT" << endl;
    centrSelector->SetUseMultRange();
    centrSelector->SetMultRange(trackMin,trackMax);
  }
  if(useOtherCentralityCut == 2){
    cout << "Setting centrality by V0" << endl;
    
    centrSelector->SetUseV0Range();
    centrSelector->SetMultRange(trackMin,trackMax);
  }
  if(useOtherCentralityCut == 3){
    cout << "Setting centrality by SPD outer" << endl;    
    centrSelector->SetUseSPDOuterRange();
    centrSelector->SetMultRange(trackMin,trackMax);
  }

  // load my task
  if (useSingleBin) {
    gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C");
    AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector); 
    task->SetIsMC(useMCKinematics);
    task->SetOfflineTrigger(AliVEvent::kMB);
    if(optionStr.Contains("TPC")) task->SetTPCOnly();
    if(optionStr.Contains("NoElectrons")) task->RejectElectrons(kTRUE);
    if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC");
    if(customSuffix!=""){
      cout << "Setting custom suffix: " << customSuffix << endl;    
      task->GetHistoManager()->SetSuffix(customSuffix);
    }
  } else {
    gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracksAllCentrality.C");
    centrSelector->SetUseV0Range(kTRUE);
    Int_t ncentr = 11;
   
    const Float_t minCentr[] = {0 ,79 ,239,559 ,1165,2135,3555,5525,8213 ,12191,15079};
    const Float_t maxCentr[] = {79,239,559,1165,2135,3555,5525,8213,12191,15079,21000};
    AliAnalysisTaskMultPbTracks ** tasks = AddTaskMultPbPbTracksAllCentrality("multPbPbtracks.root", cuts, centrSelector, ncentr,minCentr,maxCentr); 
    for(Int_t icentr = 0; icentr < ncentr; icentr++){
      tasks[icentr]->Print();
      cout << "MC KINEMATICS:" << useMCKinematics << endl;
      
      tasks[icentr]->SetIsMC(useMCKinematics);
      tasks[icentr]->SetOfflineTrigger(AliVEvent::kMB);
      if(optionStr.Contains("TPC")) tasks[icentr]->SetTPCOnly();
      if(optionStr.Contains("NoElectrons")) task[icentr]->RejectElectrons(kTRUE);
      if(useMCKinematics) tasks[icentr]->GetHistoManager()->SetSuffix("MC");
      if(customSuffix!=""){
	cout << "Setting custom suffix: " << customSuffix+long(icentr) << endl;    
	tasks[icentr]->GetHistoManager()->SetSuffix(customSuffix+long(icentr));
      }	
    }    
  }
  // Init and run the analy
  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 == kMyRunModeProofLite) {
    TChain * chain = GetAnalysisChain(data);
    mgr->StartAnalysis("proof",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 (!useOtherCentralityCut) {
    pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin);
  } else if(useOtherCentralityCut==1){
    pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax);
  } else if(useOtherCentralityCut==2){
    pathsuffix = pathsuffix + "_V0Range_" + long(trackMin) + "_" + long(trackMax);
  } else if(useOtherCentralityCut==3){
    pathsuffix = pathsuffix + "_SPDOutRange_" + 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);
  for(Int_t ibin = 0; ibin < 20; ibin++){
    TString fileBin = fileName;
    fileBin.ReplaceAll(".root",Form("_%2.2d.root",ibin));
    gSystem->Rename(fileBin, path + "/" + fileBin);    
  }
  
  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("/Users/mfloris/Work/AliSoft/AliRoot-trunk/PWGPP/background/AliHistoListWrapper.cxx+")); // FIXME
  listToLoad->Add(new TObjString("AliAnalysisMultPbTrackHistoManager.cxx+"));
  listToLoad->Add(new TObjString("AliAnalysisMultPbCentralitySelector.cxx+"));
  listToLoad->Add(new TObjString("AliAnalysisTaskMultPbTracks.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::Mgr("alice-caf.cern.ch")->SetROOTVersion("VO_ALICE@ROOT::v5-30-03-1");
      TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("current");
      TProof * p = TProof::Open("alice-caf.cern.ch", workers>0 ? Form("workers=%d",workers) : "1x");
      //      TProof * p = TProof::Open("skaf.saske.sk", workers>0 ? Form("workers=%d",workers) : "");    
      p->Exec("TObject *o = gEnv->GetTable()->FindObject(\"Proof.UseMergers\"); gEnv->GetTable()->Remove(o);", kTRUE);

      //      TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("VO_ALICE@ROOT::v5-28-00f");
      gProof->EnablePackage("VO_ALICE@AliRoot::v5-02-12-AN");
      gSystem->Load("libCore");
      gSystem->Load("libTree");
      gSystem->Load("libGeom");
      gSystem->Load("libVMC");
      gSystem->Load("libPhysics");
      gSystem->Load("libMinuit");
      gSystem->Load("libSTEERBase");
      gSystem->Load("libESD");
      gSystem->Load("libAOD");
      gSystem->Load("libANALYSIS");
      gSystem->Load("libOADB");
      gSystem->Load("libANALYSISalice");   

      // Enable the needed package
      // gProof->UploadPackage("$ALICE_ROOT/obj/STEERBase");
      // gProof->EnablePackage("$ALICE_ROOT/obj/STEERBase");
      // gProof->UploadPackage("$ALICE_ROOT/obj/ESD");
      // gProof->EnablePackage("$ALICE_ROOT/obj/ESD");
      // gProof->UploadPackage("$ALICE_ROOT/obj/AOD");
      // gProof->EnablePackage("$ALICE_ROOT/obj/AOD");
      // gProof->UploadPackage("$ALICE_ROOT/obj/ANALYSIS");
      // gProof->EnablePackage("$ALICE_ROOT/obj/ANALYSIS");
      // gProof->UploadPackage("$ALICE_ROOT/obj/OADB");
      // gProof->EnablePackage("$ALICE_ROOT/obj/OADB");
      // gProof->UploadPackage("$ALICE_ROOT/obj/ANALYSISalice");
      // gProof->EnablePackage("$ALICE_ROOT/obj/ANALYSISalice");
      // gProof->UploadPackage("$ALICE_ROOT/obj/PWG0base");
      // gProof->EnablePackage("$ALICE_ROOT/obj/PWG0base");
      // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/include"));
      // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
      // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
    }
  else if (runMode == kMyRunModeProofLite)
    {
      cout << "Init in CAF mode" << endl;
    
      gEnv->SetValue("XSec.GSI.DelegProxy", "2");
      TProof * p = TProof::Open("");
      //      TProof * p = TProof::Open("skaf.saske.sk", workers>0 ? Form("workers=%d",workers) : "");    
      //      p->Exec("TObject *o = gEnv->GetTable()->FindObject(\"Proof.UseMergers\"); gEnv->GetTable()->Remove(o);", kTRUE);

      //      TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("VO_ALICE@ROOT::v5-28-00f");
      //      TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("5.28/00f");
      gProof->UploadPackage("$ALICE_ROOT/ANALYSIS/macros/AliRootProofLite.par");
      gProof->EnablePackage("AliRootProofLite");

    }
  else
    {
      cout << "Init in Local or Grid mode" << endl;
      gSystem->Load("libCore");
      gSystem->Load("libTree");
      gSystem->Load("libGeom");
      gSystem->Load("libVMC");
      gSystem->Load("libPhysics");
      gSystem->Load("libMinuit");
      gSystem->Load("libSTEERBase");
      gSystem->Load("libESD");
      gSystem->Load("libAOD");
      gSystem->Load("libANALYSIS");
      gSystem->Load("libOADB");
      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/PWGPP/background"));
      //    gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/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 || runMode == kMyRunModeProofLite) {
      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
5ad99723	6	enum { kMyRunModeLocal = 0, kMyRunModeCAF, kMyRunModeGRID, kMyRunModeProofLite};
e0376287	7
e0376287	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,
3b8cbf2d	13	Int_t centrBin = 0, const char * centrEstimator = "VOM", Int_t useOtherCentralityCut = 0, Int_t trackMin=0, Int_t trackMax=10000,
5ad99723	14	const char* option = "",TString customSuffix = "", Int_t workers = -1, Bool_t useSingleBin=kTRUE, const char * runList = 0)
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
5ad99723	42
	43	// Parse option strings
	44	TString optionStr(option);
	45
	46	// remove SAVE option if set
	47	// 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
	48	Bool_t doSave = kFALSE;
	49	TString optionStr(option);
	50	if (optionStr.Contains("SAVE"))
	51	{
	52	optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length());
	53	doSave = kTRUE;
	54	}
	55
	56	AliESDtrackCuts * cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kFALSE);
	57	TString pathsuffix = "";
	58
	59	if(!useSingleBin) pathsuffix += "_AllCentr";
	60
	61	if (optionStr.Contains("DCA")) {
	62	delete cuts;
	63	// cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
	64	cout << ">>>> USING DCA cut" << endl;
	65	cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
	66	cuts->SetMaxChi2TPCConstrainedGlobal(); // remove golden cut
	67	pathsuffix+="_DCAcut";
	68	}
	69
	70	if (optionStr.Contains("ITSsa")) {
	71	delete cuts;
	72	cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
	73	cout << ">>>> USING ITS sa tracks" << endl;
	74	pathsuffix+="_ITSsa";
	75	}
	76
	77	if (optionStr.Contains("TPC")) {
	78	delete cuts;
	79	cuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	80	cout << ">>>> USING TPC only tracks" << endl;
	81	pathsuffix+="_TPC";
	82	}
	83
	84	if(optionStr.Contains("NoElectrons")) pathsuffix +="_NoElectrons";
	85
	86
	87
	88	Bool_t useMCKinematics = isMC;
	89	if (optionStr.Contains("NOMCKIN")) {
	90	cout << ">>>> Ignoring MC kinematics" << endl;
	91	useMCKinematics=kFALSE;
	92	pathsuffix+="_NOMCKIN";
	93	}
	94
e0376287	95	// If we are running on grid, we need the alien handler
	96	if (runMode == kMyRunModeGRID) {
	97	// Create and configure the alien handler plugin
	98	gROOT->LoadMacro("CreateAlienHandler.C");
5ad99723	99	AliAnalysisGrid *alienHandler = CreateAlienHandler(data, runList, pathsuffix.Data(), listToLoad, "full", isMC); // full
e0376287	100	if (!alienHandler) {
	101	cout << "Cannot create alien handler" << endl;
	102	exit(1);
	103	}
	104	mgr->SetGridHandler(alienHandler);
	105	}
	106
	107
	108
5ad99723	109	// Add tasks
a23f7c97	110	// physics selection
a23f7c97	111	gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
e9c445f5	112	physicsSelectionTask = AddTaskPhysicsSelection(isMC);
8b628a20	113
2b42cee2	114	//PID
	115	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
	116	AddTaskPIDResponse(isMC);
	117
5ad99723	118	// // PID QA:
	119	// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
	120	// AddTaskPIDqa();
	121
2b42cee2	122
54b31d6a	123	// Centrality
1c06a186	124	gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
5ad99723	125	AliCentralitySelectionTask *taskCentr = AddTaskCentrality();
5ad99723	126	// OBSOLETE
3b8cbf2d	127	const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root";
3b8cbf2d	128	const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root";
5ad99723	129	// END of OBSOLETE
2b42cee2	130	if(isMC) taskCentr-> SetMCInput();
	131	taskCentr->SetPass(2);
	132
2bbfd8c6	133	// Create my own centrality selector
2bbfd8c6	134	AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector();
bfae2924	135	centrSelector->SetIsMC(isMC);
8b628a20	136	centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only
2bbfd8c6	137	centrSelector->SetCentralityBin(centrBin);
bcf2601a	138	if (!useSingleBin) centrSelector->SetCentralityBin(0); // FIXME: ok?
2bbfd8c6	139	centrSelector->SetCentralityEstimator(centrEstimator);
eef42d18	140
3b8cbf2d	141	if(useOtherCentralityCut == 1){
9441cdaa	142	cout << "Setting centrality by MULT" << endl;
eef42d18	143	centrSelector->SetUseMultRange();
	144	centrSelector->SetMultRange(trackMin,trackMax);
	145	}
3b8cbf2d	146	if(useOtherCentralityCut == 2){
9441cdaa	147	cout << "Setting centrality by V0" << endl;
3b8cbf2d	148
	149	centrSelector->SetUseV0Range();
	150	centrSelector->SetMultRange(trackMin,trackMax);
	151	}
72491d7c	152	if(useOtherCentralityCut == 3){
9441cdaa	153	cout << "Setting centrality by SPD outer" << endl;
72491d7c	154	centrSelector->SetUseSPDOuterRange();
	155	centrSelector->SetMultRange(trackMin,trackMax);
	156	}
a23f7c97	157
a23f7c97	158	// load my task
bcf2601a	159	if (useSingleBin) {
	160	gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C");
	161	AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector);
	162	task->SetIsMC(useMCKinematics);
	163	task->SetOfflineTrigger(AliVEvent::kMB);
	164	if(optionStr.Contains("TPC")) task->SetTPCOnly();
5ad99723	165	if(optionStr.Contains("NoElectrons")) task->RejectElectrons(kTRUE);
bcf2601a	166	if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC");
	167	if(customSuffix!=""){
	168	cout << "Setting custom suffix: " << customSuffix << endl;
	169	task->GetHistoManager()->SetSuffix(customSuffix);
	170	}
	171	} else {
	172	gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracksAllCentrality.C");
	173	centrSelector->SetUseV0Range(kTRUE);
	174	Int_t ncentr = 11;
abd808b9	175
	176	const Float_t minCentr[] = {0 ,79 ,239,559 ,1165,2135,3555,5525,8213 ,12191,15079};
	177	const Float_t maxCentr[] = {79,239,559,1165,2135,3555,5525,8213,12191,15079,21000};
bcf2601a	178	AliAnalysisTaskMultPbTracks ** tasks = AddTaskMultPbPbTracksAllCentrality("multPbPbtracks.root", cuts, centrSelector, ncentr,minCentr,maxCentr);
bcf2601a	179	for(Int_t icentr = 0; icentr < ncentr; icentr++){
bcf2601a	180	tasks[icentr]->Print();
e9c445f5	181	cout << "MC KINEMATICS:" << useMCKinematics << endl;
e9c445f5	182
bcf2601a	183	tasks[icentr]->SetIsMC(useMCKinematics);
bcf2601a	184	tasks[icentr]->SetOfflineTrigger(AliVEvent::kMB);
bcf2601a	185	if(optionStr.Contains("TPC")) tasks[icentr]->SetTPCOnly();
5ad99723	186	if(optionStr.Contains("NoElectrons")) task[icentr]->RejectElectrons(kTRUE);
bcf2601a	187	if(useMCKinematics) tasks[icentr]->GetHistoManager()->SetSuffix("MC");
bcf2601a	188	if(customSuffix!=""){
e9c445f5	189	cout << "Setting custom suffix: " << customSuffix+long(icentr) << endl;
bcf2601a	190	tasks[icentr]->GetHistoManager()->SetSuffix(customSuffix+long(icentr));
bcf2601a	191	}
bcf2601a	192	}
e0376287	193	}
bcf2601a	194	// Init and run the analy
a23f7c97	195	if (!mgr->InitAnalysis()) return;
bcf2601a	196
a23f7c97	197	mgr->PrintStatus();
	198
	199	if (runMode == kMyRunModeLocal ) {
	200	// If running in local mode, create chain of ESD files
54b31d6a	201	cout << "RUNNING LOCAL, CHAIN" << endl;
a23f7c97	202	TChain * chain = GetAnalysisChain(data);
5ad99723	203	chain->Print();
a23f7c97	204	mgr->StartAnalysis("local",chain,nev);
5ad99723	205	} else if (runMode == kMyRunModeProofLite) {
	206	TChain * chain = GetAnalysisChain(data);
	207	mgr->StartAnalysis("proof",chain,nev);
	208	}
	209	else if (runMode == kMyRunModeCAF) {
a23f7c97	210	mgr->StartAnalysis("proof",TString(data)+"#esdTree",nev);
e0376287	211	} else if (runMode == kMyRunModeGRID) {
e0376287	212	mgr->StartAnalysis("grid");
a23f7c97	213	} else {
	214	cout << "ERROR: unknown run mode" << endl;
	215	}
	216
3b8cbf2d	217	if (!useOtherCentralityCut) {
eef42d18	218	pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin);
3b8cbf2d	219	} else if(useOtherCentralityCut==1){
eef42d18	220	pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax);
3b8cbf2d	221	} else if(useOtherCentralityCut==2){
3b8cbf2d	222	pathsuffix = pathsuffix + "_V0Range_" + long(trackMin) + "_" + long(trackMax);
72491d7c	223	} else if(useOtherCentralityCut==3){
72491d7c	224	pathsuffix = pathsuffix + "_SPDOutRange_" + long(trackMin) + "_" + long(trackMax);
eef42d18	225	}
7f5f2e0c	226	pathsuffix += customSuffix;
7f5f2e0c	227
a23f7c97	228	if (doSave) MoveOutput(data, pathsuffix.Data());
a23f7c97	229
2b42cee2	230
2b42cee2	231
a23f7c97	232
	233	}
	234
	235
	236	void MoveOutput(const char * data, const char * suffix = ""){
	237
	238	TString path("output/");
	239	path = path + TString(data).Tokenize("/")->Last()->GetName() + suffix;
	240
	241	TString fileName = "multPbPbtracks.root";
	242	gSystem->mkdir(path, kTRUE);
	243	gSystem->Rename(fileName, path + "/" + fileName);
bcf2601a	244	for(Int_t ibin = 0; ibin < 20; ibin++){
	245	TString fileBin = fileName;
	246	fileBin.ReplaceAll(".root",Form("_%2.2d.root",ibin));
	247	gSystem->Rename(fileBin, path + "/" + fileBin);
	248	}
	249
a23f7c97	250	gSystem->Rename("event_stat.root", path + "/event_stat.root");
	251	Printf(">>>>> Moved files to %s", path.Data());
	252	}
	253
	254
	255
	256	TChain * GetAnalysisChain(const char * incollection){
	257	// Builds a chain of esd files
	258	// incollection can be
	259	// - a single root file
	260	// - an xml collection of files on alien
	261	// - a ASCII containing a list of local root files
	262	TChain* analysisChain = 0;
	263	// chain
	264	analysisChain = new TChain("esdTree");
	265	if (TString(incollection).Contains(".root")){
	266	analysisChain->Add(incollection);
	267	}
	268	else if (TString(incollection).Contains("xml")){
	269	TGrid::Connect("alien://");
	270	TAlienCollection * coll = TAlienCollection::Open (incollection);
	271	while(coll->Next()){
	272	analysisChain->Add(TString("alien://")+coll->GetLFN());
	273	}
	274	} else {
	275	ifstream file_collect(incollection);
	276	TString line;
	277	while (line.ReadLine(file_collect) ) {
	278	analysisChain->Add(line.Data());
	279	}
	280	}
	281	analysisChain->GetListOfFiles()->Print();
	282
	283	return analysisChain;
	284	}
	285
	286
	287	void InitAndLoadLibs(Int_t runMode=kMyRunModeLocal, Int_t workers=0,Bool_t debug=0) {
e0376287	288	// Loads libs and par files + custom task and classes
	289
	290	// Custom stuff to be loaded
5ad99723	291	// listToLoad->Add(new TObjString("$ALICE_ROOT/ANALYSIS/AliCentralitySelectionTask.cxx+"));
	292	listToLoad->Add(new TObjString("/Users/mfloris/Work/AliSoft/AliRoot-trunk/PWGPP/background/AliHistoListWrapper.cxx+")); // FIXME
	293	listToLoad->Add(new TObjString("AliAnalysisMultPbTrackHistoManager.cxx+"));
	294	listToLoad->Add(new TObjString("AliAnalysisMultPbCentralitySelector.cxx+"));
	295	listToLoad->Add(new TObjString("AliAnalysisTaskMultPbTracks.cxx+"));
	296	// listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbTrackHistoManager.cxx+"));
	297	// listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbCentralitySelector.cxx+"));
	298	// listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisTaskMultPbTracks.cxx+"));
e0376287	299
a23f7c97	300
a23f7c97	301	if (runMode == kMyRunModeCAF)
bcf2601a	302	{
bcf2601a	303	cout << "Init in CAF mode" << endl;
a23f7c97	304
2b42cee2	305	gEnv->SetValue("XSec.GSI.DelegProxy", "2");
5ad99723	306	// TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("VO_ALICE@ROOT::v5-30-03-1");
5ad99723	307	TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("current");
84bad6b8	308	TProof * p = TProof::Open("alice-caf.cern.ch", workers>0 ? Form("workers=%d",workers) : "1x");
f07573a6	309	// TProof * p = TProof::Open("skaf.saske.sk", workers>0 ? Form("workers=%d",workers) : "");
bcf2601a	310	p->Exec("TObject *o = gEnv->GetTable()->FindObject(\"Proof.UseMergers\"); gEnv->GetTable()->Remove(o);", kTRUE);
bcf2601a	311
5ad99723	312	// TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("VO_ALICE@ROOT::v5-28-00f");
5ad99723	313	gProof->EnablePackage("VO_ALICE@AliRoot::v5-02-12-AN");
4070f709	314	gSystem->Load("libCore");
	315	gSystem->Load("libTree");
	316	gSystem->Load("libGeom");
	317	gSystem->Load("libVMC");
	318	gSystem->Load("libPhysics");
5ad99723	319	gSystem->Load("libMinuit");
2b42cee2	320	gSystem->Load("libSTEERBase");
	321	gSystem->Load("libESD");
	322	gSystem->Load("libAOD");
	323	gSystem->Load("libANALYSIS");
	324	gSystem->Load("libOADB");
	325	gSystem->Load("libANALYSISalice");
9ef42f6c	326
bcf2601a	327	// Enable the needed package
2b42cee2	328	// gProof->UploadPackage("$ALICE_ROOT/obj/STEERBase");
	329	// gProof->EnablePackage("$ALICE_ROOT/obj/STEERBase");
	330	// gProof->UploadPackage("$ALICE_ROOT/obj/ESD");
	331	// gProof->EnablePackage("$ALICE_ROOT/obj/ESD");
	332	// gProof->UploadPackage("$ALICE_ROOT/obj/AOD");
	333	// gProof->EnablePackage("$ALICE_ROOT/obj/AOD");
	334	// gProof->UploadPackage("$ALICE_ROOT/obj/ANALYSIS");
	335	// gProof->EnablePackage("$ALICE_ROOT/obj/ANALYSIS");
	336	// gProof->UploadPackage("$ALICE_ROOT/obj/OADB");
	337	// gProof->EnablePackage("$ALICE_ROOT/obj/OADB");
	338	// gProof->UploadPackage("$ALICE_ROOT/obj/ANALYSISalice");
	339	// gProof->EnablePackage("$ALICE_ROOT/obj/ANALYSISalice");
	340	// gProof->UploadPackage("$ALICE_ROOT/obj/PWG0base");
	341	// gProof->EnablePackage("$ALICE_ROOT/obj/PWG0base");
5ad99723	342	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/include"));
	343	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
	344	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
	345	}
	346	else if (runMode == kMyRunModeProofLite)
	347	{
	348	cout << "Init in CAF mode" << endl;
	349
	350	gEnv->SetValue("XSec.GSI.DelegProxy", "2");
	351	TProof * p = TProof::Open("");
	352	// TProof * p = TProof::Open("skaf.saske.sk", workers>0 ? Form("workers=%d",workers) : "");
	353	// p->Exec("TObject *o = gEnv->GetTable()->FindObject(\"Proof.UseMergers\"); gEnv->GetTable()->Remove(o);", kTRUE);
	354
	355	// TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("VO_ALICE@ROOT::v5-28-00f");
	356	// TProof::Mgr("alice-caf.cern.ch")->SetROOTVersion("5.28/00f");
	357	gProof->UploadPackage("$ALICE_ROOT/ANALYSIS/macros/AliRootProofLite.par");
	358	gProof->EnablePackage("AliRootProofLite");
	359
bcf2601a	360	}
a23f7c97	361	else
bcf2601a	362	{
bcf2601a	363	cout << "Init in Local or Grid mode" << endl;
4070f709	364	gSystem->Load("libCore");
	365	gSystem->Load("libTree");
	366	gSystem->Load("libGeom");
	367	gSystem->Load("libVMC");
	368	gSystem->Load("libPhysics");
5ad99723	369	gSystem->Load("libMinuit");
bcf2601a	370	gSystem->Load("libSTEERBase");
	371	gSystem->Load("libESD");
	372	gSystem->Load("libAOD");
	373	gSystem->Load("libANALYSIS");
9ef42f6c	374	gSystem->Load("libOADB");
bcf2601a	375	gSystem->Load("libANALYSISalice");
	376	// Use AliRoot includes to compile our task
	377	gROOT->ProcessLine(".include $ALICE_ROOT/include");
	378
	379	// gSystem->Load("libVMC");
	380	// gSystem->Load("libTree");
	381	// gSystem->Load("libSTEERBase");
	382	// gSystem->Load("libESD");
	383	// gSystem->Load("libAOD");
	384	// gSystem->Load("libANALYSIS");
	385	// gSystem->Load("libANALYSISalice");
	386	// gSystem->Load("libPWG0base");
a23f7c97	387
bcf2601a	388	gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
2bfe5463	389	gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
2bfe5463	390	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background/"));
bcf2601a	391	}
a23f7c97	392	// Load helper classes
e0376287	393	TIterator * iter = listToLoad->MakeIterator();
	394	TObjString * name = 0;
	395	while (name = (TObjString *)iter->Next()) {
	396	gSystem->ExpandPathName(name->String());
	397	cout << name->String().Data();
5ad99723	398	if (runMode == kMyRunModeCAF \|\| runMode == kMyRunModeProofLite) {
e0376287	399	gProof->Load(name->String()+(debug?"+g":""));
	400	} else {
	401	gROOT->LoadMacro(name->String()+(debug?"+g":""));
	402	}
a23f7c97	403	}
a23f7c97	404
a23f7c97	405	}