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

void runProtonAnalysis(const char* esdAnalysisType = "TPC",) {
  //Macro to run the proton analysis tested for local, proof & GRID.
  //Local: Takes three arguments, the analysis mode, the type of the ESD 
  //       analysis and the path where the tag and ESD or AOD files reside.
  //Interactive: Takes three arguments, the analysis mode, the type of the ESD 
  //             analysis and the name of the collection of tag files.
  //Batch: Takes three arguments, the analysis mode, the type of the ESD 
  //       analysis and the name of the collection file with the event list 
  //       for each file.
  //Proof: Takes four arguments, the analysis mode, the number of events,
  //       the dataset name and the analysis type in case of ESD.
  
  //Analysis mode can be: "MC", "ESD", "AOD"
  //ESD analysis type can be one of the three: "TPC", "Hybrid", "Global"
  TStopwatch timer;
  timer.Start();
  
  //runLocal("ESD",esdAnalysisType,"/home/pchrist/ALICE/Alien/Tutorial/November2007/Tags");
  //runInteractive("ESD",esdAnalysisType,"tag.xml");
  //runBatch("ESD",esdAnalysisType,"wn.xml");  
  runProof("MC",
	   200000,
	   "/COMMON/COMMON/LHC08c11_10TeV_0.5T",
	   esdAnalysisType);
  
  timer.Stop();
  timer.Print();
}

//_________________________________________________//
void runLocal(const char* mode = "ESD",
	      const char* analysisType = 0x0,
	      const char* path = "/home/pchrist/ALICE/Alien/Tutorial/November2007/Tags") {
  TStopwatch timer;
  timer.Start();

  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->UploadPackage("CORRFW.par");
  gSystem->EnablePackage("CORRFW");
  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("AliAnalysisTaskProtons.cxx++");
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);  
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }

  //____________________________________________//
  // 1st Proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetType(mode);
  taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
  switch(analysisType) {
  case "TPC":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
    break;
  case "Hybrid":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
    break;
  case "Global":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
    break;
  default:
    break;
  }
  taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
  //Momentum dependent priors
  /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
  TF1 *fitElectrons = (TF1 *)f->Get("fitElectrons");
  TF1 *fitMuons = (TF1 *)f->Get("fitMuons");
  TF1 *fitPions = (TF1 *)f->Get("fitPions");
  TF1 *fitKaons = (TF1 *)f->Get("fitKaons");
  TF1 *fitProtons = (TF1 *)f->Get("fitProtons");
  taskProtons->SetPriorProbabilityFunctions(fitElectrons,
					    fitMuons,
					    fitPions,
					    fitKaons,
					    fitProtons);*/
  mgr->AddTask(taskProtons);

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

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

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

//_________________________________________________//
void runInteractive(const char* mode = "ESD",
		    const char* analysisType = 0x0,
		    const char* collectionName = "tag.xml") {
  TStopwatch timer;
  timer.Start();
  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->UploadPackage("CORRFW.par");
  gSystem->EnablePackage("CORRFW");
  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("AliAnalysisTaskProtons.cxx++");
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);  
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }

  //____________________________________________//
  // 1st Proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetType(mode);
  taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
  switch(analysisType) {
  case "TPC":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
    break;
  case "Hybrid":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
    break;
  case "Global":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
    break;
  default:
    break;
  }
  taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
  //Momentum dependent priors
  /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
  TF1 *fitElectrons = (TF1 *)f->Get("fitElectrons");
  TF1 *fitMuons = (TF1 *)f->Get("fitMuons");
  TF1 *fitPions = (TF1 *)f->Get("fitPions");
  TF1 *fitKaons = (TF1 *)f->Get("fitKaons");
  TF1 *fitProtons = (TF1 *)f->Get("fitProtons");
  taskProtons->SetPriorProbabilityFunctions(fitElectrons,
					    fitMuons,
					    fitPions,
					    fitKaons,
					    fitProtons);*/
  mgr->AddTask(taskProtons);

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

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

