[u/mrichter/AliRoot.git] / PWG2 / runProtonAnalysisQA.C

void runProtonAnalysisQA(const char *analysisType = "TPC") {
  //Macro to run the proton QA analysis tested for local, proof & GRID.
  //Proof: Takes three arguments, the number of events, the dataset name 
  //       and the analysis type
  //Interactive: Takes two arguments, the name of the collection file with 
  //             the event list for each file and the analysis type
  //Analysis type can be one of the three: "TPC", "Hybrid", "Global"
  TStopwatch timer;
  timer.Start();
  
  runProof(200000,"/COMMON/COMMON/LHC08c11_10TeV_0.5T",analysisType);
  //runInteractive("wn.xml",analysisType);
  
  timer.Stop();
  timer.Print();
}

//_________________________________________________//
void runInteractive(const char *collectionfile,
		    const char *analysisType) {
  TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
  outputFilename1 += ".root"; //main QA file
  TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
  outputFilename2 += ".root"; //MC process QA
  TString outputFilename3 = "Protons.QA.Histograms."; 
  outputFilename3 += analysisType;
  outputFilename3 += ".root"; //Accepted cut distributions
  TString outputFilename4 = "Protons.Efficiency."; 
  outputFilename4 += analysisType;
  outputFilename4 += ".root"; //Reco and PID efficiency

  TGrid::Connect("alien://");

  //Setup the par files
  setupPar("STEERBase");
  gSystem->Load("libSTEERBase.so");
  setupPar("ESD");
  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");

  gROOT->LoadMacro("AliAnalysisTaskProtonsQA.cxx+");
  //____________________________________________//
  //Usage of event tags
  AliTagAnalysis *analysis = new AliTagAnalysis();
  TChain *chain = 0x0;
  chain = analysis->GetChainFromCollection(collectionfile,"esdTree");

  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  AliMCEventHandler *mc = new AliMCEventHandler();
  mgr->SetMCtruthEventHandler(mc);
  
  //____________________________________________//
  // 1st Proton task
  AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
  taskProtonsQA->SetTriggerMode(AliAnalysisTaskProtonsQA::kMB2);
  switch(analysisType) {
  case "TPC":
    taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kTPC);
    break;
  case "Hybrid":
    taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kHybrid);
    break;
  case "Global":
    taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kGlobal);
    break;
  default:
    break;
  }
  taskProtonsQA->SetAcceptedVertexDiamond(5.,5.,15.);
  mgr->AddTask(taskProtonsQA);

  // Create containers for input/output
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
							   TChain::Class(),
							   AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename1.Data());
  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename2.Data());
  AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename2.Data());
  AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename3.Data());
  AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("acceptedDCAList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename3.Data());
  AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("efficiencyList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename4.Data());

  //____________________________________________//
  mgr->ConnectInput(taskProtonsQA,0,cinput1);
  mgr->ConnectOutput(taskProtonsQA,0,coutput1);
  mgr->ConnectOutput(taskProtonsQA,1,coutput2);
  mgr->ConnectOutput(taskProtonsQA,2,coutput3);
  mgr->ConnectOutput(taskProtonsQA,3,coutput4);
  mgr->ConnectOutput(taskProtonsQA,4,coutput5);
  mgr->ConnectOutput(taskProtonsQA,5,coutput6);
  if (!mgr->InitAnalysis()) return;
  mgr->PrintStatus();
  mgr->StartAnalysis("local",chain);
}
 
//_________________________________________________//
void runProof(Int_t stats = 0, 
	      const char* dataset = 0x0,
	      const char *analysisType) {
  TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
  outputFilename1 += ".root"; //main QA file
  TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
  outputFilename2 += ".root"; //MC process QA
  TString outputFilename3 = "Protons.QA.Histograms."; 
  outputFilename3 += analysisType;
  outputFilename3 += ".root"; //Accepted cut distributions
  TString outputFilename4 = "Protons.Efficiency."; 
  outputFilename4 += analysisType;
  outputFilename4 += ".root"; //Reco and PID efficiency

  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");
  
  gProof->Load("AliAnalysisTaskProtonsQA.cxx++");

  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  AliMCEventHandler *mc = new AliMCEventHandler();
  mgr->SetMCtruthEventHandler(mc);
  
  //____________________________________________//
  // 1st Proton task
  AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
  taskProtonsQA->SetTriggerMode(AliAnalysisTaskProtonsQA::kMB2);
  switch(analysisType) {
  case "TPC":
    taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kTPC);
    break;
  case "Hybrid":
    taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kHybrid);
    break;
  case "Global":
    taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kGlobal);
    break;
  default:
    break;
  }
  taskProtonsQA->SetAcceptedVertexDiamond(5.,5.,15.);
  mgr->AddTask(taskProtonsQA);

  // Create containers for input/output
  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
							   TChain::Class(),
							   AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename1.Data());
  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename2.Data());
  AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename2.Data());
  AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename3.Data());
  AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("acceptedDCAList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename3.Data());
  AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("efficiencyList", 
							    TList::Class(),
							    AliAnalysisManager::kOutputContainer,
							    outputFilename4.Data());

  //____________________________________________//
  mgr->ConnectInput(taskProtonsQA,0,cinput1);
  mgr->ConnectOutput(taskProtonsQA,0,coutput1);
  mgr->ConnectOutput(taskProtonsQA,1,coutput2);
  mgr->ConnectOutput(taskProtonsQA,2,coutput3);
  mgr->ConnectOutput(taskProtonsQA,3,coutput4);
  mgr->ConnectOutput(taskProtonsQA,4,coutput5);
  mgr->ConnectOutput(taskProtonsQA,5,coutput6);
  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);
    //mgr->StartAnalysis("local",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
