BaseConfig.C

Go to the documentation of this file.

//====================================================================
struct VirtualDetCfg 
{
  virtual Bool_t UseABSO()   const { return true;  }
  virtual Bool_t UseACORDE() const { return false; }
  virtual Bool_t UseDIPO()   const { return true;  }
  virtual Bool_t UseEMCAL()  const { return true;  }
  virtual Bool_t UseFMD()    const { return true;  }
  virtual Bool_t UseFRAME()  const { return true;  }
  virtual Bool_t UseHALL()   const { return true;  }
  virtual Bool_t UseITS()    const { return true;  }
  virtual Bool_t UseMAG()    const { return true;  }
  virtual Bool_t UseMUON()   const { return true;  }
  virtual Bool_t UsePHOS()   const { return true;  }
  virtual Bool_t UsePIPE()   const { return true;  }
  virtual Bool_t UsePMD()    const { return true;  }
  virtual Bool_t UseHMPID()  const { return true;  }
  virtual Bool_t UseSHIL()   const { return true;  }
  virtual Bool_t UseT0()     const { return true;  }
  virtual Bool_t UseTOF()    const { return true;  }
  virtual Bool_t UseTPC()    const { return true;  }
  virtual Bool_t UseTRD()    const { return true;  }
  virtual Bool_t UseVZERO()  const { return true;  }
  virtual Bool_t UseZDC()    const { return true;  }
  virtual void Print() 
  {
    Printf("ABSO:   %3s", UseABSO()    ? "yes" : "no");
    Printf("ACORDE: %3s", UseACORDE()  ? "yes" : "no");
    Printf("DIPO:   %3s", UseDIPO()    ? "yes" : "no");
    Printf("EMCAL:  %3s", UseEMCAL()   ? "yes" : "no");
    Printf("FMD:    %3s", UseFMD()     ? "yes" : "no");
    Printf("FRAME:  %3s", UseFRAME()   ? "yes" : "no");
    Printf("HALL:   %3s", UseHALL()    ? "yes" : "no");
    Printf("ITS:    %3s", UseITS()     ? "yes" : "no");
    Printf("MAG:    %3s", UseMAG()     ? "yes" : "no");
    Printf("MUON:   %3s", UseMUON()    ? "yes" : "no");
    Printf("PHOS:   %3s", UsePHOS()    ? "yes" : "no");
    Printf("PIPE:   %3s", UsePIPE()    ? "yes" : "no");
    Printf("PMD:    %3s", UsePMD()     ? "yes" : "no");
    Printf("HMPID:  %3s", UseHMPID()   ? "yes" : "no");
    Printf("SHIL:   %3s", UseSHIL()    ? "yes" : "no");
    Printf("T0:     %3s", UseT0()      ? "yes" : "no");
    Printf("TOF:    %3s", UseTOF()     ? "yes" : "no");
    Printf("TPC:    %3s", UseTPC()     ? "yes" : "no");
    Printf("TRD:    %3s", UseTRD()     ? "yes" : "no");
    Printf("VZERO:  %3s", UseVZERO()   ? "yes" : "no");
    Printf("ZDC:    %3s", UseZDC()     ? "yes" : "no");
  }
  void GetRecoString(TString& enable) const
  {
    if (UseITS()) Append2Str(enable, "ITS"); 
    if (UseTPC()) Append2Str(enable, "TPC"); 
    if (UseTRD()) Append2Str(enable, "TRD"); 
    if (UseTOF()) Append2Str(enable, "TOF"); 
    if (UsePHOS())  Append2Str(enable, "PHOS"); 
    if (UseHMPID()) Append2Str(enable, "HMPID"); 
    if (UseEMCAL()) Append2Str(enable, "EMCAL"); 
    if (UseMUON())  Append2Str(enable, "MUON"); 
    if (UseFMD()) Append2Str(enable, "FMD"); 
    if (UseZDC()) Append2Str(enable, "ZDC"); 
    if (UsePMD()) Append2Str(enable, "PMD"); 
    if (UseT0())  Append2Str(enable, "T0"); 
    if (UseVZERO()) Append2Str(enable, "VZERO");
  }
  void GetSDigitString(TString& sDigits) const 
  {
    if (UseTRD()) Append2Str(sDigits, "TRD"); 
    if (UseTOF()) Append2Str(sDigits, "TOF"); 
    if (UsePHOS())  Append2Str(sDigits, "PHOS"); 
    if (UseHMPID()) Append2Str(sDigits, "HMPID"); 
    if (UseEMCAL()) Append2Str(sDigits, "EMCAL"); 
    if (UseMUON())  Append2Str(sDigits, "MUON"); 
    if (UseFMD()) Append2Str(sDigits, "FMD"); 
    if (UseZDC()) Append2Str(sDigits, "ZDC"); 
    if (UsePMD()) Append2Str(sDigits, "PMD"); 
    if (UseT0())  Append2Str(sDigits, "T0"); 
    if (UseVZERO()) Append2Str(sDigits, "VZERO");
  }
  void GetHits2DigitsString(TString& fromHits) const
  {
    if (UseITS()) Append2Str(fromHits, "ITS");
    if (UseTPC()) Append2Str(fromHits, "TPC");
  }
  static void Append2Str(TString& str, const char* append)
  {
    if (!str.IsNull()) str.Append(" ");
    str.Append(append);
  }
  virtual const char* GeometrySource() const
  {
    return 0;
  }
};
VirtualDetCfg* detCfg = 0;