//_________________________________________________//
void runBatch(const char* mode = "ESD",
	      const char* analysisType = 0x0,
	      const char *collectionfile = "wn.xml") {
  TStopwatch timer;
  timer.Start();

  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->UploadPackage("CORRFW.par");
  gSystem->EnablePackage("CORRFW");
  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("AliAnalysisTaskProtons.cxx++");
  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);  
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }
  
  //____________________________________________//
  // 1st Proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetType(mode);
  taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
  switch(analysisType) {
  case "TPC":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
    break;
  case "Hybrid":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
    break;
  case "Global":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
    break;
  default:
    break;
  }
  taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
  //Momentum dependent priors
  /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
  TF1 *fitElectrons = (TF1 *)f->Get("fitElectrons");
  TF1 *fitMuons = (TF1 *)f->Get("fitMuons");
  TF1 *fitPions = (TF1 *)f->Get("fitPions");
  TF1 *fitKaons = (TF1 *)f->Get("fitKaons");
  TF1 *fitProtons = (TF1 *)f->Get("fitProtons");
  taskProtons->SetPriorProbabilityFunctions(fitElectrons,
					    fitMuons,
					    fitPions,
					    fitKaons,
					    fitProtons);*/
  mgr->AddTask(taskProtons);

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

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

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

//_________________________________________________//
void runProof(const char* mode = "ESD",
	      Int_t stats = 0, 
	      const char* dataset = 0x0,
	      const char* analysisType = 0x0) {
  TStopwatch timer;
  timer.Start();
  
  TString smode = mode;
  TString outputFilename = "Protons."; 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");
  
  //____________________________________________//
  gProof->Load("AliAnalysisTaskProtons.cxx++");
  //____________________________________________//

  //____________________________________________//
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
  AliVEventHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);
  if(smode == "MC") {
    AliMCEventHandler *mc = new AliMCEventHandler();
    mgr->SetMCtruthEventHandler(mc);
  }
  //____________________________________________//
  // 1st Proton task
  AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  taskProtons->SetType(mode);
  taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
  switch(analysisType) {
  case "TPC":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
    break;
  case "Hybrid":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
    break;
  case "Global":
    taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
    break;
  default:
    break;
  }
  taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
  //Momentum dependent priors
  /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
  TF1 *fitElectrons = (TF1 *)f->Get("fitElectrons");
  TF1 *fitMuons = (TF1 *)f->Get("fitMuons");
  TF1 *fitPions = (TF1 *)f->Get("fitPions");
  TF1 *fitKaons = (TF1 *)f->Get("fitKaons");
  TF1 *fitProtons = (TF1 *)f->Get("fitProtons");
  taskProtons->SetPriorProbabilityFunctions(fitElectrons,
					    fitMuons,
					    fitPions,
					    fitKaons,
					    fitProtons);*/
  mgr->AddTask(taskProtons);

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

  //____________________________________________//
  mgr->ConnectInput(taskProtons,0,cinput1);
  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);
  }

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

//_________________________________________________//
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
da8c4c1c	1	void runProtonAnalysis(const char* esdAnalysisType = "TPC",) {
	2	//Macro to run the proton analysis tested for local, proof & GRID.
	3	//Local: Takes three arguments, the analysis mode, the type of the ESD
	4	// analysis and the path where the tag and ESD or AOD files reside.
	5	//Interactive: Takes three arguments, the analysis mode, the type of the ESD
	6	// analysis and the name of the collection of tag files.
	7	//Batch: Takes three arguments, the analysis mode, the type of the ESD
	8	// analysis and the name of the collection file with the event list
	9	// for each file.
	10	//Proof: Takes four arguments, the analysis mode, the number of events,
	11	// the dataset name and the analysis type in case of ESD.
	12
	13	//Analysis mode can be: "MC", "ESD", "AOD"
	14	//ESD analysis type can be one of the three: "TPC", "Hybrid", "Global"
734d2c12	15	TStopwatch timer;
	16	timer.Start();
	17
da8c4c1c	18	//runLocal("ESD",esdAnalysisType,"/home/pchrist/ALICE/Alien/Tutorial/November2007/Tags");
	19	//runInteractive("ESD",esdAnalysisType,"tag.xml");
	20	//runBatch("ESD",esdAnalysisType,"wn.xml");
	21	runProof("MC",
	22	200000,
	23	"/COMMON/COMMON/LHC08c11_10TeV_0.5T",
	24	esdAnalysisType);
df01f00b	25
734d2c12	26	timer.Stop();
	27	timer.Print();
	28	}
	29
	30	//_________________________________________________//
