Railway.C

Go to the documentation of this file.

#ifndef TRAIN_HELPER_C
#define TRAIN_HELPER_C
#ifndef __CINT__
# include "Option.C"
# include "ChainBuilder.C"
# include <TUrl.h>
# include <TString.h>
# include <TMap.h>
# include <TObjString.h>
# include <TSystem.h>
# include <TROOT.h>
# include <TError.h>
# include <TObjArray.h>
# include <TFile.h>
# include <TChain.h>
# include <AliAnalysisManager.h>
# include <iostream>
#else 
class TString;
class TUrl;
class TMap;
class Option;
class OptionList;
class TChain;
#endif

struct Railway 
{
  enum EMode { 
    kLocal, 
    kProof, 
    kGrid
  };
  enum EOperation { 
    kTest,
    kOffline,
    kSubmit,
    kTerminate, 
    kFull
  };
  enum EInput { 
    kESD, 
    kAOD, 
    kUser
  };
  Railway(const Railway& o) 
    : fUrl(o.fUrl), fOptions(o.fOptions), fVerbose(o.fVerbose)
  {}
  Railway& operator=(const Railway&) { return *this; }
  static Railway* Create(const TUrl& url, Int_t verbose=0);
  static Railway* CreateObject(const TString& cl, 
            const TUrl&    url, 
            Int_t verbose=0)
  {
    if (verbose < 3) gSystem->RedirectOutput("/dev/null","w");
    if (cl.Contains("proof", TString::kIgnoreCase) || 
  cl.Contains("vaf",   TString::kIgnoreCase) || 
  cl.Contains("lite",  TString::kIgnoreCase) || 
  cl.Contains("aaf",   TString::kIgnoreCase)) {
      gSystem->Load("libProof");
      gSystem->Load("libProofPlayer");
    }
    // (Always) recompile and with debug symbols 
    gROOT->LoadMacro(Form("%s.C++g",cl.Data()));    
    Long_t ptr = gROOT->ProcessLine(Form("new %s(\"%s\", %d);", 
           cl.Data(), url.GetUrl(), verbose));
    if (verbose < 3) gSystem->RedirectOutput(0);
    if (!ptr) { 
      Warning("Railway::CreateObject", "Failed to instantize a %s", cl.Data());
      return 0;
    }
    Railway* h = reinterpret_cast<Railway*>(ptr);
    return h;
  }
  static void ShowUrlHelp(const TString& cl)
  {
    Railway* h = CreateObject(cl, "", true);
    if (!h) return;

    std::cout << "   " << h->UrlHelp() << std::endl;
  }
  static void ShowFullHelp(const TString& cl) 
  {
    Railway* h = CreateObject(cl, "", true);
    if (!h) return;
    
    std::cout << h->Desc() << ":\n" 
        << "==============\n"
        << "  " << h->UrlHelp() << "\n\n"
        << "Options: " << std::endl;
    h->Options().Help(std::cout);
    std::cout << std::endl;
  }
  /* @} */
  virtual void UsePar(Bool_t& use);
  virtual Bool_t AddIncludePath(const TString& path)
  {
    TString p(path);
    if (!p.BeginsWith("-")) {
      // IF the path does not begin with a -, we assume its a path
      p.Prepend("-I");
    }
    gSystem->AddIncludePath(p);
    return true;
  }
  virtual Bool_t LoadLibrary(const TString& name, 
           Bool_t slave=true,
           Bool_t forcePar=false) = 0;
  virtual Bool_t LoadSource(const TString& name, bool copy=false)
  {
    TString local = name;
    if (!AuxFile(local, copy)) {
      Warning("LoadSource", "Failed to add aux source file %s", name.Data());
      return false;
    }
    // TString base(gSystem->BaseName(name));
    Info("LoadSource", "Building %s", local.Data());
    // gROOT->ProcessLine("gSystem->RedirectOutput(\"build.log\",\"a\");");
    gROOT->LoadMacro(Form("%s+g", local.Data()));
    // gROOT->ProcessLine("gSystem->RedirectOutput(0);");
    Info("LoadSource", "End of loading source");
    return true;
  }
  virtual Bool_t LoadAux(const TString& name, Bool_t copy=false)
  {
    TString local = name;
    if (!AuxFile(local, copy)) return false;
    return true;
  }

