[u/mrichter/AliRoot.git] / FMD / AliFMDInput.h

#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. 
/** @file    AliFMDInput.h
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:42:40 2006
    @brief   FMD utility classes for reading FMD data
*/
//___________________________________________________________________
/** @defgroup FMD_util Utility classes. 

    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 <TObject.h>
#ifndef ROOT_TString
# include <TString.h>
#endif
#ifndef ROOT_TArrayF
# include <TArrayF.h>
#endif
class AliRunLoader;
class AliLoader;
class AliStack;
class AliRun;
class AliRawReader;
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 AliFMDInput 
    @brief Base class for reading in various FMD data. 
    The class loops over all found events.  For each event the
    specified data is read in.   The class then loops over all
    elements of the read data, and process these with user defined
    code. 
    @code 
    struct DigitInput : public AliFMDInput 
    { 
      DigitInput() 
      { 
         // Load digits 
         AddLoad(kDigits);
	 // Make a histogram 
         fHist = new TH1F("adc", "ADC spectra", 1024, -.5, 1023.5);
      }
      // Process one digit. 
      Bool_t ProcessDigit(AliFMDDigit* d)
      { 
         fHist->Fill(d->Counts());
	 return kTRUE;
      }
      // After processing all events, display spectrum
      Bool_t Finish()
      {
        fHist->Draw();
      }
      TH1F* fHist;
    };

    void AdcSpectrum()
    { 
       DigitInput di;
       di.Run();
    }
    @endcode
    This class allows for writing small scripts, that can be compiled
    with AcLIC, to do all sorts of tests, quick prototyping, and so
    on.  It has proven to be quiet useful.   One can load more than
    one type of data in one derived class, to for example to make
    comparisons between hits and reconstructed points.   See also the
    various scripts in @c FMD/scripts. 
    @ingroup FMD_util
 */
