[u/mrichter/AliRoot.git] / MUON / AliMUONData.h

#ifndef ALIMUONDATA_H
#define ALIMUONDATA_H
//
/*  Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */
// Revision of includes 07/05/2004
//
/// \ingroup base
/// \class AliMUONData
/// \brief Class containing MUON data: hits, digits, rawclusters, globaltrigger, 
/// localtrigger, etc ...
///
//  Author: Gines Martinez, Subatech,  September 2003

#include <TNamed.h>

#include "AliLoader.h"

class AliMUONConstants;
class AliMUONRawCluster;
class AliMUONTrack;
class AliMUONTriggerTrack;
class AliMUONDigit;
class AliMUONHit;
class AliMUONLocalTrigger;
class AliMUONRegionalTrigger;
class AliMUONGlobalTrigger;

class AliRunLoader;

class TClonesArray;
class TNamed;
class TObjArray;
class TTree;
class TIterator;
class TArrayI;


//__________________________________________________________________
/////////////////////////////////////////////////////////////////////
//                                                                 //
//  class AliMUONData                                              //
//                                                                 //
/////////////////////////////////////////////////////////////////////

class AliMUONData : public TNamed 
{
  public:
  
  //  enum EChamberIteration { kAllChambers, kTrackingChambers, kTriggerChambers };
  
    AliMUONData();
    AliMUONData(AliLoader * loader, const char* name, const char* title);
    AliMUONData(const char* galiceFile);
    virtual ~AliMUONData();  
    virtual void   AddDigit(Int_t id, const AliMUONDigit& digit); // use copy constructor
    virtual void   AddSDigit(Int_t id, const AliMUONDigit& digit); // use copy constructor
    virtual void   AddHit(Int_t fIshunt, Int_t track, Int_t detElemId, 
			  Int_t idpart, Float_t X, Float_t Y, Float_t Z, 
			  Float_t tof, Float_t momentum, Float_t theta, 
			  Float_t phi, Float_t length, Float_t destep, 
			  Float_t Xref,Float_t Yref,Float_t Zref);
    
    virtual void   AddGlobalTrigger(const AliMUONGlobalTrigger& trigger); // use copy constructor

    virtual void   AddLocalTrigger(const AliMUONLocalTrigger& trigger); // use copy constructor
 
    virtual void   AddRegionalTrigger(const AliMUONRegionalTrigger& trigger); // use copy constructor