  virtual Bool_t LoadROOT()
  {
    if (gSystem->Load("libTree")    < 0) return false;
    if (gSystem->Load("libGeom")    < 0) return false;
    if (gSystem->Load("libVMC")     < 0) return false;
    if (gSystem->Load("libPhysics") < 0) return false;
    if (gSystem->Load("libMinuit")  < 0) return false;
    return true;
  }
  virtual Bool_t LoadAliROOT()
  {
    if (!gSystem->Getenv("ALICE_ROOT")) { 
      Error("Railway::LoadAliROOT", "Local AliROOT not available");
      return false;
    }
    if (!LoadLibrary("STEERBase"))     return false;
    if (!LoadLibrary("ESD"))           return false;
    if (!LoadLibrary("AOD"))           return false;
    if (!LoadLibrary("ANALYSIS"))      return false;
    if (!LoadLibrary("OADB"))          return false;
    if (!LoadLibrary("ANALYSISalice")) return false;
    return true;
  }
  virtual Bool_t LoadAliPhysics()
  {
    if (!gSystem->Getenv("ALICE_PHYSICS")) { 
      Error("Railway::LoadAliPhysics", "Local AliPhysics not available");
      return false;
    }
    if (!LoadLibrary("OADB"))          return false;
    return true;
  }
  /* @} */
  virtual UShort_t Mode() const = 0;
  virtual const char* ModeString() const { return "unknown"; }
  virtual UShort_t Operation() const { return kFull; }
  /* @} */
  virtual Short_t InputType() const
  {
    UShort_t ret = DeduceType(fUrl.GetAnchor());
    if (ret != kUser) return ret;

    if (fOptions.Has("pattern")) ret = DeduceType(fOptions.Get("pattern"));
    if (ret != kUser) return ret;
    
    ret = DeduceType(fUrl.GetFile());
    return ret;
  }
  virtual Bool_t IsMC() const { return fOptions.Has("mc"); }
  virtual TString OutputPath() const { return ""; }
  virtual TString OutputLocation() const 
  {
    AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
    if (!mgr || !mgr->GetOutputEventHandler()) return "";

    TString path(OutputPath());
    if (path.IsNull()) {
      path = gSystem->WorkingDirectory(); 
      // mgr->GetName();
    }

    TUrl u(fUrl);
    u.SetFile(path);
    u.SetAnchor("aodTree");
    TString opt(u.GetOptions());
    // if (opt.Contains("AliESDs")) 
    opt.ReplaceAll("AliESDs", "AliAOD");
    // else                         opt.Append("&pattern=AliAOD*.root");
    u.SetOptions(opt);

    return u.GetUrl();
  }
  /* @} */
  virtual Bool_t PreSetup() = 0;
  virtual Bool_t PostSetup() = 0;
  virtual Long64_t Run(Long64_t nEvents=-1) = 0;
  virtual Bool_t AddMonitor(const TString&) { return true; }
  /* @} */
  virtual void Print(Option_t* ="") const
  {
    std::cout << "Url: " << fUrl.GetUrl() << std::endl;
    fOptions.Show(std::cout);
  }
  virtual const Char_t* UrlHelp() const  = 0;
  virtual const char* Desc() const = 0;
  const TUrl& Url() const { return fUrl; }
  const OptionList& Options() const { return fOptions; }
  virtual void AuxSave(const TString& /*escaped*/, 
           Bool_t /*asShellScript*/) {}
protected:
  Railway(const TUrl& url, Int_t verbose) 
    : fUrl(url), fOptions(), fVerbose(verbose)
  {
    fOptions.Add("mc", "Assume simulation input");
    Printf("URL is %s", fUrl.GetUrl());
  }

