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

runLRCAnalysis(const char* mode = "GRID", const char* inputName= "wn.xml",Bool_t LoadTaskLocal=kTRUE) {
// This macro runs AliAnalysisTaskLRC in three modes : "Local" , "Interactive", "PROOF", "GRID" 
// ESD-only
// inputName refers to :
// "Local" - file with plane-text list of filenames 
// "Intaractive","GRID" - XML collection name
// "PROOF" - dataset name 
//  ---------------------------------------------------------
// This macro needs AliRoot-v4-17 or later 
// and macro AddTaskLRC.C in workdir

// For PROOF run PARS(ANALYSISalice.par  ANALYSIS.par  AOD.par  ESD.par  PWGCFebye.par  
// STEERBase.par ) are to be in workdir.


// Author : Andrey Ivanov , St.Peterburg State University
// Email: Andrey.Ivanov@cern.ch

// Version line : 3.6
// Version 3.6.6


if(mode!="Local" && mode!="Interactive" && mode!="PROOF" && mode!="GRID")
{
cout<<" ! Mode must be : Local , Interactive, PROOF, GRID \n";
cout<<" ! Unknown mode :"<<mode<< " \n";
return;
}

if(mode=="Local")runLRCLocal(inputName,LoadTaskLocal);
if(mode=="PROOF")runLRCProof(inputName,LoadTaskLocal);
if(mode=="Interactive")runLRCInteractive(inputName,LoadTaskLocal);
if(mode=="GRID")runLRCInteractive(inputName,LoadTaskLocal);


}

void LoadAnalysisLibs(Bool_t LoadTaskLocal=kFALSE)
{
  cout<<"  # Loadnig libs...\n";
 

 gSystem->Load("libSTEERBase");
  gSystem->Load("libESD");
  gSystem->Load("libAOD");
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice");
  if(!LoadTaskLocal){
	gSystem->Load("libEventMixing");
	gSystem->Load("libPWGCFebye");
  }
  
  //___________Compile analysis task using AClic____________//
 
  if(LoadTaskLocal){
  	gROOT->ProcessLine(".include $ALICE_ROOT/include");
	cout<<"  # Compiling AliLRCBase\n";
	gROOT->LoadMacro("AliLRCBase.cxx+g");	
	cout<<"  # Compiling AliLRCProcess\n";
	gROOT->LoadMacro("AliLRCProcess.cxx+g");
	gROOT->LoadMacro("AliRidgeAnalyser.cxx+g");
	cout<<"  # Compiling LRC analysis task\n";
  	gROOT->LoadMacro("AliAnalysisTaskLRC.cxx+g");
	}

}

Bool_t CreateLRCManager(char* name="LRCmanager",Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE)
{
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager(name);
  AliESDInputHandler* esdH = new AliESDInputHandler();
  mgr->SetInputEventHandler(esdH);  
  if(runKine){
  	AliMCEventHandler* handler = new AliMCEventHandler;
  	mgr->SetMCtruthEventHandler(handler);
  }
  
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
  
  mgr->SetCommonFileName("Test.LRC.root");
  
  
 return kTRUE;

}

void runLRCLocal(const char* inputName= "ESDs.lst",Bool_t LoadTaskLocal=kFALSE,Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE) {
  printf("  ------------------------------------------\n");
  printf("  # LRC local run manager \n");
  cout<<"  # Task from :"<<gSystem->pwd()<<"\n";
  cout<<"  # Input list :"<<inputName<<"\n";
  
  
  TStopwatch timer;
  timer.Start();
  
  LoadAnalysisLibs(LoadTaskLocal);
 
  if (!CreateLRCManager("LocalLRCTest",runKine,runAOD)) return;
  gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
  AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();

  gROOT->LoadMacro("AddTaskLRC.C");
  AddTaskLRC(runKine);
  
 
  gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
  TChain* chain = CreateESDChain(inputName);
  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  
  mgr->StartAnalysis("local",chain);

  timer.Stop();
  timer.Print();
}