9e2392b0	1	void runProtonAnalysisQA(const char *analysisType = "TPC") {
	2	//Macro to run the proton QA analysis tested for local, proof & GRID.
	3	//Proof: Takes three arguments, the number of events, the dataset name
	4	// and the analysis type
	5	//Interactive: Takes two arguments, the name of the collection file with
	6	// the event list for each file and the analysis type
	7	//Analysis type can be one of the three: "TPC", "Hybrid", "Global"
7b59a00b	8	TStopwatch timer;
	9	timer.Start();
	10
9e2392b0	11	runProof(200000,"/COMMON/COMMON/LHC08c11_10TeV_0.5T",analysisType);
9e2392b0	12	//runInteractive("wn.xml",analysisType);
7b59a00b	13
	14	timer.Stop();
	15	timer.Print();
	16	}
	17
	18	//_________________________________________________//
9e2392b0	19	void runInteractive(const char *collectionfile,
	20	const char *analysisType) {
	21	TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
	22	outputFilename1 += ".root"; //main QA file
	23	TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
	24	outputFilename2 += ".root"; //MC process QA
	25	TString outputFilename3 = "Protons.QA.Histograms.";
	26	outputFilename3 += analysisType;
	27	outputFilename3 += ".root"; //Accepted cut distributions
	28	TString outputFilename4 = "Protons.Efficiency.";
	29	outputFilename4 += analysisType;
	30	outputFilename4 += ".root"; //Reco and PID efficiency
e2f97a75	31
	32	TGrid::Connect("alien://");
	33
	34	//Setup the par files
	35	setupPar("STEERBase");
	36	gSystem->Load("libSTEERBase.so");
	37	setupPar("ESD");
	38	gSystem->Load("libESD.so");
	39	setupPar("AOD");
	40	gSystem->Load("libAOD.so");
	41	setupPar("ANALYSIS");
	42	gSystem->Load("libANALYSIS.so");
	43	setupPar("ANALYSISalice");
	44	gSystem->Load("libANALYSISalice.so");
	45	setupPar("CORRFW");
	46	gSystem->Load("libCORRFW.so");
	47	setupPar("PWG2spectra");
	48	gSystem->Load("libPWG2spectra.so");
	49
	50	gROOT->LoadMacro("AliAnalysisTaskProtonsQA.cxx+");
	51	//____________________________________________//
	52	//Usage of event tags
	53	AliTagAnalysis *analysis = new AliTagAnalysis();
	54	TChain *chain = 0x0;
	55	chain = analysis->GetChainFromCollection(collectionfile,"esdTree");
	56
	57	//____________________________________________//
	58	// Make the analysis manager
	59	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	60	AliVEventHandler* esdH = new AliESDInputHandler;
	61	mgr->SetInputEventHandler(esdH);
	62	AliMCEventHandler *mc = new AliMCEventHandler();
	63	mgr->SetMCtruthEventHandler(mc);
7b59a00b	64
e2f97a75	65	//____________________________________________//
	66	// 1st Proton task
	67	AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
5429dd65	68	taskProtonsQA->SetTriggerMode(AliAnalysisTaskProtonsQA::kMB2);
9e2392b0	69	switch(analysisType) {
	70	case "TPC":
	71	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kTPC);
	72	break;
	73	case "Hybrid":
	74	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kHybrid);
	75	break;
	76	case "Global":
	77	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kGlobal);
	78	break;
	79	default:
	80	break;
	81	}