  virtual Bool_t ParseOptions()
  {
    std::cout << "Url options: \"" << fUrl.GetOptions() << "\"" << std::endl;
    return fOptions.Parse(fUrl.GetOptions(), "&");
  }
  virtual ~Railway()
  {
  }
  const TString& MakeLibraryName(const TString& name)
  {
    static TString libName;

    libName = name;

    if (!libName.BeginsWith("lib")) { 
      // Check if the library corresponds to a compiled macro 
      if (!gSystem->AccessPathName(Form("%s_C.so", libName.Data()))) 
  libName.Append("_C");
      else if (!gSystem->AccessPathName(Form("../%s_C.so", libName.Data()))) 
  libName = Form("../%s_C", libName.Data());
      else 
  libName = Form("lib%s", libName.Data());
    }
    if (!libName.EndsWith(".so"))   libName.Append(".so");

    return libName;
  }
  virtual Bool_t AuxFile(TString& name, bool copy=false)
  {
    TString path(gSystem->ExpandPathName(name.Data()));
    TString search(gSystem->GetIncludePath());
    search.ReplaceAll("-I", ":");
    search.ReplaceAll(" ", "");
    search.Append(":");
    search.Append(gROOT->GetMacroPath());    
    // If not absolute, prepend up-one
    if (!path.BeginsWith("/")) search.Prepend("../:");
    
    // Remove any trailing AcLic instructions 
    if (path.EndsWith("+") || path.EndsWith("+g")) {
      do {
  char c = path[path.Length()-1];
  if (c != '+' && c != 'g') break;
  path.Remove(path.Length()-1);
      } while (path.Length());
    }

#if 0
    TObjArray* comps = search.Tokenize(":");
    Printf("Searching for %s in ", path.Data());
    TIter nextC(comps);
    TObject* objC = 0;
    while ((objC = nextC())) Printf("  %s", objC->GetName());
    comps->Delete();
#endif 
    TString query = gSystem->Which(search, path);
    // Printf("Got back %s", query.Data());

    if (gSystem->AccessPathName(query.Data())) { 
      // File not accessible
      Warning("Railway::AuxFile", "File %s not accessible", path.Data());
      return false;
    }
    TString base(gSystem->BaseName(query.Data()));
    name = base;
    if (gSystem->AccessPathName(base.Data()) == 0) { 
      // File or link exists - remove it 
      if (gSystem->Unlink(base) != 0) { 
  Error("Railway::AuxFile", "Failed to remove old %s", base.Data());
  return false;
      }
    }
    if (copy) 
      TFile::Cp(query, base);
    else 
      gSystem->Exec(Form("ln -s %s .", query.Data()));
    return true;
  }
  /* @} */
  TChain* LocalChain()
  {
    // --- Copy of URL -----------------------------------------------
    TString su(fUrl.GetUrl());
    if (su.BeginsWith("local", TString::kIgnoreCase))
      su.Replace(0, 5, "file", 4);
    TUrl url(su);

    // -- Check the source -------------------------------------------
    TString  src       = url.GetFile();
    if (src.IsNull()) {
      Error("LocalChain", "No input source specified: %s (%s)",
      url.GetUrl(), fUrl.GetUrl());
      return 0;
    }

    // --- Check possible pattern ------------------------------------
    TString  pattern   = fOptions.AsString("pattern", "");
    pattern.ReplaceAll("@", "#");
    pattern.ReplaceAll(":", "#");

    // --- Get the tree name -----------------------------------------
    TString  treeName  = url.GetAnchor();

    // --- Create flags for the chain builder ------------------------
    UShort_t flags     = 0;
    if (fOptions.Has("mc") &&
  AliAnalysisManager::GetAnalysisManager()
  ->GetMCtruthEventHandler() != 0) flags |= ChainBuilder::kMC;
    if (fOptions.Has("recursive"))       flags |= ChainBuilder::kRecursive;
    if (fOptions.Has("trackref"))        flags |= ChainBuilder::kTrRef;
    if (fOptions.Has("clean"))           flags |= ChainBuilder::kClean;
    if (fOptions.Has("scan"))            flags |= ChainBuilder::kScan;
    if (fVerbose > 5)                    flags |= ChainBuilder::kVerbose;

    // --- Check input -----------------------------------------------
    UShort_t type      = ChainBuilder::CheckSource(src, flags);
    if (type == ChainBuilder::kInvalid) {
      Error("LocalChain", "Cannot generate TChain from %s", src.Data());
      return 0;
    }

    // --- Create the chain ------------------------------------------
    TChain* chain = ChainBuilder::Create(type, src, treeName, pattern, flags);
    if (!chain) { 
      Error("LocalChain", "No chain defined "
      "(url=%s, src=%s, treeName=%s, pattern=%s, flags=0x%x)", 
      url.GetUrl(), src.Data(), treeName.Data(), pattern.Data(), flags);
      fOptions.Show(std::cout);
      return 0;
    }
    
    return chain;
  }
  /* @} */
  static UShort_t DeduceType(const TString& str)
  {
    if (str.IsNull()) return kUser;
    if (str.Contains("aod", TString::kIgnoreCase)) return kAOD;
    if (str.Contains("esd", TString::kIgnoreCase)) return kESD;
    return kUser;
  }
  /* @} */
  // --- Data members ------------------------------------------------
  TUrl        fUrl;     // The URI
  OptionList  fOptions; 
  Int_t       fVerbose;
};