da8c4c1c	31	void runLocal(const char* mode = "ESD",
	32	const char* analysisType = 0x0,
	33	const char* path = "/home/pchrist/ALICE/Alien/Tutorial/November2007/Tags") {
734d2c12	34	TStopwatch timer;
734d2c12	35	timer.Start();
da8c4c1c	36
	37	TString smode = mode;
	38	TString outputFilename = "Protons."; outputFilename += mode;
	39	if(analysisType) {
	40	outputFilename += "."; outputFilename += analysisType;
	41	}
	42	outputFilename += ".root";
	43
734d2c12	44	//____________________________________________________//
da8c4c1c	45	//_____________Setting up the par files_______________//
734d2c12	46	//____________________________________________________//
	47	setupPar("STEERBase");
	48	gSystem->Load("libSTEERBase.so");
734d2c12	49	setupPar("ESD");
	50	gSystem->Load("libVMC.so");
	51	gSystem->Load("libESD.so");
734d2c12	52	setupPar("AOD");
734d2c12	53	gSystem->Load("libAOD.so");
734d2c12	54	setupPar("ANALYSIS");
734d2c12	55	gSystem->Load("libANALYSIS.so");
e4358d7f	56	setupPar("ANALYSISalice");
e4358d7f	57	gSystem->Load("libANALYSISalice.so");
96f84c25	58	setupPar->UploadPackage("CORRFW.par");
96f84c25	59	gSystem->EnablePackage("CORRFW");
734d2c12	60	setupPar("PWG2spectra");
734d2c12	61	gSystem->Load("libPWG2spectra.so");
da8c4c1c	62	//____________________________________________________//
734d2c12	63
734d2c12	64	//____________________________________________//
e4358d7f	65	AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
da8c4c1c	66	tagAnalysis->ChainLocalTags(path);
734d2c12	67
	68	AliRunTagCuts *runCuts = new AliRunTagCuts();
	69	AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
	70	AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
	71	AliEventTagCuts *evCuts = new AliEventTagCuts();
	72
	73	TChain* chain = 0x0;
e4358d7f	74	chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
734d2c12	75	chain->SetBranchStatus("Calo",0);
734d2c12	76
da8c4c1c	77	//____________________________________________//
da8c4c1c	78	gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
734d2c12	79	//____________________________________________//
	80	// Make the analysis manager
	81	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	82	AliVEventHandler* esdH = new AliESDInputHandler;
	83	mgr->SetInputEventHandler(esdH);
6667f3a7	84	if(smode == "MC") {
	85	AliMCEventHandler *mc = new AliMCEventHandler();
	86	mgr->SetMCtruthEventHandler(mc);
	87	}
	88
734d2c12	89	//____________________________________________//
734d2c12	90	// 1st Proton task
e4358d7f	91	AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
6667f3a7	92	taskProtons->SetType(mode);
da8c4c1c	93	taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
	94	switch(analysisType) {
	95	case "TPC":
	96	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
	97	break;
	98	case "Hybrid":
	99	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
	100	break;
	101	case "Global":
	102	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
	103	break;
	104	default:
	105	break;
	106	}
6667f3a7	107	taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
6667f3a7	108	//Momentum dependent priors
e4358d7f	109	/TFile f = TFile::Open("PriorProb/PriorProbabilities.root ");
aafecd8b	110	TF1 fitElectrons = (TF1 )f->Get("fitElectrons");
	111	TF1 fitMuons = (TF1 )f->Get("fitMuons");
	112	TF1 fitPions = (TF1 )f->Get("fitPions");
	113	TF1 fitKaons = (TF1 )f->Get("fitKaons");
	114	TF1 fitProtons = (TF1 )f->Get("fitProtons");
e4358d7f	115	taskProtons->SetPriorProbabilityFunctions(fitElectrons,
	116	fitMuons,
	117	fitPions,
	118	fitKaons,
	119	fitProtons);*/
	120	mgr->AddTask(taskProtons);
	121
	122	// Create containers for input/output
	123	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
251e4034	124	TChain::Class(),
251e4034	125	AliAnalysisManager::kInputContainer);
e4358d7f	126	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
251e4034	127	TList::Class(),
251e4034	128	AliAnalysisManager::kOutputCont
da8c4c1c	129	outputFilename.Data());
734d2c12	130
734d2c12	131	//____________________________________________//
e4358d7f	132	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	133	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	134	if (!mgr->InitAnalysis()) return;
	135	mgr->PrintStatus();
	136	mgr->StartAnalysis("local",chain);
	137
	138	timer.Stop();
	139	timer.Print();
	140	}
	141
	142	//_________________________________________________//
