[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
class AliRunLoader;
class AliLoader;
class AliStack;
class AliRun;
class AliRawReader;
class AliFMD;
class AliFMDHit;
class AliFMDDigit;
class AliFMDSDigit;
class AliFMDRecPoint;
class AliESD;
class AliESDFMD;
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 
  };
  /** 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 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 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);
  
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),
      fMainESD(0),
      fESD(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),
      fGeoManager(0),
      fTreeMask(0),
      fIsInit(kFALSE)
  {}
  /** 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
  AliESD*       fMainESD;    // ESD Object
  AliESDFMD*    fESD;        // FMD ESD data  
  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
  TGeoManager*  fGeoManager; // Geometry manager
  Int_t         fTreeMask;   // Which tree's to load
  Bool_t        fIsInit;     // Have we been initialized 
  ClassDef(AliFMDInput,0)  //Hits for detector FMD
};

inline Bool_t AliFMDInput::ProcessHit(AliFMDHit*,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::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
8f6ee336	33	class AliRunLoader;
	34	class AliLoader;
	35	class AliStack;
	36	class AliRun;
d760ea03	37	class AliRawReader;
8f6ee336	38	class AliFMD;
8f6ee336	39	class AliFMDHit;
bf000c32	40	class AliFMDDigit;
	41	class AliFMDSDigit;
	42	class AliFMDRecPoint;
	43	class AliESD;
	44	class AliESDFMD;
8f6ee336	45	class TString;
	46	class TClonesArray;
	47	class TTree;
	48	class TGeoManager;
	49	class TParticle;
bf000c32	50	class TChain;
a1f80595	51
a1f80595	52	//___________________________________________________________________
9f662337	53	/** @class AliFMDInput
	54	@brief Base class for reading in various FMD data.
	55	The class loops over all found events. For each event the
	56	specified data is read in. The class then loops over all
	57	elements of the read data, and process these with user defined
	58	code.
	59	@code
	60	struct DigitInput : public AliFMDInput
	61	{
	62	DigitInput()
	63	{
	64	// Load digits
	65	AddLoad(kDigits);
	66	// Make a histogram
	67	fHist = new TH1F("adc", "ADC spectra", 1024, -.5, 1023.5);
	68	}
	69	// Process one digit.
	70	Bool_t ProcessDigit(AliFMDDigit* d)
	71	{
	72	fHist->Fill(d->Counts());
	73	return kTRUE;
	74	}
	75	// After processing all events, display spectrum
	76	Bool_t Finish()
	77	{
	78	fHist->Draw();
	79	}
	80	TH1F* fHist;
	81	};
	82
	83	void AdcSpectrum()
	84	{
	85	DigitInput di;
	86	di.Run();
	87	}
	88	@endcode
	89	This class allows for writing small scripts, that can be compiled
	90	with AcLIC, to do all sorts of tests, quick prototyping, and so
	91	on. It has proven to be quiet useful. One can load more than
	92	one type of data in one derived class, to for example to make
	93	comparisons between hits and reconstructed points. See also the
	94	various scripts in @c FMD/scripts.
	95	@ingroup FMD_util
	96	*/
