TupleSelector.C

Go to the documentation of this file.

#ifndef SELECTOR_C
#define SELECTOR_C

#include <TSelector.h>
#include <TQObject.h>
#ifndef __CINT__
# include <TH1.h>
# include <TString.h>
# include <TCanvas.h>
# include <TLegend.h>
# include <TLegendEntry.h>
# include <TError.h>
# include <TMath.h>
# include <THStack.h>
# include <TTree.h>
# include <TClonesArray.h>
# include <TChain.h>
# include <TSystem.h>
# include <TOutputListSelectorDataMap.h>
# include <TLatex.h>
# include <TROOT.h>
# include <TFile.h>
# include <TDirectory.h>
# include <TSystemDirectory.h>
# include <TRegexp.h>
# include <TKey.h>
# include <TFileCollection.h>
# include <THashList.h>
# include <TDSet.h>
# include <TQConnection.h>
# include <iostream>
# include <TProof.h>
# include <TStopwatch.h>
# include "AliFMDMCTrackELoss.h"
#else
// Forward declarations of types in the interface, and to trigger
// autoloading of some libraries
class TTree;
class TChain;
class TCanvas;
class TH1;
class THStack;
class TLegend;
class TCanvas;
class TString;
class TDirectory;
class TSystemDirectory;
class TRegexp;
class TDSet;
class TProof;
class AliFMDMCTrackELoss;
class AliFMDMCTrackELoss::Hit;
#endif