//====================================================================
struct VirtualOCDBCfg
{
  virtual const char* Prefix() const { return ""; }
  virtual void Init(Bool_t forSim) 
  {
    ::Fatal("VirtualOCDBConfig", "Dummy init called - redefine!");
  }
  void AddStore(const char*    key, 
    Bool_t         ideal)
  {
    AliCDBManager* cdb = AliCDBManager::Instance();
    const char* prefix = Prefix();
    TString     path   = Form("alien://Folder=/alice/simulation/%s/%s",
            prefix, !ideal ? "Residual" : "Ideal");
    ::Info("AddStore", "%s -> %s", key, path.Data());
    cdb->SetSpecificStorage(key, path);
  }
};

VirtualOCDBCfg* ocdbCfg = 0;

//====================================================================
struct VirtualEGCfg 
{
  TString runType;
  VirtualEGCfg() : runType("") {}
  virtual ~VirtualEGCfg() {}
  virtual Bool_t IsLego() const { return false; }
  static const char* DeduceRunType()
  {
    if      (grp->IsPP())                return "pythia";
    else if (grp->IsPA() || grp->IsAP()) return "dpmjet";
    else if (grp->IsAA())                return "hijing";
    return "hijing";
  }

  static void LoadLibrary(const TString& name,
        const TString& cls="")
  {
    // If we're looking for a specific class, check that first, and
    // if available, do nothing;
    if (!cls.IsNull() && gROOT->GetClass(cls)) return;

    // Now check the list of loaded and linekd libraries 
    TString libs(gSystem->GetLibraries("", "SD"));

    // IF already in the list, do nothing 
    if (libs.Contains(name)) return;

    // Otherwise load the library 
    gSystem->Load(name);
  }
  static void LoadGen(const TString& runType) {
    LoadLibrary("liblhapdf","AliStructFuncType"); // Parton density functions
    LoadLibrary("libEGPythia6","TPythia6");       // TGenerator interface
    if (!runType.EqualTo("hydjet", TString::kIgnoreCase))
      LoadPythia(false);
  }

  static void LoadPythia(Bool_t gen=true, const char* vers="6.4.21")
  {
    if (gen) LoadGen("");
    char m = vers[0];
    if (gROOT->GetClass(Form("AliPythia6%c", m))) return;

    TString v(vers); 
    v.ReplaceAll(".", "_");
    LoadLibrary("libmicrocern");
    LoadLibrary(Form("libpythia%s",v.Data()));
    LoadLibrary(Form("libAliPythia%c", m));
  }
  static void LoadHijing()
  {
    LoadPythia();
    if (gROOT->GetClass("THijing")) return;
    LoadLibrary("libhijing");
    LoadLibrary("libTHijing");
    AliPDG::AddParticlesToPdgDataBase();
  }
  static void LoadHydjet()
  {
    LoadLibrary("libTUHKMgen","TUHKMgen");
  }
  static void LoadEposLHC()
  {
    LoadLibrary("libEPOSLHC","TEposLHC");
  }
  static void LoadEpos()
  {
    LoadLibrary("libEPOS","TEpos");
  }
  static void LoadTherminator()
  {
    LoadLibrary("libTTherminator","TTherminator");
  }
  static void LoadDpmjet()
  {
    LoadPythia();
    if (gROOT->GetClass("TDPMjet")) return;
    LoadLibrary("libdpmjet");
    LoadLibrary("libTDPMjet");
  }
  static void LoadAmpt()
  {
    LoadPythia();
    if (gROOT->GetClass("TAmpt")) return;
    LoadLibrary("libampt");
    LoadLibrary("libTAmpt");
  }
  AliGenerator* MakeGenerator(const TString& rt, 
            Float_t b1, 
            Float_t b2, 
            Bool_t smear=true)
  {
    if (rt.IsNull()) { 
      ::Fatal("MakeGenerator", "No EG spec given");
      return 0;
    }

    TString runType = rt;
    runType.ToLower();

    AliGenerator* g = CreateGenerator(runType,b1,b2);
    if (g && smear) {
      // Origin and sigmaZ will be supplied from OCDB.
      // We need to set the XY smearing though
      // Numbers from Ruben 
      g->SetSigma(0.0025, 0.0029, 0);
      g->SetVertexSmear(AliGenerator::kPerEvent);
    }

    return g;
  }
  TVirtualMCDecayer* MakeDecayer(const TString& rt)
  {
    if (rt.IsNull()) { 
      ::Fatal("MakeGenerator", "No EG spec given");
      return 0;
    }

    TString runType = rt;
    rt.ToLower();

    TVirtualMCDecayer* decayer = CreateDecayer(runType);

    if (decayer) decayer->Init();
    return decayer;
  }
protected:
  virtual AliGenerator* CreateGenerator(const TString& runType, 
          Float_t b1, 
          Float_t b2) = 0;
  virtual TVirtualMCDecayer* CreateDecayer(const TString& runType) = 0;

};
VirtualEGCfg* egCfg = 0;

