]>
Commit | Line | Data |
---|---|---|
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(); | |
173 | ||
174 | /** The response shape of the VA1 shaping circuit is approximently | |
175 | given by | |
176 | @f[ | |
177 | f(x) = A(1 - \exp(-Bx)) | |
178 | @f] | |
179 | where @f$ A@f$ is the total charge collected by the pre-amp., | |
180 | and @f$ B@f$ is parameter that depends on the shaping time of | |
181 | the @b VA1 pre-amp. This member function sets the parameter @f$ | |
182 | B@f$ | |
183 | @param B */ | |
184 | void SetShapingTime(Float_t B=10) { fShapingTime = B; } | |
185 | /** @return Get the shaping time */ | |
186 | Float_t GetShapingTime() const { return fShapingTime; } | |
187 | protected: | |
188 | /** Sum energy deposited contributions from each hit in a cache | |
189 | @param fmd Pointer to detector */ | |
190 | virtual void SumContributions(AliFMD* fmd); | |
191 | /** For the stored energy contributions in the cache, convert the | |
192 | energy signal to ADC counts, and store the created digit in | |
193 | the digits array | |
194 | @param fmd Pointer to detector */ | |
195 | virtual void DigitizeHits(AliFMD* fmd) const; | |
196 | /** Convert the total energy deposited to a (set of) ADC count(s). | |
197 | See also the class description for more details. | |
198 | @param edep Total energy deposited in detector | |
199 | @param last Last charge collected in previous VA1 channnel | |
200 | @param detector Detector # | |
201 | @param ring Ring ID | |
202 | @param sector Sector # | |
203 | @param strip Strip # | |
204 | @param counts Array holding the counts on return */ | |
205 | virtual void ConvertToCount(Float_t edep, | |
206 | Float_t last, | |
207 | UShort_t detector, | |
208 | Char_t ring, | |
209 | UShort_t sector, | |
210 | UShort_t strip, | |
211 | TArrayI& counts) const; | |
212 | /** Make a pedestal | |
213 | @param detector Detector # | |
214 | @param ring Ring ID | |
215 | @param sector Sector # | |
216 | @param strip Strip # | |
217 | @return Pedestal value */ | |
218 | virtual UShort_t MakePedestal(UShort_t detector, | |
219 | Char_t ring, | |
220 | UShort_t sector, | |
221 | UShort_t strip) const; | |
222 | /** Add noise to each sample */ | |
223 | virtual void AddNoise(TArrayI&) const {} | |
224 | /** Add a digit to output */ | |
225 | virtual void AddDigit(AliFMD* /* fmd */, | |
226 | UShort_t /* detector */, | |
227 | Char_t /* ring */, | |
228 | UShort_t /* sector */, | |
229 | UShort_t /* strip */, | |
230 | Float_t /* edep */, | |
231 | UShort_t /* count1 */, | |
232 | Short_t /* count2 */, | |
233 | Short_t /* count3 */, | |
234 | Short_t /* count4 */) const {} | |
235 | ||
236 | AliRunLoader* fRunLoader; //! Run loader | |
237 | AliFMDEdepMap fEdep; // Cache of Energy from hits | |
238 | Float_t fShapingTime; // Shaping profile parameter | |
239 | ||
240 | /** Copy CTOR | |
241 | @param o object to copy from */ | |
242 | AliFMDBaseDigitizer(const AliFMDBaseDigitizer& o) | |
243 | : AliDigitizer(o), | |
244 | fRunLoader(0), | |
245 | fEdep(AliFMDMap::kMaxDetectors, | |
246 | AliFMDMap::kMaxRings, | |
247 | AliFMDMap::kMaxSectors, | |
248 | AliFMDMap::kMaxStrips), | |
249 | fShapingTime(0) | |
250 | {} | |
251 | /** Assignment operator | |
252 | @return Reference to this object */ | |
253 | AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer&) { return *this; } | |
254 | ClassDef(AliFMDBaseDigitizer,2) // Base class for FMD digitizers | |
255 | }; | |
256 | ||
257 | ||
258 | #endif | |
259 | //____________________________________________________________________ | |
260 | // | |
261 | // Local Variables: | |
262 | // mode: C++ | |
263 | // End: | |
264 | // | |
265 | // | |
266 | // EOF | |
267 | // | |
268 |