    virtual void   AddRawCluster(Int_t id, const AliMUONRawCluster& clust);
    virtual void   AddRecTrack(const AliMUONTrack& track);
    virtual void   AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack);

    TClonesArray*  Hits() {return fHits;} ///< Return hits
    TClonesArray*  Digits(Int_t DetectionPlane) const;
    TClonesArray*  SDigits(Int_t DetectionPlane) const;
    TClonesArray*  LocalTrigger() const;
    TClonesArray*  RegionalTrigger() const;
    TClonesArray*  GlobalTrigger() const;    
    TClonesArray*  RawClusters(Int_t DetectionPlane);
    
                    /// Return reconstructed tracks
    TClonesArray*  RecTracks() {return fRecTracks;} 
                   /// Return reconstructed trigger tracks
    TClonesArray*  RecTriggerTracks() {return fRecTriggerTracks;}

    void           GetTrack(Int_t it) const;
    Int_t          GetNtracks() const;
    void           GetDigits() const;
    void           GetSDigits() const;
    void           GetRawClusters() const;
    void           GetTrigger() const;
    void           GetTriggerD() const;
    void           GetRecTracks() const;
    void           GetRecTriggerTracks() const;

    Int_t          GetSplitLevel() const {return fSplitLevel;}

    Bool_t        IsRawClusterBranchesInTree();
    Bool_t        IsDigitsBranchesInTree();
    Bool_t        IsTriggerBranchesInTree();
    Bool_t        IsTriggerBranchesInTreeD();
    Bool_t        IsTrackBranchesInTree();
    Bool_t        IsTriggerTrackBranchesInTree();

                       /// Get loader
    virtual AliLoader* GetLoader() const { return fLoader; }
                       /// Set loader
    virtual void       SetLoader(AliLoader * loader) {fLoader=loader;}    
    
    virtual void   Fill(Option_t* opt=" ");
    virtual void   MakeBranch(Option_t *opt=" ");
    virtual void   SetDataContainer(Option_t *opt=" ");
    virtual void   SetTreeAddress(Option_t *opt=" ");
    
                   /// Set split level
    void           SetSplitLevel(Int_t SplitLevel) {fSplitLevel=SplitLevel;}
    
    virtual void Print(Option_t* opt="") const;
    
    virtual void   ResetHits();
    virtual void   ResetDigits();
    virtual void   ResetSDigits();
    virtual void   ResetTrigger();
    virtual void   ResetRawClusters();
    virtual void   ResetRecTracks();
    virtual void   ResetRecTriggerTracks();
  
                   /// Return tree with hits
    TTree*         TreeH() {return fLoader->TreeH(); }
                   /// Return tree with digits
    TTree*         TreeD() {return fLoader->TreeD(); }
                   /// Return tree with summable digits
    TTree*         TreeS() {return fLoader->TreeS(); }
                   /// Return tree with raw clusters
    TTree*         TreeR() {return fLoader->TreeR(); }
                   /// Return tree with tracks
    TTree*         TreeT() {return fLoader->TreeT(); }
                   /// Return tree with particles
    TTree*         TreeP() {return fLoader->TreeP(); }

                   // Methods to dump data
    void DumpKine(Int_t event2Check=0);
    void DumpHits(Int_t event2Check=0, Option_t* opt="full");
    void DumpDigits(Int_t event2Check=0, Option_t* opt="tracks");
    void DumpSDigits(Int_t event2Check=0, Option_t* opt="tracks");
    void DumpRecPoints(Int_t event2Check=0, Option_t* opt="full");
    void DumpRecTrigger(Int_t event2Check=0, Int_t write = 0, Bool_t readFromRP = kTRUE);
    
  protected: 
    AliMUONData(const AliMUONData& rhs);
    AliMUONData& operator=(const AliMUONData& rhs);

    AliRunLoader*   fRunLoader; //!< Run loader pointer
    AliLoader*      fLoader;  //!< Detector Loader pointer
    TClonesArray*   fHits;    ///< One event in treeH per primary track
    TObjArray*      fDigits;  ///< One event in treeD and one branch per detection plane
    TObjArray*      fSDigits; ///< One event in treeS and one branch per detection plane
    TObjArray*      fRawClusters; ///< One event in TreeR/Rawcluster and one branch per tracking detection plane
    TClonesArray*   fGlobalTrigger; ///< List of Global Trigger One event in TreeR/GlobalTriggerBranch
    TClonesArray*   fLocalTrigger;  ///< List of Local Trigger, One event in TreeR/LocalTriggerBranch
    TClonesArray*   fRegionalTrigger;  ///< List of Regional Trigger, One event in TreeR/LocalTriggerBranch

    TClonesArray*   fRecTracks; ///< pointer to array of reconstructed tracks
    TClonesArray*   fRecTriggerTracks; ///< pointer to array of reconstructed trigger tracks

    Int_t           fNhits;   //!< Number of Hits
    Int_t*          fNdigits; //!< Number of Digits
    Int_t*          fNSdigits;//!< Number of Digits
    Int_t*          fNrawclusters;  //!< Number of Raw Clusters
    Int_t           fNglobaltrigger;//!< Number of Global trigger
    Int_t           fNlocaltrigger; //!< Number of Local trigger
    Int_t           fNregionaltrigger; //!< Number of regional trigger
    Int_t           fNrectracks;    //!< Number of reconstructed tracks
    Int_t           fNrectriggertracks; //!< Number of reconstructed tracks
    Int_t           fSplitLevel;   ///< Splitting of branches 0 no spitting (root files are smaller) 1 splitting (larger output files)

    mutable Int_t fCurrentEvent; ///< Current event we're dealing with
    
private:  

  ClassDef(AliMUONData,3) // Data accessor for MUON module
      
};
// inline functions


/// Load hits for \a i th entry in hits three
inline void AliMUONData::GetTrack(Int_t it) const  {
  if (fLoader && fLoader->TreeH())
    fLoader->TreeH()->GetEvent(it);
}

/// Load sdigits tree
inline void AliMUONData::GetSDigits() const {
  if (fLoader && fLoader->TreeS())
    fLoader->TreeS()->GetEvent(0);
}

/// Load raw clusters tree
inline void AliMUONData::GetRawClusters() const {
  if (fLoader && fLoader->TreeR())
    fLoader->TreeR()->GetEvent(0);
}

/// Load trigger tree
inline void AliMUONData::GetTrigger() const {
  if (fLoader && fLoader->TreeR())
    fLoader->TreeR()->GetEvent(0);
}

