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

#ifndef ALIFMDBASEDIGITIZER_H
#define ALIFMDBASEDIGITIZER_H
/* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights
 * reserved. 
 *
 * See cxx source for full Copyright notice                               
 */
// Classses to make Hits into digits and summable digits. 
//    
//    Digits consists of
//    - Detector #
//    - Ring ID                                             
//    - Sector #     
//    - Strip #
//    - ADC count in this channel                                  
//
//    Summable digits consists of	
//    - Detector #
//    - Ring ID                                             
//    - Sector #     
//    - Strip #
//    - Total energy deposited in the strip
//    - ADC count in this channel                                  
//
/** @file    AliFMDBaseDigitizer.h
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:38:26 2006
    @brief   FMD Digitizers declaration
    @ingroup FMD_sim
*/
#ifndef ALIDIGITIZER_H
# include <AliDigitizer.h>
#endif
#ifndef ALIRUNDIGITIZER_H
# include <AliRunDigitizer.h>
#endif
#ifndef ALIFMDEdepMAP_H
# include "AliFMDEdepMap.h"
#endif
//====================================================================
class TClonesArray;
class AliFMD;
class AliLoader;
class AliRunLoader;
class AliFMDDigit;


//====================================================================
/** @class AliFMDBaseDigitizer AliFMDDigitizer.h <FMD/AliFMDDigitizer>
    @brief Base class for digitizers.

    This class contains the procedures simulation ADC  signal for the
    Forward Multiplicity detector  : Hits->Digits and Hits->SDigits
    
    Digits consists of
    - Detector #
    - Ring ID                                             
    - Sector #     
    - Strip #
    - ADC count in this channel                                  

    Summable digits consists of	
    - Detector #
    - Ring ID                                             
    - Sector #     
    - Strip #
    - Total energy deposited in the strip
    - ADC count in this channel                                  

    As the Digits and SDigits have so much in common, the classes
    AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
    class AliFMDBaseDigitizer.
    @verbatim
                    +---------------------+
                    | AliFMDBaseDigitizer |
                    +---------------------+
                              ^
                              |
                   +----------+---------+
                   |                    |
         +-----------------+     +------------------+
         | AliFMDDigitizer |	| AliFMDSDigitizer |
         +-----------------+	+------------------+
    @endverbatim
    These classes uses parameters fetched from the AliFMDParameters
    manager. 

    The shaping function of the VA1 is generally given by 
    @f[
    f(x) = A(1 - \exp(-Bx))
    @f]
    where A is the total charge collected in the pre-amp., and B is a
    paramter that depends on the shaping time of the VA1 circut.
    
    When simulating the shaping function of the VA1 pre-amp. chip, we
    have to take into account, that the shaping function depends on
    the previous value of read from the pre-amp.  

    That results in the following algorithm:
    @code
    last = 0;
    for (i=0; i < n_pre_amp_charge; i++) {
      charge = GetCharge(i);
      if (last < charge) 
        f(t) = (charge - last) * (1 - exp(-B * t)) + last
      else
        f(t) = (last - charge) * exp(-B * t) + charge)
      for (j=0; j < sample_rate; j++) 
        adc[j] = f(i / (# samples))
      last = charge
    }
    @endcode
    Here, the first loop is over all charges collected by the VA1
    chip, and the @c sample_rate is how many times the ALTRO ADC
    samples each of the 128  charges from the pre-amp. 

    The @c charge is the total charge @f$ Q@f$ collected by the VA1
    pre-amplifier for a strip.   @f$ Q@f$ is then given by 
    @f[
    Q = \frac{E}{e}\frac{S}{r}
    @f]
    where @f$ E@f$ is the total energy deposited in a silicon strip, 
    @f$ R@f$ is the dynamic range of the VA1 pre-amp, @f$ e@f$ is the 
    energy deposited by a single MIP, and @f$ S@f$ ALTRO channel size
    in each time step.

    The energy deposited per MIP is given by 
    @f$ 
    e = M \rho w 
    @f$
    where @f$ M@f$ is the universal number 
    @f$ 1.664 \mbox{keV}\mbox{cm}^{2}\mbox{g}^{-1}@f$, @f$ \rho@f$ is
    the density of silicon, and @f$ w@f$ is the depth of the silicon
    sensor.  

    The final ADC count is given by 
    @f[
    C' = C + P
    @f]
    where @f$ P@f$ is the (randomized) pedestal.

    This class uses the class template AliFMDEdepMap to make an
    internal cache of the energy deposted of the hits.  The class
    template is instantasized as 

    The first member of the values is the summed energy deposition in a
    given strip, while the second member of the values is the number of
    hits in a given strip.  Using the second member, it's possible to
    do some checks on just how many times a strip got hit, and what
    kind of error we get in our reconstructed hits.  Note, that this
    information is currently not written to the digits tree.  I think a
    QA (Quality Assurance) digit tree is better suited for that task.
    However, the information is there to be used in the future. 
    @ingroup FMD_sim
 */