//====================================================================
struct Spectra : public TObject
{
  TString fName;
  TH1*    fPrimary;
  TH1*    fSecondary;
  Spectra() 
    : TObject(), fName(""), fPrimary(0), fSecondary(0)
  {}
  Spectra(const char*    name, 
    const char*    title, 
    Color_t        color,
    const TArrayD& bins)
    : TObject(), 
      fName(name),
      fPrimary(0), 
      fSecondary(0)
  {
    fPrimary = new TH1D(Form("primary%s", name), 
      title, bins.GetSize()-1, 
      bins.GetArray());
    fPrimary->SetXTitle("#beta#gamma");
    fPrimary->SetMarkerColor(color);
    fPrimary->SetLineColor(color);
    fPrimary->SetMarkerStyle(20);
    fPrimary->SetFillStyle(0);
    fPrimary->SetDirectory(0);
    fPrimary->Sumw2();
      
    fSecondary = static_cast<TH1*>(fPrimary->Clone(Form("secondary%s",name)));
    fSecondary->SetMarkerStyle(24);
    fSecondary->SetMarkerSize(1.2);
    fSecondary->SetDirectory(0);
  }
  Spectra(const Spectra& o) 
    : TObject(o), 
      fName(o.fName),
      fPrimary(0), 
      fSecondary(0) 
  {
    if (o.fPrimary)
      fPrimary = static_cast<TH1*>(o.fPrimary->Clone());
    if (o.fSecondary)
      fSecondary = static_cast<TH1*>(o.fSecondary->Clone());
  }
  virtual ~Spectra() 
  {
    if (fPrimary)   delete fPrimary;
    if (fSecondary) delete fSecondary;
  }
  Spectra& operator=(const Spectra& o) 
  {
    if (&o == this) return *this;
      
    TObject::operator=(o);
    fName = o.fName;
    if (fPrimary)   { delete fPrimary;   fPrimary   = 0; }
    if (fSecondary) { delete fSecondary; fSecondary = 0; }
    if (o.fPrimary)
      fPrimary = static_cast<TH1*>(o.fPrimary->Clone());
    if (o.fSecondary)
      fSecondary = static_cast<TH1*>(o.fSecondary->Clone());
      
    return *this;
  }
  const char* GetName() const { return fName.Data(); }
  void Fill(Bool_t primary, Double_t x) 
  {
    if (primary) fPrimary->Fill(x);
    else         fSecondary->Fill(x);
  }
  TH1* Hist(Bool_t primary) const 
  {
    return (primary ? fPrimary : fSecondary);
  }
  virtual void Stack(THStack* stack, TLegend* leg)
  {
    TH1* hists[] = { fPrimary, fSecondary, 0 };
    for (Int_t i = 0; i < 2; i++) { 
      if (!hists[i]) continue;

      Int_t n = hists[i]->GetEntries();
      if (n <= 0) continue;
  
      if (stack) {
  hists[i]->Scale(1. / n, "width");
  stack->Add(hists[i]);

  if (i != 0) continue;
  if (!leg) continue;
    
  leg->AddEntry(hists[i], hists[i]->GetTitle(), "p");
      }
      else if (leg) { 
  TLegendEntry* e = leg->AddEntry("", 
          (i == 0 ? "Primary" : "Secondary"), 
          "p");
  e->SetMarkerStyle(hists[i]->GetMarkerStyle());
  e->SetFillStyle(hists[i]->GetFillStyle());
  e->SetFillColor(kBlack);
      }
    }
  }
  Long64_t Merge(TCollection *list)
  {
    TIter    nxt(list);
    TObject* obj = 0;
    Long64_t cnt = 0;
    while ((obj = nxt())) { 
      if (!obj->IsA()->InheritsFrom(this->IsA())) {
  Warning("Merge", "Will not merge a Spectra with a %s", 
    obj->IsA()->GetName());
  continue;
      }
      Spectra* oth  = static_cast<Spectra*>(obj);
      if (Add(oth)) cnt++;
    }
    // Info("Merge", "%s merged %lld entries", fName.Data(), cnt);
    return cnt;
  }
  Bool_t Add(const Spectra* oth) 
  {
    if (!oth->fName.EqualTo(fName)) {
      Warning("Merge", "Will not merge %s with %s", 
        oth->fName.Data(), fName.Data());
      return false;
    }
    // Int_t nPrmOld = fPrimary->GetEntries();
    // Int_t nSecOld = fPrimary->GetEntries();

    fPrimary  ->Add(oth->fPrimary);
    fSecondary->Add(oth->fSecondary);

    // Int_t nPrmNow = fPrimary->GetEntries();
    // Int_t nSecNow = fPrimary->GetEntries();

    // Info("Add", "%s: %d/%d merged to %d/%d", 
    //      fName.Data(), nPrmOld, nSecOld, nPrmNow, nSecNow);
    return true;
  }
  void ls(Option_t* option="") const 
  {
    TObject::ls(option);
    gROOT->IncreaseDirLevel();
    TH1* hists[] = { fPrimary, 
         fSecondary, 
         0 };
    for (Int_t i = 0; i < 2; i++) if (hists[i]) hists[i]->ls();
    gROOT->DecreaseDirLevel();
  }
  void Store(TDirectory* dir)
  {
    TDirectory* out = dir->mkdir(fName);
    out->cd();
    fPrimary->Clone("primary")->Write();
    fSecondary->Clone("secondary")->Write();
    dir->cd();
  }
  ClassDef(Spectra,1);
};
//====================================================================
struct Type : public Spectra 
{
  Type() : Spectra() {}
  Type(const char*    name, 
       const char*    title, 
       Color_t        color)
    : Spectra() // Do not use the base class ctor 
  {
    fName = name;
    fPrimary = new TH1D(Form("primary%s", name),
      title, 6, .5, 6.5);
    fPrimary->SetXTitle("particle type");
    fPrimary->SetMarkerColor(color);
    fPrimary->SetMarkerStyle(20);
    fPrimary->SetFillColor(color);
    fPrimary->SetFillStyle(3001);
    fPrimary->SetLineColor(color);
    fPrimary->SetDirectory(0);
    fPrimary->Sumw2();
    fPrimary->GetXaxis()->SetBinLabel(1, "e^{#pm}");
    fPrimary->GetXaxis()->SetBinLabel(2, "#pi^{#pm}");
    fPrimary->GetXaxis()->SetBinLabel(3, "K^{#pm}");
    fPrimary->GetXaxis()->SetBinLabel(4, "p/#bar{p}");
    fPrimary->GetXaxis()->SetBinLabel(5, "strange");
    fPrimary->GetXaxis()->SetBinLabel(6, "other");
      
    fSecondary = 
      static_cast<TH1*>(fPrimary->Clone(Form("secondary%s",name)));
    fSecondary->SetMarkerStyle(24);
    fSecondary->SetMarkerSize(1.2);
    fSecondary->SetFillStyle(3002);
    fSecondary->SetDirectory(0);
  }
  ClassDef(Type,1); 
};

