[u/mrichter/AliRoot.git] / PWGCF / EBYE / macros / runTaskFluctuationsCentralityTrain.C

enum anaModes {mLocal,mLocalPAR,mPROOF,mGrid,mGridPAR};
//mLocal: Analyze locally files in your computer using aliroot
//mLocalPAR: Analyze locally files in your computer using root + PAR files
//mPROOF: Analyze CAF files with PROOF
//mGrid: Analyze files on Grid via AliEn plug-in and using precompiled FLOW libraries
//mGridPAR: Analyze files on Grid via AliEn plug-in and using par files for FLOW package

//Analysis modes
const TString analysisType = "ESD"; //"MC", "ESD", "AOD"
const TString analysisMode = "TPC"; //"TPC", "Global"

//Centrality stuff
Int_t binfirst = 0;  //where do we start numbering bins
Int_t binlast = 8;  //where do we stop numbering bins
const Int_t numberOfCentralityBins = 9;
Float_t centralityArray[numberOfCentralityBins+1] = {0.,5.,10.,20.,30.,40.,50.,60.,70.,80.}; // in centrality percentile

//output file
TString commonOutputFileName = "outputCentrality";

//void runTaskFluctuationsCentralityTrain(Int_t mode = mPROOF, 
//Int_t nRuns = 600000, 
//Bool_t DATA = kTRUE, 
//const Char_t* dataDir="/alice/data/LHC10h_000137161_p1_4plus#esdTree", Int_t offset=0) {
//void runTaskFluctuationsCentralityTrain(Int_t mode = mLocal, 
//				Bool_t DATA = kTRUE) {
void runTaskFluctuationsCentralityTrain(const char* runListFileName = "group4.txt",
					Int_t mode = mGrid, 
					Bool_t DATA = kTRUE) {
  // Time:
  TStopwatch timer;
  timer.Start();
  
  // Load needed libraries:
  LoadLibraries(mode);
  
  // Create and configure the AliEn plug-in:
  if(mode == mGrid || mode == mGridPAR) {
    gROOT->LoadMacro("CreateAlienHandler.C");
    AliAnalysisGrid *alienHandler = CreateAlienHandler(runListFileName);  
    if (!alienHandler) return;
    gROOT->LoadMacro("AliEbyEFluctuationAnalysisTaskTrain.cxx++");
  }
  // Chains:   
  if(mode==mLocal || mode == mLocalPAR) {
    gROOT->LoadMacro("AliEbyEFluctuationAnalysisTaskTrain.cxx++");
    if (analysisType=="ESD") { 
      TChain* chain = new TChain("esdTree");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set1/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set2/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set3/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set4/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set5/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set6/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set7/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set8/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set9/AliESDs.root");
      chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set10/AliESDs.root");
    }
    else if(analysisType == "MC") {
      TChain *chain = new TChain("TE");
      chain->AddFile("galice.root");
    }
    else
      TChain* chain = CreateAODChain(dataDir, nRuns, offset);
  }
  //Proof
  if(mode == mPROOF) {
    gROOT->ProcessLine(Form(".include %s/include", gSystem->ExpandPathName("$ALICE_ROOT")));
    gProof->Load("AliEbyEFluctuationAnalysisTaskTrain.cxx++");
  }

  // Create analysis manager:
  AliAnalysisManager *mgr = new AliAnalysisManager("FluctuationsAnalysisManager");
  // Connect plug-in to the analysis manager:
  if(mode == mGrid || mode == mGridPAR) { 
    mgr->SetGridHandler(alienHandler);
  }
  // Event handlers:
  if(analysisType == "ESD") {
    AliVEventHandler* esdH = new AliESDInputHandler;
    mgr->SetInputEventHandler(esdH);
  } // end of if(analysisType == "ESD")  
  if(analysisType == "AOD") {
    AliVEventHandler* aodH = new AliAODInputHandler;
    mgr->SetInputEventHandler(aodH); 
  } // end of if(analysisType == "AOD")  
  if(analysisType == "MC") {
    AliVEventHandler* esdH = new AliESDInputHandler;
    mgr->SetInputEventHandler(esdH);
    AliMCEventHandler *mc = new AliMCEventHandler();
    mc->SetReadTR(kFALSE);
    mgr->SetMCtruthEventHandler(mc); 
  } // end of  if(analysisType == "MC")
    
  // Task to check the offline trigger:
  //if(mode == mLocal || mode == mGrid || mode == mGridPAR)
  if(analysisType != "MC") {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); 
    AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(!DATA);
    if(!DATA){physicsSelTask->GetPhysicsSelection()->SetAnalyzeMC();}
    // Enable debug printouts:
    mgr->SetDebugLevel(2);
    
    //Add the centrality determination task
    gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
    AddTaskCentrality();
    //AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
    //taskCentrality->SelectCollisionCandidates(AliVEvent::kMB);
  }

  // Load the analysis task:
  gROOT->LoadMacro("AddTaskFluctuationsCentralityTrain.C");
  for (Int_t i=binfirst; i<binlast+1; i++) {
    Float_t lowCentralityBinEdge = centralityArray[i];
    Float_t highCentralityBinEdge = centralityArray[i+1];
    Printf("\nWagon for centrality bin %i: %.0f-%.0f",i,lowCentralityBinEdge,highCentralityBinEdge);
    AddTaskFluctuationsCentralityTrain(analysisType.Data(),
				       analysisMode.Data(),
				       lowCentralityBinEdge,
				       highCentralityBinEdge,
				       commonOutputFileName);
  } // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
 //  AliEbyEFluctuationAnalysisTaskTrain* taskFA = AddTaskFluctuations(analysisType.Data(),
 //analysisMode.Data());

  // Run the analysis:
  if(!mgr->InitAnalysis()){return;}
  mgr->PrintStatus(); 
  if(mode == mLocal || mode == mLocalPAR) 
    mgr->StartAnalysis("local",chain);
  else if(mode == mPROOF) 
    mgr->StartAnalysis("proof",dataDir,nRuns,offset);
  else if(mode == mGrid || mode == mGridPAR) 
    mgr->StartAnalysis("grid");

  // Print real and CPU time used for analysis:  
  timer.Stop();
  timer.Print();
  
} // end of void runTaskFluctuations(...)

