Ignore:
Timestamp:
02/05/04 17:23:09 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc

    r3012 r3028  
    3535// - The uncertainty about the Electronic RMS to 0.3 per slice
    3636// - The F-Factor is assumed to have been measured in Munich to 1.13 - 1.17.
    37 //   We use here the Square of the Munich definition, thus:
    38 //   Mean F-Factor  = 1.15*1.15 = 1.32
    39 //   Error F-Factor = 2.*0.02   = 0.04
     37//   with the Munich definition of the F-Factor, thus:
     38//   F = Sigma(Out)/Mean(Out) * Mean(In)/Sigma(In)
     39//   Mean F-Factor  = 1.15
     40//   Error F-Factor = 0.02
    4041//
    4142/////////////////////////////////////////////////////////////////////////////
    … …  
    5051using namespace std;
    5152
    52 const Float_t MCalibrationPix::gkElectronicPedRms    = 1.5;
    53 const Float_t MCalibrationPix::gkErrElectronicPedRms = 0.3;
    54 const Float_t MCalibrationPix::gkFFactor             = 1.32;
    55 const Float_t MCalibrationPix::gkFFactorError        = 0.04;
    56 const Float_t MCalibrationPix::gkChargeLimit         = 3.;
    57 const Float_t MCalibrationPix::gkChargeErrLimit      = 0.;
    58 const Float_t MCalibrationPix::gkChargeRelErrLimit   = 1.;
    59 const Float_t MCalibrationPix::gkTimeLimit           = 1.5;
    60 const Float_t MCalibrationPix::gkTimeErrLimit        = 3.;
     53const Float_t MCalibrationPix::gkElectronicPedRms         = 1.5;
     54const Float_t MCalibrationPix::gkErrElectronicPedRms      = 0.3;
     55const Float_t MCalibrationPix::gkFFactor                  = 1.15;
     56const Float_t MCalibrationPix::gkFFactorError             = 0.02;
     57const Float_t MCalibrationPix::gkChargeLimit              = 3.;
     58const Float_t MCalibrationPix::gkChargeErrLimit           = 0.;
     59const Float_t MCalibrationPix::gkChargeRelErrLimit        = 1.;
     60const Float_t MCalibrationPix::gkTimeLimit                = 1.5;
     61const Float_t MCalibrationPix::gkTimeErrLimit             = 3.;
     62const Float_t MCalibrationPix::gkConvFFactorRelErrorLimit = 0.1;
    6163
    6264// --------------------------------------------------------------------------
    … …  
    115117  fSigmaCharge                      =  -1.;
    116118  fErrSigmaCharge                   =  -1.;
    117   fRSigmaSquare                     =  -1.;
     119  fRSigmaCharge                     =  -1.;
     120  fErrRSigmaCharge                  =  -1.;
     121
    118122  fChargeProb                       =  -1.;
    119123  fPed                              =  -1.;
    120124  fPedRms                           =  -1.;
    121125  fErrPedRms                        =   0.;
    122   fTime                             =  -1.;
    123   fErrTime                          =  -1.;
    124   fSigmaTime                        =  -1.;
     126
     127  fNumHiGainSamples                 =  -1.;
     128  fNumLoGainSamples                 =  -1.;
     129
     130  fMeanTimeOffset                   =  -1.;
     131  fMeanTimeOffsetError              =  -1.;
     132  fTimingPrecision                  =  -1.;
    125133  fTimeProb                         =  -1.;
    126134  fTimeFirstHiGain                  =   0 ;
    … …  
    134142  fPheFFactorMethod                 =  -1.;
    135143  fPheFFactorMethodError            =  -1.;
    136   fConversionFFactorMethod          =  -1.;
    137   fConversionBlindPixelMethod       =  -1.;
    138   fConversionPINDiodeMethod         =  -1.;
    139   fConversionErrorFFactorMethod     =  -1.;
    140   fConversionErrorBlindPixelMethod  =  -1.;
    141   fConversionErrorPINDiodeMethod    =  -1.;
    142   fConversionSigmaFFactorMethod     =  -1.;
    143   fConversionSigmaBlindPixelMethod  =  -1.;
    144   fConversionSigmaPINDiodeMethod    =  -1.;
     144
     145  fMeanConversionFFactorMethod      =  -1.;
     146  fMeanConversionBlindPixelMethod   =  -1.;
     147  fMeanConversionPINDiodeMethod     =  -1.;
     148
     149  fErrorConversionFFactorMethod     =  -1.;
     150  fErrorConversionBlindPixelMethod  =  -1.;
     151  fErrorConversionPINDiodeMethod    =  -1.;
     152
     153  fSigmaConversionFFactorMethod     =  -1.;
     154  fSigmaConversionBlindPixelMethod  =  -1.;
     155  fSigmaConversionPINDiodeMethod    =  -1.;
     156
     157  fFactorCalculated = kFALSE;
    145158
    146159}
    … …  
    160173// Set the pedestals from outside
    161174//
    162 void MCalibrationPix::SetPedestal(Float_t ped, Float_t pedrms)
     175void MCalibrationPix::SetPedestal(const Float_t ped, const Float_t pedrms,
     176                                  const Float_t higainsamp, const Float_t logainsamp )
    163177{
    164178
    … …  
    166180  fPedRms = pedrms;
    167181 
     182  fNumHiGainSamples = higainsamp;
     183  fNumLoGainSamples = logainsamp;
     184
    168185}
    169186
    … …  
    174191void MCalibrationPix::SetConversionFFactorMethod(Float_t c, Float_t err, Float_t sig)
    175192{
    176   fConversionFFactorMethod = c;
    177   fConversionErrorFFactorMethod = err;
    178   fConversionSigmaFFactorMethod = sig;
     193  fMeanConversionFFactorMethod = c;
     194  fErrorConversionFFactorMethod = err;
     195  fSigmaConversionFFactorMethod = sig;
    179196}
    180197
    … …  
    186203void MCalibrationPix::SetConversionBlindPixelMethod(Float_t c, Float_t err, Float_t sig)
    187204{
    188   fConversionBlindPixelMethod = c;
    189   fConversionErrorBlindPixelMethod = err;
    190   fConversionSigmaBlindPixelMethod = sig;
     205  fMeanConversionBlindPixelMethod = c;
     206  fErrorConversionBlindPixelMethod = err;
     207  fSigmaConversionBlindPixelMethod = sig;
    191208}
    192209
    … …  
    197214void MCalibrationPix::SetConversionPINDiodeMethod(Float_t c, Float_t err, Float_t sig)
    198215{
    199   fConversionPINDiodeMethod = c ;
    200   fConversionErrorPINDiodeMethod = err;
    201   fConversionSigmaPINDiodeMethod = sig;
     216  fMeanConversionPINDiodeMethod = c ;
     217  fErrorConversionPINDiodeMethod = err;
     218  fSigmaConversionPINDiodeMethod = sig;
    202219}
    203220
    … …  
    310327}
    311328
     329Float_t MCalibrationPix::GetPheFFactorMethod()
     330{
     331 
     332  if (!fFactorCalculated)
     333    CalcFFactorMethod();
     334 
     335  return fPheFFactorMethod;
     336 
     337}
     338
     339Float_t MCalibrationPix::GetPheFFactorMethodError()
     340{
     341 
     342  if (!fFactorCalculated)
     343    CalcFFactorMethod();
     344 
     345  return fPheFFactorMethodError;
     346 
     347}
     348
     349
     350Float_t MCalibrationPix::GetTotalFFactor()
     351{
     352  if (!fFactorCalculated)
     353    CalcFFactorMethod();
     354 
     355  return (fRSigmaCharge/fCharge)*TMath::Sqrt(fPheFFactorMethod);
     356}
     357
     358Float_t MCalibrationPix::GetTotalFFactorError()
     359{
     360
     361  if (!fFactorCalculated)
     362   CalcFFactorMethod();
     363
     364  const Float_t rsigmaChargeRelErrSquare = fErrRSigmaCharge * fErrRSigmaCharge
     365                                           / (fRSigmaCharge * fRSigmaCharge) ;
     366  const Float_t rChargeRelErrSquare      = fErrCharge * fErrCharge
     367                                           / (fCharge * fCharge) ;
     368  const Float_t rPheRelErrSquare         = fPheFFactorMethodError * fPheFFactorMethodError
     369                                           / (fPheFFactorMethod * fPheFFactorMethod) ;
     370
     371  return TMath::Sqrt(rsigmaChargeRelErrSquare+rChargeRelErrSquare+rPheRelErrSquare);
     372}
     373
     374
     375Float_t MCalibrationPix::GetMeanConversionFFactorMethod()
     376{
     377
     378  if (!fFactorCalculated)
     379    CalcFFactorMethod();
     380 
     381  return fMeanConversionFFactorMethod;
     382 
     383}
     384
     385Float_t MCalibrationPix::GetErrorConversionFFactorMethod()
     386{
     387
     388  if (!fFactorCalculated)
     389    CalcFFactorMethod();
     390 
     391  return fErrorConversionFFactorMethod;
     392 
     393}
     394
     395Float_t MCalibrationPix::GetSigmaConversionFFactorMethod()
     396{
     397
     398  if (!fFactorCalculated)
     399    CalcFFactorMethod();
     400 
     401  return fSigmaConversionFFactorMethod;
     402 
     403}
     404
     405
     406Float_t MCalibrationPix::GetTimingPrecisionError() const
     407{
     408  return fMeanTimeOffsetError/2.;
     409}
    312410
    313411
    … …  
    337435}
    338436
    339 Bool_t MCalibrationPix::IsFFactorMethodValid()  const
    340 {
     437Bool_t MCalibrationPix::IsFFactorMethodValid()
     438{
     439
     440  if (!fFactorCalculated)
     441    CalcFFactorMethod();
     442
    341443  return TESTBIT(fFlags, kFFactorMethodValid);     
    342444}
    … …  
    403505  if (fHist->UseLoGain())
    404506    SetHiGainSaturation();
    405      
     507
    406508  //
    407509  // 4) Fit the Lo Gain histograms with a Gaussian
    408510  //
    409   if(fHist->FitCharge())
    410     {
    411       SETBIT(fFlags,kFitted);
    412     }
     511  if (fHist->FitCharge())
     512    SETBIT(fFlags,kFitted);
    413513  else
    414514    {
    … …  
    422522  //
    423523  // 6) Retrieve the results and store them in this class
     524  //    If fFitted is false, we get the means and RMS of the histogram!!
    424525  //
    425526  fCharge         = fHist->GetChargeMean();
    … …  
    429530  fChargeProb     = fHist->GetChargeProb();
    430531
     532  //
     533  // Calculate the conversion factors
     534  //
     535  if (TESTBIT(fFlags,kHiGainSaturation))
     536    ApplyLoGainConversion();
     537
    431538  if (CheckChargeFitValidity())
    432539    SETBIT(fFlags,kChargeFitValid);
    … …  
    437544    }
    438545 
    439   //
    440   // 7) Calculate the number of photo-electrons after the F-Factor method
    441   // 8) Calculate the errors of the F-Factor method
    442   //
    443   if ((fPed > 0.)  && (fPedRms > 0.))
    444     {
     546  return kTRUE;
     547 
     548}
     549
     550//
     551// Calculate the number of photo-electrons after the F-Factor method
     552// Calculate the errors of the F-Factor method
     553//
     554Bool_t MCalibrationPix::CalcFFactorMethod()
     555{
     556
     557  if ( (fCharge    == -1.)
     558   || (fErrCharge   < 0.)
     559   || (fSigmaCharge < 0.)
     560   || (fPedRms      < 0.) )
     561    {
     562      *fLog << warn << GetDescriptor() << "Cannot calculate the FFactor Method! "
     563            << "Some of the needed parameters are not available ";
     564      CLRBIT(fFlags,kFFactorMethodValid);
     565      return kFALSE;
     566    }
     567
     568  //
     569  // Square all variables in order to avoid applications of square root
     570  //
     571  // First the relative error squares
     572  //
     573  const Float_t chargeSquare              =       fCharge*   fCharge;
     574  const Float_t chargeSquareRelErrSquare  = 4.*fErrCharge*fErrCharge / chargeSquare;
     575 
     576  const Float_t ffactorsquare             =    gkFFactor      * gkFFactor;
     577  const Float_t ffactorsquareRelErrSquare = 4.*gkFFactorError * gkFFactorError / ffactorsquare;
     578  //
     579  // Now the absolute error squares
     580  //
     581  const Float_t sigmaSquare               =       fSigmaCharge*fSigmaCharge;
     582  const Float_t sigmaSquareErrSquare      = 4.*fErrSigmaCharge*fErrSigmaCharge * sigmaSquare;
     583 
     584  Float_t pedRmsSquare                    =       fPedRms*   fPedRms;
     585  Float_t pedRmsSquareErrSquare           = 4.*fErrPedRms*fErrPedRms * pedRmsSquare;
     586 
     587  if (!TESTBIT(fFlags,kHiGainSaturation))
     588    {  /* HiGain */
     589
     590      pedRmsSquare          *= fNumHiGainSamples;
     591      pedRmsSquareErrSquare *= fNumHiGainSamples*fNumHiGainSamples;
     592    }
     593  else
     594    {  /* LoGain */
    445595     
    446596      //
    447       // Square all variables in order to avoid applications of square root
     597      // We do not know the Lo Gain Pedestal RMS, so we have to retrieve it
     598      // from the HI GAIN (all calculation per slice up to now): 
    448599      //
    449       // First the relative error squares
     600      // We extract the pure NSB contribution:
    450601      //
    451       const Float_t chargeSquare              =       fCharge*   fCharge;
    452       const Float_t chargeSquareRelErrSquare  = 4.*fErrCharge*fErrCharge / chargeSquare;
    453 
    454       const Float_t fFactorRelErrSquare       = gkFFactorError * gkFFactorError / (gkFFactor * gkFFactor);
     602      const Float_t elecRmsSquare          =    gkElectronicPedRms   *gkElectronicPedRms;
     603      const Float_t elecRmsSquareErrSquare = 4.*gkErrElectronicPedRms*gkErrElectronicPedRms * elecRmsSquare;
     604 
     605      Float_t nsbSquare             =  pedRmsSquare          - elecRmsSquare;
     606      Float_t nsbSquareRelErrSquare = (pedRmsSquareErrSquare + elecRmsSquareErrSquare)
     607                                    / (nsbSquare * nsbSquare) ;
     608     
     609      if (nsbSquare < 0.)
     610        nsbSquare = 0.;
     611
    455612      //
    456       // Now the absolute error squares
     613      // Now, we divide the NSB by the conversion factor and
     614      // add it quadratically to the electronic noise
    457615      //
    458       const Float_t sigmaSquare               =       fSigmaCharge*   fSigmaCharge;
    459       const Float_t sigmaSquareErrSquare      = 4.*fErrSigmaCharge*fErrSigmaCharge * sigmaSquare;
    460 
    461       const Float_t elecRmsSquare             =       gkElectronicPedRms*   gkElectronicPedRms;
    462       const Float_t elecRmsSquareErrSquare    = 4.*gkErrElectronicPedRms*gkErrElectronicPedRms * elecRmsSquare;
    463 
    464       Float_t pedRmsSquare                    =       fPedRms*   fPedRms;
    465       Float_t pedRmsSquareErrSquare           = 4.*fErrPedRms*fErrPedRms * pedRmsSquare;
    466 
    467       if (TESTBIT(fFlags,kHiGainSaturation))
    468         {
    469          
    470           //
    471           // We do not know the Lo Gain Pedestal RMS, so we have to retrieve it
    472           // from the Hi Gain:
    473           //
    474           // We extract the pure NSB contribution:
    475           //
    476           Float_t nsbSquare             =  pedRmsSquare          - elecRmsSquare;
    477           Float_t nsbSquareRelErrSquare = (pedRmsSquareErrSquare + elecRmsSquareErrSquare)
    478                                           / (nsbSquare * nsbSquare) ;
    479 
    480           if (nsbSquare < 0.)
    481             nsbSquare = 0.;
    482          
    483           //
    484           // Now, we divide the NSB by the conversion factor and
    485           // add it quadratically to the electronic noise
    486           //
    487           const Float_t conversionSquare             =    fConversionHiLo     *fConversionHiLo;
    488           const Float_t conversionSquareRelErrSquare = 4.*fConversionHiLoError*fConversionHiLoError/conversionSquare;
    489 
    490           //
    491           // Calculate the new "Pedestal RMS"
    492           //
    493           const Float_t convertedNsbSquare          =  nsbSquare             / conversionSquare;
    494           const Float_t convertedNsbSquareErrSquare = (nsbSquareRelErrSquare + conversionSquareRelErrSquare)
    495                                                       * convertedNsbSquare * convertedNsbSquare;
    496 
    497           pedRmsSquare           = convertedNsbSquare           + elecRmsSquare;
    498           pedRmsSquareErrSquare  = convertedNsbSquareErrSquare  + elecRmsSquareErrSquare;
    499          
    500         }    /* if (kHiGainSaturation) */
     616      const Float_t conversionSquare             =    fConversionHiLo     *fConversionHiLo;
     617      const Float_t conversionSquareRelErrSquare = 4.*fConversionHiLoError*fConversionHiLoError/conversionSquare;
     618     
     619      const Float_t convertedNsbSquare          =  nsbSquare             / conversionSquare;
     620      const Float_t convertedNsbSquareErrSquare = (nsbSquareRelErrSquare + conversionSquareRelErrSquare)
     621                                                   * convertedNsbSquare * convertedNsbSquare;
     622
     623      pedRmsSquare           = convertedNsbSquare           + elecRmsSquare;
     624      pedRmsSquareErrSquare  = convertedNsbSquareErrSquare  + elecRmsSquareErrSquare;
    501625     
    502626      //
    503       // Calculate the reduced sigmas
     627      // Now, correct for the number of used FADC slices in the LoGain:
    504628      //
    505       fRSigmaSquare = sigmaSquare - pedRmsSquare;
    506       if (fRSigmaSquare <= 0.)
    507         {
    508           *fLog << warn
    509                 << "WARNING: Cannot apply F-Factor calibration: Reduced Sigma smaller than 0 in pixel "
    510                 << fPixId << endl;
    511           if (TESTBIT(fFlags,kHiGainSaturation))
    512             ApplyLoGainConversion();
    513           return kFALSE;
    514         }
    515 
    516       const Float_t rSigmaSquareRelErrSquare = (sigmaSquareErrSquare + pedRmsSquareErrSquare)
    517                                                / (fRSigmaSquare * fRSigmaSquare) ;
    518  
     629      pedRmsSquare          *= fNumLoGainSamples;
     630      pedRmsSquareErrSquare *= fNumLoGainSamples*fNumLoGainSamples;
    519631      //
    520       // Calculate the number of phe's from the F-Factor method
    521       // (independent on Hi Gain or Lo Gain)
     632      // Correct also for the conversion to Hi-Gain:
    522633      //
    523       fPheFFactorMethod = gkFFactor * chargeSquare / fRSigmaSquare;
    524 
    525       const Float_t pheFFactorRelErrSquare =  fFactorRelErrSquare
    526                                             + chargeSquareRelErrSquare
    527                                             + rSigmaSquareRelErrSquare ;
    528          
    529       fPheFFactorMethodError        =  TMath::Sqrt(pheFFactorRelErrSquare) * fPheFFactorMethod;
    530 
    531       //
    532       // Calculate the conversion factors
    533       //
    534       if (TESTBIT(fFlags,kHiGainSaturation))
    535         ApplyLoGainConversion();
    536      
    537       const Float_t chargeRelErrSquare = fErrCharge*fErrCharge / (fCharge * fCharge);
    538      
    539       fConversionFFactorMethod        =  fPheFFactorMethod / fCharge ;
    540       fConversionErrorFFactorMethod   =  ( pheFFactorRelErrSquare + chargeRelErrSquare )
    541                                          * fConversionFFactorMethod * fConversionFFactorMethod;
    542      
    543       if ( IsChargeFitValid()               &&
    544            (fConversionFFactorMethod > 0.) &&
    545            (fConversionErrorFFactorMethod/fConversionFFactorMethod < 0.1) )
    546         SETBIT(fFlags,kFFactorMethodValid);
    547       else
    548         CLRBIT(fFlags,kFFactorMethodValid);
    549      
    550     } /*   if ((fPed > 0.)  && (fPedRms > 0.)) */
     634      pedRmsSquare          *= fConversionHiLo*fConversionHiLo;
     635      pedRmsSquareErrSquare *= fConversionHiLo*fConversionHiLo*fConversionHiLo*fConversionHiLo;
     636
     637    }   /* if (HiGainSaturation) */
     638 
     639  //
     640  // Calculate the reduced sigmas
     641  //
     642  const Float_t rsigmachargesquare = sigmaSquare - pedRmsSquare;
     643  if (rsigmachargesquare <= 0.)
     644    {
     645      *fLog << warn
     646            << "WARNING: Cannot apply F-Factor calibration: Reduced Sigma smaller than 0 in pixel "
     647            << fPixId << endl;
     648      CLRBIT(fFlags,kFFactorMethodValid);
     649      fFactorCalculated = kTRUE;
     650      return kFALSE;
     651    }
     652 
     653  const Float_t rSigmaSquareRelErrSquare = (sigmaSquareErrSquare + pedRmsSquareErrSquare)
     654                                          / (rsigmachargesquare * rsigmachargesquare) ;
     655 
     656  fRSigmaCharge    = TMath::Sqrt(rsigmachargesquare);
     657  fErrRSigmaCharge = TMath::Sqrt(sigmaSquareErrSquare + pedRmsSquareErrSquare);
     658
     659
     660  //
     661  // Calculate the number of phe's from the F-Factor method
     662  // (independent on Hi Gain or Lo Gain)
     663  //
     664  fPheFFactorMethod = ffactorsquare * chargeSquare / rsigmachargesquare;
     665
     666  const Float_t pheFFactorRelErrSquare =  ffactorsquareRelErrSquare
     667                                       + chargeSquareRelErrSquare
     668                                       + rSigmaSquareRelErrSquare ;
     669 
     670  fPheFFactorMethodError        =  TMath::Sqrt(pheFFactorRelErrSquare) * fPheFFactorMethod;
     671 
     672  const Float_t chargeRelErrSquare = fErrCharge*fErrCharge / (fCharge * fCharge);
     673 
     674  fMeanConversionFFactorMethod     =  fPheFFactorMethod / fCharge ;
     675  fErrorConversionFFactorMethod    =  ( pheFFactorRelErrSquare + chargeRelErrSquare )
     676                                   * fMeanConversionFFactorMethod * fMeanConversionFFactorMethod;
     677
     678  const Float_t convrelerror = fErrorConversionFFactorMethod/fMeanConversionFFactorMethod;
     679 
     680  if ( (fMeanConversionFFactorMethod > 0.) && (convrelerror < gkConvFFactorRelErrorLimit))
     681    SETBIT(fFlags,kFFactorMethodValid);
     682
     683  fFactorCalculated = kTRUE;
     684
     685  fSigmaConversionFFactorMethod = GetTotalFFactor()*TMath::Sqrt(fMeanConversionFFactorMethod);
    551686
    552687  return kTRUE;
    553  
    554 }
    555 
    556 //
    557 // The check return kTRUE if:
    558 //
    559 // 0) No value is nan
     688}
     689
     690
     691//
     692// The check returns kTRUE if:
     693//
     694// 0) Pixel has BIT fitted set:
     695//    This means:
     696//    a)  No result is a nan
     697//    b)  The NDF is not smaller than fNDFLimit (5)
     698//    c)  The Probability is greater than gkProbLimit (default 0.001 == 99.9%)
    560699// 1) Pixel has a fitted charge greater than 3*PedRMS
    561700// 2) Pixel has a fit error greater than 0.
    … …  
    567706{
    568707
    569   if (TMath::IsNaN(fCharge)
    570       || TMath::IsNaN(fErrCharge)
    571       || TMath::IsNaN(fSigmaCharge)
    572       || TMath::IsNaN(fErrSigmaCharge)
    573       || TMath::IsNaN(fChargeProb))
    574     {
    575       *fLog << warn << "WARNING: Some of the fit values are NAN in Pixel " << fPixId << endl;
    576       return kFALSE;
    577     }
    578  
     708  if (!TESTBIT(fFlags,kFitted))
     709    return kFALSE;
    579710
    580711  if (TESTBIT(fFlags,kExcludeQualityCheck))
    581712    return kTRUE;
    582713
    583   Float_t equivpedestal = GetPedRms();
    584 
    585   if (TESTBIT(fFlags,kHiGainSaturation))
    586     equivpedestal /= fConversionHiLo;
     714  Float_t pedestal;
     715
     716  if (!TESTBIT(fFlags,kHiGainSaturation))  /* higain */
     717    pedestal = GetPedRms()*TMath::Sqrt(fNumHiGainSamples);
     718  else                                     /*  logain */
     719    pedestal = GetPedRms()*TMath::Sqrt(fNumLoGainSamples);
    587720     
    588   if (fCharge < gkChargeLimit*equivpedestal)
     721
     722  if (fCharge < gkChargeLimit*pedestal)
    589723    {
    590724      *fLog << warn << "WARNING: Fitted Charge is smaller than "
    … …  
    614748    }
    615749
    616   if (fSigmaCharge < equivpedestal)
     750  if (fSigmaCharge < pedestal)
    617751    {
    618752      *fLog << warn << "WARNING: Sigma of Fitted Charge smaller than Pedestal RMS in Pixel "
    … …  
    635769{
    636770
    637   if (TMath::IsNaN(fTime)
    638       || TMath::IsNaN(fErrTime)
    639       || TMath::IsNaN(fSigmaTime)
     771  if (TMath::IsNaN(fMeanTimeOffset)
     772      || TMath::IsNaN(fMeanTimeOffsetError)
     773      || TMath::IsNaN(fTimingPrecision)
    640774      || TMath::IsNaN(fTimeProb))
    641775    {
    … …  
    648782    return kTRUE;
    649783
    650   if (TMath::Abs(fTime) > gkTimeLimit)
    651     {
    652       *fLog << warn << "WARNING: Abs(Fitted Rel. Time) is greater than "
    653             << gkTimeLimit << " in Pixel " << fPixId << endl;
    654       return kFALSE;
    655     }
    656 
    657   if (fErrTime > gkTimeErrLimit)
    658     {
    659       *fLog << warn << "WARNING: Error of Fitted Time is smaller than "
    660             << gkTimeErrLimit << " in Pixel " << fPixId << endl;
     784  if (TMath::Abs(fMeanTimeOffset) > gkTimeLimit)
     785    {
     786      *fLog << warn << "WARNING: Abs(Fitted Rel. Time) " << TMath::Abs(fMeanTimeOffset)
     787            << " is greater than " << gkTimeLimit << " in Pixel " << fPixId << endl;
     788      return kFALSE;
     789    }
     790
     791  if (fMeanTimeOffsetError > gkTimeErrLimit)
     792    {
     793      *fLog << warn << "WARNING: Error of Fitted Time " << fMeanTimeOffsetError
     794            << " is smaller than " << gkTimeErrLimit << " in Pixel " << fPixId << endl;
    661795      return kFALSE;
    662796    }
    … …  
    727861Bool_t MCalibrationPix::CheckOscillations()
    728862{
    729 
    730 
    731863  return kTRUE;
    732864}
    733 
    734 
    735865
    736866void MCalibrationPix::ApplyLoGainConversion()
    … …  
    773903    }
    774904 
    775   fTime          = fHist->GetRelTimeMean();
    776   fErrTime      = fHist->GetRelTimeMeanErr();
    777   fSigmaTime     = fHist->GetRelTimeSigma();
    778   fTimeProb      = fHist->GetRelTimeProb();
     905  fMeanTimeOffset      = fHist->GetRelTimeMean();
     906  fMeanTimeOffsetError = fHist->GetRelTimeMeanErr();
     907  fTimingPrecision     = fHist->GetRelTimeSigma();
     908  fTimeProb            = fHist->GetRelTimeProb();
    779909
    780910  fAbsTimeMean    = fHist->GetAbsTimeMean();
Note: See TracChangeset for help on using the changeset viewer.