//====================================================================
struct Ring : public TObject
{

  UShort_t fD;
  Char_t   fR;
  TString  fName;
  TObjArray* fSpectra; 

  enum { 
    kBetaGamma = 0,
    kBetaGammaPi, 
    kBetaGammaElectron, 
    kTypes,
    kNSpectra
  };
    
  Ring() 
    : TObject(),
      fD(0), 
      fR('\0'),
      fName(),
      fSpectra(0)
  {}
  Ring(UShort_t d, Char_t r) 
    : fD(d), 
      fR(r),
      fName(Form("FMD%d%c", d, r)),
      fSpectra(0)
  {
    Color_t color = AliForwardUtil::RingColor(fD, fR);
    TArrayD bgArray(601);
    AliForwardUtil::MakeLogScale(300, -2, 5, bgArray);
    
    fSpectra   = new TObjArray(kNSpectra);
    fSpectra->SetOwner(true);
    fSpectra->AddAt(new Spectra("BetaGamma", fName, color, bgArray), 
        kBetaGamma);
    fSpectra->AddAt(new Spectra("BetaGammaPi", fName, color, bgArray), 
        kBetaGammaPi);
    fSpectra->AddAt(new Spectra("BetaGammaElectron", fName, color, bgArray), 
        kBetaGammaElectron);
    fSpectra->AddAt(new Type("Type", fName, color), kTypes);
    // fSpectra->ls();
  }
  Ring(const Ring& r)
    : TObject(r), 
      fD(r.fD), 
      fR(r.fR), 
      fName(r.fName),
      fSpectra(0)
  {
    if (r.fSpectra) fSpectra = new TObjArray(*r.fSpectra);
  }    
  Ring& operator=(const Ring& r) 
  {
    if (&r == this) return *this;
    
    fD                     = r.fD;
    fR                     = r.fR;
    fName                  = r.fName;
    if (fSpectra) { delete fSpectra; fSpectra = 0; }
    if (r.fSpectra) fSpectra = new TObjArray(*r.fSpectra);

    return *this;
  }
  const char* GetName() const { return fName.Data(); }
  Spectra* Get(UInt_t which) 
  {
    if (!fSpectra) return 0;
    Int_t i = which;
    if (i > fSpectra->GetEntriesFast()) return 0;
    return static_cast<Spectra*>(fSpectra->At(i));
  }
  const Spectra* Get(UInt_t which) const
  {
    if (!fSpectra) return 0;
    Int_t i = which;
    if (i > fSpectra->GetEntriesFast()) return 0;
    return static_cast<Spectra*>(fSpectra->At(i));
  }
  void Fill(AliFMDMCTrackELoss::Hit* hit)
  {
    Bool_t prim = hit->IsPrimary();
    Int_t  apdg = hit->AbsPdg();
    Int_t  mfl  = Int_t(apdg/TMath::Power(10,Int_t(TMath::Log10(apdg))));
    Int_t  type = (hit->IsElectron() ? 1 : 
       hit->IsPion()     ? 2 : 
       hit->IsKaon()     ? 3 : 
       hit->IsProton()   ? 4 : 
       mfl == 3          ? 5 : 6);
    
    Get(kBetaGamma)        ->Fill(prim, hit->BetaGamma());
    Get(kTypes)            ->Fill(prim, type);
    if (hit->IsPion() || hit->IsProton() || hit->IsKaon() || apdg > 100)
      Get(kBetaGammaPi)      ->Fill(prim, hit->BetaGamma());
    if (hit->IsElectron())
      Get(kBetaGammaElectron)->Fill(prim, hit->BetaGamma());

  }
  TH1* Hist(Bool_t primary, UShort_t which) const
  {
    const Spectra* spe = Get(which); 
    if (!spe) return 0;
    return spe->Hist(primary);
  }
  Long64_t Merge(TCollection *list)
  {
    TIter    nxt(list);
    TObject* obj = 0;
    Long64_t cnt = 0;
    while ((obj = nxt())) { 
      if (!obj->IsA()->InheritsFrom(this->IsA())) {
  Warning("Merge", "Will not merge a Ring with a %s", 
    obj->IsA()->GetName());
  continue;
      }
      Ring* oth = static_cast<Ring*>(obj);
      if (oth->fD != fD || oth->fR != fR) {
  Warning("Merge", "Will not merge FMD%d%c with FMD%d%c", 
    fD, fR, oth->fD, oth->fR);
  continue;
      }
      
      if (fSpectra) {
  // fSpectra->Merge(oth->fSpectra);
  TIter thsNext(fSpectra);
  TIter othNext(oth->fSpectra);
  Spectra* thsSpec = 0;
  Spectra* othSpec = 0;
  
  while ((thsSpec = static_cast<Spectra*>(thsNext())) && 
         (othSpec = static_cast<Spectra*>(othNext()))) 
    thsSpec->Add(othSpec);

      }
      cnt++;
    }
    // Info("Merge", "FMD%d%c merged %lld entries", fD, fR, cnt);
    return cnt;
  }
  void Draw(Option_t* opt="") 
  { 
    Info("Draw", "Should draw rings here");
    ls(opt); 
  }
  void ls(Option_t* option="") const 
  {
    TObject::ls(option);
    gROOT->IncreaseDirLevel();
    if (fSpectra) fSpectra->ls(option);
    gROOT->DecreaseDirLevel();
  }
  void Store(TDirectory* dir)
  {
    TDirectory* out = dir->mkdir(fName);
    out->cd();
    TIter next(fSpectra);
    Spectra* spec = 0;
    while ((spec = static_cast<Spectra*>(next()))) 
      spec->Store(out);
    dir->cd();
  }
  