da8c4c1c	143	void runInteractive(const char* mode = "ESD",
	144	const char* analysisType = 0x0,
	145	const char* collectionName = "tag.xml") {
734d2c12	146	TStopwatch timer;
	147	timer.Start();
	148	gSystem->Load("libProofPlayer.so");
	149
da8c4c1c	150	TString smode = mode;
	151	TString outputFilename = "Protons."; outputFilename += mode;
	152	if(analysisType) {
	153	outputFilename += "."; outputFilename += analysisType;
	154	}
	155	outputFilename += ".root";
	156
734d2c12	157	printf("* Connect to AliEn *\n");
	158	TGrid::Connect("alien://");
	159
	160	//____________________________________________________//
da8c4c1c	161	//_____________Setting up the par files_______________//
734d2c12	162	//____________________________________________________//
	163	setupPar("STEERBase");
	164	gSystem->Load("libSTEERBase.so");
734d2c12	165	setupPar("ESD");
	166	gSystem->Load("libVMC.so");
	167	gSystem->Load("libESD.so");
734d2c12	168	setupPar("AOD");
734d2c12	169	gSystem->Load("libAOD.so");
734d2c12	170	setupPar("ANALYSIS");
734d2c12	171	gSystem->Load("libANALYSIS.so");
e4358d7f	172	setupPar("ANALYSISalice");
e4358d7f	173	gSystem->Load("libANALYSISalice.so");
96f84c25	174	setupPar->UploadPackage("CORRFW.par");
96f84c25	175	gSystem->EnablePackage("CORRFW");
734d2c12	176	setupPar("PWG2spectra");
734d2c12	177	gSystem->Load("libPWG2spectra.so");
da8c4c1c	178	//____________________________________________________//
734d2c12	179
734d2c12	180	//____________________________________________//
e4358d7f	181	AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
734d2c12	182
	183	AliRunTagCuts *runCuts = new AliRunTagCuts();
	184	AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
	185	AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
	186	AliEventTagCuts *evCuts = new AliEventTagCuts();
	187
	188	//grid tags
da8c4c1c	189	TAlienCollection* coll = TAlienCollection::Open(collectionName);
734d2c12	190	TGridResult* TagResult = coll->GetGridResult("",0,0);
e4358d7f	191	tagAnalysis->ChainGridTags(TagResult);
734d2c12	192	TChain* chain = 0x0;
e4358d7f	193	chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
734d2c12	194	chain->SetBranchStatus("Calo",0);
da8c4c1c	195
	196	//____________________________________________//
	197	gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
734d2c12	198	//____________________________________________//
	199	// Make the analysis manager
	200	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	201	AliVEventHandler* esdH = new AliESDInputHandler;
	202	mgr->SetInputEventHandler(esdH);
6667f3a7	203	if(smode == "MC") {
	204	AliMCEventHandler *mc = new AliMCEventHandler();
	205	mgr->SetMCtruthEventHandler(mc);
	206	}
	207
734d2c12	208	//____________________________________________//
734d2c12	209	// 1st Proton task
e4358d7f	210	AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
6667f3a7	211	taskProtons->SetType(mode);
da8c4c1c	212	taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
	213	switch(analysisType) {
	214	case "TPC":
	215	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
	216	break;
	217	case "Hybrid":
	218	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
	219	break;
	220	case "Global":
	221	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
	222	break;
	223	default:
	224	break;
	225	}
6667f3a7	226	taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
6667f3a7	227	//Momentum dependent priors
e4358d7f	228	/TFile f = TFile::Open("PriorProb/PriorProbabilities.root ");
aafecd8b	229	TF1 fitElectrons = (TF1 )f->Get("fitElectrons");
	230	TF1 fitMuons = (TF1 )f->Get("fitMuons");
	231	TF1 fitPions = (TF1 )f->Get("fitPions");
	232	TF1 fitKaons = (TF1 )f->Get("fitKaons");
	233	TF1 fitProtons = (TF1 )f->Get("fitProtons");
e4358d7f	234	taskProtons->SetPriorProbabilityFunctions(fitElectrons,
	235	fitMuons,
	236	fitPions,
	237	fitKaons,
	238	fitProtons);*/
	239	mgr->AddTask(taskProtons);
	240
	241	// Create containers for input/output
	242	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
251e4034	243	TChain::Class(),
251e4034	244	AliAnalysisManager::kInputContainer);
e4358d7f	245	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
251e4034	246	TList::Class(),
251e4034	247	AliAnalysisManager::kOutputCont
da8c4c1c	248	outputFilename.Data());
734d2c12	249
734d2c12	250	//____________________________________________//
e4358d7f	251	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	252	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	253	if (!mgr->InitAnalysis()) return;
	254	mgr->PrintStatus();
	255	mgr->StartAnalysis("local",chain);
	256
	257	timer.Stop();
	258	timer.Print();
	259	}
	260
	261	//_________________________________________________//