void runLRCProof(const char* inputName= "/COMMON/COMMON/tutorial_small",Bool_t LoadTaskLocal=kFALSE,const char* proofLink="anivanov@alice-caf.cern.ch",Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE)
{
  printf("  ------------------------------------------\n");
  printf(" # LRC PROOF run manager \n");
  cout<<"  # Task from :"<<gSystem->pwd()<<"\n";
  cout<<"  # Dataset :"<<inputName<<"\n";


	TProof::Open(proofLink);
	//TProof::Open("anivanov@localhost");.

	
  cout<<"  # Loadnig libs...\n";


gProof->EnablePackage("VO_ALICE@AliRoot::v4-20-13-AN");

  // Use AliRoot includes to compile our task
  if(LoadTaskLocal){
 //	gROOT->ProcessLine(".include $ALICE_ROOT/include");
	cout<<"  # Compiling AliLRCBase\n";
	gProof->Load("AliLRCBase.cxx+g");	
	cout<<"  # Compiling AliLRCProcess\n";
	gProof->Load("AliLRCProcess.cxx+g");
	gProof->Load("AliLRCAnalyser.cxx+g");
  	cout<<"  # Compiling analysis task\n";
  	gProof->Load("AliAnalysisTaskLRC.cxx+g");   
  }

  if (!CreateLRCManager("ProofLRCTest",runKine,runAOD)) return;
  gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
  AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
   
  gROOT->LoadMacro("AddTaskLRC.C");
  AddTaskLRC(runKine);

  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  mgr->StartAnalysis("proof", inputName);
};

void runLRCInteractive(const char* inputName= "wn.xml",Bool_t LoadTaskLocal=kFALSE,Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE) {
  
  printf("  ------------------------------------------\n");
  printf(" # LRC local-interactive/GRID run manager \n");
  cout<<"  # Task from :"<<gSystem->pwd()<<"\n";
  cout<<"  # Collection :"<<inputName<<"\n";

  TStopwatch timer;
  timer.Start();
  
  cout<<"*** Connect to AliEn ***\n";
  TGrid::Connect("alien://","anivanov");

  LoadAnalysisLibs(LoadTaskLocal);
  
  if (!CreateLRCManager("IntLRCTest",runKine,runAOD)) return;
  gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
  AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
 
  
  gROOT->LoadMacro("AddTaskLRC.C");
  AddTaskLRC(runKine);

     TAlienCollection * myCollection = 
	new TAlienCollection("wn.xml",100000) ; 
    if (!myCollection) { 
	cout << "XML collection file: " << xmlFileName << " not found" << endl;
	return;
    }

    TChain* chain = new TChain("esdTree");
    
    cout << "Preparing the file list" << endl; 
    myCollection->Reset() ; 
    while ( myCollection->Next() ) {
	cout << "Adding ESD file: " << myCollection->GetTURL("") << endl; 
	chain->Add(myCollection->GetTURL("")) ; 
    }
    
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  mgr->StartAnalysis("local",chain);

  timer.Stop();
  timer.Print();
}

