PWG2/runProtonAnalysis.C

   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"
  15   TStopwatch timer;
  16   timer.Start();
  17
  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);
  25
  26   timer.Stop();
  27   timer.Print();
  28 }
  29
  30 //_________________________________________________//
  31 void runLocal(const char* mode = "ESD",
  32               const char* analysisType = 0x0,
  33               const char* path = "/home/pchrist/ALICE/Alien/Tutorial/November2007/Tags") {
  34   TStopwatch timer;
  35   timer.Start();
  36
  37   TString smode = mode;
  38   TString outputFilename = "Protons."; outputFilename += mode;
  39   if(analysisType) {
  40     outputFilename += "."; outputFilename += analysisType;
  41   }
  42   outputFilename += ".root";
  43
  44   //____________________________________________________//
  45   //_____________Setting up the par files_______________//
  46   //____________________________________________________//
  47   setupPar("STEERBase");
  48   gSystem->Load("libSTEERBase.so");
  49   setupPar("ESD");
  50   gSystem->Load("libVMC.so");
  51   gSystem->Load("libESD.so");
  52   setupPar("AOD");
  53   gSystem->Load("libAOD.so");
  54   setupPar("ANALYSIS");
  55   gSystem->Load("libANALYSIS.so");
  56   setupPar("ANALYSISalice");
  57   gSystem->Load("libANALYSISalice.so");
  58   setupPar->UploadPackage("CORRFW.par");
  59   gSystem->EnablePackage("CORRFW");
  60   setupPar("PWG2spectra");
  61   gSystem->Load("libPWG2spectra.so");
  62   //____________________________________________________//
  63
  64   //____________________________________________//
  65   AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
  66   tagAnalysis->ChainLocalTags(path);
  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;
  74   chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
  75   chain->SetBranchStatus("*Calo*",0);
  76
  77   //____________________________________________//
  78   gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
  79   //____________________________________________//
  80   // Make the analysis manager
  81   AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
  82   AliVEventHandler* esdH = new AliESDInputHandler;
  83   mgr->SetInputEventHandler(esdH);
  84   if(smode == "MC") {
  85     AliMCEventHandler *mc = new AliMCEventHandler();
  86     mgr->SetMCtruthEventHandler(mc);
  87   }
  88
  89   //____________________________________________//
  90   // 1st Proton task
  91   AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
  92   taskProtons->SetType(mode);
  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   }
 107   taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
 108   //Momentum dependent priors
 109   /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
 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");
 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",
 124                                                            TChain::Class(),
 125                                                            AliAnalysisManager::kInputContainer);
 126   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
 127                                                             TList::Class(),
 128                                                             AliAnalysisManager::kOutputCont
 129                                                             outputFilename.Data());
 130
 131   //____________________________________________//
 132   mgr->ConnectInput(taskProtons,0,cinput1);
 133   mgr->ConnectOutput(taskProtons,0,coutput1);
 134   if (!mgr->InitAnalysis()) return;
 135   mgr->PrintStatus();
 136   mgr->StartAnalysis("local",chain);
 137
 138   timer.Stop();
 139   timer.Print();
 140 }
 141
 142 //_________________________________________________//
 143 void runInteractive(const char* mode = "ESD",
 144                     const char* analysisType = 0x0,
 145                     const char* collectionName = "tag.xml") {
 146   TStopwatch timer;
 147   timer.Start();
 148   gSystem->Load("libProofPlayer.so");
 149
 150   TString smode = mode;
 151   TString outputFilename = "Protons."; outputFilename += mode;
 152   if(analysisType) {
 153     outputFilename += "."; outputFilename += analysisType;
 154   }
 155   outputFilename += ".root";
 156
 157   printf("*** Connect to AliEn ***\n");
 158   TGrid::Connect("alien://");
 159
 160   //____________________________________________________//
 161   //_____________Setting up the par files_______________//
 162   //____________________________________________________//
 163   setupPar("STEERBase");
 164   gSystem->Load("libSTEERBase.so");
 165   setupPar("ESD");
 166   gSystem->Load("libVMC.so");
 167   gSystem->Load("libESD.so");
 168   setupPar("AOD");
 169   gSystem->Load("libAOD.so");
 170   setupPar("ANALYSIS");
 171   gSystem->Load("libANALYSIS.so");
 172   setupPar("ANALYSISalice");
 173   gSystem->Load("libANALYSISalice.so");
 174   setupPar->UploadPackage("CORRFW.par");
 175   gSystem->EnablePackage("CORRFW");
 176   setupPar("PWG2spectra");
 177   gSystem->Load("libPWG2spectra.so");
 178   //____________________________________________________//
 179
 180   //____________________________________________//
 181   AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
 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
 189   TAlienCollection* coll = TAlienCollection::Open(collectionName);
 190   TGridResult* TagResult = coll->GetGridResult("",0,0);
 191   tagAnalysis->ChainGridTags(TagResult);
 192   TChain* chain = 0x0;
 193   chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
 194   chain->SetBranchStatus("*Calo*",0);
 195
 196   //____________________________________________//
 197   gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
 198   //____________________________________________//
 199   // Make the analysis manager
 200   AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
 201   AliVEventHandler* esdH = new AliESDInputHandler;
 202   mgr->SetInputEventHandler(esdH);
 203   if(smode == "MC") {
 204     AliMCEventHandler *mc = new AliMCEventHandler();
 205     mgr->SetMCtruthEventHandler(mc);
 206   }
 207
 208   //____________________________________________//
 209   // 1st Proton task
 210   AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
 211   taskProtons->SetType(mode);
 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   }
 226   taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
 227   //Momentum dependent priors
 228   /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
 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");
 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",
 243                                                            TChain::Class(),
 244                                                            AliAnalysisManager::kInputContainer);
 245   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
 246                                                             TList::Class(),
 247                                                             AliAnalysisManager::kOutputCont
 248                                                             outputFilename.Data());
 249
 250   //____________________________________________//
 251   mgr->ConnectInput(taskProtons,0,cinput1);
 252   mgr->ConnectOutput(taskProtons,0,coutput1);
 253   if (!mgr->InitAnalysis()) return;
 254   mgr->PrintStatus();
 255   mgr->StartAnalysis("local",chain);
 256
 257   timer.Stop();
 258   timer.Print();
 259 }
 260
 261 //_________________________________________________//
 262 void runBatch(const char* mode = "ESD",
 263               const char* analysisType = 0x0,
 264               const char *collectionfile = "wn.xml") {
 265   TStopwatch timer;
 266   timer.Start();
 267
 268   TString smode = mode;
 269   TString outputFilename = "Protons."; outputFilename += mode;
 270   if(analysisType) {
 271     outputFilename += "."; outputFilename += analysisType;
 272   }
 273   outputFilename += ".root";
 274
 275   printf("*** Connect to AliEn ***\n");
 276   TGrid::Connect("alien://");
 277   gSystem->Load("libProofPlayer.so");
 278
 279   //____________________________________________________//
 280   //_____________Setting up the par files_______________//
 281   //____________________________________________________//
 282   setupPar("STEERBase");
 283   gSystem->Load("libSTEERBase.so");
 284   setupPar("ESD");
 285   gSystem->Load("libVMC.so");
 286   gSystem->Load("libESD.so");
 287   setupPar("AOD");
 288   gSystem->Load("libAOD.so");
 289   setupPar("ANALYSIS");
 290   gSystem->Load("libANALYSIS.so");
 291   setupPar("ANALYSISalice");
 292   gSystem->Load("libANALYSISalice.so");
 293   setupPar->UploadPackage("CORRFW.par");
 294   gSystem->EnablePackage("CORRFW");
 295   setupPar("PWG2spectra");
 296   gSystem->Load("libPWG2spectra.so");
 297   //____________________________________________________//
 298
 299   //____________________________________________//
 300   //Usage of event tags
 301   AliTagAnalysis *tagAnalysis = new AliTagAnalysis();
 302   TChain *chain = 0x0;
 303   chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");
 304   chain->SetBranchStatus("*Calo*",0);
 305
 306   //____________________________________________//
 307   gROOT->LoadMacro("AliAnalysisTaskProtons.cxx++");
 308   //____________________________________________//
 309   // Make the analysis manager
 310   AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
 311   AliVEventHandler* esdH = new AliESDInputHandler;
 312   mgr->SetInputEventHandler(esdH);
 313   if(smode == "MC") {
 314     AliMCEventHandler *mc = new AliMCEventHandler();
 315     mgr->SetMCtruthEventHandler(mc);
 316   }
 317
 318   //____________________________________________//
 319   // 1st Proton task
 320   AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
 321   taskProtons->SetType(mode);
 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   }
 336   taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
 337   //Momentum dependent priors
 338   /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
 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");
 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
 356                                                             outputFilename.Data());
 357
 358   //____________________________________________//
 359   mgr->ConnectInput(taskProtons,0,cinput1);
 360   mgr->ConnectOutput(taskProtons,0,coutput1);
 361   if (!mgr->InitAnalysis()) return;
 362   mgr->PrintStatus();
 363   mgr->StartAnalysis("grid",chain);
 364
 365   timer.Stop();
 366   timer.Print();
 367 }
 368
 369 //_________________________________________________//
 370 void runProof(const char* mode = "ESD",
 371               Int_t stats = 0,
 372               const char* dataset = 0x0,
 373               const char* analysisType = 0x0) {
 374   TStopwatch timer;
 375   timer.Start();
 376
 377   TString smode = mode;
 378   TString outputFilename = "Protons."; outputFilename += mode;
 379   if(analysisType) {
 380     outputFilename += "."; outputFilename += analysisType;
 381   }
 382   outputFilename += ".root";
 383
 384   printf("****** Connect to PROOF *******\n");
 385   TProof::Open("alicecaf.cern.ch");
 386   gProof->SetParallel();
 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");
 397   gProof->UploadPackage("ANALYSISalice.par");
 398   gProof->EnablePackage("ANALYSISalice");
 399   gProof->UploadPackage("CORRFW.par");
 400   gProof->EnablePackage("CORRFW");
 401   gProof->UploadPackage("PWG2spectra.par");
 402   gProof->EnablePackage("PWG2spectra");
 403
 404   //____________________________________________//
 405   gProof->Load("AliAnalysisTaskProtons.cxx++");
 406   //____________________________________________//
 407
 408   //____________________________________________//
 409   // Make the analysis manager
 410   AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
 411   AliVEventHandler* esdH = new AliESDInputHandler;
 412   mgr->SetInputEventHandler(esdH);
 413   if(smode == "MC") {
 414     AliMCEventHandler *mc = new AliMCEventHandler();
 415     mgr->SetMCtruthEventHandler(mc);
 416   }
 417   //____________________________________________//
 418   // 1st Proton task
 419   AliAnalysisTaskProtons *taskProtons = new AliAnalysisTaskProtons("TaskProtons");
 420   taskProtons->SetType(mode);
 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   }
 435   taskProtons->SetAcceptedVertexDiamond(5.,5.,15.);
 436   //Momentum dependent priors
 437   /*TFile *f = TFile::Open("PriorProb/PriorProbabilities.root ");
 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");
 443   taskProtons->SetPriorProbabilityFunctions(fitElectrons,
 444                                             fitMuons,
 445                                             fitPions,
 446                                             fitKaons,
 447                                             fitProtons);*/
 448   mgr->AddTask(taskProtons);
 449
 450   // Create containers for input/output
 451   AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 452                                                            TChain::Class(),
 453                                                            AliAnalysisManager::kInputContainer);
 454   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("outputList1",
 455                                                             TList::Class(),
 456                                                             AliAnalysisManager::kOutputContainer,
 457                                                             outputFilename.Data());
 458
 459   //____________________________________________//
 460   mgr->ConnectInput(taskProtons,0,cinput1);
 461   mgr->ConnectOutput(taskProtons,0,coutput1);
 462   if (!mgr->InitAnalysis()) return;
 463   mgr->PrintStatus();
 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   }
 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 }