//====================================================================
struct VirtualTrain 
{


  Bool_t Run(UInt_t      run, 
       const char* xmlFile = "wn.xml", 
       Int_t       stage   = 0, 
       const char* cdb     = "raw://")
  {
    // --- Load configuration script ---------------------------------
    LoadConfig();
    
    // --- Set-up for CDB access through Grid ------------------------
    TString cdbString(cdb);
    if (cdbString.Contains("raw://")) {
      TGrid::Connect("alien://");
      if (!gGrid || !gGrid->IsConnected()) {
  ::Error("Run", "No grid connection");
  return false;
      }  
    }
    
    // --- Some environment variables --------------------------------
    // Temp dir is here, and compilation is here too 
    gSystem->Setenv("TMPDIR", gSystem->pwd());
    gSystem->SetBuildDir(gSystem->pwd(), kTRUE);

    // --- Now load common libraries ---------------------------------
    LoadBaseLibraries();
    
    // --- Now create and configure manager --------------------------
    AliAnalysisManager *mgr  = new AliAnalysisManager(GetName(), 
                  "Production train");
    mgr->SetRunFromPath(grp->run);
    
    // --- Create ESD input handler ------------------------------------
    AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP();
    mgr->SetInputEventHandler(esdHandler);
    if (UseFriends()) {
      esdHandler->SetReadFriends(kTRUE);
      esdHandler->SetActiveBranches("ESDfriend");
    }

    // --- Monte Carlo handler -----------------------------------------
    if (UseMC()) {
      AliMCEventHandler* mcHandler = new AliMCEventHandler();
      mgr->SetMCtruthEventHandler(mcHandler);
      mcHandler->SetPreReadMode(1);
      mcHandler->SetReadTR(true);
    }
    // --- AOD output handler ----------------------------------------
    if (MakeAOD()) {
      AliAODHandler* aodHandler   = new AliAODHandler();
      aodHandler->SetOutputFileName("AliAOD.root");
      mgr->SetOutputEventHandler(aodHandler);
    }
    
    // --- Call user routine for adding tasks ------------------------
    if (!AddTasks()) return false;
    
    // --- Check if we are to merge ----------------------------------
    if (stage > 0) 
      return Merge(xmlfile, stage);

    // --- Otherwise run the train -----------------------------------
    TChain* chain = CreateChain();
    if (!chain) return false;

    TStopwatch timer;
    timer.Start();
    if (!mgr->InitAnalysis()) {
      ::Error("Run", "Failed to initialize the train");
      return false;
    }

    mgr->PrintStatus();
    mgr->SetSkipTerminate(kTRUE);
    mgr->StartAnalysis("local", chain);
    timer.Print();
    
  }
  Bool_t Merge(const char* dir, Int_t stage)
  {

    TStopwatch    timer;     
    timer.Start();
    TString       outputDir     = dir;
    Bool_t        final         = outputDir.Contains("Stage");
    TCollection*  outputFiles   = GetFilesToMerge(stage, final);
    if (!outputFiles) { 
      ::Warning("Merge", "Nothing to merge");
      return true;
    }
    TIter       iter(outputFiles);
    TObjString* str           = 0;
    Bool_t      merged        = kTRUE;
    while((str = static_cast<TObjString*>(iter()))) {
      TString& outputFile = str->GetString();
      // Skip already merged outputs
      if (!gSystem->AccessPathName(outputFile)) {
  ::Warning("Merge","Output file <%s> found. Not merging again.",
      outputFile.Data());
  continue;
      }
      merged = AliAnalysisAlien::MergeOutput(outputFile, 
               outputDir, 
               10, 
               stage);
      if (merged) continue; 
      
      ::Error("Merge", "Cannot merge %s\n", outputFile.Data());
    }
    // --- possible merge file information files ---------------------
    if (MergeFileInfo()) { 
      TString infolog = "fileinfo.log";
      AliAnalysisAlien::MergeInfo(infolog, dir); 
    }

    // --- If not final stage, get out here --------------------------
    if (!final) { 
      ValidateOutput();
      timer.Print();
      return true;
    }
    
    // --- set up and run termiante ----------------------------------
    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
    mgr->SetSkipTerminate(kFALSE);
    if (!mgr->InitAnalysis()) {
      ::Error("Merge", "Failed to initialize the train");
      return false;
    }
    
    mgr->PrintStatus();
    mgr->StartAnalysis("gridterminate", (TTree*)0);
    ValidateOutput();
    timer.Print();

    return true;
  }
         