/// Load trigger D tree
inline void AliMUONData::GetTriggerD() const {
  if (fLoader && fLoader->TreeD())
    fLoader->TreeD()->GetEvent(0);
}

/// Return reconstructed tracks
inline void AliMUONData::GetRecTracks() const {
  if (fLoader && fLoader->TreeT())
    fLoader->TreeT()->GetBranch("MUONTrack")->GetEvent(0);
}

/// Return reconstructed trigger tracks
inline void AliMUONData::GetRecTriggerTracks() const {
  if (fLoader && fLoader->TreeT())
    fLoader->TreeT()->GetBranch("MUONTriggerTrack")->GetEvent(0);
}


#endif
Commit	Line	Data
6309cf6e	1	#ifndef ALIMUONDATA_H
	2	#define ALIMUONDATA_H
	3	//
1391e633	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
50837721	5	* See cxx source for full Copyright notice */
	6
	7	/* $Id$ */
30178c30	8	// Revision of includes 07/05/2004
6309cf6e	9	//
692de412	10	/// \ingroup base
692de412	11	/// \class AliMUONData
c4ee792d	12	/// \brief Class containing MUON data: hits, digits, rawclusters, globaltrigger,
692de412	13	/// localtrigger, etc ...
692de412	14	///
c4ee792d	15	// Author: Gines Martinez, Subatech, September 2003
6309cf6e	16
30178c30	17	#include <TNamed.h>
f0945e46	18
1a1cdff8	19	#include "AliLoader.h"
6309cf6e	20
1a1cdff8	21	class AliMUONConstants;
6309cf6e	22	class AliMUONRawCluster;
dcd2690d	23	class AliMUONTrack;
276c44b7	24	class AliMUONTriggerTrack;
61adb9bd	25	class AliMUONDigit;
	26	class AliMUONHit;
	27	class AliMUONLocalTrigger;
47dc4ee7	28	class AliMUONRegionalTrigger;
61adb9bd	29	class AliMUONGlobalTrigger;
6309cf6e	30
6b74d6d9	31	class AliRunLoader;
	32
	33	class TClonesArray;
	34	class TNamed;
	35	class TObjArray;
	36	class TTree;
	37	class TIterator;
	38	class TArrayI;
	39
	40
6309cf6e	41	//__________________________________________________________________
	42	/////////////////////////////////////////////////////////////////////
	43	// //
	44	// class AliMUONData //
	45	// //
	46	/////////////////////////////////////////////////////////////////////
	47
53af523e	48	class AliMUONData : public TNamed
	49	{
	50	public:
f0945e46	51
834ca869	52	// enum EChamberIteration { kAllChambers, kTrackingChambers, kTriggerChambers };
f0945e46	53
6309cf6e	54	AliMUONData();
6309cf6e	55	AliMUONData(AliLoader * loader, const char* name, const char* title);
6b74d6d9	56	AliMUONData(const char* galiceFile);
6309cf6e	57	virtual ~AliMUONData();
e3ea1889	58	virtual void AddDigit(Int_t id, const AliMUONDigit& digit); // use copy constructor
e3ea1889	59	virtual void AddSDigit(Int_t id, const AliMUONDigit& digit); // use copy constructor
f1348c21	60	virtual void AddHit(Int_t fIshunt, Int_t track, Int_t detElemId,
1391e633	61	Int_t idpart, Float_t X, Float_t Y, Float_t Z,
	62	Float_t tof, Float_t momentum, Float_t theta,
	63	Float_t phi, Float_t length, Float_t destep,
	64	Float_t Xref,Float_t Yref,Float_t Zref);
61adb9bd	65
61adb9bd	66	virtual void AddGlobalTrigger(const AliMUONGlobalTrigger& trigger); // use copy constructor
61adb9bd	67
61adb9bd	68	virtual void AddLocalTrigger(const AliMUONLocalTrigger& trigger); // use copy constructor
47dc4ee7	69
47dc4ee7	70	virtual void AddRegionalTrigger(const AliMUONRegionalTrigger& trigger); // use copy constructor
61adb9bd	71
6309cf6e	72	virtual void AddRawCluster(Int_t id, const AliMUONRawCluster& clust);
dcd2690d	73	virtual void AddRecTrack(const AliMUONTrack& track);
276c44b7	74	virtual void AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack);
dcd2690d	75
5398f946	76	TClonesArray* Hits() {return fHits;} ///< Return hits
c82862d3	77	TClonesArray* Digits(Int_t DetectionPlane) const;
c82862d3	78	TClonesArray* SDigits(Int_t DetectionPlane) const;
f0945e46	79	TClonesArray* LocalTrigger() const;
47dc4ee7	80	TClonesArray* RegionalTrigger() const;
f0945e46	81	TClonesArray* GlobalTrigger() const;
1eccde20	82	TClonesArray* RawClusters(Int_t DetectionPlane);
5398f946	83
	84	/// Return reconstructed tracks
	85	TClonesArray* RecTracks() {return fRecTracks;}
	86	/// Return reconstructed trigger tracks
