[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->GetCommonInputContainer();
  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->GetCommonInputContainer();
  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->GetCommonInputContainer();
  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->GetCommonInputContainer();
  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
8a546c82	123	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
e4358d7f	124	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
251e4034	125	TList::Class(),
251e4034	126	AliAnalysisManager::kOutputCont
da8c4c1c	127	outputFilename.Data());
734d2c12	128
734d2c12	129	//____________________________________________//
e4358d7f	130	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	131	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	132	if (!mgr->InitAnalysis()) return;
	133	mgr->PrintStatus();
	134	mgr->StartAnalysis("local",chain);
	135
	136	timer.Stop();
	137	timer.Print();
	138	}
	139
	140	//_________________________________________________//
da8c4c1c	141	void runInteractive(const char* mode = "ESD",
	142	const char* analysisType = 0x0,
	143	const char* collectionName = "tag.xml") {
734d2c12	144	TStopwatch timer;
	145	timer.Start();
	146	gSystem->Load("libProofPlayer.so");
	147
da8c4c1c	148	TString smode = mode;
	149	TString outputFilename = "Protons."; outputFilename += mode;
	150	if(analysisType) {
	151	outputFilename += "."; outputFilename += analysisType;
	152	}
	153	outputFilename += ".root";
	154
734d2c12	155	printf("* Connect to AliEn *\n");
	156	TGrid::Connect("alien://");
	157
	158	//____________________________________________________//
da8c4c1c	159	//_____________Setting up the par files_______________//
734d2c12	160	//____________________________________________________//
	161	setupPar("STEERBase");
	162	gSystem->Load("libSTEERBase.so");
734d2c12	163	setupPar("ESD");
	164	gSystem->Load("libVMC.so");
	165	gSystem->Load("libESD.so");
734d2c12	166	setupPar("AOD");
734d2c12	167	gSystem->Load("libAOD.so");
734d2c12	168	setupPar("ANALYSIS");
734d2c12	169	gSystem->Load("libANALYSIS.so");
e4358d7f	170	setupPar("ANALYSISalice");
e4358d7f	171	gSystem->Load("libANALYSISalice.so");
96f84c25	172	setupPar->UploadPackage("CORRFW.par");
96f84c25	173	gSystem->EnablePackage("CORRFW");
734d2c12	174	setupPar("PWG2spectra");
734d2c12	175	gSystem->Load("libPWG2spectra.so");
da8c4c1c	176	//____________________________________________________//
734d2c12	177
734d2c12	178	//____________________________________________//
e4358d7f	179	AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
734d2c12	180
	181	AliRunTagCuts *runCuts = new AliRunTagCuts();
	182	AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
	183	AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
	184	AliEventTagCuts *evCuts = new AliEventTagCuts();
	185
	186	//grid tags
da8c4c1c	187	TAlienCollection* coll = TAlienCollection::Open(collectionName);
734d2c12	188	TGridResult* TagResult = coll->GetGridResult("",0,0);
e4358d7f	189	tagAnalysis->ChainGridTags(TagResult);
734d2c12	190	TChain* chain = 0x0;
e4358d7f	191	chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
734d2c12	192	chain->SetBranchStatus("Calo",0);
da8c4c1c	193
	194	//____________________________________________//
	195	gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
734d2c12	196	//____________________________________________//
	197	// Make the analysis manager
	198	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	199	AliVEventHandler* esdH = new AliESDInputHandler;
	200	mgr->SetInputEventHandler(esdH);
6667f3a7	201	if(smode == "MC") {
	202	AliMCEventHandler *mc = new AliMCEventHandler();
	203	mgr->SetMCtruthEventHandler(mc);
	204	}
	205
734d2c12	206	//____________________________________________//
734d2c12	207	// 1st Proton task
e4358d7f	208	AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
6667f3a7	209	taskProtons->SetType(mode);
da8c4c1c	210	taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
	211	switch(analysisType) {
	212	case "TPC":
	213	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
	214	break;
	215	case "Hybrid":
	216	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
	217	break;
	218	case "Global":
	219	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
	220	break;
	221	default:
	222	break;
	223	}
6667f3a7	224	taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
6667f3a7	225	//Momentum dependent priors
e4358d7f	226	/TFile f = TFile::Open("PriorProb/PriorProbabilities.root ");
aafecd8b	227	TF1 fitElectrons = (TF1 )f->Get("fitElectrons");
	228	TF1 fitMuons = (TF1 )f->Get("fitMuons");
	229	TF1 fitPions = (TF1 )f->Get("fitPions");
	230	TF1 fitKaons = (TF1 )f->Get("fitKaons");
	231	TF1 fitProtons = (TF1 )f->Get("fitProtons");
e4358d7f	232	taskProtons->SetPriorProbabilityFunctions(fitElectrons,
	233	fitMuons,
	234	fitPions,
	235	fitKaons,
	236	fitProtons);*/
	237	mgr->AddTask(taskProtons);
	238
	239	// Create containers for input/output
8a546c82	240	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
e4358d7f	241	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
251e4034	242	TList::Class(),
251e4034	243	AliAnalysisManager::kOutputCont
da8c4c1c	244	outputFilename.Data());
734d2c12	245
734d2c12	246	//____________________________________________//
e4358d7f	247	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	248	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	249	if (!mgr->InitAnalysis()) return;
	250	mgr->PrintStatus();
	251	mgr->StartAnalysis("local",chain);
	252
	253	timer.Stop();
	254	timer.Print();
	255	}
	256
	257	//_________________________________________________//