class AliFMDInput : public TObject
{
public:
  /** The kinds of data that can be read in. */
  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 
    kTracks	      // Hits and tracs - for BG study	
  };
  /** CTOR  */
  AliFMDInput();
  /** CTOR
      @param gAliceFile galice file  */
  AliFMDInput(const char* gAliceFile);
  /** DTOR */
  virtual ~AliFMDInput() {}

  /** Add a data type to load 
      @param tree Data to load */
  virtual void   AddLoad(ETrees tree)     { SETBIT(fTreeMask, tree); }
  /** Remove a data type to load 
      @param tree Data to @e not load */
  virtual void   RemoveLoad(ETrees tree)  { CLRBIT(fTreeMask, tree); }
  /** @return # of available events */
  virtual Int_t  NEvents() const;

  /** Initialize the class.  If a user class overloads this member
      function, then this @e must be explicitly called
      @return @c false on error */
  virtual Bool_t Init();
  /** Callled at the beginning of each event. If a user class
      overloads this member  function, then this @e must be explicitly
      called. 
      @param event Event number
      @return @c false on error */
  virtual Bool_t Begin(Int_t event);
  /** Process one event.  This loops over all the loaded data.   Users
      can overload this member function, but then it's @e strongly
      recommended to explicitly call this classes version. 
      @return @c false on error  */
  virtual Bool_t Event();
  /** Called at the end of each event. 
      @return @c false on error  */
  virtual Bool_t End();
  /** Called at the end of the run.
      @return  @c false on error */
  virtual Bool_t Finish() { return kTRUE; }
  /** Run a full job. 
      @return @c false on error  */
  virtual Bool_t Run();

  /** Loop over all hits, and call ProcessHit with that hit, and
      optionally the corresponding kinematics track. 
      @return @c false on error  */
  virtual Bool_t ProcessHits();
  /** Loop over all tracks, and call ProcessTrack with each hit for
      that track
      @return @c false on error  */
  virtual Bool_t ProcessTracks();
  /** Loop over all digits, and call ProcessDigit for each digit.
      @return @c false on error  */
  virtual Bool_t ProcessDigits();
  /** Loop over all summable digits, and call ProcessSDigit for each
      digit. 
      @return @c false on error  */
  virtual Bool_t ProcessSDigits();
  /** Loop over all digits read from raw data files, and call
      ProcessRawDigit for each digit. 
      @return @c false on error  */
  virtual Bool_t ProcessRawDigits();
  /** Loop over all reconstructed points, and call ProcessRecPoint for
      each reconstructed point. 
      @return @c false on error  */
  virtual Bool_t ProcessRecPoints();
  /** Loop over all ESD data, and call ProcessESD for each entry.
      @return  @c false on error  */
  virtual Bool_t ProcessESDs();

  /** Process one hit, and optionally it's corresponding kinematics
      track.  Users should over this to process each hit. 
      @param h Hit 
      @param p Associated track
      @return  @c false on error   */
  virtual Bool_t ProcessHit(AliFMDHit* h, TParticle* p);
  /** Process one hit per track. Users should over this to process
      each hit. 
      @param i Track number 
      @param p Track  
      @param h Associated Hit
      @return  @c false on error   */
  virtual Bool_t ProcessTrack(Int_t i, TParticle* p, AliFMDHit* h);
  /** Process one digit.  Users should over this to process each
      digit. 
      @param digit Digit
      @return  @c false on error   */
  virtual Bool_t ProcessDigit(AliFMDDigit* digit);
  /** Process one summable digit.  Users should over this to process
      each summable digit.  
      @param sdigit Summable digit
      @return  @c false on error   */
  virtual Bool_t ProcessSDigit(AliFMDSDigit* sdigit);
  /** Process one digit from raw data files.  Users should over this
      to process each raw digit.  
      @param digit Raw digit
      @return  @c false on error   */
  virtual Bool_t ProcessRawDigit(AliFMDDigit* digit);
  /** Process one reconstructed point.  Users should over this to
      process each reconstructed point.  
      @param point Reconstructed point 
      @return  @c false on error   */
  virtual Bool_t ProcessRecPoint(AliFMDRecPoint* point);
  /** Process ESD data for the FMD.  Users should overload this to
      deal with ESD data. 
      @param d    Detector number (1-3)
      @param r    Ring identifier ('I' or 'O')
      @param s    Sector number (0-19, or 0-39)
      @param t    Strip number (0-511, or 0-255)
      @param eta  Psuedo-rapidity 
      @param mult Psuedo-multiplicity 
      @return  @c false on error  */
  virtual Bool_t ProcessESD(UShort_t, Char_t, UShort_t, UShort_t, 
			    Float_t, Float_t);
  /** Service function to make a logarithmic axis. 
      @param n    Number of bins 
      @param min  Minimum of axis 
      @param max  Maximum of axis. 
      @return An array with the bin boundaries. */
  static TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max);

  /** Set the raw data input 
      @param file File name - if empty, assume simulated raw. */
  void SetRawFile(const char* file) { if (file) fRawFile = file; }
     
protected:
  /** Copy ctor 
      @param o Object to copy from  */
  AliFMDInput(const AliFMDInput& o) 
    : TObject(o),
      fGAliceFile(""),
      fLoader(0),
      fRun(0),
      fStack(0),
      fFMDLoader(0),
      fReader(0),
      fFMD(0),
      fESD(0),
      fESDEvent(0),
      fTreeE(0),
      fTreeH(0),
      fTreeD(0),
      fTreeS(0),
      fTreeR(0),
      fTreeA(0),
      fChainE(0),
      fArrayE(0),
      fArrayH(0),
      fArrayD(0),
      fArrayS(0),
      fArrayR(0),
      fArrayA(0),
      fHeader(0),
      fGeoManager(0),
      fTreeMask(0),
      fRawFile(""),      
      fIsInit(kFALSE),
      fEventCount(0)
  {}
  /** Assignement operator 
      @return  REference to this */
  AliFMDInput& operator=(const AliFMDInput&) { return *this; }

  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 
  AliFMD*       fFMD;        // FMD object
  AliESDFMD*    fESD;        // FMD ESD data  
  AliESDEvent*  fESDEvent;   // ESD Event object. 
  TTree*        fTreeE;      // Header tree 
  TTree*        fTreeH;      // Hits 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* 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
  Bool_t        fIsInit;     // Have we been initialized 
  Int_t         fEventCount; // Event counter 
  ClassDef(AliFMDInput,0)  //Hits for detector FMD
};