276c44b7	87	TClonesArray* RecTriggerTracks() {return fRecTriggerTracks;}
1a1cdff8	88
6b74d6d9	89	void GetTrack(Int_t it) const;
e89190bb	90	Int_t GetNtracks() const;
f0945e46	91	void GetDigits() const;
6b74d6d9	92	void GetSDigits() const;
	93	void GetRawClusters() const;
	94	void GetTrigger() const;
	95	void GetTriggerD() const;
	96	void GetRecTracks() const;
	97	void GetRecTriggerTracks() const;
	98
30178c30	99	Int_t GetSplitLevel() const {return fSplitLevel;}
1a1cdff8	100
c1d45bdf	101	Bool_t IsRawClusterBranchesInTree();
ce3e25a8	102	Bool_t IsDigitsBranchesInTree();
c1d45bdf	103	Bool_t IsTriggerBranchesInTree();
ce3e25a8	104	Bool_t IsTriggerBranchesInTreeD();
276c44b7	105	Bool_t IsTrackBranchesInTree();
276c44b7	106	Bool_t IsTriggerTrackBranchesInTree();
c1d45bdf	107
5398f946	108	/// Get loader
f0945e46	109	virtual AliLoader* GetLoader() const { return fLoader; }
5398f946	110	/// Set loader
ce3f5e87	111	virtual void SetLoader(AliLoader * loader) {fLoader=loader;}
dcd2690d	112
1a1cdff8	113	virtual void Fill(Option_t* opt=" ");
6309cf6e	114	virtual void MakeBranch(Option_t *opt=" ");
79fc84ff	115	virtual void SetDataContainer(Option_t *opt=" ");
ce3f5e87	116	virtual void SetTreeAddress(Option_t *opt=" ");
dcd2690d	117
5398f946	118	/// Set split level
d652f85c	119	void SetSplitLevel(Int_t SplitLevel) {fSplitLevel=SplitLevel;}
d652f85c	120
c82862d3	121	virtual void Print(Option_t* opt="") const;
c82862d3	122
6309cf6e	123	virtual void ResetHits();
6309cf6e	124	virtual void ResetDigits();
d1775029	125	virtual void ResetSDigits();
6309cf6e	126	virtual void ResetTrigger();
6309cf6e	127	virtual void ResetRawClusters();
dcd2690d	128	virtual void ResetRecTracks();
276c44b7	129	virtual void ResetRecTriggerTracks();
6309cf6e	130
5398f946	131	/// Return tree with hits
6309cf6e	132	TTree* TreeH() {return fLoader->TreeH(); }
5398f946	133	/// Return tree with digits
6309cf6e	134	TTree* TreeD() {return fLoader->TreeD(); }
5398f946	135	/// Return tree with summable digits
d1775029	136	TTree* TreeS() {return fLoader->TreeS(); }
5398f946	137	/// Return tree with raw clusters
6309cf6e	138	TTree* TreeR() {return fLoader->TreeR(); }
5398f946	139	/// Return tree with tracks
6309cf6e	140	TTree* TreeT() {return fLoader->TreeT(); }
5398f946	141	/// Return tree with particles
6309cf6e	142	TTree* TreeP() {return fLoader->TreeP(); }
6309cf6e	143
6b74d6d9	144	// Methods to dump data
	145	void DumpKine(Int_t event2Check=0);
	146	void DumpHits(Int_t event2Check=0, Option_t* opt="full");
	147	void DumpDigits(Int_t event2Check=0, Option_t* opt="tracks");
	148	void DumpSDigits(Int_t event2Check=0, Option_t* opt="tracks");
	149	void DumpRecPoints(Int_t event2Check=0, Option_t* opt="full");
	150	void DumpRecTrigger(Int_t event2Check=0, Int_t write = 0, Bool_t readFromRP = kTRUE);