a1f80595	97	class AliFMDInput : public TObject
	98	{
	99	public:
9f662337	100	/** The kinds of data that can be read in. */
a1f80595	101	enum ETrees {
8f6ee336	102	kHits = 1, // Hits
	103	kKinematics, // Kinematics (from sim)
	104	kDigits, // Digits
	105	kSDigits, // Summable digits
	106	kHeader, // Header information
	107	kRecPoints, // Reconstructed points
bf000c32	108	kESD, // Load ESD's
d760ea03	109	kRaw, // Read raw data
8f6ee336	110	kGeometry // Not really a tree
a1f80595	111	};
9f662337	112	/** CTOR */
a1f80595	113	AliFMDInput();
9f662337	114	/** CTOR
9f662337	115	@param gAliceFile galice file */
a1f80595	116	AliFMDInput(const char* gAliceFile);
9f662337	117	/** DTOR */
a1f80595	118	virtual ~AliFMDInput() {}
a1f80595	119
9f662337	120	/** Add a data type to load
9f662337	121	@param tree Data to load */
a1f80595	122	virtual void AddLoad(ETrees tree) { SETBIT(fTreeMask, tree); }
9f662337	123	/** Remove a data type to load
9f662337	124	@param tree Data to @e not load */
a1f80595	125	virtual void RemoveLoad(ETrees tree) { CLRBIT(fTreeMask, tree); }
9f662337	126	/** @return # of available events */
a1f80595	127	virtual Int_t NEvents() const;
a1f80595	128
9f662337	129	/** Initialize the class. If a user class overloads this member
	130	function, then this @e must be explicitly called
	131	@return @c false on error */
a1f80595	132	virtual Bool_t Init();
9f662337	133	/** Callled at the beginning of each event. If a user class
	134	overloads this member function, then this @e must be explicitly
	135	called.
	136	@param event Event number
	137	@return @c false on error */
a1f80595	138	virtual Bool_t Begin(Int_t event);
9f662337	139	/** Process one event. This loops over all the loaded data. Users
	140	can overload this member function, but then it's @e strongly
	141	recommended to explicitly call this classes version.
	142	@return @c false on error */
bf000c32	143	virtual Bool_t Event();
9f662337	144	/** Called at the end of each event.
9f662337	145	@return @c false on error */
a1f80595	146	virtual Bool_t End();
9f662337	147	/** Called at the end of the run.
9f662337	148	@return @c false on error */
a1f80595	149	virtual Bool_t Finish() { return kTRUE; }
9f662337	150	/** Run a full job.
9f662337	151	@return @c false on error */
a1f80595	152	virtual Bool_t Run();
bf000c32	153
9f662337	154	/** Loop over all hits, and call ProcessHit with that hit, and
	155	optionally the corresponding kinematics track.
	156	@return @c false on error */
bf000c32	157	virtual Bool_t ProcessHits();
9f662337	158	/** Loop over all digits, and call ProcessDigit for each digit.
9f662337	159	@return @c false on error */
bf000c32	160	virtual Bool_t ProcessDigits();
9f662337	161	/** Loop over all summable digits, and call ProcessSDigit for each
	162	digit.
	163	@return @c false on error */
bf000c32	164	virtual Bool_t ProcessSDigits();
9f662337	165	/** Loop over all digits read from raw data files, and call
	166	ProcessRawDigit for each digit.
	167	@return @c false on error */
d760ea03	168	virtual Bool_t ProcessRawDigits();
9f662337	169	/** Loop over all reconstructed points, and call ProcessRecPoint for
	170	each reconstructed point.
	171	@return @c false on error */
bf000c32	172	virtual Bool_t ProcessRecPoints();
a9579262	173	/** Loop over all ESD data, and call ProcessESD for each entry.
	174	@return @c false on error */
	175	virtual Bool_t ProcessESDs();
bf000c32	176
9f662337	177	/** Process one hit, and optionally it's corresponding kinematics
9f662337	178	track. Users should over this to process each hit.
a9579262	179	@param h Hit
a9579262	180	@param p Associated track
9f662337	181	@return @c false on error */
a9579262	182	virtual Bool_t ProcessHit(AliFMDHit* h, TParticle* p);
	183	/** Process one digit. Users should over this to process each
	184	digit.
	185	@param digit Digit
9f662337	186	@return @c false on error */
a9579262	187	virtual Bool_t ProcessDigit(AliFMDDigit* digit);
9f662337	188	/** Process one summable digit. Users should over this to process
9f662337	189	each summable digit.
a9579262	190	@param sdigit Summable digit
9f662337	191	@return @c false on error */
a9579262	192	virtual Bool_t ProcessSDigit(AliFMDSDigit* sdigit);
9f662337	193	/** Process one digit from raw data files. Users should over this
9f662337	194	to process each raw digit.
a9579262	195	@param digit Raw digit
9f662337	196	@return @c false on error */
a9579262	197	virtual Bool_t ProcessRawDigit(AliFMDDigit* digit);
9f662337	198	/** Process one reconstructed point. Users should over this to
9f662337	199	process each reconstructed point.
a9579262	200	@param point Reconstructed point
9f662337	201	@return @c false on error */
a9579262	202	virtual Bool_t ProcessRecPoint(AliFMDRecPoint* point);
9f662337	203	/** Process ESD data for the FMD. Users should overload this to
9f662337	204	deal with ESD data.
a9579262	205	@param d Detector number (1-3)
	206	@param r Ring identifier ('I' or 'O')
	207	@param s Sector number (0-19, or 0-39)
	208	@param t Strip number (0-511, or 0-255)
	209	@param eta Psuedo-rapidity
	210	@param mult Psuedo-multiplicity
9f662337	211	@return @c false on error */
a9579262	212	virtual Bool_t ProcessESD(UShort_t, Char_t, UShort_t, UShort_t,
a9579262	213	Float_t, Float_t);
bf000c32	214
a1f80595	215	protected:
02a27b50	216	/** Copy ctor
02a27b50	217	@param o Object to copy from */
b5ee4425	218	AliFMDInput(const AliFMDInput& o)
	219	: TObject(o),
	220	fGAliceFile(""),
	221	fLoader(0),
	222	fRun(0),
	223	fStack(0),
	224	fFMDLoader(0),
	225	fReader(0),
	226	fFMD(0),
	227	fMainESD(0),
	228	fESD(0),
	229	fTreeE(0),
	230	fTreeH(0),
	231	fTreeD(0),
	232	fTreeS(0),
	233	fTreeR(0),
	234	fTreeA(0),
	235	fChainE(0),
	236	fArrayE(0),
	237	fArrayH(0),
	238	fArrayD(0),
	239	fArrayS(0),
	240	fArrayR(0),
	241	fArrayA(0),
	242	fGeoManager(0),
	243	fTreeMask(0),
	244	fIsInit(kFALSE)
	245	{}
02a27b50	246	/** Assignement operator
	247	@return REference to this */
	248	AliFMDInput& operator=(const AliFMDInput&) { return *this; }
	249
a1f80595	250	TString fGAliceFile; // File name of gAlice file
	251	AliRunLoader* fLoader; // Loader of FMD data
	252	AliRun* fRun; // Run information
	253	AliStack* fStack; // Stack of particles
	254	AliLoader* fFMDLoader; // Loader of FMD data
d760ea03	255	AliRawReader* fReader; // Raw data reader
a1f80595	256	AliFMD* fFMD; // FMD object
bf000c32	257	AliESD* fMainESD; // ESD Object
bf000c32	258	AliESDFMD* fESD; // FMD ESD data
a1f80595	259	TTree* fTreeE; // Header tree
	260	TTree* fTreeH; // Hits tree
	261	TTree* fTreeD; // Digit tree
	262	TTree* fTreeS; // SDigit tree
	263	TTree* fTreeR; // RecPoint tree
d760ea03	264	TTree* fTreeA; // Raw data tree
bf000c32	265	TChain* fChainE; // Chain of ESD's
a1f80595	266	TClonesArray* fArrayE; // Event info array
	267	TClonesArray* fArrayH; // Hit info array
	268	TClonesArray* fArrayD; // Digit info array
	269	TClonesArray* fArrayS; // SDigit info array
d760ea03	270	TClonesArray* fArrayR; // Rec points info array
d760ea03	271	TClonesArray* fArrayA; // Raw data (digits) info array
8f6ee336	272	TGeoManager* fGeoManager; // Geometry manager
a1f80595	273	Int_t fTreeMask; // Which tree's to load
02a27b50	274	Bool_t fIsInit; // Have we been initialized
a1f80595	275	ClassDef(AliFMDInput,0) //Hits for detector FMD
	276	};
	277
a9579262	278	inline Bool_t AliFMDInput::ProcessHit(AliFMDHit,TParticle) { return kTRUE; }
	279	inline Bool_t AliFMDInput::ProcessDigit(AliFMDDigit*) { return kTRUE; }
	280	inline Bool_t AliFMDInput::ProcessSDigit(AliFMDSDigit*) { return kTRUE; }
	281	inline Bool_t AliFMDInput::ProcessRawDigit(AliFMDDigit*) { return kTRUE; }
	282	inline Bool_t AliFMDInput::ProcessRecPoint(AliFMDRecPoint*) { return kTRUE; }
	283	inline Bool_t AliFMDInput::ProcessESD(UShort_t,Char_t,UShort_t,UShort_t,
	284	Float_t,Float_t) { return kTRUE; }
	285
a1f80595	286
a1f80595	287	#endif
	288	//____________________________________________________________________
	289	//
	290	// Local Variables:
	291	// mode: C++
	292	// End:
	293	//
	294	// EOF
	295	//