[u/mrichter/AliRoot.git] / PWGLF / SPECTRA / AntiprotonToProton / runProtonsFeedDownAnalysis.C

void runProtonsFeedDownAnalysis(const char* esdAnalysisType = "Hybrid",
				const char* pidMode = "Bayesian") {
  //Macro to run the proton feed-down analysis tested for local, proof & GRID.
  //Local: Takes four arguments, the analysis mode, the type of the ESD 
  //       analysis, the PID mode and the path where the tag and ESD or 
  //       AOD files reside.
  //Interactive: Takes four arguments, the analysis mode, the type of the ESD 
  //             analysis, the PID mode and the name of the collection of tag 
  //             files.
  //Batch: Takes four arguments, the analysis mode, the type of the ESD 
  //       analysis, the PID mode and the name of the collection file with 
  //       the event list for each file.
  //Proof: Takes five arguments, the analysis level, the analysis mode in 
  //       case of ESD, the PID mode, the number of events and the dataset 
  //       name and .  
  //Analysis mode can be: "MC", "ESD", "AOD"
  //ESD analysis type can be one of the three: "TPC", "Hybrid", "Global"
  //PID mode can be one of the four: "Bayesian" (standard Bayesian approach) 
  //   "Ratio" (ratio of measured over expected/theoretical dE/dx a la STAR) 
  //   "Sigma1" (N-sigma area around the fitted dE/dx vs P band)
  //   "Sigma2" (same as previous but taking into account the No of TPC points)
  TStopwatch timer;
  timer.Start();
  
  // runLocal("ESD","TPC","Bayesian","/home/mbroz/FeedDownAnalysis/");
  //runInteractive("ESD","TPC","Bayesian","pp0901.xml");
  runBatch("ESD","TPC","Bayesian","wn.xml");  
  // runProof("ESD","TPC","Bayesian",200000,"/COMMON/COMMON/LHC09a4_run8101X");
  
  timer.Stop();
  timer.Print();
}

//_________________________________________________//
void runLocal(const char* mode = "ESD",
	      const char* analysisType = 0x0,
	      const char* pidMode = 0x0,
	      const char* path = 0x0) {
  TString smode = mode;
  TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
  if(analysisType) {
    outputFilename += "."; outputFilename += analysisType;
  }
  outputFilename += ".root";

  //____________________________________________________//
  //_____________Setting up the par files_______________//
  //____________________________________________________//
  setupPar("STEERBase");
  gSystem->Load("libSTEERBase.so");
  setupPar("ESD");
  gSystem->Load("libVMC.so");
  gSystem->Load("libESD.so");
  setupPar("AOD");
  gSystem->Load("libAOD.so");
  setupPar("ANALYSIS");
  gSystem->Load("libANALYSIS.so");
  setupPar("ANALYSISalice");
  gSystem->Load("libANALYSISalice.so");
  setupPar("CORRFW");
  gSystem->Load("libCORRFW.so");
  setupPar("PWG2spectra");
  gSystem->Load("libPWG2spectra.so");
  //____________________________________________________//  
  
  //____________________________________________//
  AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD"); 
  tagAnalysis->ChainLocalTags(path);

  AliRunTagCuts *runCuts = new AliRunTagCuts();
  AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
  AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
  AliEventTagCuts *evCuts = new AliEventTagCuts();
  
  TChain* chain = 0x0;
  chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
  //chain->SetBranchStatus("*Calo*",0);

  //____________________________________________//
  gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
  AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
									analysisType,
									pidMode);
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  AliMCEventHandler *mc = new AliMCEventHandler();
  mgr->SetMCtruthEventHandler(mc);

  //____________________________________________//
  AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

  // Create containers for input/output
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
							   TChain::Class(),
							   AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
                                                            TList::Class(),
							    AliAnalysisManager::kOutputContainer,
                                                            outputFilename.Data());

  //____________________________________________//
  mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
  mgr->ConnectOutput(taskProtons,0,coutput1);
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  mgr->StartAnalysis("local",chain);
}