  ClassDef(Ring,2);
};

//====================================================================
struct Monitor : public TObject, public TQObject 
{
  Monitor()
  {
    if (!gProof) return;

    fName = gProof->GetSessionTag();
    gDirectory->Add(this);
    // _must_ specify signal _exactly_ like below, or we won't be called
    Bool_t ret = gProof->Connect("Feedback(TList *objs)", "Monitor", this, 
         "Feedback(TList *objs)");
    if (!ret) 
      Warning("Monitor", "Failed to connect to Proof");
  }
  virtual ~Monitor() 
  {
    if (!gProof) return;
    gProof->Disconnect("Feedback(TList *objs)",this, 
           "Feedback(TList* objs)");
  }
  void SetName(const char* name) { fName = name; }
  const char* GetName() const { return fName.Data(); }
  void Feedback(TList* objs)
  {
    Info("Feedback", "Got a list of objects (%p)", objs);
    if (!objs) return;
    objs->ls();
  }
  TString fName;
  ClassDef(Monitor,1);
};


//====================================================================
struct TupleSelector : public TSelector 
{
  TString       fTitle; 
  TTree*        fTree;  
  TClonesArray* fHits;  
  Int_t         fI;     
  TObjArray*    fRings; 

  TupleSelector(const char* name="") :  
    fTitle(name), fTree(0), fHits(0), fI(0), fRings(0) 
  {
    if (fTitle.IsNull()) 
      fTitle = gSystem->BaseName(gSystem->WorkingDirectory());
    // SetOption("fb=rings");
    
  }
  const char* GetName() const { return fTitle.Data(); }
  UShort_t Index(UShort_t d, Char_t r) const
  {
    Bool_t inner = (r == 'i' || r == 'I');
    switch (d) { 
    case 1: return 0;
    case 2: return (inner ? 1 : 2);
    case 3: return (inner ? 4 : 3);
    }
    ::Warning("", "Unknown ring FMD%d%c", d, r);
    return 0xFFFF;
  }
  void Init(TTree* tree) 
  {
    Info("Init", "Got a tree: %p", tree);

    if (!tree) { 
      Warning("Init", "No tree passed");
      return;
    }
    
    fTree = tree;
    fHits = new TClonesArray("AliFMDMCTrackELoss::Hit");
    fTree->SetBranchAddress("hits", &fHits);
  }    
  void Begin(TTree* tree)
  {
    Info("Begin", "Called w/tree @ %p", tree);
    // if (tree) SlaveBegin(tree);
    new Monitor;
  }
  void SlaveBegin(TTree* tree)
  {
    Info("SlaveBegin", "Got a tree: %p", tree);
    fRings = new TObjArray(5);
    fRings->SetName("rings");
    fRings->SetOwner(true);
    fRings->AddAt(new Ring(1,'I'), Index(1,'I'));
    fRings->AddAt(new Ring(2,'I'), Index(2,'I'));
    fRings->AddAt(new Ring(2,'O'), Index(2,'O'));
    fRings->AddAt(new Ring(3,'O'), Index(3,'O'));
    fRings->AddAt(new Ring(3,'I'), Index(3,'I'));

    fOutput->Add(fRings);
    if (tree) {
      // In case of local mode, we get the tree here, 
      // and init isn't called 
      Init(tree);
    }
  }
  /* @} */