class AliFMDBaseDigitizer : public AliDigitizer 
{
public:
  /** CTOR */
  AliFMDBaseDigitizer();
  /** Normal CTOR 
      @param manager Manager of digitization */
  AliFMDBaseDigitizer(AliRunDigitizer * manager);
  /** Normal ctor 
      @param name Name 
      @param title Title */
  AliFMDBaseDigitizer(const Char_t* name, const Char_t* title);
  /** DTOR */
  virtual ~AliFMDBaseDigitizer();
   
  /** Initialize */
  virtual Bool_t Init();
  /** Run this task */
  virtual void Exec(Option_t* option="");
  
  /** The response shape of the VA1 shaping circuit is approximently
      given by 
      @f[
      f(x) = A(1 - \exp(-Bx))
      @f]
      where @f$ A@f$ is the total charge collected by the pre-amp.,
      and @f$ B@f$ is parameter that depends on the shaping time of
      the @b VA1 pre-amp.  This member function sets the parameter @f$
      B@f$ 
      @param B */
  void     SetShapingTime(Float_t B=10) { fShapingTime = B;  }  
  /** @return Get the shaping time */
  Float_t  GetShapingTime()      const { return fShapingTime; }
protected:
  /** Set-up loaders, etc. 
      @param fmd  On return, contains pointer to loaded AliFMD object.
      @param outFMD On return, contains pointer to loaded loader. 
      @return kTRUE on success, kFALSE otherwise */
  virtual Bool_t  SetupLoaders(AliFMD*& fmd, AliLoader*& outFMD);
  /** Set-up loaders, etc. 
      @param fmd Pointer to loaded AliFMD object 
      @return kFALSE on failures. */
  virtual Bool_t  LoopOverInput(AliFMD* fmd);
  /** Output to disk 
      @param outFMD Loader
      @param fmd    AliFMD object */
  virtual void OutputTree(AliLoader* outFMD, AliFMD* fmd) = 0;
  /** Sum energy deposited contributions from each hit in a cache
      @param fmd Pointer to detector */
  virtual void     SumContributions(AliFMD* fmd);
  /** For the stored energy contributions in the cache, convert the
      energy signal to ADC counts, and store the created digit in  
      the digits array
      @param fmd Pointer to detector */
  virtual void     DigitizeHits(AliFMD* fmd) const;
  /** Convert the total energy deposited to a (set of) ADC count(s).
      See also the class description for more details. 
      @param edep     Total energy deposited in detector
      @param last     Last charge collected in previous VA1 channnel
      @param detector Detector #
      @param ring     Ring ID
      @param sector   Sector #
      @param strip    Strip #
      @param counts   Array holding the counts on return */
  virtual void     ConvertToCount(Float_t   edep, 
				  Float_t   last,
				  UShort_t  detector, 
				  Char_t    ring, 
				  UShort_t  sector, 
				  UShort_t  strip,
				  TArrayI&  counts) const;
  /** Make a pedestal 
      @param detector Detector #
      @param ring     Ring ID
      @param sector   Sector #
      @param strip    Strip #
      @return Pedestal value */
  virtual UShort_t MakePedestal(UShort_t  detector, 
				Char_t    ring, 
				UShort_t  sector, 
				UShort_t  strip) const;
  /** Add noise to each sample */
  virtual void     AddNoise(TArrayI&) const {}
  /** Add a digit to output */
  virtual void     AddDigit(AliFMD*  /* fmd      */,
			    UShort_t /* detector */, 
			    Char_t   /* ring     */,
			    UShort_t /* sector   */, 
			    UShort_t /* strip    */, 
			    Float_t  /* edep     */, 
			    UShort_t /* count1   */, 
			    Short_t  /* count2   */, 
			    Short_t  /* count3   */,
			    Short_t  /* count4   */) const {}