//=============================================================//
void LoadLibraries(const anaModes mode) {  
  //--------------------------------------
  // Load the needed libraries most of them already loaded by aliroot
  //--------------------------------------
  gSystem->Load("libTree");
  gSystem->Load("libGeom");
  gSystem->Load("libVMC");
  gSystem->Load("libXMLIO");
  gSystem->Load("libPhysics");
  
  //----------------------------------------------------------
  // >>>>>>>>>>> Local mode <<<<<<<<<<<<<< 
  //----------------------------------------------------------
  if (mode==mLocal || mode==mGrid || mode == mGridPAR) {
    //--------------------------------------------------------
    // If you want to use already compiled libraries 
    // in the aliroot distribution
    //--------------------------------------------------------
    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");
    if(mode==mLocal || mode==mGrid){
      gSystem->Load("libEventMixing");
      gSystem->Load("libPWGCFebye");
    }
    if(mode==mGridPAR){
      SetupPar("EventMixing");
      SetupPar("PWGCFebye");
    }
  }
  
  else if (mode == mLocalPAR) {
    //--------------------------------------------------------
    //If you want to use root and par files from aliroot
    //--------------------------------------------------------  
    SetupPar("STEERBase");
    SetupPar("ESD");
    SetupPar("AOD");
    SetupPar("ANALYSIS");
    SetupPar("ANALYSISalice");
    SetupPar("PWGCFebye");
}
  
  //---------------------------------------------------------
  // <<<<<<<<<< PROOF mode >>>>>>>>>>>>
  //---------------------------------------------------------
  else if (mode==mPROOF) {
    // Connect to proof
    printf("*** Connect to PROOF ***\n");
    gEnv->SetValue("XSec.GSI.DelegProxy","2");
    // Put appropriate username here
    TProof::Open("alice-caf.cern.ch");
    //TProof::Open("skaf.saske.sk");
    //TProof::Open("prf000-iep-grid.saske.sk");

    gProof->EnablePackage("VO_ALICE@AliRoot::v4-21-12-AN");
 
    // Clear the Packages    
    //gProof->ClearPackage("STEERBase.par");
    //gProof->ClearPackage("ESD.par");
    //gProof->ClearPackage("AOD.par");
    //gProof->ClearPackage("ANALYSIS.par");
    //gProof->ClearPackage("ANALYSISalice.par");    
    //gProof->ClearPackage("PWGCFebye");
    
    // Upload the Packages
    //gProof->UploadPackage("STEERBase.par");
    //gProof->UploadPackage("ESD.par");    
    //gProof->UploadPackage("AOD.par");       
    //gProof->UploadPackage("ANALYSIS.par"); 
    //gProof->UploadPackage("ANALYSISalice.par");
    //gProof->UploadPackage("CORRFW.par");
    //gProof->UploadPackage("PWGCFebye");

    // Enable the Packages 
    //gProof->EnablePackage("STEERBase");
    //gProof->EnablePackage("ESD");
    //gProof->EnablePackage("AOD");
    //gProof->EnablePackage("ANALYSIS");
    //gProof->EnablePackage("ANALYSISalice");
    //gProof->EnablePackage("PWGCFebye");

    // Show enables Packages
    //gProof->ShowEnabledPackages();
  }  
  
} // end of void LoadLibraries(const anaModes mode)

