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

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

/* $Id$ */
#include "AliDigitizer.h"
#include "AliRunLoader.h"
#include "AliMUONLoader.h"
#include "AliMUONTransientDigit.h"
#include "AliMUON.h"
#include "AliMUONData.h"

class AliRunDigitizer;
class AliMUONHitMapA1;


class AliMUONDigitizer : public AliDigitizer
{
public:

	/* Default constructor initializes all the internal pointers to NULL.
	 */
	AliMUONDigitizer();
	
	/* Constructor initialises all the internal pointers to NULL and
	   sets this digitizers manager to the one specified.
	 */
	AliMUONDigitizer(AliRunDigitizer * manager);

	// Destructor
	virtual ~AliMUONDigitizer();

	// The Init method does nothing.
	// All initialization happens in Exec at the moment.  
	virtual Bool_t Init();

	// Override the TTask Exec method.
	virtual void Exec(Option_t* option = 0);

	Int_t GetDebug() const {return fDebug;}       // Get debug level.
	void SetDebug(Int_t level){fDebug = level;}   // Set debug level.    

protected:
        AliMUONDigitizer(const AliMUONDigitizer& rhs);
        AliMUONDigitizer& operator=(const AliMUONDigitizer& rhs);


	// Parses the option string given to the Exec method.
	virtual void ParseOptions(Option_t* options);

	/* Digitizers inheriting from AliMUONDigitizer should implement this abstract method 
	   so that TransientDigit objects are generated and put onto the fTDList.
	   The method would be implemented as some loop over the input stream. The data can be
	   fetched from the muondata pointer. To add to the fTDList once should use code similar
	   to the following:
	   
	     TObject* source_object;  // Assume the object from which the transient digit
	                              // is created is already initialized at this point.
	     AliMUONTransientDigit* td = new AliMUONTransientDigit();
	     // Initialize the transient digit.
	     // ...
	     
	     // The following line of code is required to have working digitisers that want
	     // to store information about which digits were created from which hits. 
	     OnCreateTransientDigit(td, source_object);
	     
	     AddOrUpdateTransientDigit(td);  // Adds to the fTDList preventing duplicates.
	 */
	virtual void GenerateTransientDigits() = 0;
	
	// Loops over the fTDList of transient digits to write them to the output stream.
	virtual void CreateDigits();

	/* Inheriting digitizers should implement this method to prepare the muondata
	   object before GenerateTransientDigits() is called. 
	   If the initialization was successful then kTRUE should be returned otherwise
	   kFALSE should be returned. 
	 */
	virtual Bool_t InitInputData(AliMUONLoader* muonloader) = 0;
	
	/* This method should be overridden to undo/cleanup what was done in the 
	   InitInputData method call.
	 */
	virtual void CleanupInputData(AliMUONLoader* muonloader) = 0;

	/* Inheriting digitizers should implement this method to prepare the muondata
	   object before CreateDigits() is called.
	   If the initialization was successful then kTRUE should be returned otherwise
	   kFALSE should be returned. 
	 */
	virtual Bool_t InitOutputData(AliMUONLoader* muonloader) = 0;

	/* When all the data is added to the muondata object and the trees need to be
	   filled then this method is called by CreateDigits(). 
	   Thus code like
	       muondata->Fill("D")
	   should go into this method.
	 */
	virtual void FillOutputData() = 0;
	
	/* This method should be overridden to undo/cleanup what was done in the 
	   InitOutputData method call.
	 */
	virtual void CleanupOutputData(AliMUONLoader* muonloader) = 0;

	/* This is called by CreateDigits when it wants the Signal value that will be written
	   to the output stream. Inheriting digitizers can override this to apply some kind 
	   of detector response.
	 */
	virtual Int_t GetSignalFrom(AliMUONTransientDigit* td) = 0;