da8c4c1c	262	void runBatch(const char* mode = "ESD",
	263	const char* analysisType = 0x0,
	264	const char *collectionfile = "wn.xml") {
734d2c12	265	TStopwatch timer;
	266	timer.Start();
	267
da8c4c1c	268	TString smode = mode;
	269	TString outputFilename = "Protons."; outputFilename += mode;
	270	if(analysisType) {
	271	outputFilename += "."; outputFilename += analysisType;
	272	}
	273	outputFilename += ".root";
	274
734d2c12	275	printf("* Connect to AliEn *\n");
	276	TGrid::Connect("alien://");
	277	gSystem->Load("libProofPlayer.so");
	278
	279	//____________________________________________________//
da8c4c1c	280	//_____________Setting up the par files_______________//
734d2c12	281	//____________________________________________________//
	282	setupPar("STEERBase");
	283	gSystem->Load("libSTEERBase.so");
734d2c12	284	setupPar("ESD");
	285	gSystem->Load("libVMC.so");
	286	gSystem->Load("libESD.so");
734d2c12	287	setupPar("AOD");
734d2c12	288	gSystem->Load("libAOD.so");
734d2c12	289	setupPar("ANALYSIS");
734d2c12	290	gSystem->Load("libANALYSIS.so");
e4358d7f	291	setupPar("ANALYSISalice");
e4358d7f	292	gSystem->Load("libANALYSISalice.so");
96f84c25	293	setupPar->UploadPackage("CORRFW.par");
96f84c25	294	gSystem->EnablePackage("CORRFW");
734d2c12	295	setupPar("PWG2spectra");
734d2c12	296	gSystem->Load("libPWG2spectra.so");
da8c4c1c	297	//____________________________________________________//
734d2c12	298
	299	//____________________________________________//
	300	//Usage of event tags
e4358d7f	301	AliTagAnalysis *tagAnalysis = new AliTagAnalysis();
734d2c12	302	TChain *chain = 0x0;
e4358d7f	303	chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");
734d2c12	304	chain->SetBranchStatus("Calo",0);
734d2c12	305
da8c4c1c	306	//____________________________________________//
da8c4c1c	307	gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
734d2c12	308	//____________________________________________//
	309	// Make the analysis manager
	310	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	311	AliVEventHandler* esdH = new AliESDInputHandler;
	312	mgr->SetInputEventHandler(esdH);
6667f3a7	313	if(smode == "MC") {
	314	AliMCEventHandler *mc = new AliMCEventHandler();
	315	mgr->SetMCtruthEventHandler(mc);
	316	}
	317
734d2c12	318	//____________________________________________//
734d2c12	319	// 1st Proton task
e4358d7f	320	AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
6667f3a7	321	taskProtons->SetType(mode);
da8c4c1c	322	taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
	323	switch(analysisType) {
	324	case "TPC":
	325	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
	326	break;
	327	case "Hybrid":
	328	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
	329	break;
	330	case "Global":
	331	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
	332	break;
	333	default:
	334	break;
	335	}
6667f3a7	336	taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
6667f3a7	337	//Momentum dependent priors
e4358d7f	338	/TFile f = TFile::Open("PriorProb/PriorProbabilities.root ");
aafecd8b	339	TF1 fitElectrons = (TF1 )f->Get("fitElectrons");
	340	TF1 fitMuons = (TF1 )f->Get("fitMuons");
	341	TF1 fitPions = (TF1 )f->Get("fitPions");
	342	TF1 fitKaons = (TF1 )f->Get("fitKaons");
	343	TF1 fitProtons = (TF1 )f->Get("fitProtons");
e4358d7f	344	taskProtons->SetPriorProbabilityFunctions(fitElectrons,
	345	fitMuons,
	346	fitPions,
	347	fitKaons,
	348	fitProtons);*/
	349	mgr->AddTask(taskProtons);
	350
	351	// Create containers for input/output
	352	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
	353	TChain::Class(),AliAnalysisManager::kInputContainer);
	354	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
	355	TList::Class(),AliAnalysisManager::kOutputCont
