[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->GetCommonInputContainer();
  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->GetCommonInputContainer();
  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
	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"
	8	TStopwatch timer;
	9	timer.Start();
	10
	11	runProof(200000,"/COMMON/COMMON/LHC08c11_10TeV_0.5T",analysisType);
	12	//runInteractive("wn.xml",analysisType);
	13
	14	timer.Stop();
	15	timer.Print();
	16	}
	17
	18	//_________________________________________________//
	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
	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);
	64
	65	//____________________________________________//
	66	// 1st Proton task
	67	AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
	68	taskProtonsQA->SetTriggerMode(AliAnalysisTaskProtonsQA::kMB2);
	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	}
	82	taskProtonsQA->SetAcceptedVertexDiamond(5.,5.,15.);
	83	mgr->AddTask(taskProtonsQA);
	84
	85	// Create containers for input/output
	86	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
	87	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
	88	TList::Class(),
	89	AliAnalysisManager::kOutputContainer,
	90	outputFilename1.Data());
	91	AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
	92	TList::Class(),
	93	AliAnalysisManager::kOutputContainer,
	94	outputFilename2.Data());
	95	AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
	96	TList::Class(),
	97	AliAnalysisManager::kOutputContainer,
	98	outputFilename2.Data());
	99	AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
	100	TList::Class(),
	101	AliAnalysisManager::kOutputContainer,
	102	outputFilename3.Data());
	103	AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("acceptedDCAList",
	104	TList::Class(),
	105	AliAnalysisManager::kOutputContainer,
	106	outputFilename3.Data());
	107	AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("efficiencyList",
	108	TList::Class(),
	109	AliAnalysisManager::kOutputContainer,
	110	outputFilename4.Data());
	111
	112	//____________________________________________//
	113	mgr->ConnectInput(taskProtonsQA,0,cinput1);
	114	mgr->ConnectOutput(taskProtonsQA,0,coutput1);
	115	mgr->ConnectOutput(taskProtonsQA,1,coutput2);
	116	mgr->ConnectOutput(taskProtonsQA,2,coutput3);
	117	mgr->ConnectOutput(taskProtonsQA,3,coutput4);
	118	mgr->ConnectOutput(taskProtonsQA,4,coutput5);
	119	mgr->ConnectOutput(taskProtonsQA,5,coutput6);
	120	if (!mgr->InitAnalysis()) return;
	121	mgr->PrintStatus();
	122	mgr->StartAnalysis("local",chain);
	123	}
	124
	125	//_________________________________________________//
	126	void runProof(Int_t stats = 0,
	127	const char* dataset = 0x0,
	128	const char *analysisType) {
	129	TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
	130	outputFilename1 += ".root"; //main QA file
	131	TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
	132	outputFilename2 += ".root"; //MC process QA
	133	TString outputFilename3 = "Protons.QA.Histograms.";
	134	outputFilename3 += analysisType;
	135	outputFilename3 += ".root"; //Accepted cut distributions
	136	TString outputFilename4 = "Protons.Efficiency.";
	137	outputFilename4 += analysisType;
	138	outputFilename4 += ".root"; //Reco and PID efficiency
	139
	140	printf("**** Connect to PROOF *****\n");
	141	TProof::Open("alicecaf.cern.ch");
	142	gProof->SetParallel();
	143
	144	// Enable the Analysis Package
	145	gProof->UploadPackage("STEERBase.par");
	146	gProof->EnablePackage("STEERBase");
	147	gProof->UploadPackage("ESD.par");
	148	gProof->EnablePackage("ESD");
	149	gProof->UploadPackage("AOD.par");
	150	gProof->EnablePackage("AOD");
	151	gProof->UploadPackage("ANALYSIS.par");
	152	gProof->EnablePackage("ANALYSIS");
	153	gProof->UploadPackage("ANALYSISalice.par");
	154	gProof->EnablePackage("ANALYSISalice");
	155	gProof->UploadPackage("CORRFW.par");
	156	gProof->EnablePackage("CORRFW");
	157	gProof->UploadPackage("PWG2spectra.par");
	158	gProof->EnablePackage("PWG2spectra");
	159
	160	gProof->Load("AliAnalysisTaskProtonsQA.cxx++");
	161
	162	//____________________________________________//
	163	// Make the analysis manager
	164	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	165	AliVEventHandler* esdH = new AliESDInputHandler;
	166	mgr->SetInputEventHandler(esdH);
	167	AliMCEventHandler *mc = new AliMCEventHandler();
	168	mgr->SetMCtruthEventHandler(mc);
	169
	170	//____________________________________________//
	171	// 1st Proton task
	172	AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
	173	taskProtonsQA->SetTriggerMode(AliAnalysisTaskProtonsQA::kMB2);
	174	switch(analysisType) {
	175	case "TPC":
	176	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kTPC);
	177	break;
	178	case "Hybrid":
	179	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kHybrid);
	180	break;
	181	case "Global":
	182	taskProtonsQA->SetAnalysisMode(AliAnalysisTaskProtonsQA::kGlobal);
	183	break;
	184	default:
	185	break;
	186	}
	187	taskProtonsQA->SetAcceptedVertexDiamond(5.,5.,15.);
	188	mgr->AddTask(taskProtonsQA);
	189
	190	// Create containers for input/output
	191	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
	192	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
	193	TList::Class(),
	194	AliAnalysisManager::kOutputContainer,
	195	outputFilename1.Data());
	196	AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
	197	TList::Class(),
	198	AliAnalysisManager::kOutputContainer,
	199	outputFilename2.Data());
	200	AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
	201	TList::Class(),
	202	AliAnalysisManager::kOutputContainer,
	203	outputFilename2.Data());
	204	AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
	205	TList::Class(),
	206	AliAnalysisManager::kOutputContainer,
	207	outputFilename3.Data());
	208	AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("acceptedDCAList",
	209	TList::Class(),
	210	AliAnalysisManager::kOutputContainer,
	211	outputFilename3.Data());
	212	AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("efficiencyList",
	213	TList::Class(),
	214	AliAnalysisManager::kOutputContainer,
	215	outputFilename4.Data());
	216
	217	//____________________________________________//
	218	mgr->ConnectInput(taskProtonsQA,0,cinput1);
	219	mgr->ConnectOutput(taskProtonsQA,0,coutput1);
	220	mgr->ConnectOutput(taskProtonsQA,1,coutput2);
	221	mgr->ConnectOutput(taskProtonsQA,2,coutput3);
	222	mgr->ConnectOutput(taskProtonsQA,3,coutput4);
	223	mgr->ConnectOutput(taskProtonsQA,4,coutput5);
	224	mgr->ConnectOutput(taskProtonsQA,5,coutput6);
	225	if (!mgr->InitAnalysis()) return;
	226	mgr->PrintStatus();
	227
	228	if(dataset)
	229	mgr->StartAnalysis("proof",dataset,stats);
	230	else {
	231	// You should get this macro and the txt file from:
	232	// http://aliceinfo.cern.ch/Offline/Analysis/CAF/
	233	gROOT->LoadMacro("CreateESDChain.C");
	234	TChain* chain = 0x0;
	235	chain = CreateESDChain("ESD82XX_30K.txt",stats);
	236	chain->SetBranchStatus("Calo",0);
	237
	238	mgr->StartAnalysis("proof",chain);
	239	//mgr->StartAnalysis("local",chain);
	240	}
	241	}
	242
	243	//_________________________________________________//
	244	Int_t setupPar(const char* pararchivename) {
	245	///////////////////
	246	// Setup PAR File//
	247	///////////////////
	248	if (pararchivename) {
	249	char processline[1024];
	250	sprintf(processline,".! tar xvzf %s.par",pararchivename);
	251	//gROOT->ProcessLine(processline);
	252	const char* ocwd = gSystem->WorkingDirectory();
	253	gSystem->ChangeDirectory(pararchivename);
	254
	255	// check for BUILD.sh and execute
	256	if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
	257	printf("*******************************\n");
	258	printf("* Building PAR archive *\n");
	259	printf("*******************************\n");
	260
	261	if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
	262	Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
	263	return -1;
	264	}
	265	}
	266	// check for SETUP.C and execute
	267	if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
	268	printf("*******************************\n");
	269	printf("* Setup PAR archive *\n");
	270	printf("*******************************\n");
	271	gROOT->Macro("PROOF-INF/SETUP.C");
	272	}
	273
	274	gSystem->ChangeDirectory("../");
	275	}
	276	return 1;
	277	}