[u/mrichter/AliRoot.git] / PWGLF / SPECTRA / PiKaPr / TestAOD / runProof.C

// TODO:
// 1. run with Many centrality bins at once
#include <string.h>

enum { kMyRunModeLocal = 0, kMyRunModeCAF, kMyRunModeGRID};

TList * listToLoad = new TList();

TChain * GetAnalysisChain(const char * incollection);

void runProof(Char_t* data = "/alice/data/LHC10h_000138653_p2_AOD049", Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 1, Bool_t isMC = 0,
              const char* option = "SAVE", Int_t workers = -1)
{
   // runMode:
   //
   // 0 local
   // 1 proof
   // 2 grid

   if (nev < 0)
      nev = 1234567890;

   InitAndLoadLibs(runMode, workers, debug);

   // Create the analysis manager
   mgr = new AliAnalysisManager;

   // Add AOD handler
   AliAODInputHandler* AODH = new AliAODInputHandler;
   mgr->SetInputEventHandler(AODH);
   mgr->SetDebugLevel(10);

   // Is this needed for AOD?
   // if(isMC) {
   //   AliMCEventHandler* handler = new AliMCEventHandler;
   //   handler->SetPreReadMode(AliMCEventHandler::kLmPreRead);
   //   mgr->SetMCtruthEventHandler(handler);
   // }


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

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

   //  AliLog::SetClassDebugLevel("AliESDtrackCuts", AliLog::kDebug);// FIXME

   // load my task
   gROOT->ProcessLine(".L AddTaskSpectraAOD.C");
   AliAnalysisTaskSpectraAOD * task = AddTaskSpectraAOD("SpectraAOD.root");
   task->SetIsMC(isMC);
   // 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 == kMyRunModeCAF)
   {
      mgr->StartAnalysis("proof", TString(data) + "#aodTree", nev);
   }
   else if (runMode == kMyRunModeGRID)
   {
      mgr->StartAnalysis("grid");
   }
   else
   {
      cout << "ERROR: unknown run mode" << endl;
   }

   TString pathsuffix = "";
   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 = "SpectraAOD.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);
   // }
   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("aodTree");
   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("AliSpectraAODHistoManager.cxx+"));
   listToLoad->Add(new TObjString("AliSpectraAODEventCuts.cxx+"));
   listToLoad->Add(new TObjString("AliSpectraAODTrackCuts.cxx+"));
   listToLoad->Add(new TObjString("AliAnalysisTaskSpectraAOD.cxx+"));

   if (runMode == kMyRunModeCAF)
   {
      cout << "Init in CAF mode" << endl;

      gEnv->SetValue("XSec.GSI.DelegProxy", "2");
      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);

      gProof->EnablePackage("VO_ALICE@AliRoot::v4-21-29-AN");
      gSystem->Load("libCore");
      gSystem->Load("libTree");
      gSystem->Load("libGeom");
      gSystem->Load("libVMC");
      gSystem->Load("libPhysics");
      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/PWG0/multPb"));
      // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
   }
   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("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)
      {
         gProof->Load(name->String() + (debug ? "+g" : ""));
      }
      else
      {
         gROOT->LoadMacro(name->String() + (debug ? "+g" : ""));
      }
   }

}
Commit	Line	Data
c88234ad	1	// TODO:
	2	// 1. run with Many centrality bins at once
	3	#include <string.h>
	4
	5	enum { kMyRunModeLocal = 0, kMyRunModeCAF, kMyRunModeGRID};
	6
	7	TList * listToLoad = new TList();
	8
	9	TChain * GetAnalysisChain(const char * incollection);
	10
	11	void runProof(Char_t* data = "/alice/data/LHC10h_000138653_p2_AOD049", Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 1, Bool_t isMC = 0,
	12	const char* option = "SAVE", Int_t workers = -1)
	13	{
	14	// runMode:
	15	//
	16	// 0 local
	17	// 1 proof
	18	// 2 grid
	19
	20	if (nev < 0)
	21	nev = 1234567890;
	22
	23	InitAndLoadLibs(runMode, workers, debug);
	24
	25	// Create the analysis manager
	26	mgr = new AliAnalysisManager;
	27
	28	// Add AOD handler
	29	AliAODInputHandler* AODH = new AliAODInputHandler;
	30	mgr->SetInputEventHandler(AODH);
	31	mgr->SetDebugLevel(10);
	32
	33	// Is this needed for AOD?
	34	// if(isMC) {
	35	// AliMCEventHandler* handler = new AliMCEventHandler;
	36	// handler->SetPreReadMode(AliMCEventHandler::kLmPreRead);
	37	// mgr->SetMCtruthEventHandler(handler);
	38	// }
	39
	40
	41	// If we are running on grid, we need the alien handler
	42	if (runMode == kMyRunModeGRID)
	43	{
	44	// Create and configure the alien handler plugin
	45	gROOT->LoadMacro("CreateAlienHandler.C");
	46	AliAnalysisGrid *alienHandler = CreateAlienHandler(data, listToLoad, "full", isMC);
	47	if (!alienHandler)
	48	{
	49	cout << "Cannot create alien handler" << endl;
	50	exit(1);
	51	}
	52	mgr->SetGridHandler(alienHandler);
	53	}
	54
	55	// Parse option strings
	56	TString optionStr(option);
	57
	58	// remove SAVE option if set
	59	// 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
	60	Bool_t doSave = kFALSE;
	61	TString optionStr(option);
	62	if (optionStr.Contains("SAVE"))
	63	{
	64	optionStr = optionStr(0, optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE") + 4, optionStr.Length());
65	doSave = kTRUE;
66	}
67
68	// AliLog::SetClassDebugLevel("AliESDtrackCuts", AliLog::kDebug);// FIXME
69
70	// load my task
71	gROOT->ProcessLine(".L AddTaskSpectraAOD.C");
72	AliAnalysisTaskSpectraAOD * task = AddTaskSpectraAOD("SpectraAOD.root");
73	task->SetIsMC(isMC);
74	// Init and run the analy
75	if (!mgr->InitAnalysis()) return;
76
77	mgr->PrintStatus();
78
79	if (runMode == kMyRunModeLocal)
80	{
81	// If running in local mode, create chain of ESD files
82	cout << "RUNNING LOCAL, CHAIN" << endl;
83	TChain * chain = GetAnalysisChain(data);
84	// chain->Print();
85	mgr->StartAnalysis("local", chain, nev);
86	}
87	else if (runMode == kMyRunModeCAF)
88	{
89	mgr->StartAnalysis("proof", TString(data) + "#aodTree", nev);
90	}
91	else if (runMode == kMyRunModeGRID)
92	{
93	mgr->StartAnalysis("grid");
94	}
95	else
96	{
97	cout << "ERROR: unknown run mode" << endl;
98	}
99
100	TString pathsuffix = "";
101	if (doSave) MoveOutput(data, pathsuffix.Data());
102
103	}
104
105
106	void MoveOutput(const char * data, const char * suffix = "")
107	{
108
109	TString path("output/");
110	path = path + TString(data).Tokenize("/")->Last()->GetName() + suffix;
111
112	TString fileName = "SpectraAOD.root";
113	gSystem->mkdir(path, kTRUE);
114	gSystem->Rename(fileName, path + "/" + fileName);
115	// for(Int_t ibin = 0; ibin < 20; ibin++){
116	// TString fileBin = fileName;
117	// fileBin.ReplaceAll(".root",Form("_%2.2d.root",ibin));
118	// gSystem->Rename(fileBin, path + "/" + fileBin);
119	// }
120	Printf(">>>>> Moved files to %s", path.Data());
121	}
122
123
124
125	TChain * GetAnalysisChain(const char * incollection)
126	{
127	// Builds a chain of esd files
128	// incollection can be
129	// - a single root file
130	// - an xml collection of files on alien
131	// - a ASCII containing a list of local root files
132	TChain* analysisChain = 0;
133	// chain
134	analysisChain = new TChain("aodTree");
135	if (TString(incollection).Contains(".root"))
136	{
137	analysisChain->Add(incollection);
138	}
139	else if (TString(incollection).Contains("xml"))
140	{
141	TGrid::Connect("alien://");
142	TAlienCollection * coll = TAlienCollection::Open(incollection);
143	while (coll->Next())
144	{
145	analysisChain->Add(TString("alien://") + coll->GetLFN());
146	}
147	}
148	else
149	{
150	ifstream file_collect(incollection);
151	TString line;
152	while (line.ReadLine(file_collect))
153	{
154	analysisChain->Add(line.Data());
155	}
156	}
157	analysisChain->GetListOfFiles()->Print();
158
159	return analysisChain;
160	}
161
162
163	void InitAndLoadLibs(Int_t runMode = kMyRunModeLocal, Int_t workers = 0, Bool_t debug = 0)
164	{
165	// Loads libs and par files + custom task and classes
166
167	// Custom stuff to be loaded
168
169	listToLoad->Add(new TObjString("AliSpectraAODHistoManager.cxx+"));
170	listToLoad->Add(new TObjString("AliSpectraAODEventCuts.cxx+"));
171	listToLoad->Add(new TObjString("AliSpectraAODTrackCuts.cxx+"));
172	listToLoad->Add(new TObjString("AliAnalysisTaskSpectraAOD.cxx+"));
173
174	if (runMode == kMyRunModeCAF)
175	{
176	cout << "Init in CAF mode" << endl;
177
178	gEnv->SetValue("XSec.GSI.DelegProxy", "2");
179	TProof * p = TProof::Open("alice-caf.cern.ch", workers > 0 ? Form("workers=%d", workers) : "1x");
180	//TProof * p = TProof::Open("skaf.saske.sk", workers>0 ? Form("workers=%d",workers) : "");
181	p->Exec("TObject *o = gEnv->GetTable()->FindObject(\"Proof.UseMergers\"); gEnv->GetTable()->Remove(o);", kTRUE);
182
183	gProof->EnablePackage("VO_ALICE@AliRoot::v4-21-29-AN");
4070f709	184	gSystem->Load("libCore");
	185	gSystem->Load("libTree");
	186	gSystem->Load("libGeom");
	187	gSystem->Load("libVMC");
	188	gSystem->Load("libPhysics");
c88234ad	189	gSystem->Load("libSTEERBase");
	190	gSystem->Load("libESD");
	191	gSystem->Load("libAOD");
	192	gSystem->Load("libANALYSIS");
	193	gSystem->Load("libOADB");
	194	gSystem->Load("libANALYSISalice");
	195
	196	// Enable the needed package
	197	// gProof->UploadPackage("$ALICE_ROOT/obj/STEERBase");
	198	// gProof->EnablePackage("$ALICE_ROOT/obj/STEERBase");
	199	// gProof->UploadPackage("$ALICE_ROOT/obj/ESD");
	200	// gProof->EnablePackage("$ALICE_ROOT/obj/ESD");
	201	// gProof->UploadPackage("$ALICE_ROOT/obj/AOD");
	202	// gProof->EnablePackage("$ALICE_ROOT/obj/AOD");
	203	// gProof->UploadPackage("$ALICE_ROOT/obj/ANALYSIS");
	204	// gProof->EnablePackage("$ALICE_ROOT/obj/ANALYSIS");
	205	// gProof->UploadPackage("$ALICE_ROOT/obj/OADB");
	206	// gProof->EnablePackage("$ALICE_ROOT/obj/OADB");
	207	// gProof->UploadPackage("$ALICE_ROOT/obj/ANALYSISalice");
	208	// gProof->EnablePackage("$ALICE_ROOT/obj/ANALYSISalice");
	209	// gProof->UploadPackage("$ALICE_ROOT/obj/PWG0base");
	210	// gProof->EnablePackage("$ALICE_ROOT/obj/PWG0base");
	211	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
2bfe5463	212	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
c88234ad	213	}
	214	else
	215	{
	216	cout << "Init in Local or Grid mode" << endl;
4070f709	217	gSystem->Load("libCore");
	218	gSystem->Load("libTree");
	219	gSystem->Load("libGeom");
	220	gSystem->Load("libVMC");
	221	gSystem->Load("libPhysics");
c88234ad	222	gSystem->Load("libSTEERBase");
	223	gSystem->Load("libESD");
	224	gSystem->Load("libAOD");
	225	gSystem->Load("libANALYSIS");
	226	gSystem->Load("libOADB");
	227	gSystem->Load("libANALYSISalice");
	228	// Use AliRoot includes to compile our task
	229	gROOT->ProcessLine(".include $ALICE_ROOT/include");
	230
	231	// gSystem->Load("libVMC");
	232	// gSystem->Load("libTree");
	233	// gSystem->Load("libSTEERBase");
	234	// gSystem->Load("libESD");
	235	// gSystem->Load("libAOD");
	236	// gSystem->Load("libANALYSIS");
	237	// gSystem->Load("libANALYSISalice");
	238	// gSystem->Load("libPWG0base");
	239
	240	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
2bfe5463	241	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
2bfe5463	242	// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background/"));
c88234ad	243	}
	244	// Load helper classes
	245	TIterator * iter = listToLoad->MakeIterator();
	246	TObjString * name = 0;
	247	while (name = (TObjString *)iter->Next())
	248	{
	249	gSystem->ExpandPathName(name->String());
	250	cout << name->String().Data();
	251	if (runMode == kMyRunModeCAF)
	252	{
	253	gProof->Load(name->String() + (debug ? "+g" : ""));
	254	}
	255	else
	256	{
	257	gROOT->LoadMacro(name->String() + (debug ? "+g" : ""));
	258	}
	259	}
	260
	261	}