// ===================================================================
void Railway::UsePar(Bool_t&) {}
Railway* 
Railway::Create(const TUrl& url, Int_t verbose)
{
  if (!url.IsValid()) { 
    Warning("Railway::Create", "URL is invalid");
    return 0;
  }

  TString prot(url.GetProtocol());
  prot.ToLower();

  TUrl tmp(url);
  TString opts(tmp.GetOptions());
  TString host(url.GetHost());
  TString cl = "";
  if (prot.EqualTo("alien")) { 
    // Create an AliEn helper 
    cl = "GridRailway";
  }
  else if (prot.EqualTo("local")) { 
    // Create Lite helper 
    cl = "LocalRailway";
  }
  else if (prot.EqualTo("proof")) { 
    // Create a Proof helper 
    if (host.IsNull()) 
      cl = "LiteRailway";
    else if (host.BeginsWith("alice-caf")) { 
      // AAF
      ::Warning("Railway::Create", "CAF has been decommissioned");
      cl = opts.Contains("plugin") ? "AAFPluginRailway" : "AAFRailway";
    }
    else if (host.BeginsWith("alivaf")) {
      // VAF
      cl = "VAFRailway";
    }
    else 
      cl = "ProofRailway";
  }
  else if (prot.EqualTo("lite")) { 
    // Create a Proof helper 
    cl = "LiteRailway";
  }
  else if (prot.EqualTo("help")) {
    // Special HELP protocol
    if (host.Contains("options")) {
      std::cout << "Possible URL types and options are:" << std::endl;
      ShowFullHelp("LocalRailway");
      ShowFullHelp("ProofRailway");
      ShowFullHelp("LiteRailway");
      ShowFullHelp("VAFRailway");
      ShowFullHelp("AAFRailway");
      ShowFullHelp("AAFPluginRailway");
      ShowFullHelp("GridRailway");
      return 0;
    }
    std::cout << "Possible URL types are:" << std::endl;
    ShowUrlHelp("LocalRailway");
    ShowUrlHelp("ProofRailway");
    ShowUrlHelp("LiteRailway");
    ShowUrlHelp("VAFRailway");
    ShowUrlHelp("AAFRailway");
    ShowUrlHelp("AAFPluginRailway");
    ShowUrlHelp("GridRailway");
    return 0;
  }
  // --- Check if we got a scheme ------------------------------------
  if (cl.IsNull()) {
    Error("Railway::Create", "Unknown scheme: %s", prot.Data());
    return 0;
  }

  // --- Use interpreter to make our object --------------------------
  Railway* helper = CreateObject(cl, url, verbose);
  if (!helper) {
    Error("Railway::Create", "Failed to make object of class %s", cl.Data());
    return 0;
  }

  // --- Parse options -----------------------------------------------
  if (!helper->ParseOptions()) {
    Error("Railway::Create", "Failed to parse options: %s", url.GetOptions());
    delete helper;
    helper = 0;
  }
  Printf("URL of helper is %s", url.GetUrl());
  return helper;
}

#endif