f0945e46	151
53af523e	152	protected:
e3ea1889	153	AliMUONData(const AliMUONData& rhs);
	154	AliMUONData& operator=(const AliMUONData& rhs);
	155
6b74d6d9	156	AliRunLoader* fRunLoader; //!< Run loader pointer
18b6b8c7	157	AliLoader* fLoader; //!< Detector Loader pointer
	158	TClonesArray* fHits; ///< One event in treeH per primary track
	159	TObjArray* fDigits; ///< One event in treeD and one branch per detection plane
	160	TObjArray* fSDigits; ///< One event in treeS and one branch per detection plane
	161	TObjArray* fRawClusters; ///< One event in TreeR/Rawcluster and one branch per tracking detection plane
	162	TClonesArray* fGlobalTrigger; ///< List of Global Trigger One event in TreeR/GlobalTriggerBranch
	163	TClonesArray* fLocalTrigger; ///< List of Local Trigger, One event in TreeR/LocalTriggerBranch
47dc4ee7	164	TClonesArray* fRegionalTrigger; ///< List of Regional Trigger, One event in TreeR/LocalTriggerBranch
47dc4ee7	165
18b6b8c7	166	TClonesArray* fRecTracks; ///< pointer to array of reconstructed tracks
	167	TClonesArray* fRecTriggerTracks; ///< pointer to array of reconstructed trigger tracks
	168
	169	Int_t fNhits; //!< Number of Hits
	170	Int_t* fNdigits; //!< Number of Digits
	171	Int_t* fNSdigits;//!< Number of Digits
	172	Int_t* fNrawclusters; //!< Number of Raw Clusters
	173	Int_t fNglobaltrigger;//!< Number of Global trigger
	174	Int_t fNlocaltrigger; //!< Number of Local trigger
47dc4ee7	175	Int_t fNregionaltrigger; //!< Number of regional trigger
18b6b8c7	176	Int_t fNrectracks; //!< Number of reconstructed tracks
	177	Int_t fNrectriggertracks; //!< Number of reconstructed tracks
	178	Int_t fSplitLevel; ///< Splitting of branches 0 no spitting (root files are smaller) 1 splitting (larger output files)
	179
	180	mutable Int_t fCurrentEvent; ///< Current event we're dealing with
f0945e46	181
f0945e46	182	private:
53af523e	183
f0945e46	184	ClassDef(AliMUONData,3) // Data accessor for MUON module
f0945e46	185
53af523e	186	};
6b74d6d9	187	// inline functions
	188
	189
	190	/// Load hits for \a i th entry in hits three
	191	inline void AliMUONData::GetTrack(Int_t it) const {
	192	if (fLoader && fLoader->TreeH())
	193	fLoader->TreeH()->GetEvent(it);
	194	}
	195
	196	/// Load sdigits tree
	197	inline void AliMUONData::GetSDigits() const {
	198	if (fLoader && fLoader->TreeS())
	199	fLoader->TreeS()->GetEvent(0);
	200	}
	201
	202	/// Load raw clusters tree
	203	inline void AliMUONData::GetRawClusters() const {
	204	if (fLoader && fLoader->TreeR())
	205	fLoader->TreeR()->GetEvent(0);
	206	}
	207
	208	/// Load trigger tree
	209	inline void AliMUONData::GetTrigger() const {
	210	if (fLoader && fLoader->TreeR())
	211	fLoader->TreeR()->GetEvent(0);
	212	}
	213
	214	/// Load trigger D tree
	215	inline void AliMUONData::GetTriggerD() const {
	216	if (fLoader && fLoader->TreeD())
	217	fLoader->TreeD()->GetEvent(0);
	218	}
	219
	220	/// Return reconstructed tracks
	221	inline void AliMUONData::GetRecTracks() const {
	222	if (fLoader && fLoader->TreeT())
e1421a68	223	fLoader->TreeT()->GetBranch("MUONTrack")->GetEvent(0);
6b74d6d9	224	}
	225
	226	/// Return reconstructed trigger tracks
	227	inline void AliMUONData::GetRecTriggerTracks() const {
	228	if (fLoader && fLoader->TreeT())
e1421a68	229	fLoader->TreeT()->GetBranch("MUONTriggerTrack")->GetEvent(0);
6b74d6d9	230	}
6b74d6d9	231
f0945e46	232
f0945e46	233
6309cf6e	234	#endif
8547965d	235