//===============================================================================================

void SetupPar(char* pararchivename) {
  //Load par files, create analysis libraries
  //For testing, if par file already decompressed and modified
  //classes then do not decompress.
  
  TString cdir(Form("%s", gSystem->WorkingDirectory() )) ; 
  TString parpar(Form("%s.par", pararchivename)) ; 
  if ( gSystem->AccessPathName(parpar.Data()) ) {
    gSystem->ChangeDirectory(gSystem->Getenv("ALICE_ROOT")) ;
    TString processline(Form(".! make %s", parpar.Data())) ; 
    gROOT->ProcessLine(processline.Data()) ;
    gSystem->ChangeDirectory(cdir) ; 
    processline = Form(".! mv /tmp/%s .", parpar.Data()) ;
    gROOT->ProcessLine(processline.Data()) ;
  } 
  if ( gSystem->AccessPathName(pararchivename) ) {  
    TString processline = Form(".! tar xvzf %s",parpar.Data()) ;
    gROOT->ProcessLine(processline.Data());
  }
  
  TString ocwd = gSystem->WorkingDirectory();
  gSystem->ChangeDirectory(pararchivename);
  
  // check for BUILD.sh and execute
  if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
    printf("*******************************\n");
    printf("*** Building PAR archive    ***\n");
    cout<<pararchivename<<endl;
    printf("*******************************\n");
    if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
      Error("runProcess","Cannot Build the PAR Archive! - Abort!");
      return -1;
    }
  }
  // check for SETUP.C and execute
  if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
    printf("*******************************\n");
    printf("*** Setup PAR archive       ***\n");
    cout<<pararchivename<<endl;
    printf("*******************************\n");
    gROOT->Macro("PROOF-INF/SETUP.C");
  }
  
  gSystem->ChangeDirectory(ocwd.Data());
  printf("Current dir: %s\n", ocwd.Data());

} // end of void SetupPar(char* pararchivename) 

//===============================================================================================

// Helper macros for creating chains
// from: CreateESDChain.C,v 1.10 jgrosseo Exp

TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
{
  // creates chain of files in a given directory or file containing a list.
  // In case of directory the structure is expected as:
  // <aDataDir>/<dir0>/AliESDs.root
  // <aDataDir>/<dir1>/AliESDs.root
  // ...
  
  if (!aDataDir)
    return 0;
  
  Long_t id, size, flags, modtime;
  if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
    {
      printf("%s not found.\n", aDataDir);
      return 0;
    }
  
  TChain* chain = new TChain("esdTree");
  TChain* chaingAlice = 0;
  
  if (flags & 2)
    {
      TString execDir(gSystem->pwd());
      TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
      TList* dirList            = baseDir->GetListOfFiles();
      Int_t nDirs               = dirList->GetEntries();
      gSystem->cd(execDir);
      
      Int_t count = 0;
      
      for (Int_t iDir=0; iDir<nDirs; ++iDir)
	{
	  TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
	  if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
	    continue;
	  
	  if (offset > 0)
	    {
	      --offset;
	      continue;
	    }
	  
	  if (count++ == aRuns)
	    break;
	  
	  TString presentDirName(aDataDir);
	  presentDirName += "/";
	  presentDirName += presentDir->GetName();	  
	  chain->Add(presentDirName + "/AliESDs.root/esdTree");
	  //  cerr<<presentDirName<<endl;
	}
      
    }
  else
    {
      // Open the input stream
      ifstream in;
      in.open(aDataDir);
      
      Int_t count = 0;
      
      // Read the input list of files and add them to the chain
      TString esdfile;
      while(in.good()) {
	in >> esdfile;
	if (!esdfile.Contains("root")) continue; // protection
	
	if (offset > 0)
	  {
	    --offset;
	    continue;
	  }
	
	if (count++ == aRuns)
	  break;
	
	// add esd file
	chain->Add(esdfile);
      }
      
      in.close();
    }
  
  return chain;

} // end of TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)