da8c4c1c	258	void runBatch(const char* mode = "ESD",
	259	const char* analysisType = 0x0,
	260	const char *collectionfile = "wn.xml") {
734d2c12	261	TStopwatch timer;
	262	timer.Start();
	263
da8c4c1c	264	TString smode = mode;
	265	TString outputFilename = "Protons."; outputFilename += mode;
	266	if(analysisType) {
	267	outputFilename += "."; outputFilename += analysisType;
	268	}
	269	outputFilename += ".root";
	270
734d2c12	271	printf("* Connect to AliEn *\n");
	272	TGrid::Connect("alien://");
	273	gSystem->Load("libProofPlayer.so");
	274
	275	//____________________________________________________//
da8c4c1c	276	//_____________Setting up the par files_______________//
734d2c12	277	//____________________________________________________//
	278	setupPar("STEERBase");
	279	gSystem->Load("libSTEERBase.so");
734d2c12	280	setupPar("ESD");
	281	gSystem->Load("libVMC.so");
	282	gSystem->Load("libESD.so");
734d2c12	283	setupPar("AOD");
734d2c12	284	gSystem->Load("libAOD.so");
734d2c12	285	setupPar("ANALYSIS");
734d2c12	286	gSystem->Load("libANALYSIS.so");
e4358d7f	287	setupPar("ANALYSISalice");
e4358d7f	288	gSystem->Load("libANALYSISalice.so");
96f84c25	289	setupPar->UploadPackage("CORRFW.par");
96f84c25	290	gSystem->EnablePackage("CORRFW");
734d2c12	291	setupPar("PWG2spectra");
734d2c12	292	gSystem->Load("libPWG2spectra.so");
da8c4c1c	293	//____________________________________________________//
734d2c12	294
	295	//____________________________________________//
	296	//Usage of event tags
e4358d7f	297	AliTagAnalysis *tagAnalysis = new AliTagAnalysis();
734d2c12	298	TChain *chain = 0x0;
e4358d7f	299	chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");
734d2c12	300	chain->SetBranchStatus("Calo",0);
734d2c12	301
da8c4c1c	302	//____________________________________________//
da8c4c1c	303	gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
734d2c12	304	//____________________________________________//
	305	// Make the analysis manager
	306	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	307	AliVEventHandler* esdH = new AliESDInputHandler;
	308	mgr->SetInputEventHandler(esdH);
6667f3a7	309	if(smode == "MC") {
	310	AliMCEventHandler *mc = new AliMCEventHandler();
	311	mgr->SetMCtruthEventHandler(mc);
	312	}
	313
734d2c12	314	//____________________________________________//
734d2c12	315	// 1st Proton task
e4358d7f	316	AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
6667f3a7	317	taskProtons->SetType(mode);
da8c4c1c	318	taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
	319	switch(analysisType) {
	320	case "TPC":
	321	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
	322	break;
	323	case "Hybrid":
	324	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
	325	break;
	326	case "Global":
	327	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
	328	break;
	329	default:
	330	break;
	331	}
6667f3a7	332	taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
6667f3a7	333	//Momentum dependent priors
e4358d7f	334	/TFile f = TFile::Open("PriorProb/PriorProbabilities.root ");
aafecd8b	335	TF1 fitElectrons = (TF1 )f->Get("fitElectrons");
	336	TF1 fitMuons = (TF1 )f->Get("fitMuons");
	337	TF1 fitPions = (TF1 )f->Get("fitPions");
	338	TF1 fitKaons = (TF1 )f->Get("fitKaons");
	339	TF1 fitProtons = (TF1 )f->Get("fitProtons");
e4358d7f	340	taskProtons->SetPriorProbabilityFunctions(fitElectrons,
	341	fitMuons,
	342	fitPions,
	343	fitKaons,
	344	fitProtons);*/
	345	mgr->AddTask(taskProtons);
	346
	347	// Create containers for input/output
8a546c82	348	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
e4358d7f	349	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
e4358d7f	350	TList::Class(),AliAnalysisManager::kOutputCont
da8c4c1c	351	outputFilename.Data());
734d2c12	352
734d2c12	353	//____________________________________________//
e4358d7f	354	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	355	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	356	if (!mgr->InitAnalysis()) return;
	357	mgr->PrintStatus();
	358	mgr->StartAnalysis("grid",chain);
	359
	360	timer.Stop();
	361	timer.Print();
	362	}
	363
	364	//_________________________________________________//