5429dd65	82	taskProtonsQA->SetAcceptedVertexDiamond(5.,5.,15.);
e2f97a75	83	mgr->AddTask(taskProtonsQA);
	84
	85	// Create containers for input/output
	86	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
	87	TChain::Class(),
	88	AliAnalysisManager::kInputContainer);
	89	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
	90	TList::Class(),
	91	AliAnalysisManager::kOutputContainer,
	92	outputFilename1.Data());
	93	AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
	94	TList::Class(),
	95	AliAnalysisManager::kOutputContainer,
	96	outputFilename2.Data());
	97	AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
	98	TList::Class(),
	99	AliAnalysisManager::kOutputContainer,
	100	outputFilename2.Data());
	101	AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
	102	TList::Class(),
	103	AliAnalysisManager::kOutputContainer,
	104	outputFilename3.Data());
	105	AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("acceptedDCAList",
	106	TList::Class(),
	107	AliAnalysisManager::kOutputContainer,
	108	outputFilename3.Data());
	109	AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("efficiencyList",
	110	TList::Class(),
	111	AliAnalysisManager::kOutputContainer,
	112	outputFilename4.Data());
	113
	114	//____________________________________________//
	115	mgr->ConnectInput(taskProtonsQA,0,cinput1);
	116	mgr->ConnectOutput(taskProtonsQA,0,coutput1);
	117	mgr->ConnectOutput(taskProtonsQA,1,coutput2);
	118	mgr->ConnectOutput(taskProtonsQA,2,coutput3);
	119	mgr->ConnectOutput(taskProtonsQA,3,coutput4);
	120	mgr->ConnectOutput(taskProtonsQA,4,coutput5);
	121	mgr->ConnectOutput(taskProtonsQA,5,coutput6);
	122	if (!mgr->InitAnalysis()) return;
	123	mgr->PrintStatus();
	124	mgr->StartAnalysis("local",chain);
	125	}
	126
	127	//_________________________________________________//
9e2392b0	128	void runProof(Int_t stats = 0,
	129	const char* dataset = 0x0,
	130	const char *analysisType) {
	131	TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
	132	outputFilename1 += ".root"; //main QA file
	133	TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
	134	outputFilename2 += ".root"; //MC process QA
	135	TString outputFilename3 = "Protons.QA.Histograms.";
	136	outputFilename3 += analysisType;
	137	outputFilename3 += ".root"; //Accepted cut distributions
	138	TString outputFilename4 = "Protons.Efficiency.";
	139	outputFilename4 += analysisType;
	140	outputFilename4 += ".root"; //Reco and PID efficiency
7b59a00b	141
7b59a00b	142	printf("**** Connect to PROOF *****\n");
96f84c25	143	TProof::Open("alicecaf.cern.ch");
7b59a00b	144	gProof->SetParallel();
	145
	146	// Enable the Analysis Package
	147	gProof->UploadPackage("STEERBase.par");
	148	gProof->EnablePackage("STEERBase");
	149	gProof->UploadPackage("ESD.par");
	150	gProof->EnablePackage("ESD");
	151	gProof->UploadPackage("AOD.par");
	152	gProof->EnablePackage("AOD");
	153	gProof->UploadPackage("ANALYSIS.par");
	154	gProof->EnablePackage("ANALYSIS");
	155	gProof->UploadPackage("ANALYSISalice.par");
	156	gProof->EnablePackage("ANALYSISalice");
f99662ca	157	gProof->UploadPackage("CORRFW.par");
f99662ca	158	gProof->EnablePackage("CORRFW");
7b59a00b	159	gProof->UploadPackage("PWG2spectra.par");
	160	gProof->EnablePackage("PWG2spectra");
	161
	162	gProof->Load("AliAnalysisTaskProtonsQA.cxx++");
	163
	164	//____________________________________________//
	165	// Make the analysis manager
	166	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	167	AliVEventHandler* esdH = new AliESDInputHandler;
	168	mgr->SetInputEventHandler(esdH);
	169	AliMCEventHandler *mc = new AliMCEventHandler();
	170	mgr->SetMCtruthEventHandler(mc);
	171
	172	//____________________________________________//
	173	// 1st Proton task
	174	AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
5429dd65	175	taskProtonsQA->SetTriggerMode(AliAnalysisTaskProtonsQA::kMB2);
9e2392b0	176	switch(analysisType) {
	177	case "TPC":
	178	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kTPC);
	179	break;
	180	case "Hybrid":
	181	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kHybrid);
	182	break;
	183	case "Global":
	184	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kGlobal);
	185	break;
	186	default:
	187	break;
	188	}
