Fixed a few problems
[u/mrichter/AliRoot.git] / FMD / AliFMDDigitizer.cxx
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
16 /* $Id$ */
17
18 //////////////////////////////////////////////////////////////////////////////
19 //
20 //  This class contains the procedures simulation ADC  signal for the
21 //  Forward Multiplicity detector  : Hits->Digits and Hits->SDigits
22 // 
23 //  Digits consists of
24 //   - Detector #
25 //   - Ring ID                                             
26 //   - Sector #     
27 //   - Strip #
28 //   - ADC count in this channel                                  
29 //
30 //  Digits consists of
31 //   - Detector #
32 //   - Ring ID                                             
33 //   - Sector #     
34 //   - Strip #
35 //   - Total energy deposited in the strip
36 //   - ADC count in this channel                                  
37 //
38 // As the Digits and SDigits have so much in common, the classes
39 // AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
40 // class AliFMDBaseDigitizer.
41 //
42 //                 +---------------------+
43 //                 | AliFMDBaseDigitizer |
44 //                 +---------------------+
45 //                           ^
46 //                           |
47 //                +----------+---------+
48 //                |                    |
49 //      +-----------------+     +------------------+
50 //      | AliFMDDigitizer |     | AliFMDSDigitizer |
51 //      +-----------------+     +------------------+
52 //
53 // These classes has several paramters: 
54 //
55 //     fPedestal
56 //     fPedestalWidth
57 //         (Only AliFMDDigitizer)
58 //         Mean and width of the pedestal.  The pedestal is simulated
59 //         by a Guassian, but derived classes my override MakePedestal
60 //         to simulate it differently (or pick it up from a database).
61 //
62 //     fVA1MipRange
63 //         The dymamic MIP range of the VA1_ALICE pre-amplifier chip 
64 //
65 //     fAltroChannelSize
66 //         The largest number plus one that can be stored in one
67 //         channel in one time step in the ALTRO ADC chip. 
68 //
69 //     fSampleRate
70 //         How many times the ALTRO ADC chip samples the VA1_ALICE
71 //         pre-amplifier signal.   The VA1_ALICE chip is read-out at
72 //         10MHz, while it's possible to drive the ALTRO chip at
73 //         25MHz.  That means, that the ALTRO chip can have time to
74 //         sample each VA1_ALICE signal up to 2 times.  Although it's
75 //         not certain this feature will be used in the production,
76 //         we'd like have the option, and so it should be reflected in
77 //         the code.
78 //
79 // The shaping function of the VA1_ALICE is given by 
80 //
81 //      f(x) = A(1 - exp(-Bx))
82 //
83 // Where A is a normalization constant, tuned so that the integral 
84 //
85 //      /1
86 //      |           A(-1 + B + exp(-B))
87 //      | f(x) dx = ------------------- = 1
88 //      |                    B
89 //      / 0
90 //
91 // and B is the a parameter defined by the shaping time (fShapingTime).  
92 //
93 // Solving the above equation, for A gives
94 //
95 //                 B
96 //      A = ----------------
97 //          -1 + B + exp(-B)
98 //
99 // So, if we define the function g: [0,1] -> [0:1] by 
100 //
101 //               / v
102 //               |              Bu + exp(-Bu) - Bv - exp(-Bv) 
103 //      g(u,v) = | f(x) dx = -A -----------------------------
104 //               |                            B
105 //               / u
106 //
107 // we can evaluate the ALTRO sample of the VA1_ALICE pre-amp between
108 // any two times (u, v), by 
109 //       
110 //
111 //                                B         Bu + exp(-Bu) - Bv - exp(-Bv)
112 //      C = Q g(u,v) = - Q ---------------- -----------------------------
113 //                         -1 + B + exp(-B)              B                  
114 //
115 //               Bu + exp(-Bu) - Bv - exp(-Bv) 
116 //        = -  Q -----------------------------
117 //                    -1 + B + exp(-B)
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 //
162 //////////////////////////////////////////////////////////////////////////////
163
164 #ifndef ROOT_TTree
165 # include <TTree.h>
166 #endif
167 #ifndef ROOT_TRandom
168 # include <TRandom.h>
169 #endif
170 #ifndef ALILOG_H
171 # include "AliLog.h"
172 #endif
173 #ifndef ALIFMDDIGITIZER_H
174 # include "AliFMDDigitizer.h"
175 #endif
176 #ifndef ALIFMD_H
177 # include "AliFMD.h"
178 #endif
179 #ifndef ALIFMDHIT_H
180 # include "AliFMDHit.h"
181 #endif
182 #ifndef ALIFMDDIGIT_H
183 # include "AliFMDDigit.h"
184 #endif
185 #ifndef ALIFMDDIGIT_H
186 # include "AliFMDSDigit.h"
187 #endif
188 #ifndef ALIRUNDIGITIZER_H
189 # include "AliRunDigitizer.h"
190 #endif
191 #ifndef ALIRUN_H
192 # include "AliRun.h"
193 #endif
194 #ifndef ALILOADER_H
195 # include "AliLoader.h"
196 #endif
197 #ifndef ALIRUNLOADER_H
198 # include "AliRunLoader.h"
199 #endif
200     
201 //____________________________________________________________________
202 ClassImp(AliFMDEdepMap);
203
204 //====================================================================
205 ClassImp(AliFMDBaseDigitizer);
206
207 //____________________________________________________________________
208 AliFMDBaseDigitizer::AliFMDBaseDigitizer()  
209   : fRunLoader(0)
210 {
211   // Default ctor - don't use it
212 }
213
214 //____________________________________________________________________
215 AliFMDBaseDigitizer::AliFMDBaseDigitizer(AliRunDigitizer* manager) 
216   : AliDigitizer(manager, "AliFMDBaseDigitizer", "FMD Digitizer base class"), 
217     fRunLoader(0),
218     fEdep(kMaxDetectors, kMaxRings, kMaxSectors, kMaxStrips)
219 {
220   // Normal CTOR
221   AliDebug(1," processed");
222   SetVA1MipRange();
223   SetAltroChannelSize();
224   SetSampleRate();
225   SetShapingTime();
226 }
227
228 //____________________________________________________________________
229 AliFMDBaseDigitizer::AliFMDBaseDigitizer(const Char_t* name, 
230                                          const Char_t* title) 
231   : AliDigitizer(name, title),
232     fRunLoader(0),
233     fEdep(kMaxDetectors, kMaxRings, kMaxSectors, kMaxStrips)
234 {
235   // Normal CTOR
236   AliDebug(1," processed");
237   SetVA1MipRange();
238   SetAltroChannelSize();
239   SetSampleRate();
240   SetShapingTime();
241 }
242
243 //____________________________________________________________________
244 AliFMDBaseDigitizer::~AliFMDBaseDigitizer()
245 {
246   // Destructor
247 }
248
249 //____________________________________________________________________
250 Bool_t 
251 AliFMDBaseDigitizer::Init()
252 {
253   // Initialization
254   return kTRUE;
255 }
256  
257
258 //____________________________________________________________________
259 void
260 AliFMDBaseDigitizer::SumContributions(AliFMD* fmd) 
261 {
262   // Sum energy deposited contributions from each hit in a cache
263   // (fEdep).  
264   if (!fRunLoader) 
265     Fatal("SumContributions", "no run loader");
266   
267   // Clear array of deposited energies 
268   fEdep.Clear();
269   
270   // Get the FMD loader 
271   AliLoader* inFMD = fRunLoader->GetLoader("FMDLoader");
272   // And load the hits 
273   inFMD->LoadHits("READ");
274   
275   // Get the tree of hits 
276   TTree* hitsTree = inFMD->TreeH();
277   if (!hitsTree)  {
278     // Try again 
279     inFMD->LoadHits("READ");
280     hitsTree = inFMD->TreeH();
281   }
282   
283   // Get the FMD branch 
284   TBranch* hitsBranch = hitsTree->GetBranch("FMD");
285   if (hitsBranch) fmd->SetHitsAddressBranch(hitsBranch);
286   else            AliFatal("Branch FMD hit not found");
287   
288   // Get a list of hits from the FMD manager 
289   TClonesArray *fmdHits = fmd->Hits();
290   
291   // Get number of entries in the tree 
292   Int_t ntracks  = Int_t(hitsTree->GetEntries());
293   
294   // Loop over the tracks in the 
295   for (Int_t track = 0; track < ntracks; track++)  {
296     // Read in entry number `track' 
297     hitsBranch->GetEntry(track);
298     
299     // Get the number of hits 
300     Int_t nhits = fmdHits->GetEntries ();
301     for (Int_t hit = 0; hit < nhits; hit++) {
302       // Get the hit number `hit'
303       AliFMDHit* fmdHit = 
304         static_cast<AliFMDHit*>(fmdHits->UncheckedAt(hit));
305       
306       // Extract parameters 
307       UShort_t detector = fmdHit->Detector();
308       Char_t   ring     = fmdHit->Ring();
309       UShort_t sector   = fmdHit->Sector();
310       UShort_t strip    = fmdHit->Strip();
311       Float_t  edep     = fmdHit->Edep();
312       if (fEdep(detector, ring, sector, strip).first != 0)
313         AliDebug(1, Form("Double hit in %d%c(%d,%d)", 
314                          detector, ring, sector, strip));
315       
316       fEdep(detector, ring, sector, strip).first  += edep;
317       fEdep(detector, ring, sector, strip).second += 1;
318       // Add this to the energy deposited for this strip
319     }  // hit loop
320   } // track loop
321 }
322
323 //____________________________________________________________________
324 void
325 AliFMDBaseDigitizer::DigitizeHits(AliFMD* fmd) const
326 {
327   // For the stored energy contributions in the cache (fEdep), convert
328   // the energy signal to ADC counts, and store the created digit in
329   // the digits array (AliFMD::fDigits)
330   //
331   TArrayI counts(3);
332   for (UShort_t detector=1; detector <= 3; detector++) {
333     // Get pointer to subdetector 
334     AliFMDSubDetector* det = 0;
335     switch (detector) {
336     case 1: det = fmd->GetFMD1(); break;
337     case 2: det = fmd->GetFMD2(); break;
338     case 3: det = fmd->GetFMD3(); break;
339     }
340     if (!det) continue;
341     for (UShort_t ringi = 0; ringi <= 1; ringi++) {
342       // Get pointer to Ring
343       AliFMDRing* r = 0;
344       switch (ringi) {
345       case 0: if (det->GetInner()) r = det->GetInner(); break;
346       case 1: if (det->GetOuter()) r = det->GetOuter(); break;
347       }
348       if (!r) continue;
349       
350       // Get number of sectors 
351       UShort_t nSectors = UShort_t(360. / r->GetTheta());
352       // Loop over the number of sectors 
353       for (UShort_t sector = 0; sector < nSectors; sector++) {
354         // Get number of strips 
355         UShort_t nStrips = r->GetNStrips();
356         // Loop over the stips 
357         for (UShort_t strip = 0; strip < nStrips; strip++) {
358           counts.Reset(-1);
359           Float_t edep = fEdep(detector, r->GetId(), sector, strip).first;
360           ConvertToCount(edep, r->GetSiThickness(), fmd->GetSiDensity(), 
361                          counts);
362           AddDigit(fmd, detector, r->GetId(), sector, strip, 
363                    edep, UShort_t(counts[0]), 
364                    Short_t(counts[1]), Short_t(counts[2]));
365 #if 0
366           // This checks if the digit created will give the `right'
367           // number of particles when reconstructed, using a naiive
368           // approach.  It's here only as a quality check - nothing
369           // else. 
370           CheckDigit(fEdep(detector, r->GetId(), sector, strip).first,
371                      fEdep(detector, r->GetId(), sector, strip).second,
372                      counts);
373 #endif
374         } // Strip
375       } // Sector 
376     } // Ring 
377   } // Detector 
378 }
379
380 //____________________________________________________________________
381 Float_t
382 AliFMDBaseDigitizer::ShapeIntegral(Float_t u, Float_t v) const
383 {
384   // Calculates the integral 
385   // 
386   //      / v
387   //      |               Bu + exp(-Bu) - Bv - exp(-Bv) 
388   //      | f(x) dx = - A -----------------------------
389   //      |                             B
390   //      / u
391   // 
392   // of the shaping function of the VA1_ALICE between times u and v
393   //
394   //      f(x) = A(1 - exp(-Bx))
395   //
396   // where A is a normalization constant, tuned so that the integral 
397   //
398   //      /1
399   //      |                              B          
400   //      | f(x) dx = 1   =>  A = ----------------
401   //      |                       -1 + B + exp(-B)
402   //      / 0
403   //
404   // and B is the a parameter defined by the shaping time (fShapingTime).  
405   // 
406   // That is, the function return the value 
407   // 
408   //        Bu + exp(-Bu) - Bv - exp(-Bv) 
409   //      - -----------------------------
410   //               -1 + B + exp(-B)
411   // 
412   // u,v should lie in the interval [0,1], and u < v
413   if (u == 0 && v == 1) return 1;
414   Float_t B = fShapingTime;
415   
416   // Calculate the integral 
417   Float_t res = - ((B * u + TMath::Exp(-B * u) - B * v - TMath::Exp(-B * v)) /
418                  (-1 + B + TMath::Exp(-B)));
419   return res;
420 }
421
422 //____________________________________________________________________
423 void
424 AliFMDBaseDigitizer::ConvertToCount(Float_t   edep, 
425                                     Float_t   siThickness, 
426                                     Float_t   siDensity, 
427                                     TArrayI&  counts) const
428 {
429   // Put noise and make ADC signal
430   // This is calculated as the product 
431   // 
432   //   DeltaEmip * SiThickness * SiDensity / Number 
433   //
434   // Where 
435   //  
436   //   DeltaEmip     is the energy loss of a MIP 
437   //   SiThickness   is the thickness of the silicon 
438   //   SiDensity     is the Silicon density 
439   //   Number        is # of e^- per MIP
440   //
441   // Note: Need to check this is correct. 
442   // 
443   const Float_t mipI = 1.664 * siThickness * siDensity;
444   // const Float_t mipI = 1.664 * 0.04 * 2.33 / 22400; // = 6.923e-6;
445   
446   // Create a pedestal 
447   UShort_t ped = MakePedestal();
448   
449   Float_t convf = 1 / mipI * Float_t(fAltroChannelSize) / fVA1MipRange;
450   Int_t n = fSampleRate;
451   for (Ssiz_t i = 0; i < n;  i++) {
452     Float_t w = ShapeIntegral(Float_t(i)/n, Float_t(i+1)/n);
453     counts[i] = UShort_t(TMath::Min(w * edep * convf + ped, 
454                                     Float_t(fAltroChannelSize))); 
455   }
456 }
457
458
459 //====================================================================
460 ClassImp(AliFMDDigitizer);
461
462 //____________________________________________________________________
463 AliFMDDigitizer::AliFMDDigitizer()  
464   : AliFMDBaseDigitizer()
465 {
466   // Default ctor - don't use it
467 }
468
469 //____________________________________________________________________
470 AliFMDDigitizer::AliFMDDigitizer(AliRunDigitizer* manager) 
471   : AliFMDBaseDigitizer(manager)
472 {
473   // Normal CTOR
474   AliDebug(1," processed");
475   SetPedestal();
476 }
477
478 //____________________________________________________________________
479 void
480 AliFMDDigitizer::Exec(Option_t*) 
481 {
482   // Get the output manager 
483   TString outFolder(fManager->GetOutputFolderName());
484   AliRunLoader* out = 
485     AliRunLoader::GetRunLoader(outFolder.Data());
486   // Get the FMD output manager 
487   AliLoader* outFMD = out->GetLoader("FMDLoader");
488
489   // Get the input loader 
490   TString inFolder(fManager->GetInputFolderName(0));
491   fRunLoader = 
492     AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
493   if (!fRunLoader) {
494     AliError("Can not find Run Loader for input stream 0");
495     return;
496   }
497   // Get the AliRun object 
498   if (!fRunLoader->GetAliRun()) fRunLoader->LoadgAlice();
499
500   // Get the AliFMD object 
501   AliFMD* fmd = static_cast<AliFMD*>(fRunLoader->GetAliRun()->GetDetector("FMD"));
502   if (!fmd) {
503     AliError("Can not get FMD from gAlice");
504     return;
505   }
506
507   Int_t nFiles= fManager->GetNinputs();
508   for (Int_t inputFile = 0; inputFile < nFiles; inputFile++) {
509     AliDebug(1,Form(" Digitizing event number %d",
510                     fManager->GetOutputEventNr()));
511     // Get the current loader 
512     fRunLoader = 
513       AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
514     if (!fRunLoader) Fatal("Exec", "no run loader");
515     // Cache contriutions 
516     SumContributions(fmd);
517   }
518   // Digitize the event 
519   DigitizeHits(fmd);
520
521   // Load digits from the tree 
522   outFMD->LoadDigits("update");
523   // Get the tree of digits 
524   TTree* digitTree = outFMD->TreeD();
525   if (!digitTree) {
526     outFMD->MakeTree("D");
527     digitTree = outFMD->TreeD();
528   }
529   digitTree->Reset();
530   // Make a branch in the tree 
531   TClonesArray* digits = fmd->Digits();
532   fmd->MakeBranchInTree(digitTree, fmd->GetName(), &(digits), 4000, 0);
533   // TBranch* digitBranch = digitTree->GetBranch(fmd->GetName());
534   // Fill the tree 
535   digitTree->Fill();
536   
537   // Write the digits to disk 
538   outFMD->WriteDigits("OVERWRITE");
539   outFMD->UnloadHits();
540   outFMD->UnloadDigits();
541
542   // Reset the digits in the AliFMD object 
543   fmd->ResetDigits();
544 }
545
546
547 //____________________________________________________________________
548 UShort_t
549 AliFMDDigitizer::MakePedestal() const 
550 {
551   return UShort_t(TMath::Max(gRandom->Gaus(fPedestal, fPedestalWidth), 0.));
552 }
553
554 //____________________________________________________________________
555 void
556 AliFMDDigitizer::AddDigit(AliFMD*  fmd,
557                           UShort_t detector, 
558                           Char_t   ring,
559                           UShort_t sector, 
560                           UShort_t strip, 
561                           Float_t  /* edep */, 
562                           UShort_t count1, 
563                           Short_t  count2, 
564                           Short_t  count3) const
565 {
566   fmd->AddDigit(detector, ring, sector, strip, count1, count2, count3);
567 }
568
569 //____________________________________________________________________
570 void
571 AliFMDDigitizer::CheckDigit(Float_t         /* edep */, 
572                             UShort_t        nhits,
573                             const TArrayI&  counts) 
574 {
575   Int_t integral = counts[0];
576   if (counts[1] >= 0) integral += counts[1];
577   if (counts[2] >= 0) integral += counts[2];
578   integral -= Int_t(fPedestal + 2 * fPedestalWidth);
579   if (integral < 0) integral = 0;
580   
581   Float_t convf = Float_t(fVA1MipRange) / fAltroChannelSize;
582   Float_t mips  = integral * convf;
583   if (mips > Float_t(nhits) + .5 || mips < Float_t(nhits) - .5) 
584     Warning("CheckDigit", "Digit -> %4.2f MIPS != %d +/- .5 hits", 
585             mips, nhits);
586 }
587
588 //====================================================================
589 ClassImp(AliFMDSDigitizer);
590
591 //____________________________________________________________________
592 AliFMDSDigitizer::AliFMDSDigitizer()  
593 {
594   // Default ctor - don't use it
595 }
596
597 //____________________________________________________________________
598 AliFMDSDigitizer::AliFMDSDigitizer(const Char_t* headerFile, 
599                                    const Char_t* /* sdigfile */)
600   : AliFMDBaseDigitizer("FMDSDigitizer", "FMD SDigitizer")
601 {
602   // Normal CTOR
603   AliDebug(1," processed");
604
605   fRunLoader = AliRunLoader::GetRunLoader(); // Open(headerFile);
606   if (!fRunLoader) 
607     Fatal("AliFMDSDigitizer", "cannot open session, header file '%s'",
608           headerFile);
609   AliLoader* loader = fRunLoader->GetLoader("FMDLoader");
610   if (!loader) 
611     Fatal("AliFMDSDigitizer", "cannot find FMD loader in specified event");
612
613   // Add task to tasks folder 
614   loader->PostSDigitizer(this);
615
616 }
617
618 //____________________________________________________________________
619 AliFMDSDigitizer::~AliFMDSDigitizer() 
620 {
621   AliLoader* loader = fRunLoader->GetLoader("FMDLoader");
622   loader->CleanSDigitizer();
623 }
624
625 //____________________________________________________________________
626 void
627 AliFMDSDigitizer::Exec(Option_t*) 
628 {
629   // Get the output manager 
630   if (!fRunLoader) {
631     Error("Exec", "Run loader is not set");
632     return;
633   }
634   if (!fRunLoader->GetAliRun()) fRunLoader->LoadgAlice();
635   if (!fRunLoader->TreeE())     fRunLoader->LoadHeader();
636   
637   AliLoader* fmdLoader = fRunLoader->GetLoader("FMDLoader");
638   if (!fmdLoader) Fatal("Exec", "no FMD loader");
639   
640   // Get the AliFMD object 
641   AliFMD* fmd = 
642     static_cast<AliFMD*>(fRunLoader->GetAliRun()->GetDetector("FMD"));
643   if (!fmd) {
644     AliError("Can not get FMD from gAlice");
645     return;
646   }
647
648   Int_t nEvents = Int_t(fRunLoader->TreeE()->GetEntries());
649   for (Int_t event = 0; event < nEvents; event++) {
650     AliDebug(1,Form(" Digitizing event number %d", event));
651     // Get the current loader 
652     fRunLoader->GetEvent(event);
653
654     if (!fmdLoader->TreeS()) fmdLoader->MakeTree("S");
655     // Make a branch
656     fmd->MakeBranch("S");
657     
658     // Cache contriutions 
659     SumContributions(fmd);
660
661     // Digitize the event 
662     DigitizeHits(fmd);
663
664     fmdLoader->TreeS()->Reset();
665     fmdLoader->TreeS()->Fill();
666     fmdLoader->WriteSDigits("OVERWRITE");
667   }
668 }
669
670 //____________________________________________________________________
671 void
672 AliFMDSDigitizer::AddDigit(AliFMD*  fmd,
673                            UShort_t detector, 
674                            Char_t   ring,
675                            UShort_t sector, 
676                            UShort_t strip, 
677                            Float_t  edep, 
678                            UShort_t count1, 
679                            Short_t  count2, 
680                            Short_t  count3) const
681 {
682   fmd->AddSDigit(detector, ring, sector, strip, edep, count1, count2, count3);
683 }
684
685
686
687 //____________________________________________________________________
688 //
689 // EOF
690 // 
691
692
693
694