da8c4c1c	365	void runProof(const char* mode = "ESD",
251e4034	366	Int_t stats = 0,
da8c4c1c	367	const char* dataset = 0x0,
da8c4c1c	368	const char* analysisType = 0x0) {
734d2c12	369	TStopwatch timer;
734d2c12	370	timer.Start();
df01f00b	371
	372	TString smode = mode;
	373	TString outputFilename = "Protons."; outputFilename += mode;
da8c4c1c	374	if(analysisType) {
	375	outputFilename += "."; outputFilename += analysisType;
	376	}
df01f00b	377	outputFilename += ".root";
df01f00b	378
734d2c12	379	printf("**** Connect to PROOF *****\n");
96f84c25	380	TProof::Open("alicecaf.cern.ch");
aafecd8b	381	gProof->SetParallel();
734d2c12	382
	383	// Enable the Analysis Package
	384	gProof->UploadPackage("STEERBase.par");
	385	gProof->EnablePackage("STEERBase");
	386	gProof->UploadPackage("ESD.par");
	387	gProof->EnablePackage("ESD");
	388	gProof->UploadPackage("AOD.par");
	389	gProof->EnablePackage("AOD");
	390	gProof->UploadPackage("ANALYSIS.par");
	391	gProof->EnablePackage("ANALYSIS");
e4358d7f	392	gProof->UploadPackage("ANALYSISalice.par");
e4358d7f	393	gProof->EnablePackage("ANALYSISalice");
251e4034	394	gProof->UploadPackage("CORRFW.par");
251e4034	395	gProof->EnablePackage("CORRFW");
734d2c12	396	gProof->UploadPackage("PWG2spectra.par");
	397	gProof->EnablePackage("PWG2spectra");
	398
da8c4c1c	399	//____________________________________________//
734d2c12	400	gProof->Load("AliAnalysisTaskProtons.cxx++");
da8c4c1c	401	//____________________________________________//
734d2c12	402
e4358d7f	403	//____________________________________________//
734d2c12	404	// Make the analysis manager
	405	AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
	406	AliVEventHandler* esdH = new AliESDInputHandler;
df01f00b	407	mgr->SetInputEventHandler(esdH);
	408	if(smode == "MC") {
	409	AliMCEventHandler *mc = new AliMCEventHandler();
	410	mgr->SetMCtruthEventHandler(mc);
	411	}
734d2c12	412	//____________________________________________//
734d2c12	413	// 1st Proton task
e4358d7f	414	AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
df01f00b	415	taskProtons->SetType(mode);
da8c4c1c	416	taskProtons->SetTriggerMode(AliAnalysisTaskProtons::kMB2);
	417	switch(analysisType) {
	418	case "TPC":
	419	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kTPC);
	420	break;
	421	case "Hybrid":
	422	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kHybrid);
	423	break;
	424	case "Global":
	425	taskProtons->SetAnalysisMode(AliAnalysisTaskProtons::kGlobal);
	426	break;
	427	default:
	428	break;
	429	}