  Bool_t Notify() 
  {
    TFile* file = (fTree ? fTree->GetCurrentFile() : 0);
    Info("Notify","processing file: %p (%s)", 
   file, (file ? file->GetName() : "nil"));
    return true;
  }
  Bool_t Process(Long64_t entry)
  {
    if (!fTree) {
      Warning("Process", "No tree");
      return false;
    }
    if (!fTree->GetTree()) {
      Warning("Process", "No real tree");
      return false;
    }
    fHits->Clear();
    fTree->GetTree()->GetEntry(entry);
    fI++;
    // if (fI % 100 == 0) {
    //   printf("Event # %6d (%6d hits)\r", fI, fHits->GetEntries());
    //   fflush(stdout);
    // }
    // Printf("Event # %7d, %6d hits", fI, fHits->GetEntries());
  
    TIter next(fHits);
    AliFMDMCTrackELoss::Hit* hit = 0;
    while ((hit = static_cast<AliFMDMCTrackELoss::Hit*>(next()))) 
      Fill(hit);
   return true;
  }
  Ring* Get(UShort_t d, Char_t r) 
  {
    return static_cast<Ring*>(fRings->At(Index(d,r)));
  }
  const Ring* Get(UShort_t d, Char_t r) const
  {
    return static_cast<Ring*>(fRings->At(Index(d,r)));
  }
  void Fill(AliFMDMCTrackELoss::Hit* hit)
  {
    Ring* r = Get(hit->D(), hit->R());
    r->Fill(hit);
  }
  /* @} */

  void SlaveTerminate()
  {
  }
  void Terminate()
  {
    Printf("\nDone (rings=%p)", fRings);

    if (!fRings) 
      fRings = static_cast<TObjArray*>(fOutput->FindObject("rings"));
    if (!fRings) { 
      Error("Terminate", "No rings in output array");
      return;
    }
    // fRings->ls();
    
    TFile* out = TFile::Open("tuple_summary.root", "RECREATE");
    Store(out);

    PlotOne(Ring::kBetaGamma,        "#beta#gamma - all",     out);
    PlotOne(Ring::kBetaGammaPi,      "#beta#gamma - Hadrons", out);
    PlotOne(Ring::kBetaGammaElectron,"#beta#gamma - e^{#pm}", out);
    PlotOne(Ring::kTypes,            "Relative abundance",    out);
  }
  void PlotOne(UShort_t which, const char* title, 
         TDirectory* dir=0, Option_t* opt="")
  {
    static Int_t cnt  = 1;
    const char*  name = Form("c%02d", cnt++);
      
    TCanvas* c = new TCanvas(name, title, 1000, 1000);
    c->SetFillColor(0);
    c->SetFillStyle(0);
    c->SetTopMargin(0.01);
    c->SetRightMargin(0.03);

    TLegend* leg   = new TLegend(0.65, 0.65, 0.975, 0.975);
    leg->SetFillStyle(0);
    leg->SetBorderSize(0);

    TString xTitle = "";
    THStack* stack = new THStack(name, title);
    for (Int_t i = 0; i < 5; i++) { 
      Ring*    ring = static_cast<Ring*>(fRings->At(i));
      Spectra* spec = ring->Get(which);
      if (!spec) { 
  Warning("PlotOne", "No spectra for %d", which);
  continue;
      }

      // Add to our stack 
      spec->Stack(stack, leg);

      // Get X title 
      if (xTitle.IsNull() && spec->Hist(true))
  xTitle = spec->Hist(true)->GetXaxis()->GetTitle();
      
      // If we're not at the last one continue 
      if (i < 4) continue;

      // Add primary/secondary entry to legend 
      spec->Stack(0, leg);

    }
    c->cd();
    if (!stack->GetHists() || 
  stack->GetHists()->GetEntries() < 0) {
      Warning("PlotOne", "No histograms added");
      return;
    }
    stack->Draw(Form("nostack %s", opt));
    stack->GetHistogram()->SetXTitle(xTitle);
    stack->GetHistogram()->GetListOfFunctions()->Add(leg);
    
    leg->Draw();

    if (which != Ring::kTypes) {
      c->SetLogx();
      c->SetLogy();
    }

    TLatex* ltx = new TLatex(0.02, 0.02, fTitle);
    ltx->SetNDC();
    ltx->SetTextColor(kRed+2);
    ltx->SetTextAlign(11);
    ltx->SetTextSize(0.02);
    ltx->Draw();
    stack->GetHistogram()->GetListOfFunctions()->Add(ltx);

    if (dir) {
      dir->cd();
      stack->Clone()->Write();
    }
      

    c->Modified();
    c->Update();
    c->cd();

    c->Print(Form("%s.pdf", name));
  }
  void Store(TDirectory* dir)
  {
    TDirectory* out = dir->mkdir(fTitle);
    out->cd();
    TIter next(fRings);
    Ring* ring = 0;
    while ((ring = static_cast<Ring*>(next()))) 
      ring->Store(out);
    dir->cd();
  }
  /* @} */

