Ignore:
Timestamp:
12/19/03 15:41:03 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/manalysis
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/MagicSoft/Mars/manalysis/MCalibrate.cc

    r2720 r2725  
    4444
    4545#include "MCalibrate.h"
     46#include "MCalibrationConfig.h"
    4647
    4748#include "MLog.h"
     
    137138        MCalibrationPix &pix = (*fCalibrations)[pixid];
    138139
     140
    139141        if (pix.IsBlindPixelMethodValid())
    140142        {
    141143            MExtractedSignalPix &sig =  (*fSignals)[pixid];
    142144
    143             Bool_t logain = sig.IsLoGainUsed();
    144        
    145145            Float_t signal;
    146             if (logain)
    147                 signal = sig.GetExtractedSignalLoGain();
     146            Float_t signalErr = 0.;
     147
     148            if (sig.IsLoGainUsed())
     149              {
     150                signal    = sig.GetExtractedSignalLoGain()*pix.GetConversionHiLo();
     151                signalErr = signal*pix.GetConversionHiLoError();
     152              }
    148153            else
    149                 signal = sig.GetExtractedSignalHiGain();
    150            
    151            
     154              {
     155                signal = sig.GetExtractedSignalHiGain();
     156              }
     157           
    152158            //      Float_t calibrationConvertionFactor = pix.GetMeanConversionFFactorMethod();
    153             Float_t calibrationConversionFactor = pix.GetMeanConversionBlindPixelMethod();
     159            Float_t calibrationConversionFactor      = pix.GetMeanConversionBlindPixelMethod();
    154160            Float_t calibrationConversionFactorError = pix.GetErrorConversionBlindPixelMethod();
    155161           
    156162
    157             Float_t nphot = signal*calibrationConversionFactor;
    158             Float_t nphoterr = signal*calibrationConversionFactorError;;
    159            
    160             fCerPhotEvt->AddPixel(pixid, nphot, nphoterr);
     163            Float_t nphot    = signal*calibrationConversionFactor;
     164
     165            Float_t nphotErr = signal*calibrationConversionFactorError*signal*calibrationConversionFactorError;
     166            nphotErr += signalErr*signalErr*calibrationConversionFactor*calibrationConversionFactor;
     167            nphotErr  = TMath::Sqrt(nphotErr);
     168
     169            fCerPhotEvt->AddPixel(pixid, nphot, nphotErr);
    161170        }
    162171        else
  • trunk/MagicSoft/Mars/manalysis/MCalibrate.h

    r2691 r2725  
    3030    MExtractedSignalCam *fSignals;      // Integrated charge in FADCs counts
    3131    MCerPhotEvt         *fCerPhotEvt; // Cerenkov Photon Event used for calculation
    32  
    33   Int_t PreProcess(MParList *pList);
    34   Int_t Process();
     32
     33    Float_t fConversionHiLo;
     34   
     35    Int_t PreProcess(MParList *pList);
     36    Int_t Process();
    3537
    3638public:
     
    3840    MCalibrate(const char *name=NULL, const char *title=NULL);
    3941
     42    void SetConversionHiLo(Float_t conv)         { fConversionHiLo = conv; }
     43   
    4044    ClassDef(MCalibrate, 0)   // Task to calculate cerenkov photons using calibration constants
    4145};
  • trunk/MagicSoft/Mars/manalysis/MCalibrationCalc.cc

    r2699 r2725  
    124124    SETBIT(fFlags, kUseBlindPixelFit);
    125125    SETBIT(fFlags, kUsePinDiodeFit);
     126
    126127}
    127128
     
    271272    // FIXME: In the future need a much more sophisticated one!!!
    272273    //
    273    
     274
    274275    while (pixel.Next())
    275276      {
     
    308309        Float_t sumhi  = sig.GetExtractedSignalHiGain();
    309310        Float_t sumlo  = sig.GetExtractedSignalLoGain();
    310         Bool_t  logain = sig.IsLoGainUsed();
    311 
    312311        Float_t mtime  = sig.GetMeanArrivalTime();
    313312
     
    356355                    << pixid << " signal = " << sumhi  << " event Nr: " << fEvents << endl;
    357356
    358             if (logain)
     357            if (sig.IsLoGainUsed())
    359358              {
    360359               
  • trunk/MagicSoft/Mars/manalysis/MCalibrationCalc.h

    r2699 r2725  
    4646  Byte_t fFlags;                           // Flag for the fits used
    4747   
    48 
     48  Float_t fConversionHiLo;
     49 
    4950  enum  { kUseTimeFits, kUseBlindPixelFit, kUsePinDiodeFit };
    5051
     
    7475
    7576  void SetPulserColor(PulserColor_t color)    { fColor = color; }
     77
     78  void SetConversionHiLo(Float_t conv)         { fConversionHiLo = conv; }
    7679 
    7780  ClassDef(MCalibrationCalc, 1)   // Task to fill the Calibration Containers from raw data
  • trunk/MagicSoft/Mars/manalysis/MCalibrationPix.cc

    r2719 r2725  
    8383  fTitle = title ? title : "Container of the MHCalibrationPixels and the fit results";
    8484
     85  //
     86  // At the moment, we don't have a database, yet,
     87  // so we get it from the configuration file
     88  //
     89  fConversionHiLo      = gkConversionHiLo;
     90  fConversionHiLoError = gkConversionHiLoError; 
     91
    8592  fHist = new MHCalibrationPixel("MHCalibrationPixel","Calibration Histograms Pixel ");
    8693
     
    124131// 8) Calculate the errors of the F-Factor method
    125132//
    126 // The fit is declared as valid, if:
     133// The fit is declared valid (fFitValid = kTRUE), if:
    127134//
    128135// 1) Pixel has a fitted charge greater than 3*PedRMS
     
    131138// 4) Pixel has a charge sigma bigger than its Pedestal RMS
    132139// 5) If FitTimes is used,
    133 //    the mean arrival time is at least 1.5 slices from the edge
     140//    the mean arrival time is at least 1.0 slices from the used edge slices
    134141//
    135 // The F-Factor method is declared as valid, if:
    136 //
    137 // 1) Pixel is FitValid
     142// The conversion factor after the F-Factor method is declared valid, if:
     143//
     144// 1) fFitValid is kTRUE
    138145// 2) Conversion Factor is bigger than 0.
    139146// 3) The error of the conversion factor is smaller than 10%
     
    142149{
    143150
     151  //
     152  // 1) Return if the charge distribution is already succesfully fitted 
     153  //
    144154  if (fHist->IsFitOK())
    145155    return kTRUE;
    146156
     157  //
     158  // 2) Set a lower Fit range according to 1.5 Pedestal RMS in order to avoid
     159  //    possible remaining cosmics to spoil the fit.
     160  //
    147161  if (fPed && fPedRms)
    148162    fHist->SetLowerFitRange(1.5*fPedRms);
     
    150164    *fLog << warn << "Cannot set lower fit range: Pedestals not available" << endl;
    151165
     166  //
     167  // 3) Decide if the LoGain Histogram is fitted or the HiGain Histogram
     168  //
    152169  if (fHist->UseLoGain())
    153170    {
    154171
    155172      SetHiGainSaturation();
    156 
     173     
     174      //
     175      // 4) Fit the Lo Gain histograms with a Gaussian
     176      //
    157177      if(!fHist->FitChargeLoGain())
    158178        {
    159179          *fLog << warn << "Could not fit Lo Gain charges of pixel " << fPixId << endl;
     180          //         
     181          // 5) In case of failure print out the fit results
     182          //
    160183          fHist->PrintChargeFitResult();
    161184        }
     
    163186  else
    164187    {
     188      //
     189      // 4) Fit the Hi Gain histograms with a Gaussian
     190      //
    165191      if(!fHist->FitChargeHiGain())
    166192        {
    167193          *fLog << warn << "Could not fit Hi Gain charges of pixel " << fPixId << endl;
     194          //         
     195          // 5) In case of failure print out the fit results
     196          //
    168197          fHist->PrintChargeFitResult();
    169198        }
     
    171200 
    172201
     202  //
     203  // 6) Retrieve the results and store them in this class
     204  //
    173205  fCharge         = fHist->GetChargeMean();
    174206  fErrCharge      = fHist->GetChargeMeanErr();
     
    187219    fFitted = kTRUE;
    188220
    189   if ( (fCharge > 3.*GetPedRms()) &&
    190        (fErrCharge  > 0.)        &&
    191        (fHist->IsFitOK())        &&
    192        (fSigmaCharge > fPedRms)  &&
    193        (fTime > fHist->GetTimeLowerFitRange()+1.) &&
    194        (fTime < fHist->GetTimeUpperFitRange()-1.) )
    195     fFitValid =  kTRUE;
    196 
    197   //
    198   // Apply the F-Factor Method
     221
     222  if (fHiGainSaturation)
     223    {
     224      if ( (fCharge     > 0.3*GetPedRms()) &&
     225          (fErrCharge  > 0.)              &&
     226          (fHist->IsFitOK())              &&
     227          (fSigmaCharge > fPedRms/fConversionHiLo)   &&
     228          (fTime > fHist->GetTimeLowerFitRange()+1.) &&
     229          (fTime < fHist->GetTimeUpperFitRange()-1.) )
     230        fFitValid =  kTRUE;
     231    }
     232  else
     233    {
     234      if ( (fCharge > 3.*GetPedRms()) &&
     235           (fErrCharge  > 0.)        &&
     236           (fHist->IsFitOK())        &&
     237           (fSigmaCharge > fPedRms)  &&
     238           (fTime > fHist->GetTimeLowerFitRange()+1.) &&
     239           (fTime < fHist->GetTimeUpperFitRange()-1.) )
     240        fFitValid =  kTRUE;
     241    }
     242 
     243  //
     244  // 7) Calculate the number of photo-electrons after the F-Factor method
     245  // 8) Calculate the errors of the F-Factor method
    199246  //
    200247  if ((fPed > 0.)  && (fPedRms > 0.))
     
    204251      // Square all variables in order to avoid applications of square root
    205252      //
    206       const Float_t chargesquare              =       fCharge*fCharge;
    207       const Float_t chargessquarerelerrsquare = 4.*fErrCharge*fErrCharge/chargesquare;
    208 
    209       const Float_t sigmasquare         =       fSigmaCharge*fSigmaCharge;
    210       const Float_t sigmasquareerr      = 2.*fErrSigmaCharge*fSigmaCharge;
    211 
    212       const Float_t pedrmssquare        =       fPedRms*fPedRms;
    213       const Float_t pedrmssquareerr     = 2.*fErrPedRms*fPedRms;
    214 
    215       const Float_t elecrmssquare       =       fElectronicPedRms*fElectronicPedRms;
    216       const Float_t elecrmssquareerr    = 2.*fErrElectronicPedRms*fElectronicPedRms;
    217 
    218       const Float_t conversionsquare    =    gkConversionHiLo     *gkConversionHiLo;
    219       const Float_t conversionsquareerr = 2.*gkConversionHiLoError*gkConversionHiLo;
    220 
    221       const Float_t ffactorrelerrsquare = fFactorError * fFactorError / fFactor / fFactor;
    222 
    223       Float_t rsigmasquarerelerrsquare  = 0.;
    224       Float_t   pheffactorrelerrsquare  = 0.;
     253      // First the relative error squares
     254      //
     255      const Float_t chargeSquare              =       fCharge*   fCharge;
     256      const Float_t chargeSquareRelErrSquare  = 4.*fErrCharge*fErrCharge / chargeSquare;
     257
     258      const Float_t fFactorRelErrSquare       = fFactorError * fFactorError / (fFactor * fFactor);
     259      //
     260      // Now the absolute error squares
     261      //
     262      const Float_t sigmaSquare               =       fSigmaCharge*   fSigmaCharge;
     263      const Float_t sigmaSquareErrSquare      = 4.*fErrSigmaCharge*fErrSigmaCharge * sigmaSquare;
     264
     265      const Float_t elecRmsSquare             =       fElectronicPedRms*   fElectronicPedRms;
     266      const Float_t elecRmsSquareErrSquare    = 4.*fErrElectronicPedRms*fErrElectronicPedRms * elecRmsSquare;
     267
     268      Float_t pedRmsSquare                    =       fPedRms*   fPedRms;
     269      Float_t pedRmsSquareErrSquare           = 4.*fErrPedRms*fErrPedRms * pedRmsSquare;
    225270
    226271      if (fHiGainSaturation)
    227272        {
    228 
     273         
    229274          //
    230275          // We do not know the Lo Gain Pedestal RMS, so we have to retrieve it
     
    233278          // We extract the pure NSB contribution:
    234279          //
    235           Float_t nsbsquare            = pedrmssquare - elecrmssquare;
    236           Float_t nsbsquareerrsquare   = pedrmssquareerr  * pedrmssquareerr +
    237                                          elecrmssquareerr * elecrmssquareerr;
    238 
    239           if (nsbsquare < 0.)
    240             nsbsquare = 0.;
     280          Float_t nsbSquare             =  pedRmsSquare          - elecRmsSquare;
     281          Float_t nsbSquareRelErrSquare = (pedRmsSquareErrSquare + elecRmsSquareErrSquare)
     282                                          / (nsbSquare * nsbSquare) ;
     283
     284          if (nsbSquare < 0.)
     285            nsbSquare = 0.;
    241286         
    242287          //
     
    244289          // add it quadratically to the electronic noise
    245290          //
    246           Float_t logainrmssquare          = nsbsquare/conversionsquare + elecrmssquare;
    247           Float_t logainrmssquareerrsquare = nsbsquareerrsquare/conversionsquare/conversionsquare
    248                                            + elecrmssquareerr * elecrmssquareerr
    249                                            + conversionsquareerr*conversionsquareerr
    250                                              / (conversionsquare*conversionsquare)
    251                                              / (conversionsquare*conversionsquare);
    252           //
    253           // Calculate the reduced sigma with the new "Pedestal RMS"
    254           //
    255           fRSigmaSquare            = sigmasquare - logainrmssquare;
    256           rsigmasquarerelerrsquare = (sigmasquareerr * sigmasquareerr + logainrmssquareerrsquare)
    257                                      / (fRSigmaSquare * fRSigmaSquare);
    258 
    259           if (fRSigmaSquare > 0.)
    260             {
    261               fPheFFactorMethod      = fFactor * chargesquare / fRSigmaSquare;
    262               pheffactorrelerrsquare =        ffactorrelerrsquare
    263                                       + chargessquarerelerrsquare
    264                                       +  rsigmasquarerelerrsquare ;
    265             }
     291          const Float_t conversionSquare             =    fConversionHiLo     *fConversionHiLo;
     292          const Float_t conversionSquareRelErrSquare = 4.*fConversionHiLoError*fConversionHiLoError/conversionSquare;
     293
     294          //
     295          // Calculate the new "Pedestal RMS"
     296          //
     297          const Float_t convertedNsbSquare          =  nsbSquare             / conversionSquare;
     298          const Float_t convertedNsbSquareErrSquare = (nsbSquareRelErrSquare + conversionSquareRelErrSquare)
     299                                                      * convertedNsbSquare * convertedNsbSquare;
     300
     301          pedRmsSquare           = convertedNsbSquare           + elecRmsSquare;
     302          pedRmsSquareErrSquare  = convertedNsbSquareErrSquare  + elecRmsSquareErrSquare;
    266303         
    267304        }    /* if (fHiGainSaturation) */
    268       else   
     305     
     306      //
     307      // Calculate the reduced sigmas
     308      //
     309      fRSigmaSquare = sigmaSquare - pedRmsSquare;
     310      if (fRSigmaSquare <= 0.)
    269311        {
    270           fRSigmaSquare            = sigmasquare - pedrmssquare;
    271           rsigmasquarerelerrsquare = (  sigmasquareerr *  sigmasquareerr
    272                                      + pedrmssquareerr * pedrmssquareerr)
    273                                    / (fRSigmaSquare * fRSigmaSquare);
    274 
    275           fPheFFactorMethod      = fFactor * chargesquare / fRSigmaSquare;
    276           //
    277           // We first calculate the squared relative error in order to save the
    278           // TMath::Sqrt
    279           //
    280           pheffactorrelerrsquare = (       ffactorrelerrsquare
    281                                    + chargessquarerelerrsquare
    282                                    +  rsigmasquarerelerrsquare );
    283          
    284 
    285         }   /* if (fHiGainSaturation) */
    286      
    287 
    288       if (fPheFFactorMethod <= 0.)
    289         {
    290           *fLog << warn << "Cannot apply F-Factor calibration: Number of PhE smaller than 0 in pixel "
     312          *fLog << warn << "Cannot apply F-Factor calibration: Reduced Sigma smaller than 0 in pixel "
    291313                << fPixId << endl;
     314          if (fHiGainSaturation)
     315            ApplyLoGainConversion();
    292316          return kFALSE;
    293317        }
    294      
    295       fConversionFFactorMethod      =  fPheFFactorMethod /  fCharge ;
    296       fConversionErrorFFactorMethod =  fConversionFFactorMethod  *
    297                                        ( pheffactorrelerrsquare +
    298                                        (fErrCharge * fErrCharge / chargesquare ) );
    299 
    300       fPheFFactorMethodError        =  TMath::Sqrt(pheffactorrelerrsquare) * fPheFFactorMethod;
    301 
    302       if ( IsFitValid()                    &&
    303           (fConversionFFactorMethod > 0.) &&
     318
     319      const Float_t rSigmaSquareRelErrSquare = (sigmaSquareErrSquare + pedRmsSquareErrSquare)
     320        / (fRSigmaSquare * fRSigmaSquare) ;
     321 
     322      //
     323      // Calculate the number of phe's from the F-Factor method
     324      // (independent on Hi Gain or Lo Gain)
     325      //
     326      fPheFFactorMethod = fFactor * chargeSquare / fRSigmaSquare;
     327
     328      const Float_t pheFFactorRelErrSquare =  fFactorRelErrSquare
     329                                            + chargeSquareRelErrSquare
     330                                            + rSigmaSquareRelErrSquare ;
     331         
     332      fPheFFactorMethodError        =  TMath::Sqrt(pheFFactorRelErrSquare) * fPheFFactorMethod;
     333
     334      //
     335      // Calculate the conversion factors
     336      //
     337      if (fHiGainSaturation)
     338        ApplyLoGainConversion();
     339     
     340      const Float_t chargeRelErrSquare = fErrCharge*fErrCharge / (fCharge * fCharge);
     341     
     342      fConversionFFactorMethod        =  fPheFFactorMethod / fCharge ;
     343      fConversionErrorFFactorMethod   =  ( pheFFactorRelErrSquare + chargeRelErrSquare )
     344                                         * fConversionFFactorMethod * fConversionFFactorMethod;
     345     
     346      if ( IsFitValid()                     &&
     347           (fConversionFFactorMethod > 0.) &&
    304348           (fConversionErrorFFactorMethod/fConversionFFactorMethod < 0.1) )
    305349        fFFactorMethodValid = kTRUE;
    306350     
    307 
     351     
    308352    } /*   if ((fPed > 0.)  && (fPedRms > 0.)) */
    309353
    310354  return kTRUE;
     355 
     356}
     357
     358
     359void MCalibrationPix::ApplyLoGainConversion()
     360{
     361 
     362  const Float_t chargeRelErrSquare     =   fErrCharge*fErrCharge
     363                                         /(   fCharge *  fCharge);
     364  const Float_t sigmaRelErrSquare      =   fErrSigmaCharge*fErrSigmaCharge
     365                                         /(   fSigmaCharge *  fSigmaCharge);
     366  const Float_t conversionRelErrSquare =   fConversionHiLoError*fConversionHiLoError
     367                                         /(fConversionHiLo    * fConversionHiLo);
     368 
     369  fCharge         *= fConversionHiLo;
     370  fErrCharge       = TMath::Sqrt(chargeRelErrSquare + conversionRelErrSquare) * fCharge;
     371 
     372  fSigmaCharge    *= fConversionHiLo;
     373  fErrSigmaCharge =  TMath::Sqrt(sigmaRelErrSquare + conversionRelErrSquare) * fSigmaCharge;
    311374 
    312375}
  • trunk/MagicSoft/Mars/manalysis/MCalibrationPix.h

    r2719 r2725  
    1212private:
    1313
    14   Int_t   fPixId;           // the pixel Id
     14  Int_t   fPixId;                        // the pixel Id
    1515 
    16   Float_t fCharge;              // The mean reduced charge after the fit
    17   Float_t fErrCharge;           // The error of reduced mean charge after the fit
    18   Float_t fSigmaCharge;         // The sigma of the mean charge after the fit
    19   Float_t fErrSigmaCharge;      // The error of the sigma of the mean charge after the fit
    20   Float_t fRSigmaSquare;        // The reduced squares of sigmas after the fit
    21   Float_t fChargeProb;          // The probability of the fit function
     16  Float_t fCharge;                       // The mean reduced charge after the fit
     17  Float_t fErrCharge;                    // The error of reduced mean charge after the fit
     18  Float_t fSigmaCharge;                  // The sigma of the mean charge after the fit
     19  Float_t fErrSigmaCharge;               // The error of the sigma of the mean charge after the fit
     20  Float_t fRSigmaSquare;                 // The reduced squares of sigmas after the fit
     21  Float_t fChargeProb;                   // The probability of the fit function
    2222
    23   Float_t fPed;                 // The mean pedestal (from MPedestalPix)
    24   Float_t fPedRms;              // The pedestal  RMS (from MPedestalPix)
    25   Float_t fErrPedRms;           // The error of the pedestal  RMS (from MPedestalPix) 
    26   Float_t fElectronicPedRms;    // The pure electronic component of the RMS
    27   Float_t fErrElectronicPedRms; // The error of the pure electronic component of the RMS
     23  Float_t fPed;                          // The mean pedestal (from MPedestalPix)
     24  Float_t fPedRms;                       // The pedestal  RMS (from MPedestalPix)
     25  Float_t fErrPedRms;                    // The error of the pedestal  RMS (from MPedestalPix) 
     26  Float_t fElectronicPedRms;             // The pure electronic component of the RMS
     27  Float_t fErrElectronicPedRms;          // The error of the pure electronic component of the RMS
    2828
    29   Float_t fTime;                // The mean arrival time after the fit 
    30   Float_t fSigmaTime;           // The error of the mean arrival time after the fit
    31   Float_t fTimeChiSquare;       // The probability of the fit function
     29  Float_t fTime;                         // The mean arrival time after the fit 
     30  Float_t fSigmaTime;                    // The error of the mean arrival time after the fit
     31  Float_t fTimeChiSquare;                // The probability of the fit function
    3232 
    33   Float_t fFactor;                  // The laboratory F-factor
    34   Float_t fFactorError;             // The laboratory F-factor Error
    35   Float_t fPheFFactorMethod;        // The number of Phe's calculated after the F-factor method
    36   Float_t fPheFFactorMethodError;   // The error on the number of Phe's calculated after the F-factor method 
     33  Float_t fFactor;                       // The laboratory F-factor
     34  Float_t fFactorError;                  // The laboratory F-factor Error
     35  Float_t fPheFFactorMethod;             // The number of Phe's calculated (F-factor method)
     36  Float_t fPheFFactorMethodError;        // The error on the number of Phe's calculated (F-factor method)
    3737
    38   Float_t fConversionFFactorMethod;    // The conversion factor to Ph's calculated after the F-factor method
    39   Float_t fConversionBlindPixelMethod; // The conversion factor to Ph's calculated after the Blind Pixel method
    40   Float_t fConversionPINDiodeMethod;   // The conversion factor to Ph's calculated after the PIN Diode method
     38  Float_t fConversionFFactorMethod;      // The conversion factor to Phe's (F-factor method)
     39  Float_t fConversionBlindPixelMethod;   // The conversion factor to Ph's (Blind Pixel method)
     40  Float_t fConversionPINDiodeMethod;     // The conversion factor to Ph's (PIN Diode method)
    4141
    42   Float_t fConversionErrorFFactorMethod;    // The conversion factor to Phe's calculated after the F-factor method
    43   Float_t fConversionErrorBlindPixelMethod; // The conversion factor to Phe's calculated after the Blind Pixel method
    44   Float_t fConversionErrorPINDiodeMethod;   // The conversion factor to Phe's calculated after the PIN Diode method
     42  Float_t fConversionErrorFFactorMethod;    // The error of the conversion factor to Phe's (F-factor method)
     43  Float_t fConversionErrorBlindPixelMethod; // The error of the conversion factor to Ph's (Blind Pixel method)
     44  Float_t fConversionErrorPINDiodeMethod;   // The error of the conversion factor to Ph's (PIN Diode method)
    4545
    46   Float_t fConversionSigmaFFactorMethod;    // The conversion factor to Ph's calculated after the F-factor method
    47   Float_t fConversionSigmaBlindPixelMethod; // The conversion factor to Ph's calculated after the Blind Pixel method
    48   Float_t fConversionSigmaPINDiodeMethod;   // The conversion factor to Phd's calculated after the PIN Diode method
     46  Float_t fConversionSigmaFFactorMethod;    // The sigma of conversion factor to Ph's (F-factor method)
     47  Float_t fConversionSigmaBlindPixelMethod; // The conversion factor to Ph's (Blind Pixel method)
     48  Float_t fConversionSigmaPINDiodeMethod;   // The conversion factor to Phd's (PIN Diode method)
    4949
    50   Bool_t  fHiGainSaturation;     // Is Lo-Gain used at all?
     50  Float_t fConversionHiLo;                  // The conversion factor between Hi Gain and Lo Gain 
     51  Float_t fConversionHiLoError;             // The error of the conversion factor between Hi Gain and Lo Gain 
     52 
     53  Bool_t  fHiGainSaturation;                // Is Lo-Gain used at all?
    5154
    5255  Bool_t  fFitValid;       
     
    8184
    8285  void SetPedestal(Float_t ped, Float_t pedrms);
    83   void SetHiGainSaturation()                        { fHiGainSaturation = kTRUE; fHist->SetUseLoGain(); }
     86  void SetHiGainSaturation()                               { fHiGainSaturation = kTRUE; fHist->SetUseLoGain(); }
    8487
     88  void ApplyLoGainConversion();
     89
     90  void SetConversionHiLo(Float_t c)                       { fConversionHiLo      = c;    }
     91  void SetConversionHiLoError(Float_t e)                    { fConversionHiLoError = e;    }
     92
     93  Float_t GetConversionHiLo()                       { return fConversionHiLo;        }
     94  Float_t GetConversionHiLoError()                  { return fConversionHiLoError;   }
     95 
    8596  void SetConversionFFactorMethod(Float_t c, Float_t err, Float_t sig)     
    8697                                                    {
     
    136147  void   SetFitValid()                                     { fFitValid = kTRUE;  }
    137148  void   SetFitted()                                      { fFitted = kTRUE;  }
    138   void   SetBlindPixelMethodValid()                             { fBlindPixelMethodValid = kTRUE;  }
    139   void   SetFFactorMethodValid()                               { fFFactorMethodValid = kTRUE;  }
    140   void   SetPINDiodeMethodValid()                              { fPINDiodeMethodValid = kTRUE;  }
     149  void   SetBlindPixelMethodValid(Bool_t b=kTRUE)               { fBlindPixelMethodValid = b;  }
     150  void   SetFFactorMethodValid(Bool_t b=kTRUE)                 { fFFactorMethodValid = b;  }
     151  void   SetPINDiodeMethodValid(Bool_t b=kTRUE)                { fPINDiodeMethodValid = b;  }
    141152 
    142153  Int_t  GetPixId()                              const  { return fPixId;   }
  • trunk/MagicSoft/Mars/manalysis/MExtractSignal.cc

    r2715 r2725  
    5959                    const char *name, const char *title)
    6060  : fNumHiGainSamples(last-first+1), fNumLoGainSamples(last-first+1),
    61     fSaturationLimit(254), fConversionHiLo(10.)
     61    fSaturationLimit(254)
    6262{
    6363
     
    215215        pix.SetExtractedSignal((Float_t)sumHi - pedes*(Float_t)fNumHiGainSamples,
    216216                               pedrms*fSqrtHiGainSamples,
    217                                ((Float_t)sumLo - pedes*(Float_t)fNumLoGainSamples)*fConversionHiLo,
     217                               ((Float_t)sumLo - pedes*(Float_t)fNumLoGainSamples),
    218218                               pedrms*fSqrtLoGainSamples
    219219                               );
  • trunk/MagicSoft/Mars/manalysis/MExtractSignal.h

    r2715 r2725  
    4141
    4242  Byte_t  fSaturationLimit;
    43   Float_t fConversionHiLo;
    4443
    4544  Bool_t ReInit(MParList *pList);
     
    5049public:
    5150
    52   MExtractSignal(const Byte_t first=4, const Byte_t last=9, const Byte_t logainshift=1, const char *name=NULL, const char *title=NULL);
     51  MExtractSignal(const Byte_t first=4, const Byte_t last=9,
     52                 const Byte_t logainshift=1,
     53                 const char *name=NULL, const char *title=NULL);
    5354 
    5455  void SetSaturationLimit(Byte_t lim)      { fSaturationLimit = lim; }
    55   void SetConversionHiLo(Float_t con)      { fConversionHiLo = con; }
    5656
    5757  ClassDef(MExtractSignal, 0)   // Task to fill the Extracted Signal Containers from raw data
Note: See TracChangeset for help on using the changeset viewer.