  AliRunLoader* fRunLoader;	   //! Run loader
  AliFMDEdepMap fEdep;             // Cache of Energy from hits 
  Float_t       fShapingTime;      // Shaping profile parameter
  
  /** Copy CTOR 
      @param o object to copy from  */
  AliFMDBaseDigitizer(const AliFMDBaseDigitizer& o) 
    : AliDigitizer(o),
      fRunLoader(0),
      fEdep(AliFMDMap::kMaxDetectors, 
	    AliFMDMap::kMaxRings, 
	    AliFMDMap::kMaxSectors, 
	    AliFMDMap::kMaxStrips),
      fShapingTime(0)
  {}
  /** Assignment operator
      @return Reference to this object */
  AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer&) { return *this; }
  ClassDef(AliFMDBaseDigitizer,2) // Base class for FMD digitizers
};


#endif
//____________________________________________________________________
//
// Local Variables:
//   mode: C++
// End:
//
//
// EOF
//
Commit	Line	Data
02a27b50	1	#ifndef ALIFMDBASEDIGITIZER_H
	2	#define ALIFMDBASEDIGITIZER_H
	3	/* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights
	4	* reserved.
	5	*
	6	* See cxx source for full Copyright notice
	7	*/
	8	// Classses to make Hits into digits and summable digits.
	9	//
	10	// Digits consists of
	11	// - Detector #
	12	// - Ring ID
	13	// - Sector #
	14	// - Strip #
	15	// - ADC count in this channel
	16	//
	17	// Summable digits consists of
	18	// - Detector #
	19	// - Ring ID
	20	// - Sector #
	21	// - Strip #
	22	// - Total energy deposited in the strip
	23	// - ADC count in this channel
	24	//
	25	/** @file AliFMDBaseDigitizer.h
	26	@author Christian Holm Christensen <cholm@nbi.dk>
	27	@date Mon Mar 27 12:38:26 2006
	28	@brief FMD Digitizers declaration
	29	@ingroup FMD_sim
	30	*/
	31	#ifndef ALIDIGITIZER_H
	32	# include <AliDigitizer.h>
	33	#endif
	34	#ifndef ALIRUNDIGITIZER_H
	35	# include <AliRunDigitizer.h>
	36	#endif
	37	#ifndef ALIFMDEdepMAP_H
	38	# include "AliFMDEdepMap.h"
	39	#endif
	40	//====================================================================
	41	class TClonesArray;
	42	class AliFMD;
	43	class AliLoader;
	44	class AliRunLoader;
	45	class AliFMDDigit;
	46
	47
	48	//====================================================================
	49	/** @class AliFMDBaseDigitizer AliFMDDigitizer.h <FMD/AliFMDDigitizer>
	50	@brief Base class for digitizers.
	51
	52	This class contains the procedures simulation ADC signal for the
	53	Forward Multiplicity detector : Hits->Digits and Hits->SDigits
	54
	55	Digits consists of
	56	- Detector #
	57	- Ring ID
	58	- Sector #
	59	- Strip #
	60	- ADC count in this channel
	61
	62	Summable digits consists of
	63	- Detector #
	64	- Ring ID
65	- Sector #
66	- Strip #
67	- Total energy deposited in the strip
68	- ADC count in this channel
69
70	As the Digits and SDigits have so much in common, the classes
71	AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
72	class AliFMDBaseDigitizer.
73	@verbatim
74	+---------------------+
75	\| AliFMDBaseDigitizer \|
76	+---------------------+
77	^
78	\|
79	+----------+---------+
80	\| \|
81	+-----------------+ +------------------+
82	\| AliFMDDigitizer \| \| AliFMDSDigitizer \|
83	+-----------------+ +------------------+
84	@endverbatim
85	These classes uses parameters fetched from the AliFMDParameters
86	manager.
87
88	The shaping function of the VA1 is generally given by
89	@f[
90	f(x) = A(1 - \exp(-Bx))
91	@f]
92	where A is the total charge collected in the pre-amp., and B is a
93	paramter that depends on the shaping time of the VA1 circut.
94
95	When simulating the shaping function of the VA1 pre-amp. chip, we
96	have to take into account, that the shaping function depends on
97	the previous value of read from the pre-amp.
98
99	That results in the following algorithm:
100	@code
101	last = 0;
102	for (i=0; i < n_pre_amp_charge; i++) {
103	charge = GetCharge(i);
104	if (last < charge)
105	f(t) = (charge - last) * (1 - exp(-B * t)) + last
106	else
107	f(t) = (last - charge) * exp(-B * t) + charge)
108	for (j=0; j < sample_rate; j++)
109	adc[j] = f(i / (# samples))
110	last = charge
111	}
112	@endcode
113	Here, the first loop is over all charges collected by the VA1
114	chip, and the @c sample_rate is how many times the ALTRO ADC
115	samples each of the 128 charges from the pre-amp.
116
117	The @c charge is the total charge @f$ Q@f$ collected by the VA1
118	pre-amplifier for a strip. @f$ Q@f$ is then given by
119	@f[
120	Q = \frac{E}{e}\frac{S}{r}
121	@f]
122	where @f$ E@f$ is the total energy deposited in a silicon strip,
123	@f$ R@f$ is the dynamic range of the VA1 pre-amp, @f$ e@f$ is the
124	energy deposited by a single MIP, and @f$ S@f$ ALTRO channel size
125	in each time step.
126
127	The energy deposited per MIP is given by
128	@f$
129	e = M \rho w
130	@f$
131	where @f$ M@f$ is the universal number
132	@f$ 1.664 \mbox{keV}\mbox{cm}^{2}\mbox{g}^{-1}@f$, @f$ \rho@f$ is
133	the density of silicon, and @f$ w@f$ is the depth of the silicon
134	sensor.
135
136	The final ADC count is given by
137	@f[
138	C' = C + P
139	@f]
140	where @f$ P@f$ is the (randomized) pedestal.
141
142	This class uses the class template AliFMDEdepMap to make an
143	internal cache of the energy deposted of the hits. The class
144	template is instantasized as
145
146	The first member of the values is the summed energy deposition in a
147	given strip, while the second member of the values is the number of
148	hits in a given strip. Using the second member, it's possible to
149	do some checks on just how many times a strip got hit, and what
150	kind of error we get in our reconstructed hits. Note, that this
151	information is currently not written to the digits tree. I think a
152	QA (Quality Assurance) digit tree is better suited for that task.
153	However, the information is there to be used in the future.
154	@ingroup FMD_sim
155	*/
156	class AliFMDBaseDigitizer : public AliDigitizer
157	{
158	public:
159	/** CTOR */
160	AliFMDBaseDigitizer();
161	/** Normal CTOR
162	@param manager Manager of digitization */
163	AliFMDBaseDigitizer(AliRunDigitizer * manager);
164	/** Normal ctor
165	@param name Name
166	@param title Title */
167	AliFMDBaseDigitizer(const Char_t* name, const Char_t* title);
168	/** DTOR */
169	virtual ~AliFMDBaseDigitizer();
170
171	/** Initialize */
172	virtual Bool_t Init();
42f1b2f5	173	/** Run this task */
	174	virtual void Exec(Option_t* option="");
	175
02a27b50	176	/** The response shape of the VA1 shaping circuit is approximently
	177	given by
	178	@f[
	179	f(x) = A(1 - \exp(-Bx))
	180	@f]
	181	where @f$ A@f$ is the total charge collected by the pre-amp.,
	182	and @f$ B@f$ is parameter that depends on the shaping time of
	183	the @b VA1 pre-amp. This member function sets the parameter @f$
	184	B@f$
	185	@param B */
	186	void SetShapingTime(Float_t B=10) { fShapingTime = B; }
	187	/** @return Get the shaping time */
	188	Float_t GetShapingTime() const { return fShapingTime; }
	189	protected:
42f1b2f5	190	/** Set-up loaders, etc.
	191	@param fmd On return, contains pointer to loaded AliFMD object.
	192	@param outFMD On return, contains pointer to loaded loader.
	193	@return kTRUE on success, kFALSE otherwise */
	194	virtual Bool_t SetupLoaders(AliFMD& fmd, AliLoader& outFMD);
	195	/** Set-up loaders, etc.
	196	@param fmd Pointer to loaded AliFMD object
	197	@return kFALSE on failures. */
	198	virtual Bool_t LoopOverInput(AliFMD* fmd);
	199	/** Output to disk
	200	@param outFMD Loader
	201	@param fmd AliFMD object */
	202	virtual void OutputTree(AliLoader* outFMD, AliFMD* fmd) = 0;
02a27b50	203	/** Sum energy deposited contributions from each hit in a cache
	204	@param fmd Pointer to detector */
	205	virtual void SumContributions(AliFMD* fmd);
	206	/** For the stored energy contributions in the cache, convert the
	207	energy signal to ADC counts, and store the created digit in
	208	the digits array
	209	@param fmd Pointer to detector */
	210	virtual void DigitizeHits(AliFMD* fmd) const;
	211	/** Convert the total energy deposited to a (set of) ADC count(s).
	212	See also the class description for more details.
	213	@param edep Total energy deposited in detector
	214	@param last Last charge collected in previous VA1 channnel
	215	@param detector Detector #
	216	@param ring Ring ID
	217	@param sector Sector #
	218	@param strip Strip #
	219	@param counts Array holding the counts on return */
	220	virtual void ConvertToCount(Float_t edep,
	221	Float_t last,
	222	UShort_t detector,
	223	Char_t ring,
	224	UShort_t sector,
	225	UShort_t strip,
	226	TArrayI& counts) const;
	227	/** Make a pedestal
	228	@param detector Detector #
	229	@param ring Ring ID
	230	@param sector Sector #
	231	@param strip Strip #
	232	@return Pedestal value */
	233	virtual UShort_t MakePedestal(UShort_t detector,
	234	Char_t ring,
	235	UShort_t sector,
	236	UShort_t strip) const;
	237	/** Add noise to each sample */
	238	virtual void AddNoise(TArrayI&) const {}
	239	/** Add a digit to output */
	240	virtual void AddDigit(AliFMD* /* fmd */,
	241	UShort_t /* detector */,
	242	Char_t /* ring */,
	243	UShort_t /* sector */,
	244	UShort_t /* strip */,
	245	Float_t /* edep */,
	246	UShort_t /* count1 */,
	247	Short_t /* count2 */,
2aeec17d	248	Short_t /* count3 */,
2aeec17d	249	Short_t /* count4 */) const {}
02a27b50	250
	251	AliRunLoader* fRunLoader; //! Run loader
	252	AliFMDEdepMap fEdep; // Cache of Energy from hits
	253	Float_t fShapingTime; // Shaping profile parameter
	254
	255	/** Copy CTOR
	256	@param o object to copy from */
	257	AliFMDBaseDigitizer(const AliFMDBaseDigitizer& o)
b5ee4425	258	: AliDigitizer(o),
	259	fRunLoader(0),
	260	fEdep(AliFMDMap::kMaxDetectors,
	261	AliFMDMap::kMaxRings,
	262	AliFMDMap::kMaxSectors,
	263	AliFMDMap::kMaxStrips),
	264	fShapingTime(0)
	265	{}
02a27b50	266	/** Assignment operator
	267	@return Reference to this object */
	268	AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer&) { return *this; }
	269	ClassDef(AliFMDBaseDigitizer,2) // Base class for FMD digitizers
	270	};
	271
	272
	273	#endif
	274	//____________________________________________________________________
	275	//
	276	// Local Variables:
	277	// mode: C++
	278	// End:
	279	//
	280	//
	281	// EOF
	282	//
	283