Int_t SetupPar(const char* pararchivename) {
  ///////////////////
  // Setup PAR File//
  ///////////////////
  if (pararchivename) {
    char processline[1024];
    TString base = gSystem->BaseName(pararchivename);
    TString dir  = gSystem->DirName(pararchivename);
    TString ocwd = gSystem->WorkingDirectory();
    // Move to dir where the par files are and unpack
    gSystem->ChangeDirectory(dir.Data());
    sprintf(processline,".! tar xvzf %s.par",base.Data());
    gROOT->ProcessLine(processline);
    // Move to par folder
    gSystem->ChangeDirectory(base.Data());
                                                                                                                                               
    // check for BUILD.sh and execute
    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
      printf("*******************************\n");
      printf("*** Building PAR archive    ***\n");
      printf("*******************************\n");
                                                                                                                                               
      if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
        Error("runAnalysis","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");
      printf("*******************************\n");
      // If dir not empty, set the full include path
      if (dir.Length()) {
         sprintf(processline, ".include %s", pararchivename);
         gROOT->ProcessLine(processline); 
      }   
      gROOT->Macro("PROOF-INF/SETUP.C");
    }
                                                                                                                                               
    gSystem->ChangeDirectory(ocwd.Data());
  }                                                                                                                                               
  return 1;
}
Commit	Line	Data
41f63c69	1	runLRCAnalysis(const char* mode = "GRID", const char* inputName= "wn.xml",Bool_t LoadTaskLocal=kTRUE) {
f62e9410	2	// This macro runs AliAnalysisTaskLRC in three modes : "Local" , "Interactive", "PROOF", "GRID"
	3	// ESD-only
	4	// inputName refers to :
	5	// "Local" - file with plane-text list of filenames
	6	// "Intaractive","GRID" - XML collection name
	7	// "PROOF" - dataset name
41cfced7	8	// ---------------------------------------------------------
d96e5666	9	// This macro needs AliRoot-v4-17 or later
41cfced7	10	// and macro AddTaskLRC.C in workdir
41cfced7	11
a022cbd0	12	// For PROOF run PARS(ANALYSISalice.par ANALYSIS.par AOD.par ESD.par PWGCFebye.par
d96e5666	13	// STEERBase.par ) are to be in workdir.
	14
	15
	16	// Author : Andrey Ivanov , St.Peterburg State University
	17	// Email: Andrey.Ivanov@cern.ch
	18
41f63c69	19	// Version line : 3.6
41f63c69	20	// Version 3.6.6
d96e5666	21
f62e9410	22
	23	if(mode!="Local" && mode!="Interactive" && mode!="PROOF" && mode!="GRID")
	24	{
	25	cout<<" ! Mode must be : Local , Interactive, PROOF, GRID \n";
	26	cout<<" ! Unknown mode :"<<mode<< " \n";
	27	return;
	28	}
	29
d96e5666	30	if(mode=="Local")runLRCLocal(inputName,LoadTaskLocal);
	31	if(mode=="PROOF")runLRCProof(inputName,LoadTaskLocal);
	32	if(mode=="Interactive")runLRCInteractive(inputName,LoadTaskLocal);
	33	if(mode=="GRID")runLRCInteractive(inputName,LoadTaskLocal);
f62e9410	34
	35
	36	}
	37