  Int_t Version() const { return 1; }
  Long64_t GetStatus() const { return fI; }
  
  /* @} */
    
  //------------------------------------------------------------------
  //------------------------------------------------------------------
  static TObject* GetChainOrDataSet(const char* file)
  {
    if (gSystem->AccessPathName(file)) return 0;

    TFile* in = TFile::Open(file, "READ");
    if (!in) return 0;

    TObject* ret = in->Get("tree");
    if (!ret) { 
      in->Close();
      return 0;
    }
    
    if (ret->IsA()->InheritsFrom(TChain::Class())) 
      static_cast<TChain*>(ret)->SetDirectory(0);
    else if (ret->IsA()->InheritsFrom(TDSet::Class())) 
      static_cast<TDSet*>(ret)->SetDirectory(0);
    else { 
      ::Warning("GetChainOrDataSet", "Found object is a %s", 
    ret->IsA()->GetName());
      ret = 0;
    }
    in->Close();
    return ret;
  }
  //------------------------------------------------------------------
  static TDSet* MakeDataSet(const TString& src=".", 
          Bool_t recursive=false, 
          Bool_t verbose=false)
  {
    TString dsFile(Form("%s/dataset.root", src.Data()));
    TDSet* dataset = static_cast<TDSet*>(GetChainOrDataSet(dsFile));
    if (dataset) {
      return dataset;
    }

    TChain* c = DoMakeChain(src, recursive, verbose);
    if (!c) return 0;
    
    dataset = new TDSet(*c, false);
    dataset->SetName("tree");
    dataset->SetLookedUp();
    dataset->Validate();
    
    delete c;
    if (dataset) { 
      TFile* out = TFile::Open(dsFile, "RECREATE");
      dataset->Write();
      dataset->SetDirectory(0);
      out->Close();
    }
      
    return dataset;
    
  }
  //------------------------------------------------------------------
  static TChain* MakeChain(const TString& src=".", 
         Bool_t recursive=false,
         Bool_t verbose=false)
  {
    TString chFile(Form("%s/chain.root", src.Data()));
    if (!gSystem->AccessPathName(chFile)) { 
      TFile* in = TFile::Open(chFile, "READ");
      if (in) { 
  TChain* ret = static_cast<TChain*>(in->Get("tree"));
  if (ret) {
    ret->SetDirectory(0);
    // ret->GetListOfFiles()->ls();
  }
  in->Close();
  if (ret) return ret;
      }
    }
    
    TChain* chain = DoMakeChain(src, recursive, verbose);
    if (chain) { 
      TFile* out = TFile::Open(chFile, "RECREATE");
      chain->Write();
      chain->SetDirectory(0);
      out->Close();
    }
      
    return chain;
  }
  //------------------------------------------------------------------
  static TChain* DoMakeChain(const TString& src=".", 
           Bool_t recursive=false,
           Bool_t verbose=false)
  {
    TChain* chain = new TChain("tree"); 
    TString savdir(gSystem->WorkingDirectory());
    TSystemDirectory d(gSystem->BaseName(src.Data()), src.Data());
    if (!ScanDirectory(&d, chain, "forward_tree_*", recursive, verbose)) {
      delete chain;
      chain = 0;
    }
    else if (!chain->GetListOfFiles() || 
  chain->GetListOfFiles()->GetEntries() <= 0) {
      delete chain;
      chain = 0;
    }
    return chain;
  }
  