  Bool_t LoadLibrary(const char *module)
  {
    // Load a module library in a given mode. Reports success.
    Int_t result = 0;
    TString mod(module);
    ::Info("LoadLibrary", "Loading %s", module);
    gROOT->IncreaseDirLevel();

    if (mod.IsNull()) {
      ::Error("LoadLibrary", "Empty module name");
      gROOT->DecreaseDirLevel();
      return kFALSE;
    }

    // If a library is specified, just load it
    if (mod.EndsWith(".so")) {
      mod.Remove(mod.Index(".so"));
      ::Info("LoadLibrary", "Loading .so: %s", mod.Data()); 
      result = gSystem->Load(mod);
      if (result < 0) {
  ::Error("oadLibrary", "Could not load library %s", module);
      }
      gROOT->DecreaseDirLevel();      
      return (result >= 0);
    }
    // Check if the library is already loaded
    if (strlen(gSystem->GetLibraries(module, "", kFALSE)) > 0) {
      ::Info("LoadLibrary", "Module %s.so already loaded", module);
      gROOT->DecreaseDirLevel();      
      return kTRUE;
    }

    ::Info("LoadLibrary", "Trying to load lib%s.so", module);
    result = gSystem->Load(Form("lib%s", module));
    if (result < 0)
      ::Error("LoadLibrary", "Could not load module %s", module);
    ::Info("LoadLibrary", "Module %s, successfully loaded", module);
    gROOT->DecreaseDirLevel();      
    return (result >= 0);
  }
  virtual Bool_t LoadBaseLibraries()
  {
    // Load common analysis libraries.
    if (!gSystem->Getenv("ALICE_PHYSICS")) {
      ::Error("LoadBaseLibraries", 
        "Analysis trains requires that analysis libraries are "
        "compiled with a local AliRoot");
      return false;
    }

    Bool_t success = true;
    // Load framework classes. Par option ignored here.
    success &= LoadLibrary("libSTEERBase.so");
    success &= LoadLibrary("libESD.so");
    success &= LoadLibrary("libAOD.so");
    success &= LoadLibrary("libANALYSIS.so");
    success &= LoadLibrary("libOADB.so");
    success &= LoadLibrary("libANALYSISalice.so");
    success &= LoadLibrary("libESDfilter.so");
    success &= LoadLibrary("libCORRFW.so");
    success &= LoadLibrary("libPWGPP.so");
    gROOT->ProcessLine(".include $ALICE_PHYSICS/include");
    if (success) {
      ::Info("LoadBaseLibraries", 
       "Load common libraries:    SUCCESS");
      ::Info("LoadBaseLibraries", 
       "Include path for Aclic compilation:\n%s",
       gSystem->GetIncludePath());
    } else {
      ::Info("LoadBaseLibraries", 
       "Load common libraries:    FAILED");
    }
    return success;
  }
  TChain* CreateChain()
  {
    if (gSystem->AccessPathName("AliESDs.root")) {
      ::Error("CreateChain", 
        "File: AliESDs.root not in ./data dir");
      return 0;
    }
    
    // Create the input chain
    TChain* chain = new TChain("esdTree");
    chain->Add("AliESDs.root");
    if (!chain->GetNtrees()) {
      delete chain;
      chain = 0;
    }

    return chain;
  }
  void ValidateOutput()
  {
    std::ofstream out;
    out.open("outputs_valid", ios::out);
    out.close();    
  }  

  virtual void LoadConfig() {};
  virtual const char* GetName() const { return "dummy"; }
  virtual Bool_t UseFriends() const { return false; }
  virtual Bool_t UseMC() const { return false; }
  virtual Bool_t MakeAOD() const { return false; }
  virtual Bool_t AddTasks() const { return true; }
  virtual Bool_t MergeFileInfo() const { return false; }
  virtual TCollection* GetFilesToMerge(Int_t stage, Bool_t final) const 
  { 
    return 0; 
  }
};




//====================================================================
void BaseConfig()
{
  Info("", "Defined base classes for configuration");
}
//
// EOF
//