LiteRailway.C

Go to the documentation of this file.

#ifndef LITEHELPER_C
#define LITEHELPER_C
#include "ProofRailway.C"
#ifndef __CINT__
# include <TUrl.h>
# include <TString.h>
# include <TChain.h>
# include <TDSet.h>
# include <AliAnalysisManager.h>
# include <AliVEventHandler.h>
#else
class TChain;
class TUrl;
#endif

// ===================================================================
struct LiteRailway : public ProofRailway
{
  LiteRailway(const TUrl& url, Int_t verbose)
    : ProofRailway(url, verbose), fChain(0)
  {
    fOptions.Add("recursive","Recursive scan");
    fOptions.Add("trackref", "For MC input, check TrackRef.root presence");
    fOptions.Add("scan",     "Scan for number of events in chain");
    fOptions.Add("clean",    "Clean chain elements");
    fOptions.Add("pattern",  "GLOB", "File name pattern", "*.root");
    fOptions.Remove("dsname");
    fOptions.Remove("storage");
  }
  LiteRailway(const LiteRailway& o) 
    : ProofRailway(o), fChain(o.fChain)
  {}
  LiteRailway& operator=(const LiteRailway& o) 
  {
    if (&o == this) return *this;
    ProofRailway::operator=(o);
    fChain = o.fChain;
    return *this;
  }
  virtual ~LiteRailway() {}
  virtual Bool_t PreSetup() 
  {
    fUrl.SetProtocol("lite");
    Bool_t ret = ProofRailway::PreSetup();
    return ret;
  }
  virtual Bool_t PostSetup()
  {
    // --- Create the chain ------------------------------------------
    fChain = LocalChain();
    if (!fChain) return false;

    return ProofRailway::PostSetup();
  }
  virtual Bool_t LoadExtraSrcs()
  {
    TString    tmp2 = fExtraSrcs.Strip(TString::kBoth, ':');
    TObjArray* srcs = tmp2.Tokenize(":");
    TIter      next2(srcs);
    TObject*   obj = 0;
    while ((obj = next2())) {
      TString full = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
               obj->GetName());
      Info("LoadExtraSrcs", "Will load %s", full.Data());
      Int_t ret = gProof->Load(Form("%s+g", full.Data()), true,true);
      if (ret < 0) { 
  Error("ProofRailway::PostSetup", "Failed to compile %s",obj->GetName());
  return false;
      }
    }
    return true;
  }    
  virtual Long64_t Run(Long64_t nEvents=-1) 
  {
    AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
    gProof->SetLogLevel(TMath::Max(fVerbose-2,0), 
      /* TProofDebug::kPacketizer| */
      TProofDebug::kLoop|
      /* TProofDebug::kSelector|
      TProofDebug::kOutput|
      TProofDebug::kInput|
      TProofDebug::kGlobal|*/
      TProofDebug::kPackage);
    if (nEvents < 0) nEvents = fChain->GetEntries();
    Long64_t off = fOptions.AsLong("offset", 0);
    if (nEvents > 0 && nEvents < off) {
      Warning("Run", "Number of events %lld < offset (%lld), stopping", 
        nEvents, off);
      return 0;
    }
    Long64_t ret = mgr->StartAnalysis("proof", fChain, nEvents, off);
    
    if (fVerbose > 2) 
      TProof::Mgr(fUrl.GetUrl())->GetSessionLogs()->Save("*","lite.log");
    return ret;
  }
  virtual TString OutputPath() const 
  {
    AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
    if (!mgr) return "";

    AliVEventHandler* outH = mgr->GetOutputEventHandler();
    if (!outH) return "";
    
    TString ret = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
            outH->GetOutputFileName());
    return ret;
  }

  virtual const Char_t* UrlHelp() const 
  {
    return "lite://<datadir_or_list>[?<options>][#<treeName]";
  }
  virtual const char* Desc() const { return "PROOF-lite"; }
  TChain* fChain;
};
#endif
//
// EOF
//