6667f3a7	430	taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
6667f3a7	431	//Momentum dependent priors
e4358d7f	432	/TFile f = TFile::Open("PriorProb/PriorProbabilities.root ");
aafecd8b	433	TF1 fitElectrons = (TF1 )f->Get("fitElectrons");
	434	TF1 fitMuons = (TF1 )f->Get("fitMuons");
	435	TF1 fitPions = (TF1 )f->Get("fitPions");
	436	TF1 fitKaons = (TF1 )f->Get("fitKaons");
	437	TF1 fitProtons = (TF1 )f->Get("fitProtons");
e4358d7f	438	taskProtons->SetPriorProbabilityFunctions(fitElectrons,
	439	fitMuons,
	440	fitPions,
	441	fitKaons,
	442	fitProtons);*/
	443	mgr->AddTask(taskProtons);
734d2c12	444
734d2c12	445	// Create containers for input/output
8a546c82	446	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
e4358d7f	447	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
251e4034	448	TList::Class(),
251e4034	449	AliAnalysisManager::kOutputContainer,
df01f00b	450	outputFilename.Data());
df01f00b	451
734d2c12	452	//____________________________________________//
e4358d7f	453	mgr->ConnectInput(taskProtons,0,cinput1);
e4358d7f	454	mgr->ConnectOutput(taskProtons,0,coutput1);
734d2c12	455	if (!mgr->InitAnalysis()) return;
734d2c12	456	mgr->PrintStatus();
e4358d7f	457
	458	if(dataset)
	459	mgr->StartAnalysis("proof",dataset,stats);
	460	else {
	461	// You should get this macro and the txt file from:
	462	// http://aliceinfo.cern.ch/Offline/Analysis/CAF/
	463	gROOT->LoadMacro("CreateESDChain.C");
	464	TChain* chain = 0x0;
	465	chain = CreateESDChain("ESD82XX_30K.txt",stats);
	466	chain->SetBranchStatus("Calo",0);
	467
	468	mgr->StartAnalysis("proof",chain);
	469	}
734d2c12	470
	471	timer.Stop();
	472	timer.Print();
	473	}
	474
	475	//_________________________________________________//
	476	Int_t setupPar(const char* pararchivename) {
	477	///////////////////
	478	// Setup PAR File//
	479	///////////////////
	480	if (pararchivename) {
	481	char processline[1024];
	482	sprintf(processline,".! tar xvzf %s.par",pararchivename);
	483	gROOT->ProcessLine(processline);
	484	const char* ocwd = gSystem->WorkingDirectory();
	485	gSystem->ChangeDirectory(pararchivename);
	486
	487	// check for BUILD.sh and execute
	488	if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
	489	printf("*******************************\n");
	490	printf("* Building PAR archive *\n");
	491	printf("*******************************\n");
	492
	493	if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
	494	Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
	495	return -1;
	496	}
	497	}
	498	// check for SETUP.C and execute
	499	if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
	500	printf("*******************************\n");
	501	printf("* Setup PAR archive *\n");
	502	printf("*******************************\n");
	503	gROOT->Macro("PROOF-INF/SETUP.C");
	504	}
	505
	506	gSystem->ChangeDirectory("../");
	507	}
	508	return 1;
	509	}