[u/mrichter/AliRoot.git] / PWG2 / SPECTRA / macros / runProtonAnalysis.C

void runProtonAnalysis(Bool_t kAnalyzeMC = kTRUE,
		       const char* esdAnalysisType = "Hybrid",
		       const char* pidMode = "Bayesian") {
  //Macro to run the proton 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", 
	   kAnalyzeMC,
	   esdAnalysisType,
	   pidMode,
	   "/home/pchrist/ALICE/Baryons/Data/104070");
  //runInteractive("ESD",kAnalyzeMC, esdAnalysisType,pidMode,"tag.xml");
  //runBatch("ESD",kAnalyzeMC, esdAnalysisType,pidMode,"wn.xml");  
  //runProof("ESD",kAnalyzeMC, esdAnalysisType,pidMode,
  //500000,0,"/COMMON/COMMON/LHC09d1_0.9TeV_0.5T#esdTree");

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

//_________________________________________________//
void runLocal(const char* mode = "ESD",
	      Bool_t kAnalyzeMC = kTRUE,
	      const char* analysisType = 0x0,
	      const char* pidMode = 0x0,
	      const char* path = "/home/pchrist/ALICE/Alien/Tutorial/November2007/Tags") {
  TString smode = mode;
  TString outputFilename = "Protons."; 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("configProtonAnalysis.C");
  AliProtonAnalysis *analysis = GetProtonAnalysisObject(mode,kAnalyzeMC,
							analysisType,
							pidMode);
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);  
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }
  
  //____________________________________________//
  //Create the proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

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

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

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

  TString smode = mode;
  TString outputFilename = "Protons."; 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("configProtonAnalysis.C");
  AliProtonAnalysis *analysis = GetProtonAnalysisObject(mode,kAnalyzeMC,
							analysisType,
							pidMode);
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);  
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }

  //____________________________________________//
  //Create the proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

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

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

//_________________________________________________//
void runBatch(const char* mode = "ESD",
	      Bool_t kAnalyzeMC = kTRUE,
	      const char* analysisType = 0x0,
	      const char* pidMode = 0x0,
	      const char *collectionfile = "wn.xml") {
  TString smode = mode;
  TString outputFilename = "Protons."; 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_______________//
  //____________________________________________________//
  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");
  //____________________________________________________//  

  //____________________________________________//
  //Usage of event tags
  AliTagAnalysis *tagAnalysis = new AliTagAnalysis();
  TChain *chain = 0x0;
  chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");
  chain->SetBranchStatus("*Calo*",0);

  //____________________________________________//
  gROOT->LoadMacro("configProtonAnalysis.C");
  AliProtonAnalysis *analysis = GetProtonAnalysisObject(mode,kAnalyzeMC,
							analysisType,
							pidMode);
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);  
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }
  
  //____________________________________________//
  //Create the proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

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

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

  gEnv->SetValue("XSec.GSI.DelegProxy","2");
  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("configProtonAnalysis.C");
  AliProtonAnalysis *analysis = GetProtonAnalysisObject(mode,kAnalyzeMC,
							analysisType,
							pidMode);
  //____________________________________________//

  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }
  //____________________________________________//
  //Create the proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetAnalysisObject(analysis);
  mgr->AddTask(taskProtons);

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

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

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