41f63c69	38	void LoadAnalysisLibs(Bool_t LoadTaskLocal=kFALSE)
41f63c69	39	{
f62e9410	40	cout<<" # Loadnig libs...\n";
41f63c69	41
41f63c69	42
4070f709	43	gSystem->Load("libSTEERBase");
	44	gSystem->Load("libESD");
	45	gSystem->Load("libAOD");
	46	gSystem->Load("libANALYSIS");
	47	gSystem->Load("libANALYSISalice");
1f7eb4d0	48	if(!LoadTaskLocal){
4070f709	49	gSystem->Load("libEventMixing");
4070f709	50	gSystem->Load("libPWGCFebye");
1f7eb4d0	51	}
f62e9410	52
	53	//___________Compile analysis task using AClic____________//
	54
d96e5666	55	if(LoadTaskLocal){
d96e5666	56	gROOT->ProcessLine(".include $ALICE_ROOT/include");
41f63c69	57	cout<<" # Compiling AliLRCBase\n";
41f63c69	58	gROOT->LoadMacro("AliLRCBase.cxx+g");
d96e5666	59	cout<<" # Compiling AliLRCProcess\n";
d96e5666	60	gROOT->LoadMacro("AliLRCProcess.cxx+g");
41f63c69	61	gROOT->LoadMacro("AliRidgeAnalyser.cxx+g");
d96e5666	62	cout<<" # Compiling LRC analysis task\n";
	63	gROOT->LoadMacro("AliAnalysisTaskLRC.cxx+g");
	64	}
41f63c69	65
	66	}
	67
	68	Bool_t CreateLRCManager(char* name="LRCmanager",Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE)
	69	{
f62e9410	70	//____________________________________________//
f62e9410	71	// Make the analysis manager
41f63c69	72	AliAnalysisManager *mgr = new AliAnalysisManager(name);
f62e9410	73	AliESDInputHandler* esdH = new AliESDInputHandler();
f62e9410	74	mgr->SetInputEventHandler(esdH);
41f63c69	75	if(runKine){
	76	AliMCEventHandler* handler = new AliMCEventHandler;
	77	mgr->SetMCtruthEventHandler(handler);
	78	}
	79
	80	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
f62e9410	81
41f63c69	82	mgr->SetCommonFileName("Test.LRC.root");
	83
	84
	85
	86	return kTRUE;
	87
	88	}
	89
	90	void runLRCLocal(const char* inputName= "ESDs.lst",Bool_t LoadTaskLocal=kFALSE,Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE) {
	91	printf(" ------------------------------------------\n");
	92	printf(" # LRC local run manager \n");
	93	cout<<" # Task from :"<<gSystem->pwd()<<"\n";
	94	cout<<" # Input list :"<<inputName<<"\n";
	95
	96
	97	TStopwatch timer;
	98	timer.Start();
	99
	100	LoadAnalysisLibs(LoadTaskLocal);
	101
	102	if (!CreateLRCManager("LocalLRCTest",runKine,runAOD)) return;
63b6cbd0	103	gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
41f63c69	104	AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
	105
	106	gROOT->LoadMacro("AddTaskLRC.C");
	107	AddTaskLRC(runKine);
	108
	109
	110
	111	gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
	112	TChain* chain = CreateESDChain(inputName);
	113
	114	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
f62e9410	115
f62e9410	116	if (!mgr->InitAnalysis()) return;
f62e9410	117	mgr->PrintStatus();
41f63c69	118
f62e9410	119	mgr->StartAnalysis("local",chain);
	120
	121	timer.Stop();
	122	timer.Print();
	123	}
	124