//===============================================================================================

TChain* CreateAODChain(const char* aDataDir, Int_t aRuns, Int_t offset)
{
  // creates chain of files in a given directory or file containing a list.
  // In case of directory the structure is expected as:
  // <aDataDir>/<dir0>/AliAOD.root
  // <aDataDir>/<dir1>/AliAOD.root
  // ...
  
  if (!aDataDir)
    return 0;
  
  Long_t id, size, flags, modtime;
  if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
    {
      printf("%s not found.\n", aDataDir);
      return 0;
    }
  
  TChain* chain = new TChain("aodTree");
  TChain* chaingAlice = 0;
  
  if (flags & 2)
    {
      TString execDir(gSystem->pwd());
      TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
      TList* dirList            = baseDir->GetListOfFiles();
      Int_t nDirs               = dirList->GetEntries();
      gSystem->cd(execDir);
      
      Int_t count = 0;
      
      for (Int_t iDir=0; iDir<nDirs; ++iDir)
	{
	  TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
	  if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
	    continue;
	  
	  if (offset > 0)
	    {
	      --offset;
	      continue;
	    }
	  
	  if (count++ == aRuns)
	    break;
	  
	  TString presentDirName(aDataDir);
	  presentDirName += "/";
	  presentDirName += presentDir->GetName();	  
	  chain->Add(presentDirName + "/AliAOD.root/aodTree");
	  // cerr<<presentDirName<<endl;
	}
      
    }
  else
    {
      // Open the input stream
      ifstream in;
      in.open(aDataDir);
      
      Int_t count = 0;
      
      // Read the input list of files and add them to the chain
      TString aodfile;
      while(in.good()) {
	in >> aodfile;
	if (!aodfile.Contains("root")) continue; // protection
	
	if (offset > 0)
	  {
	    --offset;
	    continue;
	  }
	
	if (count++ == aRuns)
	  break;
	
	// add aod file
	chain->Add(aodfile);
      }
      
      in.close();
    }
  
  return chain;

} // end of TChain* CreateAODChain(const char* aDataDir, Int_t aRuns, Int_t offset)
Commit	Line	Data
4ea82985	1	enum anaModes {mLocal,mLocalPAR,mPROOF,mGrid,mGridPAR};
	2	//mLocal: Analyze locally files in your computer using aliroot
	3	//mLocalPAR: Analyze locally files in your computer using root + PAR files
	4	//mPROOF: Analyze CAF files with PROOF
	5	//mGrid: Analyze files on Grid via AliEn plug-in and using precompiled FLOW libraries
	6	//mGridPAR: Analyze files on Grid via AliEn plug-in and using par files for FLOW package
	7
	8	//Analysis modes
	9	const TString analysisType = "ESD"; //"MC", "ESD", "AOD"
	10	const TString analysisMode = "TPC"; //"TPC", "Global"
	11
	12	//Centrality stuff
	13	Int_t binfirst = 0; //where do we start numbering bins
	14	Int_t binlast = 8; //where do we stop numbering bins
	15	const Int_t numberOfCentralityBins = 9;
	16	Float_t centralityArray[numberOfCentralityBins+1] = {0.,5.,10.,20.,30.,40.,50.,60.,70.,80.}; // in centrality percentile
	17
	18	//output file
	19	TString commonOutputFileName = "outputCentrality";
	20
	21	//void runTaskFluctuationsCentralityTrain(Int_t mode = mPROOF,
	22	//Int_t nRuns = 600000,
	23	//Bool_t DATA = kTRUE,
	24	//const Char_t* dataDir="/alice/data/LHC10h_000137161_p1_4plus#esdTree", Int_t offset=0) {
	25	//void runTaskFluctuationsCentralityTrain(Int_t mode = mLocal,
	26	// Bool_t DATA = kTRUE) {
	27	void runTaskFluctuationsCentralityTrain(const char* runListFileName = "group4.txt",
	28	Int_t mode = mGrid,
	29	Bool_t DATA = kTRUE) {
	30	// Time:
	31	TStopwatch timer;
	32	timer.Start();
	33
	34	// Load needed libraries:
	35	LoadLibraries(mode);
	36
	37	// Create and configure the AliEn plug-in:
	38	if(mode == mGrid \|\| mode == mGridPAR) {
	39	gROOT->LoadMacro("CreateAlienHandler.C");
	40	AliAnalysisGrid *alienHandler = CreateAlienHandler(runListFileName);
	41	if (!alienHandler) return;
	42	gROOT->LoadMacro("AliEbyEFluctuationAnalysisTaskTrain.cxx++");
	43	}
	44	// Chains:
	45	if(mode==mLocal \|\| mode == mLocalPAR) {
	46	gROOT->LoadMacro("AliEbyEFluctuationAnalysisTaskTrain.cxx++");
	47	if (analysisType=="ESD") {
	48	TChain* chain = new TChain("esdTree");
	49	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set1/AliESDs.root");
	50	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set2/AliESDs.root");
	51	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set3/AliESDs.root");
	52	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set4/AliESDs.root");
	53	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set5/AliESDs.root");
	54	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set6/AliESDs.root");
	55	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set7/AliESDs.root");
	56	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set8/AliESDs.root");
	57	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set9/AliESDs.root");
	58	chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set10/AliESDs.root");
	59	}
	60	else if(analysisType == "MC") {
	61	TChain *chain = new TChain("TE");
	62	chain->AddFile("galice.root");
	63	}
	64	else
65	TChain* chain = CreateAODChain(dataDir, nRuns, offset);
66	}
67	//Proof
68	if(mode == mPROOF) {
69	gROOT->ProcessLine(Form(".include %s/include", gSystem->ExpandPathName("$ALICE_ROOT")));
70	gProof->Load("AliEbyEFluctuationAnalysisTaskTrain.cxx++");
71	}
72
73	// Create analysis manager:
74	AliAnalysisManager *mgr = new AliAnalysisManager("FluctuationsAnalysisManager");
75	// Connect plug-in to the analysis manager:
76	if(mode == mGrid \|\| mode == mGridPAR) {
77	mgr->SetGridHandler(alienHandler);
78	}
79	// Event handlers:
80	if(analysisType == "ESD") {
81	AliVEventHandler* esdH = new AliESDInputHandler;
82	mgr->SetInputEventHandler(esdH);
83	} // end of if(analysisType == "ESD")
84	if(analysisType == "AOD") {
85	AliVEventHandler* aodH = new AliAODInputHandler;
86	mgr->SetInputEventHandler(aodH);
87	} // end of if(analysisType == "AOD")
88	if(analysisType == "MC") {
89	AliVEventHandler* esdH = new AliESDInputHandler;
90	mgr->SetInputEventHandler(esdH);
91	AliMCEventHandler *mc = new AliMCEventHandler();
92	mc->SetReadTR(kFALSE);
93	mgr->SetMCtruthEventHandler(mc);
94	} // end of if(analysisType == "MC")
95
96	// Task to check the offline trigger:
97	//if(mode == mLocal \|\| mode == mGrid \|\| mode == mGridPAR)
98	if(analysisType != "MC") {
99	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
100	AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(!DATA);
101	if(!DATA){physicsSelTask->GetPhysicsSelection()->SetAnalyzeMC();}
102	// Enable debug printouts:
103	mgr->SetDebugLevel(2);
104
105	//Add the centrality determination task
1c06a186	106	gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
4ea82985	107	AddTaskCentrality();
	108	//AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
	109	//taskCentrality->SelectCollisionCandidates(AliVEvent::kMB);
	110	}
	111
	112	// Load the analysis task:
	113	gROOT->LoadMacro("AddTaskFluctuationsCentralityTrain.C");
	114	for (Int_t i=binfirst; i<binlast+1; i++) {
	115	Float_t lowCentralityBinEdge = centralityArray[i];
	116	Float_t highCentralityBinEdge = centralityArray[i+1];
	117	Printf("\nWagon for centrality bin %i: %.0f-%.0f",i,lowCentralityBinEdge,highCentralityBinEdge);
	118	AddTaskFluctuationsCentralityTrain(analysisType.Data(),
	119	analysisMode.Data(),
	120	lowCentralityBinEdge,
	121	highCentralityBinEdge,
	122	commonOutputFileName);
	123	} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
	124	// AliEbyEFluctuationAnalysisTaskTrain* taskFA = AddTaskFluctuations(analysisType.Data(),
	125	//analysisMode.Data());
	126
	127	// Run the analysis:
	128	if(!mgr->InitAnalysis()){return;}
	129	mgr->PrintStatus();
	130	if(mode == mLocal \|\| mode == mLocalPAR)
	131	mgr->StartAnalysis("local",chain);
	132	else if(mode == mPROOF)
	133	mgr->StartAnalysis("proof",dataDir,nRuns,offset);
	134	else if(mode == mGrid \|\| mode == mGridPAR)
	135	mgr->StartAnalysis("grid");
	136
	137	// Print real and CPU time used for analysis:
	138	timer.Stop();
	139	timer.Print();
	140
	141	} // end of void runTaskFluctuations(...)
	142
	143	//=============================================================//
	144	void LoadLibraries(const anaModes mode) {
	145	//--------------------------------------
	146	// Load the needed libraries most of them already loaded by aliroot
	147	//--------------------------------------
	148	gSystem->Load("libTree");
	149	gSystem->Load("libGeom");
	150	gSystem->Load("libVMC");
	151	gSystem->Load("libXMLIO");
	152	gSystem->Load("libPhysics");
	153
	154	//----------------------------------------------------------
	155	// >>>>>>>>>>> Local mode <<<<<<<<<<<<<<
	156	//----------------------------------------------------------
	157	if (mode==mLocal \|\| mode==mGrid \|\| mode == mGridPAR) {
	158	//--------------------------------------------------------
	159	// If you want to use already compiled libraries
	160	// in the aliroot distribution
	161	//--------------------------------------------------------
	162	gSystem->Load("libSTEERBase");
	163	gSystem->Load("libESD");
	164	gSystem->Load("libAOD");
	165	gSystem->Load("libANALYSIS");
	166	gSystem->Load("libANALYSISalice");
	167	// Use AliRoot includes to compile our task
	168	gROOT->ProcessLine(".include $ALICE_ROOT/include");
1f7eb4d0	169	if(mode==mLocal \|\| mode==mGrid){
4070f709	170	gSystem->Load("libEventMixing");
a022cbd0	171	gSystem->Load("libPWGCFebye");
1f7eb4d0	172	}
	173	if(mode==mGridPAR){
	174	SetupPar("EventMixing");
a022cbd0	175	SetupPar("PWGCFebye");
1f7eb4d0	176	}
4ea82985	177	}
	178
	179	else if (mode == mLocalPAR) {
	180	//--------------------------------------------------------
	181	//If you want to use root and par files from aliroot
	182	//--------------------------------------------------------
	183	SetupPar("STEERBase");
	184	SetupPar("ESD");
	185	SetupPar("AOD");
	186	SetupPar("ANALYSIS");
	187	SetupPar("ANALYSISalice");
a022cbd0	188	SetupPar("PWGCFebye");
4ea82985	189	}
	190
	191	//---------------------------------------------------------
	192	// <<<<<<<<<< PROOF mode >>>>>>>>>>>>
	193	//---------------------------------------------------------
	194	else if (mode==mPROOF) {
	195	// Connect to proof
	196	printf("* Connect to PROOF *\n");
	197	gEnv->SetValue("XSec.GSI.DelegProxy","2");
	198	// Put appropriate username here
	199	TProof::Open("alice-caf.cern.ch");
	200	//TProof::Open("skaf.saske.sk");
	201	//TProof::Open("prf000-iep-grid.saske.sk");
	202
	203	gProof->EnablePackage("VO_ALICE@AliRoot::v4-21-12-AN");
	204
	205	// Clear the Packages
	206	//gProof->ClearPackage("STEERBase.par");
	207	//gProof->ClearPackage("ESD.par");
	208	//gProof->ClearPackage("AOD.par");
	209	//gProof->ClearPackage("ANALYSIS.par");
	210	//gProof->ClearPackage("ANALYSISalice.par");
a022cbd0	211	//gProof->ClearPackage("PWGCFebye");
4ea82985	212
	213	// Upload the Packages
	214	//gProof->UploadPackage("STEERBase.par");
	215	//gProof->UploadPackage("ESD.par");
	216	//gProof->UploadPackage("AOD.par");
	217	//gProof->UploadPackage("ANALYSIS.par");
	218	//gProof->UploadPackage("ANALYSISalice.par");
	219	//gProof->UploadPackage("CORRFW.par");
a022cbd0	220	//gProof->UploadPackage("PWGCFebye");
4ea82985	221
	222	// Enable the Packages
	223	//gProof->EnablePackage("STEERBase");
	224	//gProof->EnablePackage("ESD");
	225	//gProof->EnablePackage("AOD");
	226	//gProof->EnablePackage("ANALYSIS");
	227	//gProof->EnablePackage("ANALYSISalice");
a022cbd0	228	//gProof->EnablePackage("PWGCFebye");
4ea82985	229
	230	// Show enables Packages
	231	//gProof->ShowEnabledPackages();
	232	}
	233
	234	} // end of void LoadLibraries(const anaModes mode)
	235
	236	//===============================================================================================
	237
	238	void SetupPar(char* pararchivename) {
	239	//Load par files, create analysis libraries
	240	//For testing, if par file already decompressed and modified
	241	//classes then do not decompress.
	242
	243	TString cdir(Form("%s", gSystem->WorkingDirectory() )) ;
	244	TString parpar(Form("%s.par", pararchivename)) ;
	245	if ( gSystem->AccessPathName(parpar.Data()) ) {
	246	gSystem->ChangeDirectory(gSystem->Getenv("ALICE_ROOT")) ;
	247	TString processline(Form(".! make %s", parpar.Data())) ;
	248	gROOT->ProcessLine(processline.Data()) ;
	249	gSystem->ChangeDirectory(cdir) ;
	250	processline = Form(".! mv /tmp/%s .", parpar.Data()) ;
	251	gROOT->ProcessLine(processline.Data()) ;
	252	}
	253	if ( gSystem->AccessPathName(pararchivename) ) {
	254	TString processline = Form(".! tar xvzf %s",parpar.Data()) ;
	255	gROOT->ProcessLine(processline.Data());
	256	}
	257
	258	TString ocwd = gSystem->WorkingDirectory();
	259	gSystem->ChangeDirectory(pararchivename);
	260
	261	// check for BUILD.sh and execute
	262	if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
	263	printf("*******************************\n");
	264	printf("* Building PAR archive *\n");
	265	cout<<pararchivename<<endl;
	266	printf("*******************************\n");
	267	if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
	268	Error("runProcess","Cannot Build the PAR Archive! - Abort!");
	269	return -1;
	270	}
	271	}
	272	// check for SETUP.C and execute
	273	if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
	274	printf("*******************************\n");
	275	printf("* Setup PAR archive *\n");
	276	cout<<pararchivename<<endl;
	277	printf("*******************************\n");
	278	gROOT->Macro("PROOF-INF/SETUP.C");
	279	}
	280
	281	gSystem->ChangeDirectory(ocwd.Data());
	282	printf("Current dir: %s\n", ocwd.Data());
	283
	284	} // end of void SetupPar(char* pararchivename)
	285
	286	//===============================================================================================
	287
	288	// Helper macros for creating chains
	289	// from: CreateESDChain.C,v 1.10 jgrosseo Exp
	290
	291	TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
	292	{
293	// creates chain of files in a given directory or file containing a list.
294	// In case of directory the structure is expected as:
295	// <aDataDir>/<dir0>/AliESDs.root
296	// <aDataDir>/<dir1>/AliESDs.root
297	// ...
298
299	if (!aDataDir)
300	return 0;
301
302	Long_t id, size, flags, modtime;
303	if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
304	{
305	printf("%s not found.\n", aDataDir);
306	return 0;
307	}
308
309	TChain* chain = new TChain("esdTree");
310	TChain* chaingAlice = 0;
311
312	if (flags & 2)
313	{
314	TString execDir(gSystem->pwd());
315	TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
316	TList* dirList = baseDir->GetListOfFiles();
317	Int_t nDirs = dirList->GetEntries();
318	gSystem->cd(execDir);
319
320	Int_t count = 0;
321
322	for (Int_t iDir=0; iDir<nDirs; ++iDir)
323	{
324	TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
325	if (!presentDir \|\| !presentDir->IsDirectory() \|\| strcmp(presentDir->GetName(), ".") == 0 \|\| strcmp(presentDir->GetName(), "..") == 0)
326	continue;
327
328	if (offset > 0)
329	{
330	--offset;
331	continue;
332	}
333
334	if (count++ == aRuns)
335	break;
336
337	TString presentDirName(aDataDir);
338	presentDirName += "/";
339	presentDirName += presentDir->GetName();
340	chain->Add(presentDirName + "/AliESDs.root/esdTree");
341	// cerr<<presentDirName<<endl;
342	}
343
344	}
345	else
346	{
347	// Open the input stream
348	ifstream in;
349	in.open(aDataDir);
350
351	Int_t count = 0;
352
353	// Read the input list of files and add them to the chain
354	TString esdfile;
355	while(in.good()) {
356	in >> esdfile;
357	if (!esdfile.Contains("root")) continue; // protection
358
359	if (offset > 0)
360	{
361	--offset;
362	continue;
363	}
364
365	if (count++ == aRuns)
366	break;
367
368	// add esd file
369	chain->Add(esdfile);
370	}
371
372	in.close();
373	}
374
375	return chain;
376
377	} // end of TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
378
379	//===============================================================================================
380
381	TChain* CreateAODChain(const char* aDataDir, Int_t aRuns, Int_t offset)
382	{
383	// creates chain of files in a given directory or file containing a list.
384	// In case of directory the structure is expected as:
385	// <aDataDir>/<dir0>/AliAOD.root
386	// <aDataDir>/<dir1>/AliAOD.root
387	// ...
388
389	if (!aDataDir)
390	return 0;
391
392	Long_t id, size, flags, modtime;
393	if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
394	{
395	printf("%s not found.\n", aDataDir);
396	return 0;
397	}
398
399	TChain* chain = new TChain("aodTree");
400	TChain* chaingAlice = 0;
401
402	if (flags & 2)
403	{
404	TString execDir(gSystem->pwd());
405	TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
406	TList* dirList = baseDir->GetListOfFiles();
407	Int_t nDirs = dirList->GetEntries();
408	gSystem->cd(execDir);
409
410	Int_t count = 0;
411
412	for (Int_t iDir=0; iDir<nDirs; ++iDir)
413	{
414	TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
415	if (!presentDir \|\| !presentDir->IsDirectory() \|\| strcmp(presentDir->GetName(), ".") == 0 \|\| strcmp(presentDir->GetName(), "..") == 0)
416	continue;
417
418	if (offset > 0)
419	{
420	--offset;
421	continue;
422	}
423
424	if (count++ == aRuns)
425	break;
426
427	TString presentDirName(aDataDir);
428	presentDirName += "/";
429	presentDirName += presentDir->GetName();
430	chain->Add(presentDirName + "/AliAOD.root/aodTree");
431	// cerr<<presentDirName<<endl;
432	}
433
434	}
435	else
436	{
437	// Open the input stream
438	ifstream in;
439	in.open(aDataDir);
440
441	Int_t count = 0;
442
443	// Read the input list of files and add them to the chain
444	TString aodfile;
445	while(in.good()) {
446	in >> aodfile;
447	if (!aodfile.Contains("root")) continue; // protection
448
449	if (offset > 0)
450	{
451	--offset;
452	continue;
453	}
454
455	if (count++ == aRuns)
456	break;
457
458	// add aod file
459	chain->Add(aodfile);
460	}
461
462	in.close();
463	}
464
465	return chain;
466
467	} // end of TChain* CreateAODChain(const char* aDataDir, Int_t aRuns, Int_t offset)
468