AliFMDInput.h

Go to the documentation of this file.

#ifndef AliFMDInput_H
#define AliFMDInput_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
 * reserved. 
 *
 * See cxx source for full Copyright notice                               
 */
//___________________________________________________________________
//
// The classes defined here, are utility classes for reading in data
// for the FMD.  They are  put in a seperate library to not polute the
// normal libraries.  The classes are intended to be used as base
// classes for customized class that do some sort of analysis on the
// various types of data produced by the FMD. 
//___________________________________________________________________
#include <TNamed.h>
#ifndef ROOT_TString
# include <TString.h>
#endif
#ifndef ROOT_TArrayF
# include <TArrayF.h>
#endif
class AliTrackReference;
class AliRunLoader;
class AliLoader;
class AliStack;
class AliRun;
class AliRawReader;
class AliFMDRawReader;
class AliFMD;
class AliFMDHit;
class AliFMDDigit;
class AliFMDSDigit;
class AliFMDRecPoint;
class AliESDEvent;
class AliESDFMD;
class AliHeader;
class TString;
class TClonesArray;
class TTree;
class TGeoManager;
class TParticle;
class TChain;
class TSystemDirectory;

//___________________________________________________________________
class AliFMDInput : public TNamed
{
public:
  enum ETrees {
    kHits       = 1,  // Hits
    kKinematics,      // Kinematics (from sim)
    kDigits,          // Digits
    kSDigits,         // Summable digits 
    kHeader,          // Header information 
    kRecPoints,       // Reconstructed points
    kESD,             // Load ESD's
    kRaw,             // Read raw data 
    kGeometry,        // Not really a tree 
    kTrackRefs,       // Track references - also for BG study
    kRawCalib,        // Read raws and calibrate them
    kUser
  };
  AliFMDInput();
  AliFMDInput(const char* gAliceFile);
  virtual ~AliFMDInput() {}

  virtual void   AddLoad(ETrees tree)     { SETBIT(fTreeMask, tree); }
  virtual void   RemoveLoad(ETrees tree)  { CLRBIT(fTreeMask, tree); }
  virtual Int_t  NEvents() const;
  virtual Bool_t IsLoaded(ETrees tree)const { return TESTBIT(fTreeMask, tree); }
  virtual void SetLoads(UInt_t mask);
  virtual void SetLoads(const char* mask);
  virtual const char* LoadedString(Bool_t dataOnly=false) const;

  virtual Bool_t Init();
  virtual Bool_t Begin(Int_t event);
  virtual Bool_t Event();
  virtual Bool_t End();
  virtual Bool_t Finish() { return kTRUE; }
  virtual Bool_t Run(UInt_t maxEvents=0);

  virtual Bool_t ProcessHits();
  virtual Bool_t ProcessTrackRefs();
  virtual Bool_t ProcessTracks();
  virtual Bool_t ProcessStack();
  virtual Bool_t ProcessDigits();
  virtual Bool_t ProcessSDigits();
  virtual Bool_t ProcessRawDigits();
  virtual Bool_t ProcessRawCalibDigits();
  virtual Bool_t ProcessRecPoints();
  virtual Bool_t ProcessESDs();
  virtual Bool_t ProcessUsers();

  virtual Bool_t ProcessHit(AliFMDHit* h, TParticle* p);
  virtual Bool_t ProcessTrackRef(AliTrackReference* trackRef, TParticle* track);
  virtual Bool_t ProcessTrack(Int_t i, TParticle* p, AliFMDHit* h);
  virtual Bool_t ProcessParticle(Int_t i , TParticle* p);
  virtual Bool_t ProcessDigit(AliFMDDigit* digit);
  virtual Bool_t ProcessSDigit(AliFMDSDigit* sdigit);
  virtual Bool_t ProcessRawDigit(AliFMDDigit* digit);
  virtual Bool_t ProcessRawCalibDigit(AliFMDDigit* digit);
  virtual Bool_t ProcessRecPoint(AliFMDRecPoint* point);
  virtual Bool_t ProcessESD(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
          Float_t eta, Float_t mult);
  virtual Bool_t ProcessUser(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
           Float_t v);
  static TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max);

  void SetRawFile(const char* file) { if (file) fRawFile = file; }
  void SetInputDir(const char* dir) { fInputDir = (dir && dir[0] != '\0') 
      ? dir : "."; }
  static ETrees ParseLoad(const char* what);     
