6c9032d694fc9f2b0c2580b8cece433641e4da61
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALRawUtils.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 //  Utility Class for handling Raw data
20 //  Does all transitions from Digits to Raw and vice versa, 
21 //  for simu and reconstruction
22 //
23 //  Note: the current version is still simplified. Only 
24 //    one raw signal per digit is generated; either high-gain or low-gain
25 //    Need to add concurrent high and low-gain info in the future
26 //    No pedestal is added to the raw signal.
27 //*-- Author: Marco van Leeuwen (LBL)
28
29 #include "AliEMCALRawUtils.h"
30   
31 #include "TF1.h"
32 #include "TGraph.h"
33 class TSystem;
34   
35 class AliLog;
36 #include "AliRun.h"
37 #include "AliRunLoader.h"
38 class AliCaloAltroMapping;
39 #include "AliAltroBuffer.h"
40 #include "AliRawReader.h"
41 #include "AliCaloRawStream.h"
42 #include "AliDAQ.h"
43   
44 #include "AliEMCALRecParam.h"
45 #include "AliEMCALLoader.h"
46 #include "AliEMCALGeometry.h"
47 class AliEMCALDigitizer;
48 #include "AliEMCALDigit.h"
49 #include "AliEMCAL.h"
50   
51 ClassImp(AliEMCALRawUtils)
52   
53 // Signal shape parameters
54 Double_t AliEMCALRawUtils::fgTimeBinWidth  = 100E-9 ; // each sample is 100 ns
55 Double_t AliEMCALRawUtils::fgTimeTrigger = 1.5E-6 ;   // 15 time bins ~ 1.5 musec
56
57 // some digitization constants
58 Int_t    AliEMCALRawUtils::fgThreshold = 1;
59 Int_t    AliEMCALRawUtils::fgDDLPerSuperModule = 2;  // 2 ddls per SuperModule
60 Int_t    AliEMCALRawUtils::fgPedestalValue = 32;     // pedestal value for digits2raw
61 Double_t AliEMCALRawUtils::fgFEENoise = 3.;          // 3 ADC channels of noise (sampled)
62
63 AliEMCALRawUtils::AliEMCALRawUtils()
64   : fHighLowGainFactor(0.), fOrder(0), fTau(0.), fNoiseThreshold(0),
65     fNPedSamples(0), fGeom(0), fOption("")
66 {
67
68   //These are default parameters.  
69   //Can be re-set from without with setter functions
70   fHighLowGainFactor = 16. ;          // adjusted for a low gain range of 82 GeV (10 bits) 
71   fOrder = 2;                         // order of gamma fn
72   fTau = 2.35;                        // in units of timebin, from CERN 2007 testbeam
73   fNoiseThreshold = 3;
74   fNPedSamples = 5;
75
76   //Get Mapping RCU files from the AliEMCALRecParam                                 
77   const TObjArray* maps = AliEMCALRecParam::GetMappings();
78   if(!maps) AliFatal("Cannot retrieve ALTRO mappings!!");
79
80   for(Int_t i = 0; i < 4; i++) {
81     fMapping[i] = (AliAltroMapping*)maps->At(i);
82   }
83
84   //To make sure we match with the geometry in a simulation file,
85   //let's try to get it first.  If not, take the default geometry
86   AliRunLoader *rl = AliRunLoader::Instance();
87   if(!rl) AliError("Cannot find RunLoader!");
88   if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL")) {
89     fGeom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
90   } else {
91     AliInfo(Form("Using default geometry in raw reco"));
92     fGeom =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
93   }
94
95   if(!fGeom) AliFatal(Form("Could not get geometry!"));
96
97 }
98
99 //____________________________________________________________________________
100 AliEMCALRawUtils::AliEMCALRawUtils(AliEMCALGeometry *pGeometry)
101   : fHighLowGainFactor(0.), fOrder(0), fTau(0.), fNoiseThreshold(0),
102     fNPedSamples(0), fGeom(pGeometry), fOption("")
103 {
104   //
105   // Initialize with the given geometry - constructor required by HLT
106   // HLT does not use/support AliRunLoader(s) instances
107   // This is a minimum intervention solution
108   // Comment by MPloskon@lbl.gov
109   //
110
111   //These are default parameters. 
112   //Can be re-set from without with setter functions 
113   fHighLowGainFactor = 16. ;          // adjusted for a low gain range of 82 GeV (10 bits)
114   fOrder = 2;                         // order of gamma fn
115   fTau = 2.35;                        // in units of timebin, from CERN 2007 testbeam
116   fNoiseThreshold = 3;
117   fNPedSamples = 5;
118
119   //Get Mapping RCU files from the AliEMCALRecParam
120   const TObjArray* maps = AliEMCALRecParam::GetMappings();
121   if(!maps) AliFatal("Cannot retrieve ALTRO mappings!!");
122
123   for(Int_t i = 0; i < 4; i++) {
124     fMapping[i] = (AliAltroMapping*)maps->At(i);
125   }
126
127   if(!fGeom) AliFatal(Form("Could not get geometry!"));
128
129 }
130
131 //____________________________________________________________________________
132 AliEMCALRawUtils::AliEMCALRawUtils(const AliEMCALRawUtils& rawU)
133   : TObject(),
134     fHighLowGainFactor(rawU.fHighLowGainFactor), 
135     fOrder(rawU.fOrder),
136     fTau(rawU.fTau),
137     fNoiseThreshold(rawU.fNoiseThreshold),
138     fNPedSamples(rawU.fNPedSamples),
139     fGeom(rawU.fGeom), 
140     fOption(rawU.fOption)
141 {
142   //copy ctor
143   fMapping[0] = rawU.fMapping[0];
144   fMapping[1] = rawU.fMapping[1];
145   fMapping[2] = rawU.fMapping[2];
146   fMapping[3] = rawU.fMapping[3];
147 }
148
149 //____________________________________________________________________________
150 AliEMCALRawUtils& AliEMCALRawUtils::operator =(const AliEMCALRawUtils &rawU)
151 {
152   //assignment operator
153
154   if(this != &rawU) {
155     fHighLowGainFactor = rawU.fHighLowGainFactor;
156     fOrder = rawU.fOrder;
157     fTau = rawU.fTau;
158     fNoiseThreshold = rawU.fNoiseThreshold;
159     fNPedSamples = rawU.fNPedSamples;
160     fGeom = rawU.fGeom;
161     fOption = rawU.fOption;
162     fMapping[0] = rawU.fMapping[0];
163     fMapping[1] = rawU.fMapping[1];
164     fMapping[2] = rawU.fMapping[2];
165     fMapping[3] = rawU.fMapping[3];
166   }
167
168   return *this;
169
170 }
171
172 //____________________________________________________________________________
173 AliEMCALRawUtils::~AliEMCALRawUtils() {
174   //dtor
175
176 }
177
178 //____________________________________________________________________________
179 void AliEMCALRawUtils::Digits2Raw()
180 {
181   // convert digits of the current event to raw data
182   
183   AliRunLoader *rl = AliRunLoader::Instance();
184   AliEMCALLoader *loader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
185
186   // get the digits
187   loader->LoadDigits("EMCAL");
188   loader->GetEvent();
189   TClonesArray* digits = loader->Digits() ;
190   
191   if (!digits) {
192     Warning("Digits2Raw", "no digits found !");
193     return;
194   }
195
196   static const Int_t nDDL = 12*2; // 12 SM hardcoded for now. Buffers allocated dynamically, when needed, so just need an upper limit here
197   AliAltroBuffer* buffers[nDDL];
198   for (Int_t i=0; i < nDDL; i++)
199     buffers[i] = 0;
200
201   Int_t adcValuesLow[fgkTimeBins];
202   Int_t adcValuesHigh[fgkTimeBins];
203
204   // loop over digits (assume ordered digits)
205   for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
206     AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
207     if (digit->GetAmp() < fgThreshold) 
208       continue;
209
210     //get cell indices
211     Int_t nSM = 0;
212     Int_t nIphi = 0;
213     Int_t nIeta = 0;
214     Int_t iphi = 0;
215     Int_t ieta = 0;
216     Int_t nModule = 0;
217     fGeom->GetCellIndex(digit->GetId(), nSM, nModule, nIphi, nIeta);
218     fGeom->GetCellPhiEtaIndexInSModule(nSM, nModule, nIphi, nIeta,iphi, ieta) ;
219     
220     //Check which is the RCU, 0 or 1, of the cell.
221     Int_t iRCU = -111;
222     //RCU0
223     if (0<=iphi&&iphi<8) iRCU=0; // first cable row
224     else if (8<=iphi&&iphi<16 && 0<=ieta&&ieta<24) iRCU=0; // first half; 
225     //second cable row
226     //RCU1
227     else if(8<=iphi&&iphi<16 && 24<=ieta&&ieta<48) iRCU=1; // second half; 
228     //second cable row
229     else if(16<=iphi&&iphi<24) iRCU=1; // third cable row
230
231     if (nSM%2==1) iRCU = 1 - iRCU; // swap for odd=C side, to allow us to cable both sides the same
232
233     if (iRCU<0) 
234       Fatal("Digits2Raw()","Non-existent RCU number: %d", iRCU);
235     
236     //Which DDL?
237     Int_t iDDL = fgDDLPerSuperModule* nSM + iRCU;
238     if (iDDL >= nDDL)
239       Fatal("Digits2Raw()","Non-existent DDL board number: %d", iDDL);
240
241     if (buffers[iDDL] == 0) {      
242       // open new file and write dummy header
243       TString fileName = AliDAQ::DdlFileName("EMCAL",iDDL);
244       //Select mapping file RCU0A, RCU0C, RCU1A, RCU1C
245       Int_t iRCUside=iRCU+(nSM%2)*2;
246       //iRCU=0 and even (0) SM -> RCU0A.data   0
247       //iRCU=1 and even (0) SM -> RCU1A.data   1
248       //iRCU=0 and odd  (1) SM -> RCU0C.data   2
249       //iRCU=1 and odd  (1) SM -> RCU1C.data   3
250       //cout<<" nSM "<<nSM<<"; iRCU "<<iRCU<<"; iRCUside "<<iRCUside<<endl;
251       buffers[iDDL] = new AliAltroBuffer(fileName.Data(),fMapping[iRCUside]);
252       buffers[iDDL]->WriteDataHeader(kTRUE, kFALSE);  //Dummy;
253     }
254     
255     // out of time range signal (?)
256     if (digit->GetTimeR() > GetRawFormatTimeMax() ) {
257       AliInfo("Signal is out of time range.\n");
258       buffers[iDDL]->FillBuffer((Int_t)digit->GetAmp());
259       buffers[iDDL]->FillBuffer(GetRawFormatTimeBins() );  // time bin
260       buffers[iDDL]->FillBuffer(3);          // bunch length      
261       buffers[iDDL]->WriteTrailer(3, ieta, iphi, nSM);  // trailer
262       // calculate the time response function
263     } else {
264       Bool_t lowgain = RawSampledResponse(digit->GetTimeR(), digit->GetAmp(), adcValuesHigh, adcValuesLow) ; 
265       if (lowgain) 
266         buffers[iDDL]->WriteChannel(ieta, iphi, 0, GetRawFormatTimeBins(), adcValuesLow, fgThreshold);
267       else 
268         buffers[iDDL]->WriteChannel(ieta,iphi, 1, GetRawFormatTimeBins(), adcValuesHigh, fgThreshold);
269     }
270   }
271   
272   // write headers and close files
273   for (Int_t i=0; i < nDDL; i++) {
274     if (buffers[i]) {
275       buffers[i]->Flush();
276       buffers[i]->WriteDataHeader(kFALSE, kFALSE);
277       delete buffers[i];
278     }
279   }
280
281   loader->UnloadDigits();
282 }
283
284 //____________________________________________________________________________
285 void AliEMCALRawUtils::Raw2Digits(AliRawReader* reader,TClonesArray *digitsArr)
286 {
287   // convert raw data of the current event to digits                                                                                     
288
289   digitsArr->Clear(); 
290
291   if (!digitsArr) {
292     Error("Raw2Digits", "no digits found !");
293     return;
294   }
295   if (!reader) {
296     Error("Raw2Digits", "no raw reader found !");
297     return;
298   }
299
300   AliCaloRawStream in(reader,"EMCAL",fMapping);
301   // Select EMCAL DDL's;
302   reader->Select("EMCAL");
303
304   //Updated fitting routine from 2007 beam test takes into account
305   //possibility of two peaks in data and selects first one for fitting
306   //Also sets some of the starting parameters based on the shape of the
307   //given raw signal being fit
308
309   TF1 * signalF = new TF1("signal", RawResponseFunction, 0, GetRawFormatTimeBins(), 5);
310   signalF->SetParameters(10.,0.,fTau,fOrder,5.); //set all defaults once, just to be safe
311   signalF->SetParNames("amp","t0","tau","N","ped");
312   signalF->SetParameter(2,fTau); // tau in units of time bin
313   signalF->SetParLimits(2,2,-1);
314   signalF->SetParameter(3,fOrder); // order
315   signalF->SetParLimits(3,2,-1);
316   
317   Int_t id =  -1;
318   Float_t time = 0. ; 
319   Float_t amp = 0. ; 
320
321   //Graph to hold data we will fit (should be converted to an array
322   //later to speed up processing
323   TGraph * gSig = new TGraph(GetRawFormatTimeBins()); 
324
325   Int_t readOk = 1;
326   Int_t lowGain = 0;
327   Int_t caloFlag = 0; // low, high gain, or TRU, or LED ref.
328
329   while (readOk && in.GetModule() < 0) 
330     readOk = in.Next();  // Go to first digit
331
332   while (readOk) { 
333
334     id =  fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
335     caloFlag = in.GetCaloFlag();
336     lowGain = in.IsLowGain();
337     Int_t maxTime = in.GetTime();  // timebins come in reverse order
338     if (maxTime < 0 || maxTime >= GetRawFormatTimeBins()) {
339       AliWarning(Form("Invalid time bin %d",maxTime));
340       maxTime = GetRawFormatTimeBins();
341     }
342     gSig->Set(maxTime+1);
343     // There is some kind of zero-suppression in the raw data, 
344     // so set up the TGraph in advance
345     for (Int_t i=0; i < maxTime; i++) {
346       gSig->SetPoint(i, i , 0);
347     }
348
349     Int_t iTime = 0;
350     do {
351       if (in.GetTime() >= gSig->GetN()) {
352           AliWarning("Too many time bins");
353           gSig->Set(in.GetTime());
354       }
355       
356       gSig->SetPoint(in.GetTime(), in.GetTime(), in.GetSignal()) ;
357
358       if (in.GetTime() > maxTime)
359         maxTime = in.GetTime();
360       iTime++;
361     } while ((readOk = in.Next()) && !in.IsNewHWAddress());
362
363     FitRaw(gSig, signalF, amp, time) ; 
364     
365     if (caloFlag == 0 || caloFlag == 1) { // low gain or high gain 
366       if (amp > 0 && amp < 2000) {  //check both high and low end of
367         //result, 2000 is somewhat arbitrary - not nice with magic numbers in the code..
368         AliDebug(2,Form("id %d lowGain %d amp %g", id, lowGain, amp));
369         
370         AddDigit(digitsArr, id, lowGain, (Int_t)amp, time);
371       }
372         
373     }
374
375     // Reset graph
376     for (Int_t index = 0; index < gSig->GetN(); index++) {
377       gSig->SetPoint(index, index, 0) ;  
378     } 
379     // Reset starting parameters for fit function
380     signalF->SetParameters(10.,0.,fTau,fOrder,5.); //reset all defaults just to be safe
381
382   }; // EMCAL entries loop
383   
384   delete signalF ; 
385   delete gSig;
386   
387   return ; 
388 }
389
390 //____________________________________________________________________________ 
391 void AliEMCALRawUtils::AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Int_t amp, Float_t time) {
392   //
393   // Add a new digit. 
394   // This routine checks whether a digit exists already for this tower 
395   // and then decides whether to use the high or low gain info
396   //
397   // Called by Raw2Digits
398   
399   AliEMCALDigit *digit = 0, *tmpdigit = 0;
400   
401   TIter nextdigit(digitsArr);
402   while (digit == 0 && (tmpdigit = (AliEMCALDigit*) nextdigit())) {
403     if (tmpdigit->GetId() == id)
404       digit = tmpdigit;
405   }
406
407   if (!digit) { // no digit existed for this tower; create one
408     if (lowGain) 
409       amp = Int_t(fHighLowGainFactor * amp); 
410     Int_t idigit = digitsArr->GetEntries();
411     new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, idigit) ;   
412   }
413   else { // a digit already exists, check range 
414          // (use high gain if signal < cut value, otherwise low gain)
415     if (lowGain) { // new digit is low gain
416       if (digit->GetAmp() > fgkOverflowCut) {  // use if stored digit is out of range
417         digit->SetAmp(Int_t(fHighLowGainFactor * amp));
418         digit->SetTime(time);
419       }
420     }
421     else if (amp < fgkOverflowCut) { // new digit is high gain; use if not out of range
422       digit->SetAmp(amp);
423       digit->SetTime(time);
424     }
425   }
426 }
427
428 //____________________________________________________________________________ 
429 void AliEMCALRawUtils::FitRaw(TGraph * gSig, TF1* signalF, Float_t & amp, Float_t & time) const 
430 {
431   // Fits the raw signal time distribution; from AliEMCALGetter 
432
433   amp = time = 0. ; 
434   Double_t ped = 0;
435   Int_t nPed = 0;
436
437   for (Int_t index = 0; index < fNPedSamples; index++) {
438     Double_t ttime, signal;
439     gSig->GetPoint(index, ttime, signal) ; 
440     if (signal > 0) {
441       ped += signal;
442       nPed++;
443     }
444   }
445
446   if (nPed > 0)
447     ped /= nPed;
448   else {
449     AliWarning("Could not determine pedestal");   
450     ped = 10; // put some small value as first guess
451   }
452
453   Int_t maxFound = 0;
454   Int_t iMax = 0;
455   Float_t max = -1;
456   Float_t maxFit = gSig->GetN();
457   Float_t minAfterSig = 9999;
458   Int_t tminAfterSig = gSig->GetN();
459   Int_t nPedAfterSig = 0;
460   Int_t plateauWidth = 0;
461   Int_t plateauStart = 9999;
462   Float_t cut = 0.3;
463
464   for (Int_t i=fNPedSamples; i < gSig->GetN(); i++) {
465     Double_t ttime, signal;
466     gSig->GetPoint(i, ttime, signal) ; 
467     if (!maxFound && signal > max) {
468       iMax = i;
469       max = signal;
470     }
471     else if ( max > ped + fNoiseThreshold ) {
472       maxFound = 1;
473       minAfterSig = signal;
474       tminAfterSig = i;
475     }
476     if (maxFound) {
477       if ( signal < minAfterSig) {
478         minAfterSig = signal;
479         tminAfterSig = i;
480       }
481       if (i > tminAfterSig + 5) {  // Two close peaks; end fit at minimum
482         maxFit = tminAfterSig;
483         break;
484       }
485       if ( signal < cut*max){   //stop fit at 30% amplitude(avoid the pulse shape falling edge)
486         maxFit = i;
487         break;
488       }
489       if ( signal < ped + fNoiseThreshold)
490         nPedAfterSig++;
491       if (nPedAfterSig >= 5) {  // include 5 pedestal bins after peak
492         maxFit = i;
493         break;
494       }
495     }
496     //Add check on plateau
497     if (signal >= fgkRawSignalOverflow - fNoiseThreshold) {
498       if(plateauWidth == 0) plateauStart = i;
499       plateauWidth++;
500     }
501   }
502
503   if(plateauWidth > 0) {
504     for(int j = 0; j < plateauWidth; j++) {
505       //Note, have to remove the same point N times because after each
506       //remove, the positions of all subsequent points have shifted down
507       gSig->RemovePoint(plateauStart);
508     }
509   }
510
511   if ( max - ped > fNoiseThreshold ) { // else its noise 
512     AliDebug(2,Form("Fitting max %d ped %d", max, ped));
513     signalF->SetRange(0,maxFit);
514
515     if(max-ped > 50) 
516       signalF->SetParLimits(2,1,3);
517
518     signalF->SetParameter(4, ped) ; 
519     signalF->SetParameter(1, iMax);
520     signalF->SetParameter(0, max);
521     
522     gSig->Fit(signalF, "QROW"); // Note option 'W': equal errors on all points
523     amp = signalF->GetParameter(0); 
524     time = signalF->GetParameter(1)*GetRawFormatTimeBinWidth() - fgTimeTrigger;
525   }
526   return;
527 }
528 //__________________________________________________________________
529 Double_t AliEMCALRawUtils::RawResponseFunction(Double_t *x, Double_t *par)
530 {
531   // Matches version used in 2007 beam test
532   //
533   // Shape of the electronics raw reponse:
534   // It is a semi-gaussian, 2nd order Gamma function of the general form
535   //
536   // t' = (t - t0 + tau) / tau
537   // F = A * t**N * exp( N * ( 1 - t) )   for t >= 0
538   // F = 0                                for t < 0 
539   //
540   // parameters:
541   // A:   par[0]   // Amplitude = peak value
542   // t0:  par[1]
543   // tau: par[2]
544   // N:   par[3]
545   // ped: par[4]
546   //
547   Double_t signal ;
548   Double_t tau =par[2];
549   Double_t n =par[3];
550   Double_t ped = par[4];
551   Double_t xx = ( x[0] - par[1] + tau ) / tau ;
552
553   if (xx <= 0) 
554     signal = ped ;  
555   else {  
556     signal = ped + par[0] * TMath::Power(xx , n) * TMath::Exp(n * (1 - xx )) ; 
557   }
558   return signal ;  
559 }
560
561 //__________________________________________________________________
562 Bool_t AliEMCALRawUtils::RawSampledResponse(
563 const Double_t dtime, const Double_t damp, Int_t * adcH, Int_t * adcL) const 
564 {
565   // for a start time dtime and an amplitude damp given by digit, 
566   // calculates the raw sampled response AliEMCAL::RawResponseFunction
567
568   Bool_t lowGain = kFALSE ; 
569
570   // A:   par[0]   // Amplitude = peak value
571   // t0:  par[1]                            
572   // tau: par[2]                            
573   // N:   par[3]                            
574   // ped: par[4]
575
576   TF1 signalF("signal", RawResponseFunction, 0, GetRawFormatTimeBins(), 5);
577   signalF.SetParameter(0, damp) ; 
578   signalF.SetParameter(1, (dtime + fgTimeTrigger)/fgTimeBinWidth) ; 
579   signalF.SetParameter(2, fTau) ; 
580   signalF.SetParameter(3, fOrder);
581   signalF.SetParameter(4, fgPedestalValue);
582
583   for (Int_t iTime = 0; iTime < GetRawFormatTimeBins(); iTime++) {
584     Double_t signal = signalF.Eval(iTime) ;     
585
586     //According to Terry Awes, 13-Apr-2008
587     //add gaussian noise in quadrature to each sample
588     //Double_t noise = gRandom->Gaus(0.,fgFEENoise);
589     //signal = sqrt(signal*signal + noise*noise);
590
591     adcH[iTime] =  static_cast<Int_t>(signal + 0.5) ;
592     if ( adcH[iTime] > fgkRawSignalOverflow ){  // larger than 10 bits 
593       adcH[iTime] = fgkRawSignalOverflow ;
594       lowGain = kTRUE ; 
595     }
596
597     signal /= fHighLowGainFactor;
598
599     adcL[iTime] =  static_cast<Int_t>(signal + 0.5) ;
600     if ( adcL[iTime] > fgkRawSignalOverflow)  // larger than 10 bits 
601       adcL[iTime] = fgkRawSignalOverflow ;
602   }
603   return lowGain ; 
604 }