Changeset 3655 for trunk/MagicSoft/Mars


Ignore:
Timestamp:
04/05/04 19:13:31 (20 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r3652 r3655  
    1818
    1919                                                 -*-*- END OF LINE -*-*-
     20
     21 2004/04/05: Markus Gaug
     22
     23   * msignal/MExtractedSignalPINDiode.h
     24     - new function GetLastUsedSlice()
     25
     26   * mcalib/MCalibrationChargeCalc.[h,cc]
     27     - holds also pointers to MExtractedSignalPINDiode and
     28       MExtractedSignalBlindPixel and does the checks inside the task
     29       (instead of inside the containers)
     30
    2031
    2132 2004/04/05: Nadia Tonello

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

    r3644 r3655  
    199199#include "MExtractedSignalCam.h"
    200200#include "MExtractedSignalPix.h"
     201#include "MExtractedSignalBlindPixel.h"
     202#include "MExtractedSignalPINDiode.h"
    201203
    202204#include "MBadPixelsCam.h"
    … …  
    224226      fRawEvt(NULL), fRunHeader(NULL), fGeom(NULL),
    225227      fBadPixels(NULL), fEvtTime(NULL),
    226       fSignals(NULL), fPINDiode(NULL), fBlindPixel(NULL)
     228      fSignals(NULL), fSigBlind(NULL), fSigPIN(NULL),
     229      fPINDiode(NULL), fBlindPixel(NULL)
    227230{
    228231
    … …  
    267270//  - MRawEvtData
    268271//  - MPedestalCam
     272//  - MExtractedSignalCam
     273//  - MExtractedSignalBlindPixel
     274//  - MExtractedSignalPINDiode
    269275//
    270276// The following output containers are also searched and created if
    … …  
    288294    }
    289295 
     296  fPedestals = (MPedestalCam*)pList->FindObject("MPedestalCam");
     297  if (!fPedestals)
     298    {
     299      *fLog << err << "MPedestalCam not found... aborting" << endl;
     300      return kFALSE;
     301    }
     302 
     303  fSignals = (MExtractedSignalCam*)pList->FindObject("MExtractedSignalCam");
     304  if (!fSignals)
     305    {
     306      *fLog << err << "MExtractedSignalCam not found... aborting" << endl;
     307      return kFALSE;
     308    }
     309 
     310  fSigBlind = (MExtractedSignalBlindPixel*)pList->FindObject("MExtractedSignalBlindPixel");
     311  if (!fSigBlind)
     312    *fLog << warn << "MExtractedSignalBlindPixel not found... no blind pixel method! " << endl;
     313  else
     314    {
     315      fBlindPixel = (MCalibrationChargeBlindPix*)pList->FindCreateObj("MCalibrationChargeBlindPix");
     316      if (!fBlindPixel)
     317        {
     318          *fLog << err << "Cannot find nor create MCalibrationChargeBlindPix... aborting" << endl;
     319          return kFALSE;
     320        }
     321    }
     322 
     323  fSigPIN  = (MExtractedSignalPINDiode*)pList->FindObject("MExtractedSignalPINDiode");
     324  if (!fSigPIN)
     325    *fLog << warn << "MExtractedSignalPINDiode not found... no PIN Diode method! " << endl;
     326  else
     327    {
     328      fPINDiode = (MCalibrationChargePINDiode*)pList->FindCreateObj("MCalibrationChargePINDiode");
     329      if (!fPINDiode)
     330        {
     331          *fLog << err << "Cannot find nor create MCalibrationChargePINDiode... aborting" << endl;
     332          return kFALSE;
     333        }
     334    }
     335 
    290336  fCam = (MCalibrationChargeCam*)pList->FindCreateObj("MCalibrationChargeCam");
    291337  if (!fCam)
    292     return kFALSE;
     338    {
     339      *fLog << err << "Cannot find nor create MCalibrationChargeCam... aborting" << endl;
     340      return kFALSE;
     341    }
    293342 
    294343  fQECam = (MCalibrationQECam*)pList->FindCreateObj("MCalibrationQECam");
    295344  if (!fQECam)
    296     return kFALSE;
    297  
    298   fPINDiode = (MCalibrationChargePINDiode*)pList->FindCreateObj("MCalibrationChargePINDiode");
    299   if (!fPINDiode)
    300     return kFALSE;
    301  
    302   fBlindPixel = (MCalibrationChargeBlindPix*)pList->FindCreateObj("MCalibrationChargeBlindPix");
    303   if (!fBlindPixel)
    304     return kFALSE;
     345    {
     346      *fLog << err << "Cannot find nor create MCalibrationQECam... aborting" << endl;
     347      return kFALSE;
     348    }
    305349 
    306350  fEvtTime = (MTime*)pList->FindObject("MTime");
    307  
    308   fPedestals = (MPedestalCam*)pList->FindObject("MPedestalCam");
    309   if (!fPedestals)
    310     {
    311       *fLog << err << "MPedestalCam not found... aborting" << endl;
    312       return kFALSE;
    313     }
    314  
    315   fSignals = (MExtractedSignalCam*)pList->FindObject("MExtractedSignalCam");
    316   if (!fSignals)
    317     {
    318       *fLog << err << "MExtractedSignalCam not found... aborting" << endl;
    319       return kFALSE;
    320     }
    321351 
    322352  return kTRUE;
    … …  
    407437// Finalize pedestals:
    408438//
    409 // * Retrieve pedestal and pedestal RMS from MPedestalPix
    410 // * Retrieve total entries from MPedestalCam
    411 // * sum up pedestal and pedestalRMS for the average pixel
    412 // * set pedestal*number of used samples in MCalibrationChargePix
    413 // * set pedestal RMS * sqrt of number of used samples in MCalibrationChargePix
     439// - Retrieve pedestal and pedestal RMS from MPedestalPix
     440// - Retrieve total entries from MPedestalCam
     441// - Sum up pedestal and pedestalRMS for the average pixel
     442// - Set pedestal*number of used samples in MCalibrationChargePix
     443// - Set pedestal RMS * sqrt of number of used samples in MCalibrationChargePix
    414444//
    415445//
    … …  
    472502}
    473503
     504// ---------------------------------------------------------------------
    474505//
    475506// Finalize charges per pixel:
    476 // * Check chage validity
    477 // * check absolute time validity
    478 // * calculate the reduced sigma
    479 // * caluclate the number of photo-electrons
    480 //
     507// - Check chage validity
     508// - Check absolute time validity
     509// - Calculate the reduced sigma
     510// - Calculate the number of photo-electrons
    481511//
    482512Bool_t MCalibrationChargeCalc::FinalizeCharges(MCalibrationChargePix &cal, MBadPixelsPix &bad)
    … …  
    526556  // The check returns kTRUE if:
    527557  //
    528   // The mean arrival time is at least 1.0 slices from the lower edge slices and 2 slices from the upper edge
     558  // The mean arrival time is at least fTimeLowerLimit slices from the lower edge
     559  // and fUpperLimit slices from the upper edge
    529560  //
    530561  const Byte_t loweredge  = cal.IsHiGainSaturation() ? fSignals->GetFirstUsedSliceLoGain()
    … …  
    575606}
    576607
    577 //
    578 // * Finalize the pedestals
    579 // * Do the quality checks
    580 // * Calculate the reduced sigma
    581 // * Calculate the F-Factor Method
     608// ------------------------------------------------------------------------
     609//
     610// Returns kFALSE if pointer to MExtractedSignalPINDiode is NULL
     611// Returns kFALSE if pointer to MCalibrationChargePINDiode is NULL
     612//
     613// The check return kTRUE if:
     614//
     615// 1) PINDiode has a fitted charge greater than fChargeLimit*PedRMS
     616// 2) PINDiode has a fit error greater than fChargeErrLimit
     617// 3) PINDiode has a fitted charge greater its fChargeRelErrLimit times its charge error
     618// 4) PINDiode has a charge sigma bigger than its Pedestal RMS
     619// 5) The mean arrival time is at least fTimeLowerLimit slices from the lower edge
     620//    and fUpperLimit slices from the upper edge
     621//
     622Bool_t MCalibrationChargeCalc::FinalizePINDiode()
     623{
     624
     625  if (!fSigPIN)
     626    return kFALSE;
     627 
     628  if (!fPINDiode)
     629    return kFALSE; 
     630
     631  if (fPINDiode->GetMean() < fChargeLimit*fPINDiode->GetPedRms())
     632    {
     633      *fLog << warn << "WARNING: Fitted Charge is smaller than "
     634            << fChargeLimit << " Pedestal RMS in PINDiode " << endl;
     635      return kFALSE;
     636    }
     637 
     638  if (fPINDiode->GetMeanErr() < fChargeErrLimit)
     639    {
     640      *fLog << warn << "WARNING: Error of Fitted Charge is smaller than "
     641            << fChargeErrLimit << " in PINDiode " << endl;
     642      return kFALSE;
     643    }
     644     
     645  if (fPINDiode->GetMean() < fChargeRelErrLimit*fPINDiode->GetMeanErr())
     646    {
     647      *fLog << warn << "WARNING: Fitted Charge is smaller than "
     648            << fChargeRelErrLimit << "* its error in PINDiode " << endl;
     649      return kFALSE;
     650    }
     651     
     652  if (fPINDiode->GetSigma() < fPINDiode->GetPedRms())
     653    {
     654      *fLog << warn << "WARNING: Sigma of Fitted Charge smaller than Pedestal RMS in PINDiode " << endl;
     655      return kFALSE;
     656    }
     657
     658  const Byte_t  loweredge  = fSigPIN->GetFirstUsedSlice();
     659  const Byte_t  upperedge  = fSigPIN->GetLastUsedSlice();
     660  const Float_t lowerlimit = (Float_t)loweredge + fTimeLowerLimit;
     661  const Float_t upperlimit = (Float_t)upperedge + fTimeUpperLimit; 
     662
     663  if (fPINDiode->GetAbsTimeMean() < lowerlimit)
     664    {
     665      *fLog << warn << "WARNING: Mean ArrivalTime in first " << fTimeLowerLimit
     666            << " extraction bin in PIN Diode " << endl;
     667      *fLog << fPINDiode->GetAbsTimeMean() << "   " << lowerlimit << endl;
     668      return kFALSE;
     669    }
     670 
     671  if ( fPINDiode->GetAbsTimeMean() > upperlimit )
     672    {
     673      *fLog << warn << "WARNING: Mean ArrivalTime in last " << fTimeUpperLimit
     674            << " two extraction bins in PIN Diode " << endl;
     675      *fLog << fPINDiode->GetAbsTimeMean() << "   " << upperlimit << endl;
     676      return kFALSE;
     677    }
     678
     679  if (!fPINDiode->CalcFluxOutsidePlexiglass())
     680    {
     681      *fLog << warn << "Could not calculate the flux of photons from the PIN Diode, "
     682            << "will skip PIN Diode Calibration " << endl;
     683      return kFALSE;
     684    }
     685 
     686  return kTRUE;
     687}
     688
     689
     690// -----------------------------------------------------------------------
     691//
     692// - Finalize the pedestals
     693// - Do the quality checks
     694// - Calculate the reduced sigma
     695// - Calculate the F-Factor Method
    582696//
    583697Int_t MCalibrationChargeCalc::PostProcess()
    … …  
    698812  // PIN Diode calibration
    699813  //
    700   if (!fPINDiode->CheckChargeFitValidity() || !fPINDiode->CheckTimeFitValidity())
    701   {
    702       *fLog << warn << "Could not calculate the flux of photons from the PIN Diode, "
    703             << "charge fit not valid " << endl;
    704       fCam->SetPINDiodeMethodValid(kFALSE);
    705   }
     814  if (!FinalizePINDiode())
     815    fCam->SetPINDiodeMethodValid(kFALSE);
    706816  else
    707   {
    708       if (!fPINDiode->CalcFluxOutsidePlexiglass())
    709       {
    710           *fLog << warn << "Could not calculate the flux of photons from the PIN Diode, "
    711                 << "will skip PIN Diode Calibration " << endl;
    712           fCam->SetPINDiodeMethodValid(kFALSE);
    713       }
    714       else
    715       {
    716           fCam->SetPINDiodeMethodValid(kTRUE);
    717           fCam->ApplyPINDiodeCalibration(*fGeom,*fBadPixels, *fPINDiode);
    718       }
    719   }
     817    {
     818      fCam->SetPINDiodeMethodValid(kTRUE);
     819      fCam->ApplyPINDiodeCalibration(*fGeom,*fBadPixels, *fPINDiode);
     820    }
    720821
    721822  fCam->SetReadyToSave();

  • trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.h

    r3602 r3655  
    3030class MGeomCam;
    3131class MExtractedSignalCam;
     32class MExtractedSignalBlindPixel;
     33class MExtractedSignalPINDiode;
    3234class MBadPixelsCam;
    3335class MBadPixelsPix;
    … …  
    3739private:
    3840
    39   static const Float_t fgChargeLimit;       // The default for fChargeLimit
    40   static const Float_t fgChargeErrLimit;    // The default for fChargeErrLimit
    41   static const Float_t fgChargeRelErrLimit; // The default for fChargeRelErrLimit
    42   static const Float_t fgTimeLowerLimit;    // The default for fTimeLowerLimit
    43   static const Float_t fgTimeUpperLimit;    // The default for fTimeUpperLimit
     41  static const Float_t fgChargeLimit;       // Default for fChargeLimit        (now set to: 3.)
     42  static const Float_t fgChargeErrLimit;    // Default for fChargeErrLimit     (now set to: 0.)
     43  static const Float_t fgChargeRelErrLimit; // Default for fChargeRelErrLimit  (now set to: 1.)
     44  static const Float_t fgTimeLowerLimit;    // Default for fTimeLowerLimit     (now set to: 1.)
     45  static const Float_t fgTimeUpperLimit;    // Default for fTimeUpperLimit     (now set to: 2.)
    4446 
    45   Float_t fChargeLimit;          // The limit (in units of PedRMS) for acceptance of the fitted mean charge
    46   Float_t fChargeErrLimit;       // The limit (in units of PedRMS) for acceptance of the fitted charge sigma square
    47   Float_t fChargeRelErrLimit;    // The limit (in units of Sigma of fitted charge) for acceptance of the fitted mean 
    48   Float_t fTimeLowerLimit;       // The limit (in units of FADC slices) for distance to first signal extraction slice
    49   Float_t fTimeUpperLimit;       // The limit (in units of FADC slices) for distance to last signal extraction slice
     47  Float_t fChargeLimit;          // Limit (in units of PedRMS) for acceptance of mean charge
     48  Float_t fChargeErrLimit;       // Limit (in units of PedRMS) for acceptance of charge sigma square
     49  Float_t fChargeRelErrLimit;    // Limit (in units of Sigma of fitted charge) for acceptance of mean 
     50  Float_t fTimeLowerLimit;       // Limit (in units of FADC slices) for dist. to first signal slice
     51  Float_t fTimeUpperLimit;       // Limit (in units of FADC slices) for dist. to last signal slice
    5052
    5153  MPedestalCam               *fPedestals;     //! Pedestals of all pixels in the camera
    … …  
    5961  MTime                      *fEvtTime;       //! Time of the event
    6062
    61   MExtractedSignalCam        *fSignals;       // Extracted signal of all pixels in the camera
     63  MExtractedSignalCam        *fSignals;       //! Extracted signal of pixels in the camera
     64  MExtractedSignalBlindPixel *fSigBlind;      //! Extracted signal of Blind Pixel
     65  MExtractedSignalPINDiode   *fSigPIN;        //! Extracted signal of PIN Diode
     66
    6267  MCalibrationChargePINDiode *fPINDiode;      // Calibration results of the PIN Diode
    6368  MCalibrationChargeBlindPix *fBlindPixel;    // Calibration results of the Blind Pixel
    … …  
    8388  void FinalizeAvPedestals(MCalibrationChargePix &cal, Float_t avped, Float_t avrms, Int_t avnum);
    8489  Bool_t FinalizeCharges(MCalibrationChargePix &cal, MBadPixelsPix &bad);
    85 
     90  Bool_t FinalizePINDiode();
     91 
    8692  void PrintUnsuitable(MBadPixelsPix::UnsuitableType_t typ, const char *text) const;   
    8793  void PrintUncalibrated(MBadPixelsPix::UncalibratedType_t typ, const char *text) const;

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

    r3642 r3655  
    102102  SetOscillating          ( kFALSE );
    103103  SetExcluded             ( kFALSE );
    104   SetExcludeQualityCheck  ( kFALSE );
    105104}
    106105
    … …  
    114113  SetChargeFitValid     ( kFALSE );
    115114  SetTimeFitValid       ( kFALSE );
    116   SetMeanTimeInFirstBin ( kFALSE );
    117   SetMeanTimeInLastBin  ( kFALSE );
    118115   
    119116  fPed                              =  -1.;
    … …  
    128125  fAbsTimeRms                       =  -1.;
    129126
    130   fTimeLowerEdge                    =  -1.;
    131   fTimeUpperEdge                    =  -1.;
    132 
    133127  fConvertedPhotons                 =  -1.;
    134128  fConvertedPhotonsErr              =  -1.;
    … …  
    166160// Set the Excluded Bit from outside
    167161//
    168 void MCalibrationChargePINDiode::SetExcludeQualityCheck(Bool_t b )
    169 {
    170   b ?  SETBIT(fCalibFlags, kExcludeQualityCheck) : CLRBIT(fCalibFlags, kExcludeQualityCheck);
    171 }
    172 
    173 // --------------------------------------------------------------------------
    174 //
    175 // Set the Excluded Bit from outside
    176 //
    177162void MCalibrationChargePINDiode::SetChargeFitValid(Bool_t b )   
    178163{
    … …  
    194179}
    195180
    196 void MCalibrationChargePINDiode::SetMeanTimeInFirstBin(const Bool_t b)
    197 {
    198   b ? SETBIT(fCalibFlags,kMeanTimeInFirstBin) : CLRBIT(fCalibFlags,kMeanTimeInFirstBin);
    199 }
    200 
    201 void MCalibrationChargePINDiode::SetMeanTimeInLastBin(const Bool_t b)
    202 {
    203   b ? SETBIT(fCalibFlags,kMeanTimeInLastBin) : CLRBIT(fCalibFlags,kMeanTimeInLastBin);
    204 }
    205 
    206 Bool_t MCalibrationChargePINDiode::IsMeanTimeInFirstBin() const
    207 {
    208   return TESTBIT(fCalibFlags,kMeanTimeInFirstBin);
    209 }
    210 
    211 Bool_t MCalibrationChargePINDiode::IsMeanTimeInLastBin() const
    212 {
    213   return TESTBIT(fCalibFlags,kMeanTimeInLastBin);
    214 }
    215 
    216181Bool_t MCalibrationChargePINDiode::IsChargeFitValid() const
    217182{
    … …  
    222187{
    223188  return TESTBIT(fCalibFlags, kTimeFitValid); 
    224 }
    225 
    226 //
    227 // The check return kTRUE if:
    228 //
    229 // 1) PINDiode has a fitted charge greater than fChargeLimit*PedRMS
    230 // 2) PINDiode has a fit error greater than fChargeErrLimit
    231 // 3) PINDiode has a fitted charge greater its fChargeRelErrLimit times its charge error
    232 // 4) PINDiode has a charge sigma bigger than its Pedestal RMS
    233 //
    234 Bool_t MCalibrationChargePINDiode::CheckChargeFitValidity()
    235 {
    236 
    237 
    238   if (GetMean() < fChargeLimit*GetPedRms())
    239     {
    240       *fLog << warn << "WARNING: Fitted Charge is smaller than "
    241             << fChargeLimit << " Pedestal RMS in PINDiode " << endl;
    242       return kFALSE;
    243     }
    244  
    245   if (GetMeanErr() < fChargeErrLimit)
    246     {
    247       *fLog << warn << "WARNING: Error of Fitted Charge is smaller than "
    248             << fChargeErrLimit << " in PINDiode " << endl;
    249       return kFALSE;
    250     }
    251      
    252   if (GetMean() < fChargeRelErrLimit*GetMeanErr())
    253     {
    254       *fLog << warn << "WARNING: Fitted Charge is smaller than "
    255             << fChargeRelErrLimit << "* its error in PINDiode " << endl;
    256       return kFALSE;
    257     }
    258      
    259   if (GetSigma() < GetPedRms())
    260     {
    261       *fLog << warn << "WARNING: Sigma of Fitted Charge smaller than Pedestal RMS in PINDiode " << endl;
    262       return kFALSE;
    263     }
    264   return kTRUE;
    265 }
    266 
    267 //
    268 // The check returns kTRUE if:
    269 //
    270 // The mean arrival time is at least 1.0 slices from the used edge slices
    271 //
    272 Bool_t MCalibrationChargePINDiode::CheckTimeFitValidity()
    273 {
    274 
    275   if ( fAbsTimeMean < fTimeLowerEdge+1.)
    276     {
    277       *fLog << warn << "WARNING: Mean ArrivalTime in first extraction bin of the PINDiode " << endl;
    278       SetMeanTimeInFirstBin();
    279       return kFALSE;
    280     }
    281 
    282   if ( fAbsTimeMean > fTimeUpperEdge-1.)
    283     {
    284       *fLog << warn << "WARNING: Mean ArrivalTime in last extraction bin of the PINDiode " << endl;
    285       SetMeanTimeInLastBin();
    286       return kFALSE;
    287     }
    288 
    289   return kTRUE;
    290189}
    291190

  • trunk/MagicSoft/Mars/mcalib/MCalibrationChargePINDiode.h

    r3642 r3655  
    1010private:
    1111
    12   static const Float_t fgChargeLimit;       // The default limit (in units of PedRMS) for acceptance of the fitted mean charge
    13   static const Float_t fgChargeErrLimit;    // The default limit (in units of PedRMS) for acceptance of the fitted charge sigma
    14   static const Float_t fgChargeRelErrLimit; // The default limit (in units of Error of fitted charge) for acceptance of the fitted mean 
     12  static const Float_t fgChargeLimit;                //! Default for fChargeLimit
     13  static const Float_t fgChargeErrLimit;             //! Default for fChargeErrLimit
     14  static const Float_t fgChargeRelErrLimit;          //! Default for fChargeRelErrLimit
     15  static const Float_t fgConversionChargePhotons;    //! Default for fConversionChargePhotons
     16  static const Float_t fgConversionChargePhotonsErr; //! Default for fConversionChargePhotonsErr
     17  static const Float_t gkPINDiodeArea;               //! PIN Diode Effective Area in mm^2 
     18  static const Float_t gkFluxCameravsPINDiode;       //! Flux Conversion PIN Diode - inner pixel
     19  static const Float_t gkFluxCameravsPINDiodeErr;    //! Error of flux conv. PIN Diode - inner pixel
     20  static const Float_t gkPINDiodeQEGreen;            //! Quantum Efficiency at 520 nm
     21  static const Float_t gkPINDiodeQEBlue;             //! Quantum Efficiency at 460 nm
     22  static const Float_t gkPINDiodeQEUV;               //! Quantum Efficiency at 370 nm
     23  static const Float_t gkPINDiodeQECT1;              //! Quantum Efficiency at 370 nm
     24  static const Float_t gkPINDiodeQEGreenErr;         //! Uncertainty QE at 520 nm
     25  static const Float_t gkPINDiodeQEBlueErr ;         //! Uncertainty QE at 460 nm
     26  static const Float_t gkPINDiodeQEUVErr   ;         //! Uncertainty QE at 370 nm
     27  static const Float_t gkPINDiodeQECT1Err  ;         //! Uncertainty QE at 370 nmu
     28 
    1529
    16   static const Float_t fgConversionChargePhotons;    // The default mean conversion from PIN Diode charge to the number of incident photons
    17   static const Float_t fgConversionChargePhotonsErr; // The default error of the mean conversion from PIN Diode charge to the number of incident photons
    18 
    19   static const Float_t gkPINDiodeArea;         // The Blind Pixel area in mm^2 
    20 
    21   static const Float_t gkFluxCameravsPINDiode     ;
    22   static const Float_t gkFluxCameravsPINDiodeErr  ;
    23  
    24   static const Float_t gkPINDiodeQEGreen;
    25   static const Float_t gkPINDiodeQEBlue ;
    26   static const Float_t gkPINDiodeQEUV   ;
    27   static const Float_t gkPINDiodeQECT1  ;
    28  
    29   static const Float_t gkPINDiodeQEGreenErr;
    30   static const Float_t gkPINDiodeQEBlueErr ;
    31   static const Float_t gkPINDiodeQEUVErr   ;
    32   static const Float_t gkPINDiodeQECT1Err  ;
    33  
    34   Float_t fChargeLimit;                     // The limit (in units of PedRMS) for acceptance of the fitted mean charge
    35   Float_t fChargeErrLimit;                  // The limit (in units of PedRMS) for acceptance of the fitted charge sigma
    36   Float_t fChargeRelErrLimit;               // The limit (in units of Error of fitted charge) for acceptance of the fitted mean 
    37  
    38   Float_t fConversionChargePhotons;         // The mean conversion from PIN Diode charge to the number of incident photons
    39   Float_t fConversionChargePhotonsErr;      // The error of the mean conversion from PIN Diode charge to the number of incident photons
    40 
    41   Float_t fPed;                   // The mean pedestal (from MPedestalPix)
    42   Float_t fPedRms;                // The pedestal  RMS (from MPedestalPix)
    43 
    44   Float_t fRmsChargeMean;
    45   Float_t fRmsChargeMeanErr;
    46   Float_t fRmsChargeSigma; 
    47   Float_t fRmsChargeSigmaErr;
    48 
    49   Byte_t  fCalibFlags;                            // Flag for the set Bits
    50 
    51   Float_t fAbsTimeMean;
    52   Float_t fAbsTimeRms;
    53 
    54   Float_t fTimeLowerEdge;
    55   Float_t fTimeUpperEdge;
    56 
    57   Float_t fConvertedPhotons;
    58   Float_t fConvertedPhotonsErr;
    59 
    60   Float_t fMeanFluxOutsidePlexiglass;         //  The mean number of photons in an INNER PIXEL outside the plexiglass
    61   Float_t fMeanFluxErrOutsidePlexiglass;      //  The uncertainty about the number of photons in an INNER PIXEL 
     30  Float_t fAbsTimeMean;                     // Mean Absolute Arrival Time
     31  Float_t fAbsTimeRms;                      // RMS Mean Absolute Arrival Time
     32  Byte_t  fCalibFlags;                      // Bit-field for the class-own bits
     33  Float_t fChargeLimit;                     // Limit (in units of PedRMS) for acceptance fitted mean charge
     34  Float_t fChargeErrLimit;                  // Limit (in units of PedRMS) for acceptance fitted charge sigma
     35  Float_t fChargeRelErrLimit;               // Limit (in units of Error of fitted charge) for acceptance fitted mean 
     36  Float_t fConversionChargePhotons;         // Mean conv. PIN Diode charge to number of incident photons
     37  Float_t fConversionChargePhotonsErr;      // Error mean conv. PIN Diode charge to nr. incident photons
     38  Float_t fConvertedPhotons;                // Number photons incidident on PIN Diode
     39  Float_t fConvertedPhotonsErr;             // Error on nr. photons incid. on PIN Diode
     40  Float_t fMeanFluxOutsidePlexiglass;       // Mean number photons in INNER PIXEL outside plexiglass
     41  Float_t fMeanFluxErrOutsidePlexiglass;    // Error on nr. photons in INNER PIXEL outside plexiglass
     42  Float_t fPed;                             // Mean pedestal (from MPedestalPix)
     43  Float_t fPedRms;                          // Pedestal  RMS (from MPedestalPix)
     44  Float_t fRmsChargeMean;                   // Mean of RMS of summed FADC slices distribution
     45  Float_t fRmsChargeMeanErr;                // Error on Mean RMS summed FADC slices distribution
     46  Float_t fRmsChargeSigma;                  // Sigma of RMS of summed FADC slices distribution   
     47  Float_t fRmsChargeSigmaErr;               // Error on Sigma RMS summed FADC slices distribution
    6248
    6349  PulserColor_t fColor; 
    6450
    65   enum  { kExcludeQualityCheck, kOscillating,
     51  enum  { kOscillating,
    6652          kChargeFitValid, kTimeFitValid,
    67           kMeanTimeInFirstBin, kMeanTimeInLastBin,
    6853          kFluxOutsidePlexiglassAvailable  };   
    6954
    … …  
    9681
    9782  void SetOscillating     ( const Bool_t b=kTRUE);
    98   void SetExcludeQualityCheck( const Bool_t b = kTRUE );
    9983  void SetChargeFitValid     ( const Bool_t b = kTRUE );
    10084  void SetTimeFitValid       ( const Bool_t b = kTRUE );
    10185  void SetFluxOutsidePlexiglassAvailable ( const Bool_t b = kTRUE );
    102 
    103   // Setters ONLY for MC:
    104   void  SetMeanTimeInFirstBin( const Bool_t b = kTRUE );
    105   void  SetMeanTimeInLastBin ( const Bool_t b = kTRUE );
    10686
    10787  // Getters
    … …  
    11090
    11191  // Pedestals
    112   Float_t GetPed()             const { return fPed;    }
    113   Float_t GetPedRms()          const { return fPedRms; }
    114 
     92  Float_t GetAbsTimeMean()     const { return fAbsTimeMean; }
     93  Float_t GetAbsTimeRms ()     const { return fAbsTimeRms;  }
     94  Float_t GetPed()             const { return fPed;         }
     95  Float_t GetPedRms()          const { return fPedRms;      }
    11596
    11697  Bool_t  IsChargeFitValid()    const;
    11798  Bool_t  IsTimeFitValid()      const;
    11899
    119   Bool_t  IsMeanTimeInFirstBin() const;
    120   Bool_t  IsMeanTimeInLastBin()  const;
    121 
    122   Bool_t  CheckChargeFitValidity();
    123   Bool_t  CheckTimeFitValidity();
    124100  Bool_t  CalcFluxOutsidePlexiglass();
    125101
    126   ClassDef(MCalibrationChargePINDiode, 1)       // Container for Calibration PIN Diode
     102  ClassDef(MCalibrationChargePINDiode, 1)       // Container Charge Calibration Results PIN Diode
    127103};
    128104

  • trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.h

    r3647 r3655  
    1010private:
    1111
    12   Float_t fQEGreen;          // The calibrated quantum efficiency at 520 nm
    13   Float_t fQEBlue;           // The calibrated quantum efficiency at 460 nm
    14   Float_t fQEUV;             // The calibrated quantum efficiency at 370 nm
    15   Float_t fQECT1;            // The calibrated quantum efficiency at 370 nm
    16  
    17   Float_t fQEGreenErr;       // The uncertainty about the calibrated QE at 520 nm
    18   Float_t fQEBlueErr;        // The uncertainty about the calibrated QE at 460 nm
    19   Float_t fQEUVErr;          // The uncertainty about the calibrated QE at 370 nm
    20   Float_t fQECT1Err;         // The uncertainty about the calibrated QE at 370 nm
     12  Float_t fQEGreen;          // Calibrated quantum efficiency at 520 nm
     13  Float_t fQEBlue;           // Calibrated quantum efficiency at 460 nm
     14  Float_t fQEUV;             // Calibrated quantum efficiency at 370 nm
     15  Float_t fQECT1;            // Calibrated quantum efficiency at 370 nm
     16  Float_t fQEGreenErr;       // Uncertainty calibrated QE at 520 nm
     17  Float_t fQEBlueErr;        // Uncertainty calibrated QE at 460 nm
     18  Float_t fQEUVErr;          // Uncertainty calibrated QE at 370 nm
     19  Float_t fQECT1Err;         // Uncertainty calibrated QE at 370 nm
    2120 
    2221public:

  • trunk/MagicSoft/Mars/msignal/MExtractedSignalPINDiode.h

    r3322 r3655  
    3535   
    3636    // Getter
    37     Float_t GetExtractedSignal()    const { return fExtractedSignal; }
    38     Float_t GetExtractedSignalErr() const { return fExtractedSignalErr; }
    39     Float_t GetExtractedTime()      const { return fExtractedTime; }
    40     Float_t GetExtractedTimeErr()   const { return fExtractedTimeErr; }
    41     Float_t GetExtractedRms()       const { return fExtractedRms; }
    42     Float_t GetExtractedRmsErr()    const { return fExtractedRmsErr; }
    43 
    44     Byte_t  GetNumFADCSamples()     const { return fNumFADCSamples;  }
    45    
    46 
     37    Float_t GetExtractedSignal()    const { return fExtractedSignal;       }
     38    Float_t GetExtractedSignalErr() const { return fExtractedSignalErr;    }
     39    Float_t GetExtractedTime()      const { return fExtractedTime;         }
     40    Float_t GetExtractedTimeErr()   const { return fExtractedTimeErr;      }
     41    Float_t GetExtractedRms()       const { return fExtractedRms;          }
     42    Float_t GetExtractedRmsErr()    const { return fExtractedRmsErr;       }
     43    Byte_t  GetNumFADCSamples()     const { return fNumFADCSamples;        }
     44    Byte_t  GetFirstUsedSlice()     const { return fFirst;                 }
     45    Byte_t  GetLastUsedSlice()      const { return fFirst+fNumFADCSamples; }   
    4746   
    4847    Bool_t IsValid() const;   
Note: See TracChangeset for help on using the changeset viewer.