  //------------------------------------------------------------------
  static Bool_t ScanDirectory(TSystemDirectory* dir,
            TChain*           chain, 
            const TString&    pattern, 
            Bool_t            recursive,
            Bool_t            verbose) 
  {
    if (!dir) {
      ::Error("ScanDirectory", "No diretory passed");
      return false;
    }
    if (verbose) ::Info("ScanDirectory", "Scanning %s", dir->GetName());

    Bool_t  ret = false;
    TRegexp wild(pattern, true);
    TString oldDir(gSystem->WorkingDirectory());
    TList* files = dir->GetListOfFiles();

    if (!gSystem->ChangeDirectory(oldDir)) { 
      ::Error("ScanDirectory", "Failed to go back to %s", 
        oldDir.Data());
      return false;
    }
    if (!files) {
      ::Warning("ScanDirectory", "No files");
      return false;
    }

    TList toAdd;
    toAdd.SetOwner();

    // Sort list of files and check if we should add it 
    files->Sort();
    TIter next(files);
    TSystemFile* file = 0;
    while ((file = static_cast<TSystemFile*>(next()))) {
      TString name(file->GetName());
      TString title(file->GetTitle());
      TString full(gSystem->ConcatFileName(file->GetTitle(), name.Data()));
      if (file->IsA()->InheritsFrom(TSystemDirectory::Class())) full = title;


      if (name.EqualTo(".")||name.EqualTo(".."))  {
  // Ignore special links 
  if (verbose) ::Info("ScanDirectory", "Ignoring special %s",
          name.Data());
  continue;
      }

      if (verbose) ::Info("ScanDirectory", "Looking at %s", full.Data());

      FileStat_t fs;
      if (gSystem->GetPathInfo(full.Data(), fs)) {
  ::Warning("ScanDirectory", "Cannot stat %s (%s)", 
      full.Data(), gSystem->WorkingDirectory());
  continue;
      }
      // Check if this is a directory 
      if (file->IsDirectory(full)) { 
  if (verbose) ::Info("ScanDirectory", "Got a directory: %s", 
          full.Data());
  if (recursive) {
    // if (title[0] == '/') 
    TSystemDirectory* d = new TSystemDirectory(file->GetName(),
                 full.Data());
    if (ScanDirectory(d, chain, pattern, recursive, verbose))
      ret = true;
    delete d;
  }
  continue;
      }

      // If this is not a root file, ignore 
      if (!name.EndsWith(".root") && 
    !name.EndsWith(".zip",TString::kIgnoreCase)) {
  if (verbose) ::Info("ScanDirectory", "Ignoring non-ROOT or ZIP %s",
          name.Data());
  continue;
      }

      // If this file does not contain AliESDs, ignore 
      if (!name.Contains(wild)) {
  if (verbose) ::Info("ScanDirectory", "%s does not match %s",
          name.Data(), pattern.Data());
  continue;
      }
      // Add 
      if (verbose) 
  ::Info("::ScanDirectory", "Candidate %s", full.Data());
      toAdd.Add(new TObjString(full));
    }
    TIter nextAdd(&toAdd);
    TObjString* s = 0;
    Int_t added = 0;
    while ((s = static_cast<TObjString*>(nextAdd()))) {
      // Info("ChainBuilder::ScanDirectory", 
      //      "Adding %s", s->GetString().Data());
      TString fn = s->GetString();
      if (!CheckFile(fn, chain, true/*verbose*/)) continue;
       
      added++;
    }
    if (added > 0) ret = true;
    if (verbose) ::Info("ScanDirectory", "Added %d files", added);

    gSystem->ChangeDirectory(oldDir);
    return ret;  
  }
  //------------------------------------------------------------------
  static Bool_t CheckFile(const TString& path, 
        TChain* chain,
        Bool_t verbose)
  {
    // Info("", "Checking %s", path.Data());
    TString fn   = path;

    gSystem->RedirectOutput("/dev/null", "w");
    TFile*  test = TFile::Open(fn, "READ");
    gSystem->RedirectOutput(0);
    if (!test) { 
      ::Warning("CheckFile", "Failed to open %s", fn.Data());
      return false;
    }
    
    Bool_t           ok = false;
    TObject*         o  = test->Get(chain->GetName());
    TTree*           t  = dynamic_cast<TTree*>(o);
    TFileCollection* c  = dynamic_cast<TFileCollection*>(o);
    if (t) {
      Int_t n = t->GetEntries();
      test->Close();
      chain->Add(fn, n);
      ok = true;
      if (verbose) ::Info("CheckFile", "Added file %s (%d)", fn.Data(), n);
    } else if (c) {
      chain->AddFileInfoList(c->GetList());
      ok = true;
      if (verbose) ::Info("CheckFile", "Added file collection %s", fn.Data());
    } else {
      // Let's try to find a TFileCollection 
      TList* l = test->GetListOfKeys();
      TIter next(l);
      TKey* k = 0;
      while ((k = static_cast<TKey*>(next()))) {
  TString cl(k->GetClassName());
  if (!cl.EqualTo("TFileCollection")) continue;
  c = dynamic_cast<TFileCollection*>(k->ReadObj());
  if (!c) { 
    ::Warning("CheckFile", "Returned collection invalid");
    continue;
  }
  // Info("", "Adding file collection");
  chain->AddFileInfoList(c->GetList());
  ok = true;
  if (verbose) ::Info("CheckFile", "Added file collection %s", fn.Data());
      }
      test->Close();
    }

    if (!ok) 
      ::Warning("CheckFile", 
    "The file %s does not contain the tree %s "
    "or a file collection", 
    path.Data(), chain->GetName());
    return ok;
  }

