[u/mrichter/AliRoot.git] / PWGCF / EBYE / macros / runBalancePsiEfficiencyTaskCentralityTrain.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 analysisMode = "TPC"; //"TPC", "Global"

//Centrality stuff
Int_t binfirst = 0;  //where do we start numbering bins
Int_t binlast = 7;  //where do we stop numbering bins
const Int_t numberOfCentralityBins = 8;
Double_t centralityArray[numberOfCentralityBins+1] = {0.,10.,20.,30.,40.,50.,60.,70.,80.}; // in centrality percentile
Bool_t kUsePID = kFALSE;
const TString  centralityEstimator = "V0M";
Double_t vertexZ = 10.;

//output file
TString commonOutputFileName = "outputEfficiency";

//void runEfficiencyTaskCentralityTrain(Int_t mode = mPROOF, 
//Int_t nRuns = 600000, 
//Bool_t DATA = kFALSE, 
//const Char_t* dataDir="/alice/data/LHC10h_000137161_p1_4plus#esdTree", Int_t offset=0) {
void runBalancePsiEfficiencyTaskCentralityTrain(Int_t mode = mLocal, Bool_t DATA = kFALSE) {
//void runEfficiencyTaskCentralityTrain(const char* runListFileName = "listOfRuns.txt",Int_t mode = mGrid,  Bool_t DATA = kFALSE) {
  // 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("AliAnalysisTaskEfficiencyBF.cxx++");  //gROOT->LoadMacro("AliAnalysisEfficiencyTaskCentralityTrain.cxx++");
  }
  // Chains:   
  if(mode==mLocal || mode == mLocalPAR) {
    //gROOT->LoadMacro("AliAnalysisEfficiencyTaskCentralityTrain.cxx++");
    //gROOT->LoadMacro("AliAnalysisTaskEfficiencyBF.cxx++");
    TChain* chain = new TChain("esdTree");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set1/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set2/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set3/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set4/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set5/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set6/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set7/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set8/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set9/AliESDs.root");
    chain->Add("/glusterfs/alice1/alice2/pchrist/HeavyIons/MC/Set10/AliESDs.root");
  }
  //Proof
  if(mode == mPROOF) {
    gROOT->ProcessLine(Form(".include %s/include", gSystem->ExpandPathName("$ALICE_ROOT")));
    gProof->Load("AliAnalysisTaskEfficiencyBF.cxx++");
  }

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

  if(kUsePID) {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
    AddTaskPIDResponse(1); 
  }

  // Load the analysis task:
  gROOT->LoadMacro("$ALICE_ROOT/PWGCF/EBYE/macros/AddTaskBalancePsiEfficiency.C");
  
  for (Int_t i=binfirst; i<binlast+1; i++) {
    //for (Int_t i = 0; i < 9; i++) {
    Double_t lowCentralityBinEdge = centralityArray[i];
    Double_t highCentralityBinEdge = centralityArray[i+1];
    Printf("\nWagon for centrality bin %i: %.0f-%.0f",i,lowCentralityBinEdge,highCentralityBinEdge);
    AddTaskBalancePsiEfficiency(centralityEstimator.Data(), lowCentralityBinEdge, highCentralityBinEdge, vertexZ, commonOutputFileName.Data());
  } // end of for (Int_t i=0; i<numberOfCentralityBins; i++)

  // 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");
    gSystem->Load("libEventMixing.so");
    gSystem->Load("libCORRFW.so");
    gSystem->Load("libPWGTools.so");
    gSystem->Load("libPWGCFebye.so");

    // Use AliRoot includes to compile our task                                   
    gROOT->ProcessLine(".include $ALICE_ROOT/include");
  }
  
  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");
}
  
  //---------------------------------------------------------
  // <<<<<<<<<< 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");
 
    TString extraLibs = "";
    extraLibs += "CORRFW:PWGTools";

    TList *list = new TList();
    list->Add(new TNamed("ALIROOT_EXTRA_LIBS",extraLibs.Data()));

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