protected:
  AliFMDInput(const AliFMDInput& o) 
    : TNamed(o),
      fGAliceFile(""),
      fLoader(0),
      fRun(0),
      fStack(0),
      fFMDLoader(0),
      fReader(0),
      fFMDReader(0),
      fFMD(0),
      fESD(0),
      fESDEvent(0),
      fTreeE(0),
      fTreeH(0),
      fTreeTR(0),
      fTreeD(0),
      fTreeS(0),
      fTreeR(0),
      fTreeA(0),
      fChainE(0),
      fArrayE(0),
      fArrayH(0),
      fArrayTR(0),
      fArrayD(0),
      fArrayS(0),
      fArrayR(0),
      fArrayA(0),
      fHeader(0),
      fGeoManager(0),
      fTreeMask(0),
      fRawFile(""),      
      fInputDir("."),
      fIsInit(kFALSE),
      fEventCount(0),
      fNEvents(-1)
  {}
  AliFMDInput& operator=(const AliFMDInput&) { return *this; }
  virtual Float_t GetSignal(UShort_t d, Char_t r, UShort_t s, UShort_t t);

  static const char* TreeName(ETrees tree, bool shortest=false);

  static TChain* MakeChain(const char* what, const char* datadir, 
         bool recursive=false);
  static void ScanDirectory(TSystemDirectory* dir, 
          const TString& olddir, 
          TChain* chain, 
          const char* pattern, bool recursive);

  TString          fGAliceFile; // File name of gAlice file
  AliRunLoader*    fLoader;     // Loader of FMD data 
  AliRun*          fRun;        // Run information
  AliStack*        fStack;      // Stack of particles 
  AliLoader*       fFMDLoader;  // Loader of FMD data 
  AliRawReader*    fReader;     // Raw data reader 
  AliFMDRawReader* fFMDReader;  // FMD raw reader
  AliFMD*          fFMD;        // FMD object
  AliESDFMD*       fESD;        // FMD ESD data  
  AliESDEvent*     fESDEvent;   // ESD Event object. 
  TTree*           fTreeE;      // Header tree 
  TTree*           fTreeH;      // Hits tree
  TTree*           fTreeTR;     // Track Reference tree
  TTree*           fTreeD;      // Digit tree 
  TTree*           fTreeS;      // SDigit tree 
  TTree*           fTreeR;      // RecPoint tree
  TTree*           fTreeA;      // Raw data tree
  TChain*          fChainE;     // Chain of ESD's
  TClonesArray*    fArrayE;     // Event info array
  TClonesArray*    fArrayH;     // Hit info array
  TClonesArray*    fArrayTR;    // Hit info array
  TClonesArray*    fArrayD;     // Digit info array
  TClonesArray*    fArrayS;     // SDigit info array
  TClonesArray*    fArrayR;     // Rec points info array
  TClonesArray*    fArrayA;     // Raw data (digits) info array
  AliHeader*       fHeader;     // Header 
  TGeoManager*     fGeoManager; // Geometry manager
  Int_t            fTreeMask;   // Which tree's to load
  TString          fRawFile;    // Raw input file
  TString          fInputDir;   // Input directory
  Bool_t           fIsInit;     // Have we been initialized 
  Int_t            fEventCount; // Event counter 
  Int_t            fNEvents;    // The maximum number of events
  static const ETrees fgkAllLoads[kUser+1]; // List of all possible loads
  ClassDef(AliFMDInput,0)  //Hits for detector FMD
};

inline Bool_t AliFMDInput::ProcessHit(AliFMDHit*,TParticle*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessTrackRef(AliTrackReference*, 
             TParticle*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessTrack(Int_t,TParticle*,
          AliFMDHit*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessParticle(Int_t,TParticle*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessDigit(AliFMDDigit*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessSDigit(AliFMDSDigit*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessRawDigit(AliFMDDigit*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessRawCalibDigit(AliFMDDigit*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessRecPoint(AliFMDRecPoint*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessESD(UShort_t,Char_t,UShort_t,UShort_t,
              Float_t,Float_t) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessUser(UShort_t,Char_t,UShort_t,UShort_t,
               Float_t) { return kTRUE; }
inline Float_t AliFMDInput::GetSignal(UShort_t, Char_t, UShort_t, UShort_t) { 
  return 0.; }


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