  static Bool_t Run(Long64_t maxEvents=-1, 
        const char* title="")
  {
    TStopwatch timer;
    timer.Start();
    TChain* chain = MakeChain("tuple");
    if (!chain) { 
      ::Error("Run", "No chain!");
      return false;
    }

    TupleSelector* s = new TupleSelector(title);
    Int_t status= chain->Process(s, "", maxEvents);
    timer.Print();
    return status >= 0;
  }
  static Bool_t Proof(Long64_t    maxEvents, 
          const char* opt="",
          const char* title="")
  {
    TStopwatch timer;
    timer.Start();
    TProof::Reset("lite:///?workers=8");
    TProof::Open("lite:///?workers=8");
    gProof->ClearCache();
    TString ali = gSystem->ExpandPathName("$(ALICE_PHYSICS)");
    TString fwd = ali + "/PWGLF/FORWARD/analysis2";
    gProof->AddIncludePath(Form("%s/include", ali.Data()));
    gProof->Load(Form("%s/scripts/LoadLibs.C",fwd.Data()), true);
    gProof->Exec("LoadLibs()");
    // gROOT->ProcessLine("gProof->SetLogLevel(5);");
    gProof->Load(Form("%s/scripts/TupleSelector.C+%s", fwd.Data(), opt),true);

    TDSet* dataset = MakeDataSet("tuple");
    if (!dataset) { 
      ::Error("Proof", "No dataset");
      return false;
    }
    
    TupleSelector* s = new TupleSelector(title);
    gProof->AddFeedback("rings");
    gProof->Process(dataset, s, "", maxEvents);
    timer.Print();
    return true; // status >= 0;
  }    

  /* @} */
  ClassDef(TupleSelector,2);

private:
  TupleSelector(const TupleSelector&); // {}
  TupleSelector& operator=(const TupleSelector&); // { return *this; } 

};


  
#endif
// Local Variables:
//   mode: C++
// End:
// 
// EOF
//