41f63c69	125	void runLRCProof(const char* inputName= "/COMMON/COMMON/tutorial_small",Bool_t LoadTaskLocal=kFALSE,const char* proofLink="anivanov@alice-caf.cern.ch",Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE)
f62e9410	126	{
	127	printf(" ------------------------------------------\n");
	128	printf(" # LRC PROOF run manager \n");
	129	cout<<" # Task from :"<<gSystem->pwd()<<"\n";
	130	cout<<" # Dataset :"<<inputName<<"\n";
	131
	132
d96e5666	133	TProof::Open(proofLink);
41f63c69	134	//TProof::Open("anivanov@localhost");.
f62e9410	135
	136
	137	cout<<" # Loadnig libs...\n";
f62e9410	138
41cfced7	139
41cfced7	140
41f63c69	141	gProof->EnablePackage("VO_ALICE@AliRoot::v4-20-13-AN");
41cfced7	142
f62e9410	143	// Use AliRoot includes to compile our task
d96e5666	144	if(LoadTaskLocal){
41f63c69	145	// gROOT->ProcessLine(".include $ALICE_ROOT/include");
	146	cout<<" # Compiling AliLRCBase\n";
	147	gProof->Load("AliLRCBase.cxx+g");
d96e5666	148	cout<<" # Compiling AliLRCProcess\n";
d96e5666	149	gProof->Load("AliLRCProcess.cxx+g");
41f63c69	150	gProof->Load("AliLRCAnalyser.cxx+g");
d96e5666	151	cout<<" # Compiling analysis task\n";
41f63c69	152	gProof->Load("AliAnalysisTaskLRC.cxx+g");
d96e5666	153	}
f62e9410	154
41f63c69	155	if (!CreateLRCManager("ProofLRCTest",runKine,runAOD)) return;
63b6cbd0	156	gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
41f63c69	157	AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
41cfced7	158
41f63c69	159	gROOT->LoadMacro("AddTaskLRC.C");
	160	AddTaskLRC(runKine);
	161
	162	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
41cfced7	163	if (!mgr->InitAnalysis()) return;
f62e9410	164	mgr->PrintStatus();
41cfced7	165	mgr->StartAnalysis("proof", inputName);
f62e9410	166	};
f62e9410	167
41f63c69	168	void runLRCInteractive(const char* inputName= "wn.xml",Bool_t LoadTaskLocal=kFALSE,Bool_t runKine=kFALSE,Bool_t runAOD=kFALSE) {
f62e9410	169
f62e9410	170	printf(" ------------------------------------------\n");
41cfced7	171	printf(" # LRC local-interactive/GRID run manager \n");
f62e9410	172	cout<<" # Task from :"<<gSystem->pwd()<<"\n";
	173	cout<<" # Collection :"<<inputName<<"\n";
	174
f62e9410	175	TStopwatch timer;
f62e9410	176	timer.Start();
f62e9410	177
41f63c69	178	cout<<"* Connect to AliEn *\n";
	179	TGrid::Connect("alien://","anivanov");
	180
	181	LoadAnalysisLibs(LoadTaskLocal);
f62e9410	182
41f63c69	183	if (!CreateLRCManager("IntLRCTest",runKine,runAOD)) return;
63b6cbd0	184	gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
41f63c69	185	AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
d96e5666	186
f62e9410	187
41f63c69	188	gROOT->LoadMacro("AddTaskLRC.C");
	189	AddTaskLRC(runKine);
	190
	191	TAlienCollection * myCollection =
f62e9410	192	new TAlienCollection("wn.xml",100000) ;
	193	if (!myCollection) {
	194	cout << "XML collection file: " << xmlFileName << " not found" << endl;
	195	return;
	196	}
	197
	198	TChain* chain = new TChain("esdTree");
	199
	200	cout << "Preparing the file list" << endl;
	201	myCollection->Reset() ;
	202	while ( myCollection->Next() ) {
	203	cout << "Adding ESD file: " << myCollection->GetTURL("") << endl;
	204	chain->Add(myCollection->GetTURL("")) ;
	205	}
	206
41f63c69	207	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
f62e9410	208	if (!mgr->InitAnalysis()) return;
	209	mgr->PrintStatus();
	210	mgr->StartAnalysis("local",chain);
	211
	212	timer.Stop();
	213	timer.Print();
	214	}
41cfced7	215
	216	Int_t SetupPar(const char* pararchivename) {
	217	///////////////////
	218	// Setup PAR File//
	219	///////////////////
	220	if (pararchivename) {
	221	char processline[1024];
	222	TString base = gSystem->BaseName(pararchivename);
	223	TString dir = gSystem->DirName(pararchivename);
	224	TString ocwd = gSystem->WorkingDirectory();
	225	// Move to dir where the par files are and unpack
	226	gSystem->ChangeDirectory(dir.Data());
	227	sprintf(processline,".! tar xvzf %s.par",base.Data());
	228	gROOT->ProcessLine(processline);
	229	// Move to par folder
	230	gSystem->ChangeDirectory(base.Data());
	231
	232	// check for BUILD.sh and execute
	233	if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
	234	printf("*******************************\n");
	235	printf("* Building PAR archive *\n");
	236	printf("*******************************\n");
	237
	238	if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
	239	Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
	240	return -1;
	241	}
	242	}
	243	// check for SETUP.C and execute
	244	if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
	245	printf("*******************************\n");
	246	printf("* Setup PAR archive *\n");
	247	printf("*******************************\n");
	248	// If dir not empty, set the full include path
	249	if (dir.Length()) {
	250	sprintf(processline, ".include %s", pararchivename);
	251	gROOT->ProcessLine(processline);
	252	}
	253	gROOT->Macro("PROOF-INF/SETUP.C");
	254	}
	255
	256	gSystem->ChangeDirectory(ocwd.Data());
	257	}
	258	return 1;
	259	}