inline Bool_t AliFMDInput::ProcessHit(AliFMDHit*,TParticle*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessTrack(Int_t,TParticle*,
					AliFMDHit*) { 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::ProcessRecPoint(AliFMDRecPoint*) { return kTRUE; }
inline Bool_t AliFMDInput::ProcessESD(UShort_t,Char_t,UShort_t,UShort_t,
				      Float_t,Float_t) { return kTRUE; }


#endif
//____________________________________________________________________
//
// Local Variables:
//   mode: C++
// End:
//
// EOF
//
Commit	Line	Data
a1f80595	1	#ifndef AliFMDInput_H
	2	#define AliFMDInput_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
	4	* reserved.
	5	*
	6	* See cxx source for full Copyright notice
	7	*/
02a27b50	8	//___________________________________________________________________
	9	//
	10	// The classes defined here, are utility classes for reading in data
	11	// for the FMD. They are put in a seperate library to not polute the
	12	// normal libraries. The classes are intended to be used as base
	13	// classes for customized class that do some sort of analysis on the
	14	// various types of data produced by the FMD.
c2fc1258	15	/** @file AliFMDInput.h
	16	@author Christian Holm Christensen <cholm@nbi.dk>
	17	@date Mon Mar 27 12:42:40 2006
	18	@brief FMD utility classes for reading FMD data
	19	*/
a1f80595	20	//___________________________________________________________________
9f662337	21	/** @defgroup FMD_util Utility classes.
	22
	23	The classes defined here, are utility classes for reading in data
	24	for the FMD. They are put in a seperate library to not polute the
	25	normal libraries. The classes are intended to be used as base
	26	classes for customized class that do some sort of analysis on the
	27	various types of data produced by the FMD.
	28	*/
8f6ee336	29	#include <TObject.h>
a1f80595	30	#ifndef ROOT_TString
	31	# include <TString.h>
	32	#endif
7003fbd0	33	#ifndef ROOT_TArrayF
	34	# include <TArrayF.h>
	35	#endif
8f6ee336	36	class AliRunLoader;
	37	class AliLoader;
	38	class AliStack;
	39	class AliRun;
d760ea03	40	class AliRawReader;
8f6ee336	41	class AliFMD;
8f6ee336	42	class AliFMDHit;
bf000c32	43	class AliFMDDigit;
	44	class AliFMDSDigit;
	45	class AliFMDRecPoint;
df137876	46	class AliESDEvent;
bf000c32	47	class AliESDFMD;
9b98d361	48	class AliHeader;
8f6ee336	49	class TString;
	50	class TClonesArray;
	51	class TTree;
	52	class TGeoManager;
	53	class TParticle;
bf000c32	54	class TChain;
a1f80595	55
a1f80595	56	//___________________________________________________________________
9f662337	57	/** @class AliFMDInput
	58	@brief Base class for reading in various FMD data.
	59	The class loops over all found events. For each event the
	60	specified data is read in. The class then loops over all
	61	elements of the read data, and process these with user defined
	62	code.
	63	@code
	64	struct DigitInput : public AliFMDInput
	65	{
	66	DigitInput()
	67	{
	68	// Load digits
	69	AddLoad(kDigits);
	70	// Make a histogram
	71	fHist = new TH1F("adc", "ADC spectra", 1024, -.5, 1023.5);
	72	}
	73	// Process one digit.
	74	Bool_t ProcessDigit(AliFMDDigit* d)
	75	{
	76	fHist->Fill(d->Counts());
	77	return kTRUE;
	78	}
	79	// After processing all events, display spectrum
	80	Bool_t Finish()
	81	{
	82	fHist->Draw();
	83	}
	84	TH1F* fHist;
	85	};
	86
	87	void AdcSpectrum()
	88	{
	89	DigitInput di;
	90	di.Run();
	91	}
	92	@endcode
	93	This class allows for writing small scripts, that can be compiled
	94	with AcLIC, to do all sorts of tests, quick prototyping, and so
	95	on. It has proven to be quiet useful. One can load more than
	96	one type of data in one derived class, to for example to make
	97	comparisons between hits and reconstructed points. See also the
	98	various scripts in @c FMD/scripts.
	99	@ingroup FMD_util
	100	*/
a1f80595	101	class AliFMDInput : public TObject
	102	{
	103	public:
9f662337	104	/** The kinds of data that can be read in. */
a1f80595	105	enum ETrees {
8f6ee336	106	kHits = 1, // Hits
	107	kKinematics, // Kinematics (from sim)
	108	kDigits, // Digits
	109	kSDigits, // Summable digits
	110	kHeader, // Header information
	111	kRecPoints, // Reconstructed points
bf000c32	112	kESD, // Load ESD's
d760ea03	113	kRaw, // Read raw data
f95a63c4	114	kGeometry, // Not really a tree
f95a63c4	115	kTracks // Hits and tracs - for BG study
a1f80595	116	};
9f662337	117	/** CTOR */
a1f80595	118	AliFMDInput();
9f662337	119	/** CTOR
9f662337	120	@param gAliceFile galice file */
a1f80595	121	AliFMDInput(const char* gAliceFile);
9f662337	122	/** DTOR */
a1f80595	123	virtual ~AliFMDInput() {}
a1f80595	124
9f662337	125	/** Add a data type to load
9f662337	126	@param tree Data to load */
a1f80595	127	virtual void AddLoad(ETrees tree) { SETBIT(fTreeMask, tree); }
9f662337	128	/** Remove a data type to load
9f662337	129	@param tree Data to @e not load */
a1f80595	130	virtual void RemoveLoad(ETrees tree) { CLRBIT(fTreeMask, tree); }
9f662337	131	/** @return # of available events */
a1f80595	132	virtual Int_t NEvents() const;
a1f80595	133
9f662337	134	/** Initialize the class. If a user class overloads this member
	135	function, then this @e must be explicitly called
	136	@return @c false on error */
a1f80595	137	virtual Bool_t Init();
9f662337	138	/** Callled at the beginning of each event. If a user class
	139	overloads this member function, then this @e must be explicitly
	140	called.
	141	@param event Event number
	142	@return @c false on error */
a1f80595	143	virtual Bool_t Begin(Int_t event);
9f662337	144	/** Process one event. This loops over all the loaded data. Users
	145	can overload this member function, but then it's @e strongly
	146	recommended to explicitly call this classes version.
	147	@return @c false on error */
bf000c32	148	virtual Bool_t Event();
9f662337	149	/** Called at the end of each event.
9f662337	150	@return @c false on error */
a1f80595	151	virtual Bool_t End();
9f662337	152	/** Called at the end of the run.
9f662337	153	@return @c false on error */
a1f80595	154	virtual Bool_t Finish() { return kTRUE; }
9f662337	155	/** Run a full job.
9f662337	156	@return @c false on error */
a1f80595	157	virtual Bool_t Run();
bf000c32	158
9f662337	159	/** Loop over all hits, and call ProcessHit with that hit, and
	160	optionally the corresponding kinematics track.
	161	@return @c false on error */
bf000c32	162	virtual Bool_t ProcessHits();
f95a63c4	163	/** Loop over all tracks, and call ProcessTrack with each hit for
	164	that track
	165	@return @c false on error */
	166	virtual Bool_t ProcessTracks();
9f662337	167	/** Loop over all digits, and call ProcessDigit for each digit.
9f662337	168	@return @c false on error */
bf000c32	169	virtual Bool_t ProcessDigits();
9f662337	170	/** Loop over all summable digits, and call ProcessSDigit for each
	171	digit.
	172	@return @c false on error */
bf000c32	173	virtual Bool_t ProcessSDigits();
9f662337	174	/** Loop over all digits read from raw data files, and call
	175	ProcessRawDigit for each digit.
	176	@return @c false on error */
d760ea03	177	virtual Bool_t ProcessRawDigits();
9f662337	178	/** Loop over all reconstructed points, and call ProcessRecPoint for
	179	each reconstructed point.
	180	@return @c false on error */
bf000c32	181	virtual Bool_t ProcessRecPoints();
a9579262	182	/** Loop over all ESD data, and call ProcessESD for each entry.
	183	@return @c false on error */
	184	virtual Bool_t ProcessESDs();
bf000c32	185
9f662337	186	/** Process one hit, and optionally it's corresponding kinematics
9f662337	187	track. Users should over this to process each hit.
a9579262	188	@param h Hit
a9579262	189	@param p Associated track
9f662337	190	@return @c false on error */
a9579262	191	virtual Bool_t ProcessHit(AliFMDHit* h, TParticle* p);
f95a63c4	192	/** Process one hit per track. Users should over this to process
	193	each hit.
	194	@param i Track number
	195	@param p Track
	196	@param h Associated Hit
	197	@return @c false on error */
	198	virtual Bool_t ProcessTrack(Int_t i, TParticle* p, AliFMDHit* h);
a9579262	199	/** Process one digit. Users should over this to process each
	200	digit.
	201	@param digit Digit
9f662337	202	@return @c false on error */
a9579262	203	virtual Bool_t ProcessDigit(AliFMDDigit* digit);
9f662337	204	/** Process one summable digit. Users should over this to process
9f662337	205	each summable digit.
a9579262	206	@param sdigit Summable digit
9f662337	207	@return @c false on error */
a9579262	208	virtual Bool_t ProcessSDigit(AliFMDSDigit* sdigit);
9f662337	209	/** Process one digit from raw data files. Users should over this
9f662337	210	to process each raw digit.
a9579262	211	@param digit Raw digit
9f662337	212	@return @c false on error */
a9579262	213	virtual Bool_t ProcessRawDigit(AliFMDDigit* digit);
9f662337	214	/** Process one reconstructed point. Users should over this to
9f662337	215	process each reconstructed point.
a9579262	216	@param point Reconstructed point
9f662337	217	@return @c false on error */
a9579262	218	virtual Bool_t ProcessRecPoint(AliFMDRecPoint* point);
9f662337	219	/** Process ESD data for the FMD. Users should overload this to
9f662337	220	deal with ESD data.
a9579262	221	@param d Detector number (1-3)
	222	@param r Ring identifier ('I' or 'O')
	223	@param s Sector number (0-19, or 0-39)
	224	@param t Strip number (0-511, or 0-255)
	225	@param eta Psuedo-rapidity
	226	@param mult Psuedo-multiplicity
9f662337	227	@return @c false on error */
a9579262	228	virtual Bool_t ProcessESD(UShort_t, Char_t, UShort_t, UShort_t,
a9579262	229	Float_t, Float_t);
69893a66	230	/** Service function to make a logarithmic axis.
	231	@param n Number of bins
	232	@param min Minimum of axis
	233	@param max Maximum of axis.
	234	@return An array with the bin boundaries. */
	235	static TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max);
039842fe	236
	237	/** Set the raw data input
	238	@param file File name - if empty, assume simulated raw. */
	239	void SetRawFile(const char* file) { if (file) fRawFile = file; }
	240
a1f80595	241	protected:
02a27b50	242	/** Copy ctor
02a27b50	243	@param o Object to copy from */
b5ee4425	244	AliFMDInput(const AliFMDInput& o)
	245	: TObject(o),
	246	fGAliceFile(""),
	247	fLoader(0),
	248	fRun(0),
	249	fStack(0),
	250	fFMDLoader(0),
	251	fReader(0),
	252	fFMD(0),
b5ee4425	253	fESD(0),
df137876	254	fESDEvent(0),
b5ee4425	255	fTreeE(0),
	256	fTreeH(0),
	257	fTreeD(0),
	258	fTreeS(0),
	259	fTreeR(0),
	260	fTreeA(0),
	261	fChainE(0),
	262	fArrayE(0),
	263	fArrayH(0),
	264	fArrayD(0),
	265	fArrayS(0),
	266	fArrayR(0),
	267	fArrayA(0),
17e542eb	268	fHeader(0),
b5ee4425	269	fGeoManager(0),
b5ee4425	270	fTreeMask(0),
6ce810fc	271	fRawFile(""),
17e542eb	272	fIsInit(kFALSE),
17e542eb	273	fEventCount(0)
b5ee4425	274	{}
02a27b50	275	/** Assignement operator
	276	@return REference to this */
	277	AliFMDInput& operator=(const AliFMDInput&) { return *this; }
	278
a1f80595	279	TString fGAliceFile; // File name of gAlice file
	280	AliRunLoader* fLoader; // Loader of FMD data
	281	AliRun* fRun; // Run information
	282	AliStack* fStack; // Stack of particles
	283	AliLoader* fFMDLoader; // Loader of FMD data
d760ea03	284	AliRawReader* fReader; // Raw data reader
a1f80595	285	AliFMD* fFMD; // FMD object
bf000c32	286	AliESDFMD* fESD; // FMD ESD data
df137876	287	AliESDEvent* fESDEvent; // ESD Event object.
a1f80595	288	TTree* fTreeE; // Header tree
	289	TTree* fTreeH; // Hits tree
	290	TTree* fTreeD; // Digit tree
	291	TTree* fTreeS; // SDigit tree
	292	TTree* fTreeR; // RecPoint tree
d760ea03	293	TTree* fTreeA; // Raw data tree
bf000c32	294	TChain* fChainE; // Chain of ESD's
a1f80595	295	TClonesArray* fArrayE; // Event info array
	296	TClonesArray* fArrayH; // Hit info array
	297	TClonesArray* fArrayD; // Digit info array
	298	TClonesArray* fArrayS; // SDigit info array
d760ea03	299	TClonesArray* fArrayR; // Rec points info array
d760ea03	300	TClonesArray* fArrayA; // Raw data (digits) info array
9b98d361	301	AliHeader* fHeader; // Header
8f6ee336	302	TGeoManager* fGeoManager; // Geometry manager
a1f80595	303	Int_t fTreeMask; // Which tree's to load
039842fe	304	TString fRawFile; // Raw input file
02a27b50	305	Bool_t fIsInit; // Have we been initialized
69893a66	306	Int_t fEventCount; // Event counter
a1f80595	307	ClassDef(AliFMDInput,0) //Hits for detector FMD
	308	};
	309
a9579262	310	inline Bool_t AliFMDInput::ProcessHit(AliFMDHit,TParticle) { return kTRUE; }
f95a63c4	311	inline Bool_t AliFMDInput::ProcessTrack(Int_t,TParticle*,
f95a63c4	312	AliFMDHit*) { return kTRUE; }
a9579262	313	inline Bool_t AliFMDInput::ProcessDigit(AliFMDDigit*) { return kTRUE; }
	314	inline Bool_t AliFMDInput::ProcessSDigit(AliFMDSDigit*) { return kTRUE; }
	315	inline Bool_t AliFMDInput::ProcessRawDigit(AliFMDDigit*) { return kTRUE; }
	316	inline Bool_t AliFMDInput::ProcessRecPoint(AliFMDRecPoint*) { return kTRUE; }
	317	inline Bool_t AliFMDInput::ProcessESD(UShort_t,Char_t,UShort_t,UShort_t,
	318	Float_t,Float_t) { return kTRUE; }
	319
a1f80595	320
a1f80595	321	#endif
	322	//____________________________________________________________________
	323	//
	324	// Local Variables:
	325	// mode: C++
	326	// End:
	327	//
	328	// EOF
	329	//