	/* Should be overridden by inheriting digitizers such that this method adds the digits
	   to the correct tree. 
	 */
	virtual void AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6]) = 0;

	/* Should be called by GenerateTransientDigits() when a new transient digit is generated
	   form a source object from the input stream. The source object could be an AliMUONHit
	   or AliMUONSDigit for example.
	 */ 
	virtual void OnCreateTransientDigit(AliMUONTransientDigit* /*digit*/, TObject* /*source_object*/);

	/* Called by AddDigit(AliMUONTransientDigit*, Int_t) when transient digit is added to the 
	   muondata object ready for writing to the data trees.
	 */ 
	virtual void OnWriteTransientDigit(AliMUONTransientDigit* digit);
	
	// Wrapper method for AddDigit(Int_t, Int_t[kMAXTRACKS], Int_t[kMAXTRACKS], Int_t[6])
	void AddDigit(AliMUONTransientDigit* td, Int_t response_charge);

	// Creates a new fTDList object, and creates and fills the fHitMap arrays.
	// Note: this method assumes the array pointers are NULL when calling this method.
	void InitArrays();
	
	// Frees the memory allocated for fTDList and the fHitMap arrays.
	void CleanupArrays();

	/* Gets the run loader and muon loader pointers from the given folder name. If an error 
	   occurred then kFALSE is returned else kTRUE on success. 
	 */
	Bool_t FetchLoaders(const char* foldername, AliRunLoader*& runloader, AliMUONLoader*& muonloader);

	/* Gets the gAlice, and MUON module pointers from the specified run loader. If an error 
	   occurred then kFALSE is returned else kTRUE on success. 
	 */
	Bool_t FetchGlobalPointers(AliRunLoader* runloader);

	// Adds the transient digit uniquely to the fTDList.
	void AddOrUpdateTransientDigit(AliMUONTransientDigit* mTD);
	
	// Updates a TransientDigit in fTDList
	void UpdateTransientDigit(AliMUONTransientDigit * mTD);
	
	// Adds the new TransientDigit to fTDList
	void AddTransientDigit(AliMUONTransientDigit * mTD);

	// Verify that a TransientDigit already exists.
	Bool_t ExistTransientDigit(AliMUONTransientDigit * mTD); 

	// Sorts the 3 most significant tracks.    
	void SortTracks(Int_t *tracks, Int_t *charges, Int_t ntr);


	AliRunLoader* runloader;        //! Global run loader.
	AliMUONLoader* gime;            //! MUON specific loader.
	AliMUON* pMUON;                 //! Pointer to MUON module.
	AliMUONData* muondata;          //! muon data interface

	AliMUONHitMapA1 **fHitMap;      //! pointer to array of pointers to hitmaps
	TObjArray *fTDList;             //! list of AliMUONTransientDigits
	Int_t fTDCounter;               //! nr. of AliMUONTransientDigit
	Int_t fMask;                    //! mask dependent on input file
	Bool_t fSignal;                 //! kTRUE if signal file is processed 

private:

	Int_t fDebug;                   //! Debug level.

	ClassDef(AliMUONDigitizer, 1)   // MUON merging/digitization
};    
#endif
Commit	Line	Data
28752ff4	1	#ifndef ALIMUONDIGITIZER_H
	2	#define ALIMUONDIGITIZER_H
	3	/* Copyright(c) 1998-2001, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
b8278504	7	#include "AliDigitizer.h"
cf286af7	8	#include "AliRunLoader.h"
	9	#include "AliMUONLoader.h"
	10	#include "AliMUONTransientDigit.h"
	11	#include "AliMUON.h"
	12	#include "AliMUONData.h"
28752ff4	13
28752ff4	14	class AliRunDigitizer;
8f36c696	15	class AliMUONHitMapA1;
28752ff4	16
cf286af7	17
	18	class AliMUONDigitizer : public AliDigitizer
	19	{
	20	public:
	21
	22	/* Default constructor initializes all the internal pointers to NULL.
	23	*/
	24	AliMUONDigitizer();
	25
	26	/* Constructor initialises all the internal pointers to NULL and
	27	sets this digitizers manager to the one specified.
	28	*/
	29	AliMUONDigitizer(AliRunDigitizer * manager);
	30
8789635b	31	// Destructor
	32	virtual ~AliMUONDigitizer();
	33
cf286af7	34	// The Init method does nothing.
	35	// All initialization happens in Exec at the moment.
	36	virtual Bool_t Init();
	37
	38	// Override the TTask Exec method.
	39	virtual void Exec(Option_t* option = 0);
	40
	41	Int_t GetDebug() const {return fDebug;} // Get debug level.
	42	void SetDebug(Int_t level){fDebug = level;} // Set debug level.
	43
	44	protected:
11ca64ac	45	AliMUONDigitizer(const AliMUONDigitizer& rhs);
	46	AliMUONDigitizer& operator=(const AliMUONDigitizer& rhs);
	47