//_________________________________________________//
void runInteractive(const char* mode = "ESD",
		    const char* analysisType = 0x0,
		    const char* pidMode = 0x0,
		    const char* collectionName = "tag.xml") {
  gSystem->Load("libProofPlayer.so");

  TString smode = mode;
  TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
  if(analysisType) {
    outputFilename += "."; outputFilename += analysisType;
  }
  outputFilename += ".root";

  printf("*** Connect to AliEn ***\n");
  TGrid::Connect("alien://");
 
  //____________________________________________________//
  //_____________Setting up the par files_______________//
  //____________________________________________________//
  setupPar("STEERBase");
  gSystem->Load("libSTEERBase.so");
  setupPar("ESD");
  gSystem->Load("libVMC.so");
  gSystem->Load("libESD.so");
  setupPar("AOD");
  gSystem->Load("libAOD.so");
  setupPar("ANALYSIS");
  gSystem->Load("libANALYSIS.so");
  setupPar("ANALYSISalice");
  gSystem->Load("libANALYSISalice.so");
  setupPar("CORRFW");
  gSystem->Load("libCORRFW.so");
  setupPar("PWG2spectra");
  gSystem->Load("libPWG2spectra.so");
  //____________________________________________________//  
 
  //____________________________________________//
  AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
 
  AliRunTagCuts *runCuts = new AliRunTagCuts();
  AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
  AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
  AliEventTagCuts *evCuts = new AliEventTagCuts();
 
  //grid tags
  TAlienCollection* coll = TAlienCollection::Open(collectionName);
  TGridResult* TagResult = coll->GetGridResult("",0,0);
  tagAnalysis->ChainGridTags(TagResult);
  TChain* chain = 0x0;
  chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
  //chain->SetBranchStatus("*Calo*",0);
  
  //____________________________________________//
  gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
  AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
									analysisType,
									pidMode);
  //____________________________________________//
  // Make the analysis manager
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  AliMCEventHandler *mc = new AliMCEventHandler();
  mgr->SetMCtruthEventHandler(mc);

  //____________________________________________//
  AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

  // Create containers for input/output
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
							   TChain::Class(),
							   AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
                                                            TList::Class(),
							    AliAnalysisManager::kOutputContainer,
                                                            outputFilename.Data());
  
  //____________________________________________//
  mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
  mgr->ConnectOutput(taskProtons,0,coutput1);
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  mgr->StartAnalysis("local",chain);
}

//_________________________________________________//
void runBatch(const char* mode = "ESD",
	      const char* analysisType = 0x0,
	      const char* pidMode = 0x0,
	      const char *collectionfile = "wn.xml") {
  TString smode = mode;
  TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
  if(analysisType) {
    outputFilename += "."; outputFilename += analysisType;
  }
  outputFilename += ".root";

  printf("*** Connect to AliEn ***\n");
  TGrid::Connect("alien://");
  gSystem->Load("libProofPlayer.so");

  //____________________________________________________//
  //_____________Setting up the par files_______________//
  //____________________________________________________//
  gSystem->Load("libSTEERBase.so");
  gSystem->Load("libESD.so");
  gSystem->Load("libAOD.so");
  gSystem->Load("libANALYSIS") ;
  gSystem->Load("libANALYSISalice") ;
  gSystem->Load("libCORRFW.so") ;

  setupPar("PWG2spectra");
  gSystem->Load("libPWG2spectra.so");
  //____________________________________________________//  

  //____________________________________________//
  AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
  TChain *chain = 0x0;
  chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");

  //____________________________________________//
  gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
  AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
									analysisType,
									pidMode);
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  AliMCEventHandler *mc = new AliMCEventHandler();
  mgr->SetMCtruthEventHandler(mc);

  //____________________________________________//
  AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

  // Create containers for input/output
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
							   TChain::Class(),
							   AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
                                                            TList::Class(),
							    AliAnalysisManager::kOutputContainer,
                                                            outputFilename.Data());

  //____________________________________________//
  mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
  mgr->ConnectOutput(taskProtons,0,coutput1);
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  mgr->StartAnalysis("local",chain);
}