da8c4c1c	356	outputFilename.Data());
734d2c12	357
734d2c12	358	//____________________________________________//
e4358d7f	359	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	360	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	361	if (!mgr->InitAnalysis()) return;
	362	mgr->PrintStatus();
	363	mgr->StartAnalysis("grid",chain);
	364
	365	timer.Stop();
	366	timer.Print();
	367	}
	368
	369	//_________________________________________________//
da8c4c1c	370	void runProof(const char* mode = "ESD",
251e4034	371	Int_t stats = 0,
da8c4c1c	372	const char* dataset = 0x0,
da8c4c1c	373	const char* analysisType = 0x0) {
734d2c12	374	TStopwatch timer;
734d2c12	375	timer.Start();
df01f00b	376
	377	TString smode = mode;
	378	TString outputFilename = "Protons."; outputFilename += mode;
da8c4c1c	379	if(analysisType) {
	380	outputFilename += "."; outputFilename += analysisType;
	381	}
df01f00b	382	outputFilename += ".root";
df01f00b	383
734d2c12	384	printf("**** Connect to PROOF *****\n");
96f84c25	385	TProof::Open("alicecaf.cern.ch");
aafecd8b	386	gProof->SetParallel();
734d2c12	387
	388	// Enable the Analysis Package
	389	gProof->UploadPackage("STEERBase.par");
	390	gProof->EnablePackage("STEERBase");
	391	gProof->UploadPackage("ESD.par");
	392	gProof->EnablePackage("ESD");
	393	gProof->UploadPackage("AOD.par");
	394	gProof->EnablePackage("AOD");
	395	gProof->UploadPackage("ANALYSIS.par");
	396	gProof->EnablePackage("ANALYSIS");
e4358d7f	397	gProof->UploadPackage("ANALYSISalice.par");
e4358d7f	398	gProof->EnablePackage("ANALYSISalice");
251e4034	399	gProof->UploadPackage("CORRFW.par");
251e4034	400	gProof->EnablePackage("CORRFW");
734d2c12	401	gProof->UploadPackage("PWG2spectra.par");
	402	gProof->EnablePackage("PWG2spectra");
	403
da8c4c1c	404	//____________________________________________//
734d2c12	405	gProof->Load("AliAnalysisTaskProtons.cxx++");
da8c4c1c	406	//____________________________________________//
734d2c12	407
e4358d7f	408	//____________________________________________//
734d2c12	409	// Make the analysis manager
	410	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	411	AliVEventHandler* esdH = new AliESDInputHandler;
df01f00b	412	mgr->SetInputEventHandler(esdH);
	413	if(smode == "MC") {
	414	AliMCEventHandler *mc = new AliMCEventHandler();
	415	mgr->SetMCtruthEventHandler(mc);
	416	}
734d2c12	417	//____________________________________________//
734d2c12	418	// 1st Proton task
e4358d7f	419	AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
df01f00b	420	taskProtons->SetType(mode);
da8c4c1c	421	taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
	422	switch(analysisType) {
	423	case "TPC":
	424	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
	425	break;
	426	case "Hybrid":
	427	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
	428	break;
	429	case "Global":
	430	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
	431	break;
	432	default:
	433	break;
	434	}
6667f3a7	435	taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
6667f3a7	436	//Momentum dependent priors
e4358d7f	437	/TFile f = TFile::Open("PriorProb/PriorProbabilities.root ");
aafecd8b	438	TF1 fitElectrons = (TF1 )f->Get("fitElectrons");
	439	TF1 fitMuons = (TF1 )f->Get("fitMuons");
	440	TF1 fitPions = (TF1 )f->Get("fitPions");
	441	TF1 fitKaons = (TF1 )f->Get("fitKaons");
	442	TF1 fitProtons = (TF1 )f->Get("fitProtons");
e4358d7f	443	taskProtons->SetPriorProbabilityFunctions(fitElectrons,
	444	fitMuons,
	445	fitPions,
	446	fitKaons,
	447	fitProtons);*/
	448	mgr->AddTask(taskProtons);
734d2c12	449
734d2c12	450	// Create containers for input/output
e4358d7f	451	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
251e4034	452	TChain::Class(),
251e4034	453	AliAnalysisManager::kInputContainer);
e4358d7f	454	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
251e4034	455	TList::Class(),
251e4034	456	AliAnalysisManager::kOutputContainer,
df01f00b	457	outputFilename.Data());
df01f00b	458
734d2c12	459	//____________________________________________//
e4358d7f	460	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	461	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	462	if (!mgr->InitAnalysis()) return;
734d2c12	463	mgr->PrintStatus();
e4358d7f	464
	465	if(dataset)
	466	mgr->StartAnalysis("proof",dataset,stats);
	467	else {
	468	// You should get this macro and the txt file from:
	469	// http://aliceinfo.cern.ch/Offline/Analysis/CAF/
	470	gROOT->LoadMacro("CreateESDChain.C");
	471	TChain* chain = 0x0;
	472	chain = CreateESDChain("ESD82XX_30K.txt",stats);
	473	chain->SetBranchStatus("Calo",0);
	474
	475	mgr->StartAnalysis("proof",chain);
	476	}
734d2c12	477
	478	timer.Stop();
	479	timer.Print();
	480	}
	481
	482	//_________________________________________________//
	483	Int_t setupPar(const char* pararchivename) {
	484	///////////////////
	485	// Setup PAR File//
	486	///////////////////
	487	if (pararchivename) {
	488	char processline[1024];
	489	sprintf(processline,".! tar xvzf %s.par",pararchivename);
	490	gROOT->ProcessLine(processline);
	491	const char* ocwd = gSystem->WorkingDirectory();
	492	gSystem->ChangeDirectory(pararchivename);
	493
	494	// check for BUILD.sh and execute
	495	if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
	496	printf("*******************************\n");
	497	printf("* Building PAR archive *\n");
	498	printf("*******************************\n");
	499
	500	if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
	501	Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
	502	return -1;
	503	}
	504	}
	505	// check for SETUP.C and execute
	506	if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
	507	printf("*******************************\n");
	508	printf("* Setup PAR archive *\n");
	509	printf("*******************************\n");
	510	gROOT->Macro("PROOF-INF/SETUP.C");
	511	}
	512
	513	gSystem->ChangeDirectory("../");
	514	}
	515	return 1;
	516	}