cf286af7	48
	49	// Parses the option string given to the Exec method.
	50	virtual void ParseOptions(Option_t* options);
	51
	52	/* Digitizers inheriting from AliMUONDigitizer should implement this abstract method
	53	so that TransientDigit objects are generated and put onto the fTDList.
	54	The method would be implemented as some loop over the input stream. The data can be
	55	fetched from the muondata pointer. To add to the fTDList once should use code similar
	56	to the following:
	57
	58	TObject* source_object; // Assume the object from which the transient digit
	59	// is created is already initialized at this point.
	60	AliMUONTransientDigit* td = new AliMUONTransientDigit();
	61	// Initialize the transient digit.
	62	// ...
	63
	64	// The following line of code is required to have working digitisers that want
	65	// to store information about which digits were created from which hits.
	66	OnCreateTransientDigit(td, source_object);
	67
	68	AddOrUpdateTransientDigit(td); // Adds to the fTDList preventing duplicates.
	69	*/
	70	virtual void GenerateTransientDigits() = 0;
	71
	72	// Loops over the fTDList of transient digits to write them to the output stream.
	73	virtual void CreateDigits();
	74
	75	/* Inheriting digitizers should implement this method to prepare the muondata
	76	object before GenerateTransientDigits() is called.
	77	If the initialization was successful then kTRUE should be returned otherwise
	78	kFALSE should be returned.
	79	*/
	80	virtual Bool_t InitInputData(AliMUONLoader* muonloader) = 0;
	81
	82	/* This method should be overridden to undo/cleanup what was done in the
	83	InitInputData method call.
	84	*/
	85	virtual void CleanupInputData(AliMUONLoader* muonloader) = 0;
	86
	87	/* Inheriting digitizers should implement this method to prepare the muondata
	88	object before CreateDigits() is called.
	89	If the initialization was successful then kTRUE should be returned otherwise
	90	kFALSE should be returned.
	91	*/
	92	virtual Bool_t InitOutputData(AliMUONLoader* muonloader) = 0;
	93
	94	/* When all the data is added to the muondata object and the trees need to be
	95	filled then this method is called by CreateDigits().
	96	Thus code like
	97	muondata->Fill("D")
	98	should go into this method.
	99	*/
	100	virtual void FillOutputData() = 0;
	101
	102	/* This method should be overridden to undo/cleanup what was done in the
	103	InitOutputData method call.
	104	*/
	105	virtual void CleanupOutputData(AliMUONLoader* muonloader) = 0;
	106
	107	/* This is called by CreateDigits when it wants the Signal value that will be written
	108	to the output stream. Inheriting digitizers can override this to apply some kind
	109	of detector response.
	110	*/
	111	virtual Int_t GetSignalFrom(AliMUONTransientDigit* td) = 0;
112
113	/* Should be overridden by inheriting digitizers such that this method adds the digits
114	to the correct tree.
115	*/
116	virtual void AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6]) = 0;
117
118	/* Should be called by GenerateTransientDigits() when a new transient digit is generated
119	form a source object from the input stream. The source object could be an AliMUONHit
120	or AliMUONSDigit for example.
121	*/
122	virtual void OnCreateTransientDigit(AliMUONTransientDigit* /digit/, TObject* /source_object/);
123
124	/* Called by AddDigit(AliMUONTransientDigit*, Int_t) when transient digit is added to the
125	muondata object ready for writing to the data trees.
126	*/
127	virtual void OnWriteTransientDigit(AliMUONTransientDigit* digit);
128
129	// Wrapper method for AddDigit(Int_t, Int_t[kMAXTRACKS], Int_t[kMAXTRACKS], Int_t[6])
130	void AddDigit(AliMUONTransientDigit* td, Int_t response_charge);
131
132	// Creates a new fTDList object, and creates and fills the fHitMap arrays.
133	// Note: this method assumes the array pointers are NULL when calling this method.
134	void InitArrays();
135
136	// Frees the memory allocated for fTDList and the fHitMap arrays.
137	void CleanupArrays();
138
139	/* Gets the run loader and muon loader pointers from the given folder name. If an error
140	occurred then kFALSE is returned else kTRUE on success.
141	*/
142	Bool_t FetchLoaders(const char* foldername, AliRunLoader& runloader, AliMUONLoader& muonloader);
143
144	/* Gets the gAlice, and MUON module pointers from the specified run loader. If an error
145	occurred then kFALSE is returned else kTRUE on success.
146	*/
147	Bool_t FetchGlobalPointers(AliRunLoader* runloader);
148
149	// Adds the transient digit uniquely to the fTDList.
150	void AddOrUpdateTransientDigit(AliMUONTransientDigit* mTD);
151
152	// Updates a TransientDigit in fTDList
153	void UpdateTransientDigit(AliMUONTransientDigit * mTD);
154
155	// Adds the new TransientDigit to fTDList
156	void AddTransientDigit(AliMUONTransientDigit * mTD);
157
158	// Verify that a TransientDigit already exists.
159	Bool_t ExistTransientDigit(AliMUONTransientDigit * mTD);
160
161	// Sorts the 3 most significant tracks.
162	void SortTracks(Int_t tracks, Int_t charges, Int_t ntr);
163
164
165	AliRunLoader* runloader; //! Global run loader.
166	AliMUONLoader* gime; //! MUON specific loader.
167	AliMUON* pMUON; //! Pointer to MUON module.
168	AliMUONData* muondata; //! muon data interface
169
170	AliMUONHitMapA1 **fHitMap; //! pointer to array of pointers to hitmaps
171	TObjArray *fTDList; //! list of AliMUONTransientDigits
172	Int_t fTDCounter; //! nr. of AliMUONTransientDigit
173	Int_t fMask; //! mask dependent on input file
174	Bool_t fSignal; //! kTRUE if signal file is processed
175
176	private:
177
178	Int_t fDebug; //! Debug level.
179
180	ClassDef(AliMUONDigitizer, 1) // MUON merging/digitization
28752ff4	181	};
28752ff4	182	#endif