//_________________________________________________//
void runProof(const char* mode = "ESD",
	      const char* analysisType = 0x0,
	      const char* pidMode = 0x0,
	      Int_t stats = 0, 
	      const char* dataset = 0x0) {  
  TString smode = mode;
  TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
  if(analysisType) {
    outputFilename += "."; outputFilename += analysisType;
  }
  outputFilename += ".root";

  printf("****** Connect to PROOF *******\n");
  TProof::Open("alicecaf.cern.ch"); 
  //gProof->SetParallel();

  // Enable the Analysis Package
  gProof->UploadPackage("STEERBase.par");
  gProof->EnablePackage("STEERBase");
  gProof->UploadPackage("ESD.par");
  gProof->EnablePackage("ESD");
  gProof->UploadPackage("AOD.par");
  gProof->EnablePackage("AOD");
  gProof->UploadPackage("ANALYSIS.par");
  gProof->EnablePackage("ANALYSIS");
  gProof->UploadPackage("ANALYSISalice.par");
  gProof->EnablePackage("ANALYSISalice");
  gProof->UploadPackage("CORRFW.par");
  gProof->EnablePackage("CORRFW");
  gProof->UploadPackage("PWG2spectra.par");
  gProof->EnablePackage("PWG2spectra");
  
  //____________________________________________//
  gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
  AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
									analysisType,
									pidMode);
  //____________________________________________//

  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  AliMCEventHandler *mc = new AliMCEventHandler();
  mgr->SetMCtruthEventHandler(mc);
  //____________________________________________//
  //Create the proton task
  AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

  // Create containers for input/output
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
							   TChain::Class(),
							   AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
                                                            TList::Class(),
							    AliAnalysisManager::kOutputContainer,
                                                            outputFilename.Data());

  //____________________________________________//
  mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
  mgr->ConnectOutput(taskProtons,0,coutput1);
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();

  if(dataset)
    mgr->StartAnalysis("proof",dataset,stats);
  else {
    // You should get this macro and the txt file from:
    // http://aliceinfo.cern.ch/Offline/Analysis/CAF/
    gROOT->LoadMacro("CreateESDChain.C");
    TChain* chain = 0x0;
    chain = CreateESDChain("ESD82XX_30K.txt",stats);
    chain->SetBranchStatus("*Calo*",0);

    mgr->StartAnalysis("proof",chain);
  }
}

