PWG/muon/runMuMu.C

   1 ///
   2 /// Example macro to run the AliAnalysisTaskMuMu task
   3 ///
   4 /// \author L. Aphecetche
   5 ///
   6
   7 //______________________________________________________________________________
   8 void LoadLocalLibs(Bool_t localAnalysis=kTRUE)
   9 {
  10   gSystem->Load("libVMC");
  11   gSystem->Load("libMinuit");
  12   gSystem->Load("libTree");
  13   gSystem->Load("libProofPlayer");
  14   gSystem->Load("libXMLParser");
  15   gSystem->Load("libSTEERBase");
  16   gSystem->Load("libESD");
  17   gSystem->Load("libAOD");
  18   gSystem->Load("libANALYSIS");
  19   gSystem->Load("libANALYSISalice");
  20
  21   if (!localAnalysis)
  22   {
  23     gSystem->Load("libCORRFW");
  24   }
  25   else
  26   {
  27         gROOT->LoadMacro("AliOADBMuonTrackCutsParam.cxx+g");
  28         gROOT->LoadMacro("AliAnalysisMuonUtility.cxx+g");
  29         gROOT->LoadMacro("AliMuonTrackCuts.cxx+g");
  30         gROOT->LoadMacro("AliMergeableCollection.cxx+g");
  31         gROOT->LoadMacro("AliAnalysisMuMuBinning.cxx+g");
  32         gROOT->LoadMacro("AliMuonEventCuts.cxx+g");
  33
  34     gROOT->LoadMacro("AliAnalysisMuMuCutElement.cxx+g");
  35     gROOT->LoadMacro("AliAnalysisMuMuCutCombination.cxx+g");
  36     gROOT->LoadMacro("AliAnalysisMuMuCutRegistry.cxx+g");
  37     gROOT->LoadMacro("AliAnalysisMuMuEventCutter.cxx+g");
  38     gROOT->LoadMacro("AliAnalysisMuMuBase.cxx+g");
  39
  40     gROOT->LoadMacro("AliAnalysisTaskMuMu.cxx+g");
  41
  42     gROOT->LoadMacro("AliAnalysisMuMuGlobal.cxx+g");
  43
  44     gROOT->LoadMacro("AliAnalysisMuMuMinv.cxx+g");
  45     gROOT->LoadMacro("AliAnalysisMuMuSingle.cxx+g");
  46     gROOT->LoadMacro("AliAnalysisMuMuNch.cxx+g");
  47
  48   }
  49 }
  50
  51 //______________________________________________________________________________
  52 TChain* CreateLocalChain(const char* filelist)
  53 {
  54         TChain* c = new TChain("aodTree");
  55
  56         char line[1024];
  57
  58         ifstream in(filelist);
  59         while ( in.getline(line,1024,'\n') )
  60         {
  61                 c->Add(line);
  62         }
  63         return c;
  64 }
  65
  66 //______________________________________________________________________________
  67 TString GetInputType(const TString& sds, TProof* p)
  68 {
  69    if (sds.Length()==0 ) return "AOD";
  70
  71    if (sds.Contains("SIM_JPSI")) return "AOD";
  72
  73    if (sds.Contains("AOD")) return "AOD";
  74    if (sds.Contains("ESD")) return "ESD";
  75
  76    if ( gSystem->AccessPathName(gSystem->ExpandPathName(sds.Data())) )
  77    {
  78         // dataset is not a local file so it must be a dataset name
  79         if (!p) return "NOPROOF";
  80
  81         TFileCollection* fc = p->GetDataSet(sds.Data());
  82     if (!fc) return "NODATASET";
  83
  84     TIter next(fc->GetList());
  85     TFileInfo* fi;
  86     while ( ( fi = static_cast<TFileInfo*>(next()) ) )
  87     {
  88       TUrl url(*(fi->GetFirstUrl()));
  89           TString surl(url.GetUrl());
  90
  91           if (surl.Contains("AOD")) return "AOD";
  92           if (surl.Contains("AliESD")) return "ESD";
  93     }
  94
  95    }
  96    else
  97    {
  98    std::cout << "Will use datasets from file " << sds.Data() << std::endl;
  99
 100    // dataset is a local text file containing a list of dataset names
 101         std::ifstream in(sds.Data());
 102         char line[1014];
 103
 104         while (in.getline(line,1023,'\n'))
 105         {
 106           TString sline(line);
 107         sline.ToUpper();
 108         if ( sline.Contains("SIM_JPSI") ) return "AOD";
 109         if ( sline.Contains("AOD") ) return "AOD";
 110         if ( sline.Contains("ESD") ) return "ESD";
 111         }
 112    }
 113
 114    return "BUG";
 115 }
 116
 117 //______________________________________________________________________________
 118 AliAnalysisTask* runMuMu(const char* dataset="SIM_JPSI_LHC13f_CynthiaTuneWithRejectList_000197388",
 119                          Bool_t simulations=kTRUE,
 120                          Bool_t baseline=kFALSE,
 121                          const char* where="laphecet@nansafmaster.in2p3.fr/?N")
 122 {
 123   // Create the analysis manager
 124
 125   Bool_t prooflite = (strlen(where)==0) || TString(where).Contains("workers");
 126
 127   TString sds(dataset);
 128
 129 //  if (!prooflite && sds.Length()>0) TProof::Mgr(where)->SetROOTVersion("VO_ALICE@ROOT::v5-34-05");
 130
 131   TProof* p(0x0);
 132   TString alirootMode("");
 133   TString workers("workers=8x");
 134
 135   if (TString(where).Contains("alice-caf"))
 136   {
 137     workers="workers=1x";
 138   }
 139   if (TString(where).Contains("localhost:2093"))
 140   {
 141     workers="workers=8x";
 142   }
 143
 144   if (prooflite)
 145   {
 146     cout << "Will work in LITE mode" << endl;
 147   }
 148
 149   if ( sds.Length()>0 )
 150   {
 151     p = TProof::Open(where,workers.Data());
 152
 153     if (!p)
 154     {
 155       cout << "Cannot connect to Proof : " << where << endl;
 156       return 0;
 157     }
 158
 159     alirootMode.ToUpper();
 160
 161     if ( alirootMode == "PAR" )
 162     {
 163       cout << "Will work with PAR files" << endl;
 164
 165       std::vector<std::string> pars;
 166
 167       pars.push_back("STEERBase");
 168       pars.push_back("ESD");
 169       pars.push_back("AOD");
 170       pars.push_back("ANALYSIS");
 171       pars.push_back("OADB");
 172       pars.push_back("ANALYSISalice");
 173       //       pars.push_back("CORRFW");
 174       //       pars.push_back("PWGmuon");
 175
 176       Bool_t ok(kTRUE);
 177
 178       for ( std::vector<std::string>::size_type i = 0; i < pars.size(); ++i )
 179       {
 180         std::string package = pars[i];
 181
 182         if ( gProof->UploadPackage(package.c_str()) )
 183         {
 184           ok = kFALSE;
 185         }
 186
 187         if ( gProof->EnablePackage(package.c_str(),"",kTRUE) )
 188         {
 189           ok = kFALSE;
 190         }
 191
 192         if (!ok)
 193         {
 194           cout << "Problem with PAR " << package.c_str() << endl;
 195           return 0;
 196         }
 197       }
 198     }
 199     else
 200     {
 201       TList* list = new TList();
 202
 203       //       list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "PWG3base"));
 204       //       list->Add(new TNamed("ALIROOT_EXTRA_INCLUDES", "PWG3"));
 205       //       list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "PWG3base"));//:CORRFW:PWG3muon"));
 206       //       list->Add(new TNamed("ALIROOT_EXTRA_INCLUDES", "PWG3/base"));//:PWG3/muon"));
 207
 208       //    list->Add(new TNamed("ALIROOT_ENABLE_ALIEN", "1"));
 209
 210       if (!alirootMode.IsNull())
 211       {
 212         list->Add(new TNamed("ALIROOT_MODE", alirootMode.Data()));
 213       }
 214       else
 215       {
 216         list->Add(new TNamed("ALIROOT_MODE",""));
 217       }
 218
 219       if (!prooflite)
 220       {
 221 //        p->SetParameter("PROOF_UseTreeCache", 0);
 222         p->EnablePackage("VO_ALICE@AliRoot::v5-04-65-AN", list, kTRUE);
 223       }
 224       else
 225       {
 226         //      list->Add(new TNamed("ALIROOT_LOCAL_PATH",gSystem->Getenv("ALICE_ROOT")));
 227         p->UploadPackage("$ALICE_ROOT/ANALYSIS/macros/AliRootProofLite.par");
 228         if (p->EnablePackage("AliRootProofLite",list)) return 0;
 229       }
 230     }
 231
 232     // compile task on workers
 233     if ( alirootMode != "PAR" )
 234     {
 235       p->Load("AliOADBMuonTrackCutsParam.cxx+");
 236       p->Load("AliAnalysisMuonUtility.cxx+");
 237       p->Load("AliMuonTrackCuts.cxx+");
 238       p->Load("AliMergeableCollection.cxx+");
 239       p->Load("AliAnalysisMuMuBinning.cxx+");
 240       p->Load("AliMuonEventCuts.cxx+");
 241        p->Load("AliAnalysisMuMuCutElement.cxx+");
 242        p->Load("AliAnalysisMuMuCutCombination.cxx+");
 243        p->Load("AliAnalysisMuMuCutRegistry.cxx+");
 244       p->Load("AliAnalysisMuMuBase.cxx+");
 245       p->Load("AliAnalysisTaskMuMu.cxx+");
 246        p->Load("AliAnalysisMuMuEventCutter.cxx+");
 247      p->Load("AliAnalysisMuMuGlobal.cxx+");
 248      p->Load("AliAnalysisMuMuNch.cxx+");
 249      p->Load("AliAnalysisMuMuSingle.cxx+");
 250      p->Load("AliAnalysisMuMuMinv.cxx+");
 251         }
 252   }
 253
 254   LoadLocalLibs(kTRUE);
 255
 256   AliAnalysisManager *mgr = new AliAnalysisManager("MuMu");
 257
 258   AliInputEventHandler* input(0x0);
 259
 260   TString inputType = GetInputType(sds,p);
 261
 262   if ( inputType == "AOD" )
 263   {
 264     input = new AliAODInputHandler;
 265   }
 266   else if ( inputType == "ESD" )
 267   {
 268     input = new AliESDInputHandler;
 269   }
 270   else
 271   {
 272         std::cout << "Cannot get input type !" << std::endl;
 273         return 0;
 274   }
 275
 276   mgr->SetInputEventHandler(input);
 277
 278   TList* triggers = new TList;
 279   triggers->SetOwner(kTRUE);
 280
 281   if (!simulations)
 282   {
 283     triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD"));
 284
 285 //   triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MUL"));
 286 //   triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MSL"));
 287 //   triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MSH"));
 288 //   triggers->Add(new TObjString("CMSL7-B-NOPF-MUON & 0MUL"));
 289 //   triggers->Add(new TObjString("CMSL7-B-NOPF-MUON & 0MSH"));
 290 //
 291 //   triggers->Add(new TObjString("CMSL7-B-NOPF-MUON"));
 292 //   triggers->Add(new TObjString("CMSH7-B-NOPF-MUON"));
 293 //    triggers->Add(new TObjString("CMUL7-B-NOPF-MUON"));
 294
 295   // below for MB periods only
 296 //  triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD"));
 297 //   triggers->Add(new TObjString("CMSH7-B-NOPF-ALLNOTRD"));
 298   triggers->Add(new TObjString("CMUL7-B-NOPF-ALLNOTRD"));
 299   triggers->Add(new TObjString("CMUL7-B-NOPF-MUON"));
 300 //   triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD & 0MUL"));
 301 //   triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD & 0MSH"));
 302   }
 303
 304   TString outputname("test.MuMu.AOD.1.root");
 305
 306   if ( sds.Length()>0 )
 307   {
 308         TString af("local");
 309
 310         if ( gProof )
 311         {
 312           af="unknown";
 313           TString master(gProof->GetSessionTag());
 314       if (master.Contains("lx")) af = "caf";
 315       if (master.Contains("nansaf")) af = "saf";
 316       if (master.Contains("skaf")) af = "skaf";
 317       if (master.Contains("localhost:2093")) af="laf";
 318         }
 319         outputname = Form("%s.%s.root",gSystem->BaseName(sds.Data()),af.Data());
 320     outputname.ReplaceAll("|","-");
 321         cout << outputname << endl;
 322   }
 323
 324   AliAnalysisTask* task(0x0);
 325
 326   if (!baseline)
 327   {
 328         gROOT->LoadMacro("AddTaskMuMu.C");
 329
 330         task = AddTaskMuMu(outputname.Data(),triggers,"pA",simulations);
 331   }
 332   else
 333   {
 334         gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddTaskBaseLine.C");
 335         task = AddTaskBaseLine();
 336   }
 337
 338   if (!mgr->InitAnalysis())
 339   {
 340         cout << "Could not InitAnalysis" << endl;
 341     return 0;
 342   }
 343
 344   if ( sds.Length()>0 )
 345   {
 346     TStopwatch timer;
 347
 348     mgr->StartAnalysis("proof",sds.Data());
 349
 350     timer.Print();
 351   }
 352   else
 353   {
 354     mgr->PrintStatus();
 355
 356         task->Print();
 357
 358 //      return task;
 359
 360     TChain* c = CreateLocalChain("list.aod.txt");
 361 //      mgr->SetNSysInfo(10);
 362     TStopwatch timer;
 363 //    mgr->SetDebugLevel(10);
 364     mgr->StartAnalysis("local",c);
 365     timer.Print();
 366 //    mgr->ProfileTask("AliAnalysisTaskMuMu");
 367 //    if (baseline) mgr->ProfileTask("baseline");
 368   }
 369
 370   AliCodeTimer::Instance()->Print();
 371
 372   if (alirootMode=="PAR")
 373   {
 374     TProofLog *pl = TProof::Mgr(where)->GetSessionLogs(); pl->Save("*","aod.log");
 375   }
 376
 377   delete triggers;
 378
 379   return task;
 380 }
 381