AliRoot Core  3dc7879 (3dc7879)
AliFMDBaseDigitizer.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 /* $Id$ */
22 //
24 // This class contains the procedures simulation ADC signal for the
25 // Forward Multiplicity detector : Hits->Digits and Hits->SDigits
26 //
27 // Digits consists of
28 // - Detector #
29 // - Ring ID
30 // - Sector #
31 // - Strip #
32 // - ADC count in this channel
33 //
34 // Digits consists of
35 // - Detector #
36 // - Ring ID
37 // - Sector #
38 // - Strip #
39 // - Total energy deposited in the strip
40 // - ADC count in this channel
41 //
42 // As the Digits and SDigits have so much in common, the classes
43 // AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
44 // class AliFMDBaseDigitizer.
45 //
46 // +---------------------+
47 // | AliFMDBaseDigitizer |
48 // +---------------------+
49 // ^
50 // |
51 // +----------+---------+
52 // | |
53 // +-----------------+ +------------------+
54 // | AliFMDDigitizer | | AliFMDSDigitizer |
55 // +-----------------+ +------------------+
56 //
57 // These classes has several paramters:
58 //
59 // fPedestal
60 // fPedestalWidth
61 // (Only AliFMDDigitizer)
62 // Mean and width of the pedestal. The pedestal is simulated
63 // by a Guassian, but derived classes my override MakePedestal
64 // to simulate it differently (or pick it up from a database).
65 //
66 // fVA1MipRange
67 // The dymamic MIP range of the VA1_ALICE pre-amplifier chip
68 //
69 // fAltroChannelSize
70 // The largest number plus one that can be stored in one
71 // channel in one time step in the ALTRO ADC chip.
72 //
73 // fSampleRate
74 // How many times the ALTRO ADC chip samples the VA1_ALICE
75 // pre-amplifier signal. The VA1_ALICE chip is read-out at
76 // 10MHz, while it's possible to drive the ALTRO chip at
77 // 25MHz. That means, that the ALTRO chip can have time to
78 // sample each VA1_ALICE signal up to 2 times. Although it's
79 // not certain this feature will be used in the production,
80 // we'd like have the option, and so it should be reflected in
81 // the code.
82 //
83 //
84 // The shaping function of the VA1_ALICE is generally given by
85 //
86 // f(x) = A(1 - exp(-Bx))
87 //
88 // where A is the total charge collected in the pre-amp., and B is a
89 // paramter that depends on the shaping time of the VA1_ALICE circut.
90 //
91 // When simulating the shaping function of the VA1_ALICe
92 // pre-amp. chip, we have to take into account, that the shaping
93 // function depends on the previous value of read from the pre-amp.
94 //
95 // That results in the following algorithm:
96 //
97 // last = 0;
98 // FOR charge IN pre-amp. charge train DO
99 // IF last < charge THEN
100 // f(t) = (charge - last) * (1 - exp(-B * t)) + last
101 // ELSE
102 // f(t) = (last - charge) * exp(-B * t) + charge)
103 // ENDIF
104 // FOR i IN # samples DO
105 // adc_i = f(i / (# samples))
106 // DONE
107 // last = charge
108 // DONE
109 //
110 // Here,
111 //
112 // pre-amp. charge train
113 // is a series of 128 charges read from the VA1_ALICE chip
114 //
115 // # samples
116 // is the number of times the ALTRO ADC samples each of the 128
117 // charges from the pre-amp.
118 //
119 // Where Q is the total charge collected by the VA1_ALICE
120 // pre-amplifier. Q is then given by
121 //
122 // E S
123 // Q = - -
124 // e R
125 //
126 // where E is the total energy deposited in a silicon strip, R is the
127 // dynamic range of the VA1_ALICE pre-amp (fVA1MipRange), e is the
128 // energy deposited by a single MIP, and S ALTRO channel size in each
129 // time step (fAltroChannelSize).
130 //
131 // The energy deposited per MIP is given by
132 //
133 // e = M * rho * w
134 //
135 // where M is the universal number 1.664, rho is the density of
136 // silicon, and w is the depth of the silicon sensor.
137 //
138 // The final ADC count is given by
139 //
140 // C' = C + P
141 //
142 // where P is the (randomized) pedestal (see MakePedestal)
143 //
144 // This class uses the class template AliFMDMap<Type> to make an
145 // internal cache of the energy deposted of the hits. The class
146 // template is instantasized as
147 //
148 // typedef AliFMDMap<std::pair<Float_t, UShort_t> > AliFMDEdepMap;
149 //
150 // The first member of the values is the summed energy deposition in a
151 // given strip, while the second member of the values is the number of
152 // hits in a given strip. Using the second member, it's possible to
153 // do some checks on just how many times a strip got hit, and what
154 // kind of error we get in our reconstructed hits. Note, that this
155 // information is currently not written to the digits tree. I think a
156 // QA (Quality Assurance) digit tree is better suited for that task.
157 // However, the information is there to be used in the future.
158 //
159 //
160 // Latest changes by Christian Holm Christensen
161 //
163 
164 // /1
165 // | A(-1 + B + exp(-B))
166 // | f(x) dx = ------------------- = 1
167 // | B
168 // / 0
169 //
170 // and B is the a parameter defined by the shaping time (fShapingTime).
171 //
172 // Solving the above equation, for A gives
173 //
174 // B
175 // A = ----------------
176 // -1 + B + exp(-B)
177 //
178 // So, if we define the function g: [0,1] -> [0:1] by
179 //
180 // / v
181 // | Bu + exp(-Bu) - Bv - exp(-Bv)
182 // g(u,v) = | f(x) dx = -A -----------------------------
183 // | B
184 // / u
185 //
186 // we can evaluate the ALTRO sample of the VA1_ALICE pre-amp between
187 // any two times (u, v), by
188 //
189 //
190 // B Bu + exp(-Bu) - Bv - exp(-Bv)
191 // C = Q g(u,v) = - Q ---------------- -----------------------------
192 // -1 + B + exp(-B) B
193 //
194 // Bu + exp(-Bu) - Bv - exp(-Bv)
195 // = - Q -----------------------------
196 // -1 + B + exp(-B)
197 //
198 
199 #include <TMath.h>
200 #include <TTree.h> // ROOT_TTree
201 //#include <TRandom.h> // ROOT_TRandom
202 // #include <AliLog.h> // ALILOG_H
203 #include "AliFMDDebug.h" // Better debug macros
204 #include "AliFMDBaseDigitizer.h" // ALIFMDDIGITIZER_H
205 #include "AliFMD.h" // ALIFMD_H
206 #include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
207 #include "AliFMDDetector.h" // ALIFMDDETECTOR_H
208 #include "AliFMDRing.h" // ALIFMDRING_H
209 #include "AliFMDHit.h" // ALIFMDHIT_H
210 // #include "AliFMDDigit.h" // ALIFMDDIGIT_H
211 #include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
212 // #include <AliDigitizationInput.h> // ALIRUNDIGITIZER_H
213 //#include <AliRun.h> // ALIRUN_H
214 #include <AliLoader.h> // ALILOADER_H
215 #include <AliRun.h> // ALILOADER_H
216 #include <AliRunLoader.h> // ALIRUNLOADER_H
217 #include <TRandom.h>
218 
219 //====================================================================
220 ClassImp(AliFMDBaseDigitizer)
221 #if 0
222  ; // This is here to keep Emacs for indenting the next line
223 #endif
224 
225 //____________________________________________________________________
227  : fFMD(0),
228  fRunLoader(0),
229  fEdep(AliFMDMap::kMaxDetectors,
230  AliFMDMap::kMaxRings,
231  AliFMDMap::kMaxSectors,
232  AliFMDMap::kMaxStrips),
233  fShapingTime(6),
234  fStoreTrackRefs(kTRUE),
235  fIgnoredLabels(0)
236 {
237  AliFMDDebug(1, ("Constructed"));
238  // Default ctor - don't use it
239 }
240 
241 //____________________________________________________________________
243  : AliDigitizer(digInput, "AliFMDBaseDigitizer", "FMD Digitizer base class"),
244  fFMD(0),
245  fRunLoader(0),
246  fEdep(0), // nDet==0 means 51200 slots
247  fShapingTime(6),
248  fStoreTrackRefs(kTRUE),
249  fIgnoredLabels(0)
250 {
251  // Normal CTOR
252  AliFMDDebug(1, ("Constructed"));
253  SetShapingTime();
254 }
255 
256 //____________________________________________________________________
258  const Char_t* title)
259  : AliDigitizer(name, title),
260  fFMD(0),
261  fRunLoader(0),
262  fEdep(0), // nDet==0 means 51200 slots
263  fShapingTime(6),
264  fStoreTrackRefs(kTRUE),
265  fIgnoredLabels(0)
266 {
267  // Normal CTOR
268  AliFMDDebug(1, (" Constructed"));
269  SetShapingTime();
270 }
271 
272 //____________________________________________________________________
274 {
275  // Destructor
276 }
277 
278 //____________________________________________________________________
281 {
282  //
283  // Assignment operator
284  //
285  // Return:
286  // Reference to this object
287  //
288  if (&o == this) return *this;
291  fEdep = o.fEdep;
295  return *this;
296 }
297 
298 //____________________________________________________________________
299 Bool_t
301 {
302  // Initialization. Get a pointer to the parameter manager, and
303  // initialize it.
305  if (AliLog::GetDebugLevel("FMD","") >= 15)
307  return kTRUE;
308 }
309 
310 //____________________________________________________________________
311 UShort_t
313  Char_t ring,
314  UShort_t sector,
315  UShort_t strip) const
316 {
317  // Make a pedestal. The pedestal value is drawn from a Gaussian
318  // distribution. The mean of the distribution is the measured
319  // pedestal, and the width is the measured noise.
321  Float_t mean =param->GetPedestal(detector,ring,sector,strip);
322  Float_t width =param->GetPedestalWidth(detector,ring,sector,strip);
323  return UShort_t(TMath::Max(gRandom->Gaus(mean, width), 0.));
324 }
325 
326 //____________________________________________________________________
327 void
329  Char_t ring,
330  UShort_t sector,
331  UShort_t strip,
332  Float_t edep,
333  Bool_t isPrimary,
334  Int_t nTrack,
335  Int_t* tracknos,
336  Int_t offset)
337 {
338  // Add edep contribution from (detector,ring,sector,strip) to cache
340  AliFMDDebug(10, ("Adding contribution %7.5f for FMD%d%c[%2d,%3d] "
341  " from %d tracks (%s)",
342  edep,
343  detector,
344  ring,
345  sector,
346  strip,
347  nTrack,
348  (isPrimary ? "primary" : "secondary")));
349  // Check if strip is `dead'
350  if (param->IsDead(detector, ring, sector, strip)) {
351  AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is marked as dead",
352  detector, ring, sector, strip));
353  return;
354  }
355  // Check if strip is out-side read-out range
356  // if (strip < minstrip || strip > maxstrip) {
357  // AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is outside range [%3d,%3d]",
358  // detector,ring,sector,strip,minstrip,maxstrip));
359  // continue;
360  // }
361 
362  AliFMDEdepHitPair& entry = fEdep(detector, ring, sector, strip);
363 
364  // Give warning in case of double sdigit
365  if (entry.fEdep != 0)
366  AliFMDDebug(5, ("Double digit in FMD%d%c[%2d,%3d]",
367  detector, ring, sector, strip));
368 
369  // Sum energy deposition
370  Int_t oldN = entry.fN;
371  entry.fEdep += edep;
372  entry.fN += nTrack;
373  if (isPrimary) entry.fNPrim += nTrack;
374  if (fStoreTrackRefs) {
375  if (entry.fLabels.fN < entry.fN) {
376  AliFMDDebug(15, ("== New label array size %d, was %d, added %d",
377  entry.fN, entry.fLabels.fN, nTrack));
378  entry.fLabels.Set(entry.fN);
379  }
380  for (Int_t i = 0; i < nTrack; i++) {
381  AliFMDDebug(15, ("=> Setting track label # %d", oldN+i));
382  entry.fLabels[oldN + i] = tracknos[i]+offset;
383  AliFMDDebug(15, ("<= Setting track label # %d", oldN+i));
384  }
385  }
386  AliFMDDebug(15,("Adding contribution %f to FMD%d%c[%2d,%3d] (%f) track %d (offset %d)",
387  edep, detector, ring, sector, strip,
388  entry.fEdep, (nTrack > 0 ? tracknos[0] : -1),offset));
389 
390 }
391 
392 //____________________________________________________________________
393 void
395 {
396  // For the stored energy contributions in the cache (fEdep), convert
397  // the energy signal to ADC counts, and store the created digit in
398  // the digits array (AliFMD::fDigits)
399  //
400  AliFMDDebug(5, ("Will now digitize all the summed signals"));
401  fIgnoredLabels = 0;
403 
404  TArrayI counts(4);
405  for (UShort_t detector=1; detector <= 3; detector++) {
406  AliFMDDebug(10, ("Processing hits in FMD%d", detector));
407  // Get pointer to subdetector
408  AliFMDDetector* det = geometry->GetDetector(detector);
409  if (!det) continue;
410  for (UShort_t ringi = 0; ringi <= 1; ringi++) {
411  Char_t ring = ringi == 0 ? 'I' : 'O';
412  AliFMDDebug(10, (" Processing hits in FMD%d%c", detector,ring));
413  // Get pointer to Ring
414  AliFMDRing* r = det->GetRing(ring);
415  if (!r) continue;
416 
417  // Get number of sectors
418  UShort_t nSectors = UShort_t(360. / r->GetTheta());
419  // Loop over the number of sectors
420  for (UShort_t sector = 0; sector < nSectors; sector++) {
421  AliFMDDebug(10, (" Processing hits in FMD%d%c[%2d]",
422  detector,ring,sector));
423  // Get number of strips
424  UShort_t nStrips = r->GetNStrips();
425  // Loop over the stips
426  Float_t last = 0;
427  for (UShort_t strip = 0; strip < nStrips; strip++) {
428  // Reset the counter array to the invalid value -1
429  counts.Reset(-1);
430  // Reset the last `ADC' value when we've get to the end of a
431  // VA1_ALICE channel.
432  if (strip % 128 == 0) last = 0;
433 
434  const AliFMDEdepHitPair& entry = fEdep(detector,ring,sector,strip);
435  Float_t edep = entry.fEdep;
436  UShort_t ntot = entry.fN;
437  UShort_t nprim = entry.fNPrim;
438  const TArrayI& labels = entry.fLabels;
439  if (edep > 0)
440  AliFMDDebug(15, ("Edep = %f for FMD%d%c[%2d,%3d]",
441  edep, detector, ring, sector, strip));
442  ConvertToCount(edep, last, detector, ring, sector, strip, counts);
443  last = edep;
444 
445 
446  // The following line was introduced - wrongly - by Peter
447  // Hristov. It _will_ break the digitisation and the
448  // following reconstruction. The behviour of the
449  // digitisation models exactly the front-end as it should
450  // (no matter what memory concuption it may entail). The
451  // check should be on zero suppression, since that's what
452  // models the front-end - if zero suppression is turned on
453  // in the front-end, then we can suppress empty digits -
454  // otherwise we shoud never do that. Note, that the line
455  // affects _both_ normal digitisation and digitisation for
456  // summable digits, since the condition is on the energy
457  // deposition and not on the actual number of counts. If
458  // this line should go anywhere, it should be in the
459  // possible overloaded AliFMDSDigitizer::AddDigit - not
460  // here.
461  //
462  // if (edep<=0) continue;
463  AddDigit(detector, ring, sector, strip, edep,
464  UShort_t(counts[0]), Short_t(counts[1]),
465  Short_t(counts[2]), Short_t(counts[3]),
466  ntot, nprim, labels);
467  AliFMDDebug(15, (" Adding digit in FMD%d%c[%2d,%3d]=%d",
468  detector,ring,sector,strip,counts[0]));
469 #if 0
470  // This checks if the digit created will give the `right'
471  // number of particles when reconstructed, using a naiive
472  // approach. It's here only as a quality check - nothing
473  // else.
474  CheckDigit(digit, fEdep(detector, ring, sector, strip).fN,
475  counts);
476 #endif
477  } // Strip
478  } // Sector
479  } // Ring
480  } // Detector
481  if (fIgnoredLabels > 0)
482  AliWarning(Form("%d track labels could not be associated with digits "
483  "due to limited storage facilities in AliDigit",
484  fIgnoredLabels));
485 }
486 
487 //____________________________________________________________________
488 void
490  Float_t last,
491  UShort_t detector,
492  Char_t ring,
493  UShort_t sector,
494  UShort_t strip,
495  TArrayI& counts) const
496 {
497  // Convert the total energy deposited to a (set of) ADC count(s).
498  //
499  // This is done by
500  //
501  // Energy_Deposited ALTRO_Channel_Size
502  // ADC = -------------------------- ------------------- + pedestal
503  // Energy_Deposition_Of_1_MIP VA1_ALICE_MIP_Range
504  //
505  // Energy_Deposited fAltroChannelSize
506  // = --------------------------------- ----------------- + pedestal
507  // 1.664 * Si_Thickness * Si_Density fVA1MipRange
508  //
509  //
510  // = Energy_Deposited * ConversionFactor + pedestal
511  //
512  // However, this is modified by the response function of the
513  // VA1_ALICE pre-amp. chip in case we are doing oversampling of the
514  // VA1_ALICE output.
515  //
516  // In that case, we get N=fSampleRate values of the ADC, and the
517  // `EnergyDeposited' is a function of which sample where are
518  // calculating the ADC for
519  //
520  // ADC_i = f(EnergyDeposited, i/N, Last) * ConversionFactor + pedestal
521  //
522  // where Last is the Energy deposited in the previous strip.
523  //
524  // Here, f is the shaping function of the VA1_ALICE. This is given
525  // by
526  //
527  // | (E - l) * (1 - exp(-B * t) + l if E > l
528  // f(E, t, l) = <
529  // | (l - E) * exp(-B * t) + E otherwise
530  //
531  //
532  // = E + (l - E) * ext(-B * t)
533  //
535  Float_t convF = (param->GetDACPerMIP() / param->GetEdepMip() *
536  param->GetPulseGain(detector,ring,sector,strip));
537  Int_t ped = MakePedestal(detector,ring,sector,strip);
538  Int_t maxAdc = param->GetAltroChannelSize()-1;
539  if (maxAdc < 0) {
540  AliWarning(Form("Maximum ADC is %d < 0, forcing it to 1023", maxAdc));
541  maxAdc = 1023;
542  }
543  UShort_t rate = param->GetSampleRate(detector,ring,sector,strip);
544  AliFMDDebug(15, ("Sample rate for FMD%d%c[%2d,%3d] = %d",
545  detector, ring, sector, strip, rate));
546  if (rate < 1 || rate > 4) {
547  AliWarning(Form("Invalid sample rate for for FMD%d%c[%2d,%3d] = %d",
548  detector, ring, sector, strip, rate));
549  rate = 1;
550  }
551 
552  // In case we don't oversample, just return the end value.
553  if (rate == 1) {
554  Float_t a = edep * convF + ped;
555  if (a < 0) a = 0;
556  counts[0] = UShort_t(TMath::Min(a, Float_t(maxAdc)));
557  AliFMDDebug(15, ("FMD%d%c[%2d,%3d]: converting ELoss %f to "
558  "ADC %4d (%f,%d)",
559  detector,ring,sector,strip,edep,counts[0],convF,ped));
560  return;
561  }
562 
563 
564  // Create a pedestal
565  Float_t b = fShapingTime;
566  for (Ssiz_t i = 0; i < rate; i++) {
567  Float_t t = Float_t(i) / rate + 1./rate;
568  Float_t s = edep + (last - edep) * TMath::Exp(-b * t);
569  Float_t a = Int_t(s * convF + ped);
570  if (a < 0) a = 0;
571  counts[i] = UShort_t(TMath::Min(a, Float_t(maxAdc)));
572  }
573  AliFMDDebug(15, ("Converted edep = %f to ADC (%x,%x,%x,%x) "
574  "[gain: %f=(%f/%f*%f), pedestal: %d, rate: %d]",
575  edep, counts[0], counts[1], counts[2], counts[3],
576  convF, param->GetDACPerMIP(),param->GetEdepMip(),
577  param->GetPulseGain(detector,ring,sector,strip),
578  ped, rate));
579 }
580 
581 //____________________________________________________________________
582 void
583 AliFMDBaseDigitizer::AddDigit(UShort_t detector,
584  Char_t ring,
585  UShort_t sector,
586  UShort_t strip,
587  Float_t /* edep */,
588  UShort_t count1,
589  Short_t count2,
590  Short_t count3,
591  Short_t count4,
592  UShort_t ntot,
593  UShort_t /* nprim */,
594  const TArrayI& refs) const
595 {
596  // Add a digit or summable digit
597  fFMD->AddDigitByFields(detector, ring, sector, strip,
598  count1, count2, count3, count4,
599  ntot, fStoreTrackRefs ? refs.fArray : 0);
600  if (fStoreTrackRefs && ntot > 3) fIgnoredLabels += ntot - 3;
601 }
602 
603 //____________________________________________________________________
604 TTree*
606 {
607  // Create output tree using loader. If the passed loader differs
608  // from the currently set loader in the FMD object, reset the FMD
609  // loader to be the passed loader. This is for the cases wher the
610  // output is different from the output.
611  AliFMDDebug(5, ("Making digits tree"));
612  loader->LoadDigits("UPDATE"); // "RECREATE");
613  TTree* out = loader->TreeD();
614  if (!out) loader->MakeTree("D");
615  out = loader->TreeD();
616  if (out) {
617  out->Reset();
618  if (loader != fFMD->GetLoader())
619  fFMD->SetLoader(loader);
620  fFMD->MakeBranch("D");
621  }
622  return out;
623 }
624 
625 //____________________________________________________________________
626 void
628 {
629  // Write the digits to disk
630  AliFMDDebug(5, ("Storing %d digits", fFMD->Digits()->GetEntries()));
631  loader->WriteDigits("OVERWRITE");
632  loader->UnloadDigits();
633  // Reset the digits in the AliFMD object
634  fFMD->ResetDigits();
635 }
636 
637 //____________________________________________________________________
638 //
639 // EOF
640 //
641 
642 
643 
644 
Float_t GetDACPerMIP() const
TBrowser b
Definition: RunAnaESD.C:12
virtual void AddDigitByFields(UShort_t detector=0, Char_t ring='\0', UShort_t sector=0, UShort_t strip=0, UShort_t count1=0, Short_t count2=-1, Short_t count3=-1, Short_t count4=-1, UShort_t nrefs=0, Int_t *refs=0)
Definition: AliFMD.cxx:780
Bool_t IsDead(UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip) const
Geometry mananger for the FMD.
virtual void StoreDigits(const AliLoader *loader)
TClonesArray * Digits() const
Definition: AliDetector.h:34
AliFMDDetector * GetDetector(Int_t i) const
Hit in the FMD.
void SetLoader(AliLoader *loader)
Definition: AliDetector.h:66
virtual void MakeTree(Option_t *opt)
Definition: AliLoader.cxx:346
This class is a singleton that handles various parameters of the FMD detectors. This class reads from...
Manager of FMD parameters.
Float_t GetPulseGain(UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip) const
FMD ring geometry parameters.
TTree * TreeD() const
Definition: AliLoader.h:87
AliFMDRing * GetRing(Char_t id) const
void Print(Option_t *option="A") const
Float_t GetEdepMip() const
virtual TTree * MakeOutputTree(AliLoader *loader)
AliFMDBaseDigitizer & operator=(const AliFMDBaseDigitizer &o)
Base class for caches of per-strip information.This is used to index a strip. Data stored depends on ...
Definition: AliFMDMap.h:19
Base class for the geometry description and parameters of the FMD sub detectors FMD1, FMD2, and FMD3.
#define AliWarning(message)
Definition: AliLog.h:541
FMD Digitizers declaration.
void SetShapingTime(Float_t B=10)
virtual void MakeBranch(Option_t *opt=" ")
Definition: AliFMD.cxx:557
virtual void AddContribution(UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip, Float_t edep, Bool_t isPrimary, Int_t nTrackno, Int_t *tracknos, Int_t offset=0)
void UnloadDigits() const
Definition: AliLoader.h:131
Singleton object of FMD geometry descriptions and parameters. This class is a singleton that handles ...
virtual void DigitizeHits() const
Declaration of AliFMD detector driver.
AliDigitizer & operator=(const AliDigitizer &dig)
Definition: AliDigitizer.h:31
virtual void AddDigit(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, UShort_t ntot, UShort_t nprim, const TArrayI &refs) const
Int_t GetNStrips() const
Definition: AliFMDRing.h:204
#define AliFMDDebug(N, A)
Definition: AliFMDDebug.h:39
static AliFMDParameters * Instance()
virtual Int_t WriteDigits(Option_t *opt="") const
Definition: AliLoader.h:148
Double_t GetTheta() const
Definition: AliFMDRing.h:199
AliLoader * GetLoader() const
Definition: AliDetector.h:67
Geometry description and parameters of a ring in the FMD detector.
Definition: AliFMDRing.h:41
static Int_t GetDebugLevel(const char *module, const char *className)
Definition: AliLog.cxx:843
virtual void ConvertToCount(Float_t edep, Float_t last, UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip, TArrayI &counts) const
Int_t LoadDigits(Option_t *opt="")
Definition: AliLoader.h:106
virtual void ResetDigits()
static AliFMDGeometry * Instance()
Float_t GetPedestal(UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip) const
UShort_t GetAltroChannelSize() const
Float_t GetPedestalWidth(UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip) const
UShort_t GetSampleRate(UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip) const
Sub-detector base class declaration.
Cache of Energy deposited, hit information per strip. Contains a pair of energy deposited fEdep and n...
UShort_t Init(Bool_t forceReInit=kFALSE, UInt_t what=kAll)
AliFMDEdepMap fEdep
Run loader.
virtual UShort_t MakePedestal(UShort_t detector, Char_t ring, UShort_t sector, UShort_t strip) const
Base class for digitizers.