//_________________________________________________//
Int_t setupPar(const char* pararchivename) {
  ///////////////////
  // Setup PAR File//
  ///////////////////
  if (pararchivename) {
    char processline[1024];
    sprintf(processline,".! tar xvzf %s.par",pararchivename);
    gROOT->ProcessLine(processline);
    const char* 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");
      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");
      gROOT->Macro("PROOF-INF/SETUP.C");
    }
    
    gSystem->ChangeDirectory("../");
  } 
  return 1;
}
Commit	Line	Data
ab11cbe5	1	void runProtonsFeedDownAnalysis(const char* esdAnalysisType = "Hybrid",
	2	const char* pidMode = "Bayesian") {
	3	//Macro to run the proton feed-down analysis tested for local, proof & GRID.
	4	//Local: Takes four arguments, the analysis mode, the type of the ESD
	5	// analysis, the PID mode and the path where the tag and ESD or
	6	// AOD files reside.
	7	//Interactive: Takes four arguments, the analysis mode, the type of the ESD
	8	// analysis, the PID mode and the name of the collection of tag
	9	// files.
	10	//Batch: Takes four arguments, the analysis mode, the type of the ESD
	11	// analysis, the PID mode and the name of the collection file with
	12	// the event list for each file.
	13	//Proof: Takes five arguments, the analysis level, the analysis mode in
	14	// case of ESD, the PID mode, the number of events and the dataset
	15	// name and .
	16	//Analysis mode can be: "MC", "ESD", "AOD"
	17	//ESD analysis type can be one of the three: "TPC", "Hybrid", "Global"
	18	//PID mode can be one of the four: "Bayesian" (standard Bayesian approach)
	19	// "Ratio" (ratio of measured over expected/theoretical dE/dx a la STAR)
	20	// "Sigma1" (N-sigma area around the fitted dE/dx vs P band)
	21	// "Sigma2" (same as previous but taking into account the No of TPC points)
	22	TStopwatch timer;
	23	timer.Start();
	24
	25	// runLocal("ESD","TPC","Bayesian","/home/mbroz/FeedDownAnalysis/");
	26	//runInteractive("ESD","TPC","Bayesian","pp0901.xml");
	27	runBatch("ESD","TPC","Bayesian","wn.xml");
	28	// runProof("ESD","TPC","Bayesian",200000,"/COMMON/COMMON/LHC09a4_run8101X");
	29
	30	timer.Stop();
	31	timer.Print();
	32	}
	33
	34	//_________________________________________________//
	35	void runLocal(const char* mode = "ESD",
	36	const char* analysisType = 0x0,
	37	const char* pidMode = 0x0,
	38	const char* path = 0x0) {
	39	TString smode = mode;
	40	TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
	41	if(analysisType) {
	42	outputFilename += "."; outputFilename += analysisType;
	43	}
	44	outputFilename += ".root";
	45
	46	//____________________________________________________//
	47	//_____________Setting up the par files_______________//
	48	//____________________________________________________//
	49	setupPar("STEERBase");
	50	gSystem->Load("libSTEERBase.so");
	51	setupPar("ESD");
	52	gSystem->Load("libVMC.so");
	53	gSystem->Load("libESD.so");
	54	setupPar("AOD");
	55	gSystem->Load("libAOD.so");
	56	setupPar("ANALYSIS");
	57	gSystem->Load("libANALYSIS.so");
	58	setupPar("ANALYSISalice");
	59	gSystem->Load("libANALYSISalice.so");
	60	setupPar("CORRFW");
	61	gSystem->Load("libCORRFW.so");
	62	setupPar("PWG2spectra");
	63	gSystem->Load("libPWG2spectra.so");
	64	//____________________________________________________//
65
66	//____________________________________________//
67	AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
68	tagAnalysis->ChainLocalTags(path);
69
70	AliRunTagCuts *runCuts = new AliRunTagCuts();
71	AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
72	AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
73	AliEventTagCuts *evCuts = new AliEventTagCuts();
74
75	TChain* chain = 0x0;
76	chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
77	//chain->SetBranchStatus("Calo",0);
78
79	//____________________________________________//
80	gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
81	AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
82	analysisType,
83	pidMode);
84	//____________________________________________//
85	// Make the analysis manager
86	AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
87	AliVEventHandler* esdH = new AliESDInputHandler;
88	mgr->SetInputEventHandler(esdH);
89	AliMCEventHandler *mc = new AliMCEventHandler();
90	mgr->SetMCtruthEventHandler(mc);
91
92	//____________________________________________//
93	AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
94	taskProtons->SetAnalysisObject(analysis);
95	mgr->AddTask(taskProtons);
96
97	// Create containers for input/output
98	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
99	TChain::Class(),
100	AliAnalysisManager::kInputContainer);
101	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
102	TList::Class(),
103	AliAnalysisManager::kOutputContainer,
104	outputFilename.Data());
105
106	//____________________________________________//
107	mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
108	mgr->ConnectOutput(taskProtons,0,coutput1);
109	if (!mgr->InitAnalysis()) return;
110	mgr->PrintStatus();
111	mgr->StartAnalysis("local",chain);
112	}
113
114	//_________________________________________________//
115	void runInteractive(const char* mode = "ESD",
116	const char* analysisType = 0x0,
117	const char* pidMode = 0x0,
118	const char* collectionName = "tag.xml") {
119	gSystem->Load("libProofPlayer.so");
120
121	TString smode = mode;
122	TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
123	if(analysisType) {
124	outputFilename += "."; outputFilename += analysisType;
125	}
126	outputFilename += ".root";
127
128	printf("* Connect to AliEn *\n");
129	TGrid::Connect("alien://");
130
131	//____________________________________________________//
132	//_____________Setting up the par files_______________//
133	//____________________________________________________//
134	setupPar("STEERBase");
135	gSystem->Load("libSTEERBase.so");
136	setupPar("ESD");
137	gSystem->Load("libVMC.so");
138	gSystem->Load("libESD.so");
139	setupPar("AOD");
140	gSystem->Load("libAOD.so");
141	setupPar("ANALYSIS");
142	gSystem->Load("libANALYSIS.so");
143	setupPar("ANALYSISalice");
144	gSystem->Load("libANALYSISalice.so");
145	setupPar("CORRFW");
146	gSystem->Load("libCORRFW.so");
147	setupPar("PWG2spectra");
148	gSystem->Load("libPWG2spectra.so");
149	//____________________________________________________//
150
151	//____________________________________________//
152	AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
153
154	AliRunTagCuts *runCuts = new AliRunTagCuts();
155	AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
156	AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
157	AliEventTagCuts *evCuts = new AliEventTagCuts();
158
159	//grid tags
160	TAlienCollection* coll = TAlienCollection::Open(collectionName);
161	TGridResult* TagResult = coll->GetGridResult("",0,0);
162	tagAnalysis->ChainGridTags(TagResult);
163	TChain* chain = 0x0;
164	chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
165	//chain->SetBranchStatus("Calo",0);
166
167	//____________________________________________//
168	gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
169	AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
170	analysisType,
171	pidMode);
172	//____________________________________________//
173	// Make the analysis manager
174	// Make the analysis manager
175	AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
176	AliVEventHandler* esdH = new AliESDInputHandler;
177	mgr->SetInputEventHandler(esdH);
178	AliMCEventHandler *mc = new AliMCEventHandler();
179	mgr->SetMCtruthEventHandler(mc);
180
181	//____________________________________________//
182	AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
183	taskProtons->SetAnalysisObject(analysis);
184	mgr->AddTask(taskProtons);
185
186	// Create containers for input/output
187	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
188	TChain::Class(),
189	AliAnalysisManager::kInputContainer);
190	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
191	TList::Class(),
192	AliAnalysisManager::kOutputContainer,
193	outputFilename.Data());
194
195	//____________________________________________//
196	mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
197	mgr->ConnectOutput(taskProtons,0,coutput1);
198	if (!mgr->InitAnalysis()) return;
199	mgr->PrintStatus();
200	mgr->StartAnalysis("local",chain);
201	}
202
203	//_________________________________________________//
204	void runBatch(const char* mode = "ESD",
205	const char* analysisType = 0x0,
206	const char* pidMode = 0x0,
207	const char *collectionfile = "wn.xml") {
208	TString smode = mode;
209	TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
210	if(analysisType) {
211	outputFilename += "."; outputFilename += analysisType;
212	}
213	outputFilename += ".root";
214
215	printf("* Connect to AliEn *\n");
216	TGrid::Connect("alien://");
217	gSystem->Load("libProofPlayer.so");
218
219	//____________________________________________________//
220	//_____________Setting up the par files_______________//
221	//____________________________________________________//
222	gSystem->Load("libSTEERBase.so");
223	gSystem->Load("libESD.so");
224	gSystem->Load("libAOD.so");
225	gSystem->Load("libANALYSIS") ;
226	gSystem->Load("libANALYSISalice") ;
227	gSystem->Load("libCORRFW.so") ;
228
229	setupPar("PWG2spectra");
230	gSystem->Load("libPWG2spectra.so");
231	//____________________________________________________//
232
233	//____________________________________________//
234	AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
235	TChain *chain = 0x0;
236	chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");
237
238	//____________________________________________//
239	gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
240	AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
241	analysisType,
242	pidMode);
243	//____________________________________________//
244	// Make the analysis manager
245	AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
246	AliVEventHandler* esdH = new AliESDInputHandler;
247	mgr->SetInputEventHandler(esdH);
248	AliMCEventHandler *mc = new AliMCEventHandler();
249	mgr->SetMCtruthEventHandler(mc);
250
251	//____________________________________________//
252	AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
253	taskProtons->SetAnalysisObject(analysis);
254	mgr->AddTask(taskProtons);
255
256	// Create containers for input/output
257	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
258	TChain::Class(),
259	AliAnalysisManager::kInputContainer);
260	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
261	TList::Class(),
262	AliAnalysisManager::kOutputContainer,
263	outputFilename.Data());
264
265	//____________________________________________//
266	mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
267	mgr->ConnectOutput(taskProtons,0,coutput1);
268	if (!mgr->InitAnalysis()) return;
269	mgr->PrintStatus();
270	mgr->StartAnalysis("local",chain);
271	}
272
273	//_________________________________________________//
274	void runProof(const char* mode = "ESD",
275	const char* analysisType = 0x0,
276	const char* pidMode = 0x0,
277	Int_t stats = 0,
278	const char* dataset = 0x0) {
279	TString smode = mode;
280	TString outputFilename = "Protons.FeedDown."; outputFilename += mode;
281	if(analysisType) {
282	outputFilename += "."; outputFilename += analysisType;
283	}
284	outputFilename += ".root";
285
286	printf("**** Connect to PROOF *****\n");
287	TProof::Open("alicecaf.cern.ch");
288	//gProof->SetParallel();
289
290	// Enable the Analysis Package
291	gProof->UploadPackage("STEERBase.par");
292	gProof->EnablePackage("STEERBase");
293	gProof->UploadPackage("ESD.par");
294	gProof->EnablePackage("ESD");
295	gProof->UploadPackage("AOD.par");
296	gProof->EnablePackage("AOD");
297	gProof->UploadPackage("ANALYSIS.par");
298	gProof->EnablePackage("ANALYSIS");
299	gProof->UploadPackage("ANALYSISalice.par");
300	gProof->EnablePackage("ANALYSISalice");
301	gProof->UploadPackage("CORRFW.par");
302	gProof->EnablePackage("CORRFW");
303	gProof->UploadPackage("PWG2spectra.par");
304	gProof->EnablePackage("PWG2spectra");
305
306	//____________________________________________//
307	gROOT->LoadMacro("configProtonFeedDownAnalysis.C");
308	AliProtonFeedDownAnalysis *analysis = GetProtonFeedDownAnalysisObject(mode,
309	analysisType,
310	pidMode);
311	//____________________________________________//
312
313	//____________________________________________//
314	// Make the analysis manager
315	AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManagerFD");
316	AliVEventHandler* esdH = new AliESDInputHandler;
317	mgr->SetInputEventHandler(esdH);
318	AliMCEventHandler *mc = new AliMCEventHandler();
319	mgr->SetMCtruthEventHandler(mc);
320	//____________________________________________//
321	//Create the proton task
322	AliProtonFeedDownAnalysisTask *taskProtons = new AliProtonFeedDownAnalysisTask("TaskProtonsFD");
323	taskProtons->SetAnalysisObject(analysis);
324	mgr->AddTask(taskProtons);
325
326	// Create containers for input/output
327	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
328	TChain::Class(),
329	AliAnalysisManager::kInputContainer);
330	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList",
331	TList::Class(),
332	AliAnalysisManager::kOutputContainer,
333	outputFilename.Data());
334
335	//____________________________________________//
336	mgr->ConnectInput(taskProtons,0,mgr->GetCommonInputContainer());
337	mgr->ConnectOutput(taskProtons,0,coutput1);
338	if (!mgr->InitAnalysis()) return;
339	mgr->PrintStatus();
340
341	if(dataset)
342	mgr->StartAnalysis("proof",dataset,stats);
343	else {
344	// You should get this macro and the txt file from:
345	// http://aliceinfo.cern.ch/Offline/Analysis/CAF/
346	gROOT->LoadMacro("CreateESDChain.C");
347	TChain* chain = 0x0;
348	chain = CreateESDChain("ESD82XX_30K.txt",stats);
349	chain->SetBranchStatus("Calo",0);
350
351	mgr->StartAnalysis("proof",chain);
352	}
353	}
354
355	//_________________________________________________//
356	Int_t setupPar(const char* pararchivename) {
357	///////////////////
358	// Setup PAR File//
359	///////////////////
360	if (pararchivename) {
361	char processline[1024];
362	sprintf(processline,".! tar xvzf %s.par",pararchivename);
363	gROOT->ProcessLine(processline);
364	const char* ocwd = gSystem->WorkingDirectory();
365	gSystem->ChangeDirectory(pararchivename);
366
367	// check for BUILD.sh and execute
368	if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
369	printf("*******************************\n");
370	printf("* Building PAR archive *\n");
371	printf("*******************************\n");
372
373	if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
374	Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
375	return -1;
376	}
377	}
378	// check for SETUP.C and execute
379	if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
380	printf("*******************************\n");
381	printf("* Setup PAR archive *\n");
382	printf("*******************************\n");
383	gROOT->Macro("PROOF-INF/SETUP.C");
384	}
385
386	gSystem->ChangeDirectory("../");
387	}
388	return 1;
389	}