5429dd65	189	taskProtonsQA->SetAcceptedVertexDiamond(5.,5.,15.);
7b59a00b	190	mgr->AddTask(taskProtonsQA);
	191
	192	// Create containers for input/output
	193	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
f99662ca	194	TChain::Class(),
f99662ca	195	AliAnalysisManager::kInputContainer);
5b8133c7	196	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
f99662ca	197	TList::Class(),
f99662ca	198	AliAnalysisManager::kOutputContainer,
d4733690	199	outputFilename1.Data());
5b8133c7	200	AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
d4733690	201	TList::Class(),
	202	AliAnalysisManager::kOutputContainer,
	203	outputFilename2.Data());
5b8133c7	204	AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
d4733690	205	TList::Class(),
d4733690	206	AliAnalysisManager::kOutputContainer,
0008a5a6	207	outputFilename2.Data());
5b8133c7	208	AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
	209	TList::Class(),
	210	AliAnalysisManager::kOutputContainer,
	211	outputFilename3.Data());
	212	AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("acceptedDCAList",
	213	TList::Class(),
	214	AliAnalysisManager::kOutputContainer,
	215	outputFilename3.Data());
e2f97a75	216	AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("efficiencyList",
	217	TList::Class(),
	218	AliAnalysisManager::kOutputContainer,
	219	outputFilename4.Data());
7b59a00b	220
	221	//____________________________________________//
	222	mgr->ConnectInput(taskProtonsQA,0,cinput1);
	223	mgr->ConnectOutput(taskProtonsQA,0,coutput1);
d4733690	224	mgr->ConnectOutput(taskProtonsQA,1,coutput2);
d4733690	225	mgr->ConnectOutput(taskProtonsQA,2,coutput3);
5b8133c7	226	mgr->ConnectOutput(taskProtonsQA,3,coutput4);
5b8133c7	227	mgr->ConnectOutput(taskProtonsQA,4,coutput5);
e2f97a75	228	mgr->ConnectOutput(taskProtonsQA,5,coutput6);
7b59a00b	229	if (!mgr->InitAnalysis()) return;
	230	mgr->PrintStatus();
	231
	232	if(dataset)
	233	mgr->StartAnalysis("proof",dataset,stats);
	234	else {
	235	// You should get this macro and the txt file from:
	236	// http://aliceinfo.cern.ch/Offline/Analysis/CAF/
	237	gROOT->LoadMacro("CreateESDChain.C");
	238	TChain* chain = 0x0;
	239	chain = CreateESDChain("ESD82XX_30K.txt",stats);
	240	chain->SetBranchStatus("Calo",0);
	241
	242	mgr->StartAnalysis("proof",chain);
f99662ca	243	//mgr->StartAnalysis("local",chain);
7b59a00b	244	}
7b59a00b	245	}
	246
	247	//_________________________________________________//
	248	Int_t setupPar(const char* pararchivename) {
	249	///////////////////
	250	// Setup PAR File//
	251	///////////////////
	252	if (pararchivename) {
	253	char processline[1024];
	254	sprintf(processline,".! tar xvzf %s.par",pararchivename);
3e23254a	255	//gROOT->ProcessLine(processline);
7b59a00b	256	const char* ocwd = gSystem->WorkingDirectory();
	257	gSystem->ChangeDirectory(pararchivename);
	258
	259	// check for BUILD.sh and execute
	260	if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
	261	printf("*******************************\n");
	262	printf("* Building PAR archive *\n");
	263	printf("*******************************\n");
	264
	265	if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
	266	Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
	267	return -1;
	268	}
	269	}
	270	// check for SETUP.C and execute
	271	if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
	272	printf("*******************************\n");
	273	printf("* Setup PAR archive *\n");
	274	printf("*******************************\n");
	275	gROOT->Macro("PROOF-INF/SETUP.C");
	276	}
	277
	278	gSystem->ChangeDirectory("../");
	279	}
	280	return 1;
	281	}