Selector class for flow on the fly
authorsnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Feb 2007 11:14:49 +0000 (11:14 +0000)
committersnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Feb 2007 11:14:49 +0000 (11:14 +0000)
PWG2/FLOW/AliSelectorFoF.cxx [new file with mode: 0644]
PWG2/FLOW/AliSelectorFoF.h [new file with mode: 0644]

diff --git a/PWG2/FLOW/AliSelectorFoF.cxx b/PWG2/FLOW/AliSelectorFoF.cxx
new file mode 100644 (file)
index 0000000..56e5928
--- /dev/null
@@ -0,0 +1,506 @@
+/* AliSelectorFoF.cxx, v1.1 01/02/2007 esimili Exp */
+/* derived from AliSelector.cxx,v 1.17 2006/08/31 jgrosseo Exp */
+
+// The class definition in esdV0.h has been generated automatically
+// by the ROOT utility TTree::MakeSelector(). This class is derived
+// from the ROOT class TSelector. For more information on the TSelector
+// framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.
+
+// The following methods are defined in this file:
+//    Begin():        called everytime a loop on the tree starts,
+//                    a convenient place to create your histograms.
+//    SlaveBegin():   called after Begin(), when on PROOF called only on the
+//                    slave servers.
+//    Process():      called for each event, in this function you decide what
+//                    to read and fill your histograms.
+//    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
+//                    called only on the slave servers.
+//    Terminate():    called at the end of the loop on the tree,
+//                    a convenient place to draw/fit your histograms.
+//
+// To use this file, try the following session on your Tree T:
+//
+// Root > T->Process("AliSelector.C")
+// Root > T->Process("AliSelector.C","some options")
+// Root > T->Process("AliSelector.C+")
+//
+
+#include "AliSelectorFoF.h"
+
+#include <TStyle.h>
+#include <TSystem.h>
+#include <TCanvas.h>
+#include <TRegexp.h>
+#include <TTime.h>
+#include <TFriendElement.h>
+#include <TTree.h>
+#include <TChain.h>
+#include <TFile.h>
+#include <TTimeStamp.h>
+#include <TMath.h>
+#include <TObject.h>
+#include <TObjArray.h>
+#include <TSelector.h>
+
+#include "AliLog.h"     
+#include "AliESD.h"     
+#include "AliESDtrack.h"  
+#include "AliESDv0.h"    
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+using namespace std; //required for resolving the 'cout' symbol
+
+#include "AliFlowEvent.h"
+#include "AliFlowTrack.h"
+#include "AliFlowV0.h"
+#include "AliFlowConstants.h"
+#include "AliFlowSelection.h"
+#include "AliFlowMaker.h"
+#include "AliFlowAnalyser.h"
+#include "AliFlowWeighter.h"
+
+ClassImp(AliSelectorFoF)
+
+//-----------------------------------------------------------------------
+
+AliSelectorFoF::AliSelectorFoF() :
+  TSelector(),
+  fTree(0),
+  fESD(0),
+  fCountFiles(0),
+  fKineFile(0)
+{
+  //
+  // Constructor. Initialization of pointers
+  //
+  
+  fFlowEventFileName    = "fof_flowEvts.root" ;    
+  fFlowWgtFileName      = "fof_flowWgts.root" ;    
+  fFlowAnalysisFileName = "fof_flowAnal.root" ;    
+}
+
+//-----------------------------------------------------------------------
+
+AliSelectorFoF::~AliSelectorFoF()
+{
+  //
+  // Destructor
+  //
+
+ if (fTree) { fTree->ResetBranchAddresses() ; }
+
+ if (fESD)
+ {
+   delete fESD;
+   fESD = 0;
+ }
+}
+
+//-----------------------------------------------------------------------
+
+void AliSelectorFoF::CheckOptions()
+{
+  // checks the option string for the debug flag
+
+  AliLog::SetClassDebugLevel(ClassName(), AliLog::kInfo);
+
+  TString option = GetOption();
+
+  if (option.Contains("moredebug"))
+  {
+    printf("Enabling verbose debug mode for %s\n", ClassName());
+    AliLog::SetClassDebugLevel(ClassName(), AliLog::kDebug+1);
+    AliInfo(Form("Called with option %s.", option.Data()));
+  }
+  else if (option.Contains("debug"))
+  {
+    printf("Enabling debug mode for %s\n", ClassName());
+    AliLog::SetClassDebugLevel(ClassName(), AliLog::kDebug);
+    AliInfo(Form("Called with option %s.", option.Data()));
+  }
+}
+
+//-----------------------------------------------------------------------
+
+void AliSelectorFoF::Begin(TTree*)
+{
+  // The Begin() function is called at the start of the query.
+  // When running with PROOF Begin() is only called on the client.
+  // The tree argument is deprecated (on PROOF 0 is passed).
+  
+  cout << " HERE I begin !!! " << endl ; cout << endl ;
+
+  CheckOptions();
+
+  AliDebug(AliLog::kDebug, "============BEGIN===========");
+
+ // flags
+ fDoNothing     = kFALSE ;  // kFALSE ;
+ fOnFlyAnalysis = kTRUE ;  // kTRUE ;    
+ fOnFlyWeight   = kFALSE ;  // kTRUE ;
+ fSaveFlowEvents= kTRUE ;   // kTRUE ;
+
+// Maker part :
+ fFlowMaker = new AliFlowMaker() ;
+ // ESD Cuts
+ fFlowMaker->SetNHitsCut(1) ;
+ fFlowMaker->SetECut(0.01,100.) ; 
+ fFlowMaker->PrintCutList() ;
+
+// Opens flow event (output) file
+ if(fSaveFlowEvents)  
+ { 
+ // flow events file (output)
+  fFlowfile = new TFile(fFlowEventFileName.Data(),"RECREATE") ;
+  fFlowfile->cd() ; 
+  cout << " . Writing AliFlowEvents on  : " << fFlowEventFileName.Data()   << "  . " << endl ;
+ }
+// Analysis part :
+ if(fOnFlyWeight || fOnFlyAnalysis)  
+ { 
+  cout << " . Here the flow selection ... " << endl ;
+  cout << endl ;
+
+ // AliFlowSelection...
+  fFlowSelect = new AliFlowSelection() ;
+  // Event Cuts
+  fFlowSelect->SetCentralityCut(-1) ;
+  fFlowSelect->SetRunIdCut(-1) ;
+  // R.P. calculation cuts
+  for(int j=0;j<Flow::nHars;j++)
+  {
+   fFlowSelect->SetEtaCut(0., 1.1, j, 1) ;
+   fFlowSelect->SetPtCut(0.1, 10. , j, 1);
+  }
+  fFlowSelect->SetConstrainCut(kTRUE) ;
+  fFlowSelect->SetDcaGlobalCut(0.,0.1);
+  // Correlation analysis cuts (not all of them)
+  fFlowSelect->SetEtaPart(-1.1,1.1);
+  fFlowSelect->SetPtPart(0.1,10.);
+  fFlowSelect->SetConstrainablePart(kTRUE);
+  fFlowSelect->SetDcaGlobalPart(0.,0.1);
+  // V0 analysis cuts (not all of them ... they are useless anyway)
+  fFlowSelect->SetV0Mass(0.4875,0.5078) ;       // Mk0 = 0.49765
+  fFlowSelect->SetV0SideBands(0.08) ;
+  fFlowSelect->SetV0Pt(0.1,10.) ;
+  fFlowSelect->SetV0Eta(-2.1,2.1) ;
+  // print list :
+  cout << " . Selection for R.P. calculation: " << endl ;
+  fFlowSelect->PrintSelectionList() ;
+  cout << " . Selection for correlation analysis: " << endl ;
+  fFlowSelect->PrintList() ;
+  cout << " . Selection for V0 analysis: " << endl ;
+  fFlowSelect->PrintV0List() ;
+
+// Weight part :
+  if(fOnFlyWeight)  
+  { 
+   cout << " . Here the flow weighter ... " << endl ;
+   cout << endl ;
+
+  // AliFlowWeighter...
+   fFlowWeighter = new AliFlowWeighter(fFlowSelect) ;
+
+  // Wgt file (create)
+   fFlowWgtFile = new TFile(fFlowWgtFileName.Data(),"RECREATE") ;
+   fFlowWeighter->SetWgtFile(fFlowWgtFile) ;
+   cout << " . Writing Wgt Histograms on  : " << fFlowWeighter->GetWgtFileName()  << "  . " << endl ;
+   fFlowWeighter->Init() ;
+  }
+
+  if(fOnFlyAnalysis)  
+  { 
+   cout << " . Here the flow analysis ... " << endl ;
+   cout << endl ;
+
+  // AliFlowAnalyser...
+   fFlowAnal = new AliFlowAnalyser(fFlowSelect) ;
+
+  // Wgt file (read)
+   //TString wgtFileName = "fFlowPhiWgt.root" ;
+   //TFile* wgtFile = new TFile(wgtFileName.Data(),"READ");
+   //fFlowAnal->FillWgtArrays(wgtFile) ; // fix this !!!
+   //cout << " . Weights from  : " << fFlowAnal->GetWgtFileName() << "  . " << endl ;
+
+  // analysis file (output)
+   fFlowAnal->SetHistFileName(fFlowAnalysisFileName.Data()) ;
+   cout << " . Writing Analysis Histograms on  : " << fFlowAnal->GetHistFileName()   << "  . " << endl ;
+
+  // Analysis settings
+   fFlowAnal->SetFlowForV0(kFALSE) ;         // default kTRUE.
+   fFlowAnal->SetEtaSub() ;            // default kFALSE
+   //fFlowAnal->SetV1Ep1Ep2() ;        // default kFALSE.
+   fFlowAnal->SetShuffle() ;           // default kFALSE. shuffles track array
+   //fFlowAnal->SetRedoWgt();            // default kFALSE. recalculates phiWgt (even if phiWgt file is already there)
+   fFlowAnal->SetUsePhiWgt(kFALSE) ;   // default kTRUE if phiWgt file is there, kFALSE if not (& phiWgt file is created)
+   fFlowAnal->SetUseOnePhiWgt() ; // or // fFlowAnal->SetUseFirstLastPhiWgt() ; // uses 1 or 3 wgt histograms (default is 1)
+   fFlowAnal->SetUseBayWgt(kFALSE) ;   // default kFALSE. uses bayesian weights in P.id.
+   //fFlowAnal->SetUsePtWgt(); // default kFALSE. uses pT as a weight for RP determination
+   //fFlowAnal->SetUseEtaWgt();        // default kFALSE. uses eta as a weight for RP determination
+   fFlowAnal->Init() ;
+  }
+ }
+
+ cout << "                ... init is done " << endl ; 
+}
+
+//-----------------------------------------------------------------------
+
+void AliSelectorFoF::SlaveBegin(TTree* tree)
+{
+  // The SlaveBegin() function is called after the Begin() function.
+  // When running with PROOF SlaveBegin() is called on each slave server.
+  // The tree argument is deprecated (on PROOF 0 is passed).
+
+  CheckOptions();
+
+  AliDebug(AliLog::kDebug, "=======SLAVEBEGIN========");
+  AliDebug(AliLog::kDebug, Form("Hostname: %s", gSystem->HostName()));
+  AliDebug(AliLog::kDebug, Form("Time: %s", gSystem->Now().AsString()));
+
+  if (tree != 0) { Init(tree) ; }
+}
+
+//-----------------------------------------------------------------------
+
+void AliSelectorFoF::Init(TTree *tree)
+{
+  // The Init() function is called when the selector needs to initialize
+  // a new tree or chain. Typically here the branch addresses of the tree
+  // will be set. It is normaly not necessary to make changes to the
+  // generated code, but the routine can be extended by the user if needed.
+  // Init() will be called many times when running with PROOF.
+
+  AliDebug(AliLog::kDebug, "=========Init==========");
+
+  fTree = tree;
+
+  if (fTree == 0)
+  {
+   AliDebug(AliLog::kError, "ERROR: tree argument is 0.");
+   return;
+  }
+
+  // Set branch address
+  fTree->SetBranchAddress("ESD", &fESD);
+  if (fESD != 0) { AliDebug(AliLog::kInfo, "INFO: Found ESD branch in chain.") ; }
+}
+
+//-----------------------------------------------------------------------
+
+Bool_t AliSelectorFoF::Notify()
+{
+  // The Notify() function is called when a new file is opened. This
+  // can be either for a new TTree in a TChain or when when a new TTree
+  // is started when using PROOF. Typically here the branch pointers
+  // will be retrieved. It is normaly not necessary to make changes
+  // to the generated code, but the routine can be extended by the
+  // user if needed.
+
+  AliDebug(AliLog::kDebug, "=========NOTIFY==========");
+  AliDebug(AliLog::kDebug, Form("Hostname: %s", gSystem->HostName()));
+  AliDebug(AliLog::kDebug, Form("Time: %s", TTimeStamp(time(0)).AsString()));
+
+  ++fCountFiles;
+  if (fTree)
+  {
+    TFile *f = fTree->GetCurrentFile();
+    AliDebug(AliLog::kInfo, Form("Processing %d. file %s", fCountFiles, f->GetName()));
+  }
+  else
+  {
+    AliDebug(AliLog::kError, "fTree not available");
+  }
+
+  DeleteKinematicsFile();
+
+  return kTRUE;
+}
+
+//-----------------------------------------------------------------------
+
+Bool_t AliSelectorFoF::Process(Long64_t entry)
+{
+  // The Process() function is called for each entry in the tree (or possibly
+  // keyed object in the case of PROOF) to be processed. The entry argument
+  // specifies which entry in the currently loaded tree is to be processed.
+  // It can be passed to either TTree::GetEntry() or TBranch::GetEntry()
+  // to read either all or the required parts of the data. When processing
+  // keyed objects with PROOF, the object is already loaded and is available
+  // via the fObject pointer.
+  //
+  // This function should contain the "body" of the analysis. It can contain
+  // simple or elaborate selection criteria, run algorithms on the data
+  // of the event and typically fill histograms.
+
+  // WARNING when a selector is used with a TChain, you must use
+  //  the pointer to the current TTree to call GetEntry(entry).
+  //  The entry is always the local entry number in the current tree.
+  //  Assuming that fTree is the pointer to the TChain being processed,
+  //  use fTree->GetTree()->GetEntry(entry).
+
+  AliDebug(AliLog::kDebug, Form("=========PROCESS========== Entry %lld", entry));
+
+  if(!fTree)
+  {
+   AliDebug(AliLog::kError, "ERROR: fTree is 0.") ;
+   return kFALSE ;
+  }
+
+  fEventNumber = entry ;
+  fTree->GetTree()->GetEntry(fEventNumber) ;
+
+  if(fESD) { AliDebug(AliLog::kDebug, Form("ESD: We have %d tracks.", fESD->GetNumberOfTracks())); }
+  cout << " event !!! " << entry << endl ;
+
+  fRunID = fESD->GetRunNumber() ;
+  fEventNumber = fESD->GetEventNumber() ;
+  fNumberOfTracks = fESD->GetNumberOfTracks() ;
+  fNumberOfV0s = fESD->GetNumberOfV0s() ;
+
+  cout << " *evt n. " << fEventNumber << " (run " << fRunID << ") " << endl ;
+  cout << "  tracks: " << fNumberOfTracks << " ,   v0s " << fNumberOfV0s << endl ;
+
+ // Dummy Loop
+  if(fDoNothing)  { cout << " ... doing nothing ... " << endl ; return kTRUE; } 
+
+ // Instantiate a new AliFlowEvent
+  cout << " filling the flow event :| " << endl ;
+  fFlowEvent = fFlowMaker->FillFlowEvent(fESD) ;
+  if(!fFlowEvent) { cout << "!something bad occurred" << endl ; return kFALSE ; }
+  else                   { cout << " event filled :) " << entry << "                # t.G. ! #       "<< endl ; }
+
+ // Saves the AliFlowEvent
+  if(fSaveFlowEvents)
+  { 
+   cout << " saving flow event :| " << endl ;
+   TString strID = "" ; strID += entry ; 
+   fFlowfile->cd() ; fFlowEvent->Write(strID.Data()) ;
+   cout << " saved :) " << strID.Data() << "                # t.g. ! #       " << endl ; cout << endl ;  
+  }
+
+ // Weights
+  if(fOnFlyWeight)
+  { 
+   cout << " weightening :| " << endl ;
+   bool done = fFlowWeighter->WeightEvent(fFlowEvent) ;  
+   if(done) { cout << " weights done :) " << entry << "                # t.h.v. ! #       " << endl ; } 
+  }
+  
+ // On-Fly Analysis
+  if(fOnFlyAnalysis)  
+  {
+   cout << " doing analysis :| " << endl ;
+   bool done = fFlowAnal->Analyse(fFlowEvent) ;
+   if(done) { cout << " analysis done :) " << entry << "                # t.h.v. ! #       " << endl ; } 
+  }
+   
+  return kTRUE;
+}
+
+//-----------------------------------------------------------------------
+
+void AliSelectorFoF::SlaveTerminate()
+{
+  // The SlaveTerminate() function is called after all entries or objects
+  // have been processed. When running with PROOF SlaveTerminate() is called
+  // on each slave server.
+
+  AliDebug(AliLog::kDebug, "=======SLAVETERMINATE=======");
+
+  DeleteKinematicsFile();
+}
+
+//-----------------------------------------------------------------------
+
+void AliSelectorFoF::Terminate()
+{
+  // The Terminate() function is the last function to be called during
+  // a query. It always runs on the client, it can be used to present
+  // the results graphically or save the results to file.
+
+  AliDebug(AliLog::kDebug, "=========TERMINATE==========");
+
+  cout << " Finished ... " << endl ;
+
+  if(fDoNothing) { cout << "             ... & nothing was done ! " << endl ; cout << endl ; return ; }
+
+  cout << "  nTracks:  " << fFlowMaker->GetNgoodTracks() << endl ;   
+  cout << "  nV0s:  " << fFlowMaker->GetNgoodV0s()  << endl ;               
+  cout << "  nTracks (|eta|<0.5):  " << fFlowMaker->GetNgoodTracksEta() << endl ; 
+  cout << "  nTracks+:  " << fFlowMaker->GetNposiTracks() << endl ;         
+  cout << "  nTracks-:  " << fFlowMaker->GetNnegaTracks() << endl ;         
+  cout << "  nTracks unconstrained:  " << fFlowMaker->GetNunconstrained() << endl ;     
+  cout << "  Bayesian :  " ; 
+  for(int ii=0;ii<5;ii++) { cout << fFlowMaker->GetBayesianNorm(ii) << "   " ; } 
+  cout << " . " << endl ; 
+
+  if(fOnFlyWeight) { fFlowWeighter->Finish() ; delete fFlowWeighter ; }
+  
+  if(fOnFlyAnalysis) 
+  { 
+   cout << endl ; cout << "Particles normalized abundance:" << endl;  // shows the bayesian vector
+   fFlowAnal->Resolution() ; cout << endl;
+   fFlowAnal->PrintRunBayesian() ; cout << endl;
+   fFlowAnal->Finish() ;  cout << endl;
+   delete fFlowAnal ;
+  }
+     
+  if(fSaveFlowEvents) { fFlowfile->Close() ; cout << " file closed . " << endl ; }
+  delete fFlowMaker ;
+
+  delete fFlowSelect ;
+  
+  cout << endl ; 
+  return ;
+} 
+
+//-----------------------------------------------------------------------
+
+TTree* AliSelectorFoF::GetKinematics()
+{
+  // Returns kinematics tree corresponding to current ESD active in fTree
+  // Loads the kinematics from the kinematics file, the file is identified by replacing "AliESDs" to
+  // "Kinematics" in the file path of the ESD file. This is a hack, to be changed!
+
+  if (!fKineFile)
+  {
+    if(!fTree->GetCurrentFile()) { return 0 ; }
+
+    TString fileName(fTree->GetCurrentFile()->GetName());
+    fileName.ReplaceAll("AliESDs", "Kinematics");
+
+    // temporary workaround for PROOF bug #18505
+    fileName.ReplaceAll("#Kinematics.root#Kinematics.root", "#Kinematics.root");
+
+    AliDebug(AliLog::kInfo, Form("Opening %s", fileName.Data()));
+
+    fKineFile = TFile::Open(fileName);
+    if(!fKineFile) { return 0 ; }
+  }
+
+  return dynamic_cast<TTree*> (fKineFile->Get(Form("Event%d/TreeK", fTree->GetTree()->GetReadEntry())));
+}
+
+//-----------------------------------------------------------------------
+
+void AliSelectorFoF::DeleteKinematicsFile()
+{
+  //
+  // Closes the kinematics file and deletes the pointer.
+  //
+
+  if (fKineFile)
+  {
+    fKineFile->Close();
+    delete fKineFile;
+    fKineFile = 0;
+  }
+}
+
+//-----------------------------------------------------------------------
+
+
diff --git a/PWG2/FLOW/AliSelectorFoF.h b/PWG2/FLOW/AliSelectorFoF.h
new file mode 100644 (file)
index 0000000..538999c
--- /dev/null
@@ -0,0 +1,107 @@
+/* Id: AliSelectorFoF.h, v1.1 01/02/2007 esimili Exp */
+/* derived from AliSelector.h,v 1.10 2006/08/15 jgrosseo Exp */
+
+// This selector is only dependent on the ESD library, if you need the whole of AliROOT use AliSelectorRL
+#ifndef ALISELECTORF_H
+#define ALISELECTORF_H
+
+#include <TSelector.h>
+
+class AliFlowEvent;
+class AliFlowSelection;
+class AliFlowMaker;
+class AliFlowAnalyser; 
+class AliFlowWeighter;
+
+class AliESD;
+class AliESDtrack;
+class AliESDv0;
+
+class TFile;
+class TTree;
+class TString;
+
+class AliSelectorFoF : public TSelector {
+
+
+  public:
+
+    AliSelectorFoF();
+    virtual ~AliSelectorFoF();
+
+   // defalt AliSelector things
+    virtual Int_t   Version() const {return 1;}
+    virtual void    Begin(TTree*);
+    virtual void    SlaveBegin(TTree* tree);
+    virtual void    Init(TTree *tree);
+    virtual Bool_t  Notify();
+    virtual Bool_t  Process(Long64_t entry);
+    virtual void    SlaveTerminate();
+    virtual void    Terminate();
+
+  // output file name
+    void            SetFlowEventFileName(TString name)    { fFlowEventFileName = name ; }
+    void            SetFlowWeightFileName(TString name)   { fFlowWgtFileName = name ; }
+    void            SetFlowAnalysisFileName(TString name) { fFlowAnalysisFileName = name ; }
+    TString         GetFlowEventFileName()               { return fFlowEventFileName ; }
+    TString         GetFlowWeightFileName()              { return fFlowWgtFileName ; } 
+    TString         GetFlowAnalysisFileName()            { return fFlowAnalysisFileName ; } 
+
+  // tasks
+    void            SetDoNothing(Bool_t kt = kTRUE)      { fDoNothing = kt ; }
+    void            SetSaveFlowEvents(Bool_t kt = kTRUE) { fSaveFlowEvents = kt ; }
+    void            SetOnFlyAnalysis(Bool_t kt = kTRUE)  { fOnFlyAnalysis = kt ; }
+    void            SetOnFlyWeight(Bool_t kt = kTRUE)    { fOnFlyWeight = kt ; }
+
+
+ protected:
+  
+    TTree        *fTree;                 //! pointer to the TTree containing the events
+    AliESD*       fESD;                          //! "ESD" branch in fChain
+    Int_t        fCountFiles ;           //! number of processed file
+
+  // output file names
+    TString      fFlowEventFileName;     //! AliFlowEvents file 
+    TString      fFlowAnalysisFileName;  //! Analysis Histograms file
+    TString      fFlowWgtFileName;       //! Weights file
+
+  // defalt AliSelector things
+    TTree*       GetKinematics();
+    void         CheckOptions();
+
+
+ private:
+
+  // flow things
+    TFile*            fFlowfile ;         //! pointer to flow event file
+    TFile*            fFlowWgtFile ;      //! pointer to flow weight file
+    AliFlowEvent*     fFlowEvent ;        //! pointer to flow event
+    AliFlowSelection* fFlowSelect;       //! pointer to flow selection
+    AliFlowMaker*     fFlowMaker ;        //! flow evt maker
+    AliFlowWeighter*  fFlowWeighter ;     //! flow phi weights
+    AliFlowAnalyser*  fFlowAnal ;         //! flow analysis
+
+  // enumerators                                 
+    Int_t             fRunID;            //! last run ID
+    Int_t            fEventNumber ;      //! progressive enumeration of ESD events
+    Int_t             fNumberOfTracks ;   //! progressive enumeration of ESD tracks
+    Int_t             fNumberOfV0s ;      //! progressive enumeration of ESD V0
+    Int_t             fNumberOfEvents ;   //! total number of ESD events in file
+  // Flags
+    Bool_t            fDoNothing ;        //! flag for a dummy execution 
+    Bool_t            fSaveFlowEvents ;   //! flag for saving the flow events 
+    Bool_t            fOnFlyAnalysis ;    //! flag for on-fly analysis 
+    Bool_t            fOnFlyWeight ;      //! flag for on-fly analysis 
+
+  // defalt AliSelector things
+    void             DeleteKinematicsFile();
+    TFile*            fKineFile;          //! pointer to Kinematics.root if the file was opened
+
+    AliSelectorFoF(const AliSelectorFoF&);
+    AliSelectorFoF& operator=(const AliSelectorFoF&);
+
+  ClassDef(AliSelectorFoF,0);
+};
+
+#endif