Ignore:
Timestamp:
08/10/04 10:35:48 (20 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/mpedestal
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/mpedestal/MPedCalcFromLoGain.cc

    r4404 r4556  
    2727!
    2828\* ======================================================================== */
     29
    2930/////////////////////////////////////////////////////////////////////////////
    3031//
    … …  
    142143#include "MGeomCam.h"
    143144
    144 #include "MBadPixelsPix.h"
    145 #include "MBadPixelsCam.h"
    146 
    147 #include "MGeomCamMagic.h"
    148 
    149145ClassImp(MPedCalcFromLoGain);
    150146
    … …  
    177173    : fWindowSizeHiGain(fgHiGainWindowSize),
    178174      fWindowSizeLoGain(fgLoGainWindowSize),
    179       fGeom(NULL),fBad(NULL)
     175      fGeom(NULL)
    180176{
    181177  fName  = name  ? name  : "MPedCalcFromLoGain";
    … …  
    202198void MPedCalcFromLoGain::Clear(const Option_t *o)
    203199{
    204 
    205200  fRawEvt    = NULL;
    206201  fRunHeader = NULL;
    … …  
    218213void MPedCalcFromLoGain::SetRange(Byte_t hifirst, Byte_t hilast, Byte_t lofirst, Byte_t lolast)
    219214{
    220 
    221215  MExtractor::SetRange(hifirst,hilast,lofirst,lolast);
    222216
    … …  
    225219  //
    226220  SetWindowSize(fWindowSizeHiGain,fWindowSizeLoGain);
    227  
    228 }
    229 
    230 
    231 // --------------------------------------------------------------------------
    232 //
    233 void MPedCalcFromLoGain::SetMaxHiGainVar(Byte_t maxvar) {
     221}
     222
     223// --------------------------------------------------------------------------
     224//
     225void MPedCalcFromLoGain::SetMaxHiGainVar(Byte_t maxvar)
     226{
    234227  fMaxHiGainVar = maxvar;
    235228}
    236 
    237229
    238230// --------------------------------------------------------------------------
    … …  
    251243void MPedCalcFromLoGain::SetWindowSize(Byte_t windowh, Byte_t windowl)
    252244{
    253  
    254245  fWindowSizeHiGain = windowh & ~1;
    255246  fWindowSizeLoGain = windowl & ~1;
    … …  
    286277    }
    287278 
    288  
    289279  fNumHiGainSamples = (Float_t)fWindowSizeHiGain;
    290280  fNumLoGainSamples = (Float_t)fWindowSizeLoGain;
    … …  
    292282  fSqrtHiGainSamples = TMath::Sqrt(fNumHiGainSamples);
    293283  fSqrtLoGainSamples = TMath::Sqrt(fNumLoGainSamples);
    294 
    295 }
    296 
    297  
    298    
     284}
     285
    299286// --------------------------------------------------------------------------
    300287//
    … …  
    304291//  - MRawRunHeader
    305292//  - MGeomCam
    306 //  - MBadPixelsCam
    307293//
    308294// The following output containers are also searched and created if
    … …  
    313299Int_t MPedCalcFromLoGain::PreProcess( MParList *pList )
    314300{
    315 
    316301  Clear();
    317302 
    … …  
    340325  if (!fPedestals)
    341326    return kFALSE;
    342 
    343   fBad       =  (MBadPixelsCam*)pList->FindObject("MBadPixelsCam");
    344327
    345328  return kTRUE;
    … …  
    361344// the functions SetRange() are mostly overloaded and perform more checks,
    362345// modifying the ranges again, if necessary.
    363 //
    364 // A loop over the MBadPixelsCam is performed and bad pixels are set
    365 // to MPedestalPix::SetValid(kFALSE);
    366346//
    367347Bool_t MPedCalcFromLoGain::ReInit(MParList *pList)
    … …  
    463443        << " LoGain FADC samples starting with slice: " << (int)fLoGainFirst << endl;
    464444 
    465  
    466   if (fBad)
    467     {
    468       const Int_t nbads = fBad->GetSize();
    469       for (Int_t i=0; i<(nbads>npixels?npixels:nbads);i++)
    470         if ((*fBad)[i].IsBad())
    471           (*fPedestals)[i].SetValid(kFALSE);
    472     }
    473  
    474445  return kTRUE;
    475      
    476 }
     446}
     447
    477448// --------------------------------------------------------------------------
    478449//
    … …  
    483454Int_t MPedCalcFromLoGain::Process()
    484455{
    485 
    486456  MRawEvtPixelIter pixel(fRawEvt);
    487457 
    488   //   cout << "fHiGainFirst: " << (Int_t)fHiGainFirst << " fWindowSizeHiGain: " << (Int_t)fWindowSizeHiGain << " fLoGainFirst: " << (Int_t)fLoGainFirst << " fWindowSizeLoGain: " << (Int_t)fWindowSizeLoGain << endl;
    489 
    490 
    491458  while (pixel.Next()) {
    492459   

  • trunk/MagicSoft/Mars/mpedestal/MPedCalcFromLoGain.h

    r4404 r4556  
    1616class MGeomCam;
    1717class MBadPixelsCam;
     18
    1819class MPedCalcFromLoGain : public MExtractor
    1920{
    20 
    2121  static const Byte_t fgHiGainFirst;      // First FADC slice Hi-Gain (currently set to: 3)
    2222  static const Byte_t fgHiGainLast;       // Last FADC slice Hi-Gain (currently set to: 14)
    … …  
    2727  static const Byte_t fgMaxHiGainVar;     // The maximum difference between the highest and lowest slice
    2828                                          // in the high gain window allowed in order to use low gain
    29                                           // for pedestal calculation
    30   Int_t   fNumEventsDump; // Number of event after which MPedestalCam gets updated
     29
     30  Int_t   fNumEventsDump;    // Number of event after which MPedestalCam gets updated
    3131
    3232  Byte_t  fMaxHiGainVar;
    33   Byte_t  fWindowSizeHiGain;             // Number of Hi Gain slices in window
    34   Byte_t  fWindowSizeLoGain;             // Number of Lo Gain slices in window 
     33  Byte_t  fWindowSizeHiGain; // Number of Hi Gain slices in window
     34  Byte_t  fWindowSizeLoGain; // Number of Lo Gain slices in window
    3535
    3636  Bool_t  fPedestalUpdate;
    3737 
    38   MGeomCam     *fGeom;       // Camera geometry
    39   MBadPixelsCam *fBad;       // Bad Pixels
     38  MGeomCam*fGeom;            // Camera geometry
    4039 
    41   TArrayI fNumEventsUsed;   // Number of events used for pedestal calc for each pixel
    42   TArrayI fTotalCounter;    // Counter for dumping values to Pedestal Container
    43   TArrayD fSumx;            // sum of values
    44   TArrayD fSumx2;           // sum of squared values
    45   TArrayD fSumAB0;          // sum of ABFlag=0 slices
    46   TArrayD fSumAB1;          // sum of ABFlag=1 slices
     40  TArrayI fNumEventsUsed;    // Number of events used for pedestal calc for each pixel
     41  TArrayI fTotalCounter;     // Counter for dumping values to Pedestal Container
     42  TArrayD fSumx;             // sum of values
     43  TArrayD fSumx2;            // sum of squared values
     44  TArrayD fSumAB0;           // sum of ABFlag=0 slices
     45  TArrayD fSumAB1;           // sum of ABFlag=1 slices
    4746 
    48   Int_t  PreProcess ( MParList *pList );
    49   Bool_t ReInit     ( MParList *pList );
     47  Int_t  PreProcess (MParList *pList);
     48  Bool_t ReInit     (MParList *pList);
    5049  Int_t  Process    ();
    5150  Int_t  PostProcess();
    5251 
    5352public:
    54 
    5553  MPedCalcFromLoGain(const char *name=NULL, const char *title=NULL);
    5654 

  • trunk/MagicSoft/Mars/mpedestal/MPedCalcPedRun.cc

    r4368 r4556  
    135135#include "MGeomCam.h"
    136136
    137 #include "MBadPixelsPix.h"
    138 #include "MBadPixelsCam.h"
    139 
    140 #include "MGeomCamMagic.h"
    141 
    142137ClassImp(MPedCalcPedRun);
    143138
    … …  
    168163    : fWindowSizeHiGain(fgHiGainWindowSize),
    169164      fWindowSizeLoGain(fgLoGainWindowSize),
    170       fGeom(NULL),fBad(NULL)
    171 {
    172   fName  = name  ? name  : "MPedCalcPedRun";
    173   fTitle = title ? title : "Task to calculate pedestals from pedestal runs raw data";
    174  
    175   AddToBranchList("fHiGainPixId");
    176   AddToBranchList("fHiGainFadcSamples");
    177  
    178   SetRange(fgHiGainFirst, fgHiGainLast, fgLoGainFirst, fgLoGainLast);
    179   Clear();
     165      fGeom(NULL)
     166{
     167    fName  = name  ? name  : "MPedCalcPedRun";
     168    fTitle = title ? title : "Task to calculate pedestals from pedestal runs raw data";
     169
     170    AddToBranchList("fHiGainPixId");
     171    AddToBranchList("fHiGainFadcSamples");
     172
     173    SetRange(fgHiGainFirst, fgHiGainLast, fgLoGainFirst, fgLoGainLast);
     174    Clear();
    180175}
    181176
    … …  
    190185void MPedCalcPedRun::Clear(const Option_t *o)
    191186{
    192 
    193   fNumSamplesTot    = 0;
    194 
    195   fRawEvt    = NULL;
    196   fRunHeader = NULL;
    197   fPedestals = NULL;
     187    fNumSamplesTot = 0;
     188
     189    fRawEvt    = NULL;
     190    fRunHeader = NULL;
     191    fPedestals = NULL;
    198192}
    199193
    … …  
    208202void MPedCalcPedRun::SetRange(Byte_t hifirst, Byte_t hilast, Byte_t lofirst, Byte_t lolast)
    209203{
    210 
    211   MExtractor::SetRange(hifirst,hilast,lofirst,lolast);
    212 
    213   //
    214   // Redo the checks if the window is still inside the ranges
    215   //
    216   SetWindowSize(fWindowSizeHiGain,fWindowSizeLoGain);
    217  
    218 }
    219 
     204    MExtractor::SetRange(hifirst,hilast,lofirst,lolast);
     205
     206    //
     207    // Redo the checks if the window is still inside the ranges
     208    //
     209    SetWindowSize(fWindowSizeHiGain,fWindowSizeLoGain);
     210}
    220211
    221212// --------------------------------------------------------------------------
    … …  
    275266  fSqrtHiGainSamples = TMath::Sqrt(fNumHiGainSamples);
    276267  fSqrtLoGainSamples = TMath::Sqrt(fNumLoGainSamples);
    277 
    278 }
    279 
    280  
    281    
     268}
     269
    282270// --------------------------------------------------------------------------
    283271//
    … …  
    287275//  - MRawRunHeader
    288276//  - MGeomCam
    289 //  - MBadPixelsCam
    290277//
    291278// The following output containers are also searched and created if
    … …  
    296283Int_t MPedCalcPedRun::PreProcess( MParList *pList )
    297284{
    298 
    299285  Clear();
    300286 
    … …  
    313299    }
    314300
    315   fGeom   = (MGeomCam*)pList->FindObject("MGeomCam");
     301  fGeom = (MGeomCam*)pList->FindObject("MGeomCam");
    316302  if (!fGeom)
    317303    {
    … …  
    323309  if (!fPedestals)
    324310    return kFALSE;
    325 
    326   fBad       =  (MBadPixelsCam*)pList->FindObject("MBadPixelsCam");
    327311
    328312  return kTRUE;
    … …  
    345329// modifying the ranges again, if necessary.
    346330//
    347 // A loop over the MBadPixelsCam is performed and bad pixels are set
    348 // to MPedestalPix::SetValid(kFALSE);
    349 //
    350331Bool_t MPedCalcPedRun::ReInit(MParList *pList)
    351332{
    352  
    353    
    354333  Int_t lastdesired   = (Int_t)fLoGainLast;
    355334  Int_t lastavailable = (Int_t)fRunHeader->GetNumSamplesLoGain()-1;
    … …  
    414393
    415394
    416   Int_t npixels  = fPedestals->GetSize();
    417   Int_t areas    = fPedestals->GetAverageAreas();
    418   Int_t sectors  = fPedestals->GetAverageSectors();
     395  const Int_t npixels  = fPedestals->GetSize();
     396  const Int_t areas    = fPedestals->GetAverageAreas();
     397  const Int_t sectors  = fPedestals->GetAverageSectors();
    419398 
    420399  if (fSumx.GetSize()==0)
    … …  
    449428        << " LoGain FADC samples starting with slice: " << (int)fLoGainFirst << endl;
    450429
    451 
    452   if (fBad)
    453     {
    454       const Int_t nbads = fBad->GetSize();
    455       for (Int_t i=0; i<(nbads>npixels?npixels:nbads);i++)
    456         if ((*fBad)[i].IsBad())
    457           (*fPedestals)[i].SetValid(kFALSE);
    458     }
    459  
    460430  return kTRUE;
    461      
    462 }
     431}
     432
    463433// --------------------------------------------------------------------------
    464434//
    … …  
    469439Int_t MPedCalcPedRun::Process()
    470440{
    471 
    472441  MRawEvtPixelIter pixel(fRawEvt);
    473442 
    … …  
    549518Int_t MPedCalcPedRun::PostProcess()
    550519{
    551 
    552520  // Compute pedestals and rms from the whole run
    553521  const ULong_t n     = fNumSamplesTot;

  • trunk/MagicSoft/Mars/mpedestal/MPedCalcPedRun.h

    r4001 r4556  
    1515
    1616class MGeomCam;
    17 class MBadPixelsCam;
     17
    1818class MPedCalcPedRun : public MExtractor
    1919{
     20    static const Byte_t fgHiGainFirst;      // First FADC slice Hi-Gain (currently set to: 3)
     21    static const Byte_t fgHiGainLast;       // Last FADC slice Hi-Gain (currently set to: 14)
     22    static const Byte_t fgLoGainFirst;      // First FADC slice Lo-Gain (currently set to: 3)
     23    static const Byte_t fgLoGainLast;       // Last FADC slice Lo-Gain (currently set to: 14)
     24    static const Byte_t fgHiGainWindowSize; // The extraction window Hi-Gain
     25    static const Byte_t fgLoGainWindowSize; // The extraction window Lo-Gain
    2026
    21   static const Byte_t fgHiGainFirst;      // First FADC slice Hi-Gain (currently set to: 3)
    22   static const Byte_t fgHiGainLast;       // Last FADC slice Hi-Gain (currently set to: 14)
    23   static const Byte_t fgLoGainFirst;      // First FADC slice Lo-Gain (currently set to: 3)
    24   static const Byte_t fgLoGainLast;       // Last FADC slice Lo-Gain (currently set to: 14)
    25   static const Byte_t fgHiGainWindowSize; // The extraction window Hi-Gain
    26   static const Byte_t fgLoGainWindowSize; // The extraction window Lo-Gain
     27    UInt_t  fNumSamplesTot;
     28    Byte_t  fWindowSizeHiGain; // Number of Hi Gain slices in window
     29    Byte_t  fWindowSizeLoGain; // Number of Lo Gain slices in window
    2730
    28   UInt_t  fNumSamplesTot;
    29   Byte_t  fWindowSizeHiGain;             // Number of Hi Gain slices in window
    30   Byte_t  fWindowSizeLoGain;             // Number of Lo Gain slices in window 
    31  
    32   MGeomCam     *fGeom;       // Camera geometry
    33   MBadPixelsCam *fBad;       // Bad Pixels
    34  
    35   TArrayD fSumx;         // sum of values
    36   TArrayD fSumx2;        // sum of squared values
    37   TArrayD fAreaSumx;     // averaged sum of values per area idx
    38   TArrayD fAreaSumx2;    // averaged sum of squared values per area idx
    39   TArrayI fAreaValid;    // number of valid pixel with area idx 
    40   TArrayD fSectorSumx;   // averaged sum of values per sector
    41   TArrayD fSectorSumx2;  // averaged sum of squared values per sector
    42   TArrayI fSectorValid;  // number of valid pixel with sector idx 
    43  
    44   Int_t  PreProcess ( MParList *pList );
    45   Bool_t ReInit     ( MParList *pList );
    46   Int_t  Process    ();
    47   Int_t  PostProcess();
    48  
     31    MGeomCam *fGeom;           // Camera geometry
     32
     33    TArrayD fSumx;             // sum of values
     34    TArrayD fSumx2;            // sum of squared values
     35    TArrayD fAreaSumx;         // averaged sum of values per area idx
     36    TArrayD fAreaSumx2;        // averaged sum of squared values per area idx
     37    TArrayI fAreaValid;        // number of valid pixel with area idx
     38    TArrayD fSectorSumx;       // averaged sum of values per sector
     39    TArrayD fSectorSumx2;      // averaged sum of squared values per sector
     40    TArrayI fSectorValid;      // number of valid pixel with sector idx
     41
     42    Int_t  PreProcess (MParList *pList);
     43    Bool_t ReInit     (MParList *pList);
     44    Int_t  Process    ();
     45    Int_t  PostProcess();
     46
    4947public:
     48    MPedCalcPedRun(const char *name=NULL, const char *title=NULL);
    5049
    51   MPedCalcPedRun(const char *name=NULL, const char *title=NULL);
    52  
    53   void Clear(const Option_t *o="");
    54   void SetRange(Byte_t hifirst=0, Byte_t hilast=0, Byte_t lofirst=0, Byte_t lolast=0);
    55   void SetWindowSize(Byte_t windowh=0, Byte_t windowl=0);
    56  
    57   ClassDef(MPedCalcPedRun, 0)   // Task to calculate pedestals from pedestal runs raw data
     50    void Clear(const Option_t *o="");
     51    void SetRange(Byte_t hifirst=0, Byte_t hilast=0, Byte_t lofirst=0, Byte_t lolast=0);
     52    void SetWindowSize(Byte_t windowh=0, Byte_t windowl=0);
     53
     54    ClassDef(MPedCalcPedRun, 0)   // Task to calculate pedestals from pedestal runs raw data
    5855};
    5956

  • trunk/MagicSoft/Mars/mpedestal/MPedestalPix.cc

    r4404 r4556  
    1717!
    1818!   Author(s): Thomas Bretz   12/2000 <mailto:tbretz@uni-sw.gwdg.de>
    19 !              Markus Gaug    04/2004 <mailto:markus@ifae.es>               
    20 !             Florian Goebel 06/2004 <mailto:fgoebel@mppmu.mpg.de>
     19!   Author(s): Markus Gaug    04/2004 <mailto:markus@ifae.es>
     20!   Author(s): Florian Goebel 06/2004 <mailto:fgoebel@mppmu.mpg.de>
    2121!
    2222!   Copyright: MAGIC Software Development, 2000-2004
    … …  
    2626
    2727/////////////////////////////////////////////////////////////////////////////
    28 //                                                                         //
    29 // MPedestalPix                                                            //
    30 //                                                                         //
    31 // This is the storage container to hold informations about the pedestal   //
    32 // (offset) value of one Pixel (PMT).                                      //
    33 //                                                                         //
    34 // version 2:                                                              //
    35 // ----------                                                              //
    36 // added:                                                                  //
    37 //  fPedestalABoffset   difference between pedestal mean of odd slices and //
    38 //                      the total pedestal mean (fPedestal)                //
    39 //  fNumEvents          number of times, the Process was executed          //
    40 //                      (to estimate the error of pedestal)                //
    41 //                                                                         //
     28//
     29// MPedestalPix
     30//
     31// This is the storage container to hold informations about the pedestal
     32// (offset) value of one Pixel (PMT).
     33//
     34//  Float_t fPedestal:
     35//   - mean value of pedestal (PMT offset)
     36//  Float_t fPedestalRms:
     37//   - root mean square / sigma  / standard deviation of pedestal
     38//  Float_t fPedestalABoffset:
     39//   - the difference between odd slice pedestal mean and the
     40//     total pedestal mean (fPedestal). For even slices pedestal
     41//     use -fPedestalABoffset.
     42//  UInt_t  fNumEvents:
     43//   - number of times, the Process was executed (to estimate the error
     44//     of pedestal)
     45//
     46// version 2:
     47// ----------
     48// added:
     49//  fPedestalABoffset   difference between pedestal mean of odd slices and
     50//                      the total pedestal mean (fPedestal)
     51//  fNumEvents          number of times, the Process was executed
     52//                      (to estimate the error of pedestal)
     53//
     54// version 3:
     55// ----------
     56// - fValid removed
     57//
    4258/////////////////////////////////////////////////////////////////////////////
    4359#include "MPedestalPix.h"
    … …  
    5066using namespace std;
    5167
     68// ------------------------------------------------------------------------
     69//
     70// Default constructor. Calls Clear()
     71//
    5272MPedestalPix::MPedestalPix()
    53   : fValid(kTRUE)
    5473{
    55   Clear();
     74    Clear();
    5675}
    57 
    5876
    5977// ------------------------------------------------------------------------
    … …  
    6381void MPedestalPix::Clear(Option_t *o)
    6482{
    65   fPedestal         = -1.;
    66   fPedestalRms      = -1.;
    67   fPedestalABoffset = -1.;
    68   fNumEvents        = 0;
     83    fPedestal         = -1;
     84    fPedestalRms      = -1;
     85    fPedestalABoffset = -1;
     86    fNumEvents        = 0;
    6987}
    7088
     89// ------------------------------------------------------------------------
     90//
     91// Set all values to 0
     92//
    7193void MPedestalPix::InitUseHists()
    7294{
    73 
    74   fPedestal         = 0.;
    75   fPedestalRms      = 0.;
    76   fPedestalABoffset = 0.;
    77   fNumEvents        = 0;
     95    fPedestal         = 0;
     96    fPedestalRms      = 0;
     97    fPedestalABoffset = 0;
     98    fNumEvents        = 0;
    7899}
    79100
    80 
     101// ------------------------------------------------------------------------
     102//
     103// Set fPedestal=m, fPedestalRms=r, fPedestalABoffset=offs, fNumEvents=n
     104//
    81105void MPedestalPix::Set(Float_t m, Float_t r, Float_t offs, UInt_t n)
    82106{
    83   fPedestal         = m;
    84   fPedestalRms      = r;
    85   fPedestalABoffset = offs;
    86   fNumEvents        = n;
     107    fPedestal         = m;
     108    fPedestalRms      = r;
     109    fPedestalABoffset = offs;
     110    fNumEvents        = n;
    87111}
    88112
    89 
     113// ------------------------------------------------------------------------
     114//
     115// Return kTRUE if pedestal AND pedestal rms is valid (>=0)
     116//
    90117Bool_t MPedestalPix::IsValid() const
    91118{
    92  
    93   if (!fValid)
    94     return kFALSE;
    95  
    96  return fPedestal>=0||fPedestalRms>=0;
     119    return fPedestal>=0 && fPedestalRms>=0;
    97120}

  • trunk/MagicSoft/Mars/mpedestal/MPedestalPix.h

    r4404 r4556  
    99{
    1010private:
     11    Float_t fPedestal;         // mean value of pedestal (PMT offset)
     12    Float_t fPedestalRms;      // root mean square / sigma  / standard deviation of pedestal
     13    Float_t fPedestalABoffset; // the difference between odd slice pedestal mean and total mean
     14    UInt_t  fNumEvents;        // number of times, the Process was executed (to estimate the error of pedestal)
    1115
    12   Float_t fPedestal;     // mean value of pedestal (PMT offset)
    13   Float_t fPedestalRms;  // root mean square / sigma  / standard deviation of pedestal
    14   Float_t fPedestalABoffset; // the difference between odd slice pedestal mean and the
    15                              // total pedestal mean (fPedestal). For even slices pedestal
    16                              // use -fPedestalABoffset.
    17   UInt_t fNumEvents; // number of times, the Process was executed (to estimate the error of pedestal)
    18   Bool_t fValid;   // flag to set pixel valid
    19  
    2016public:
    21   MPedestalPix();
    22  
    23   void Clear(Option_t *o="");
    24  
    25   // Using histograms
    26   void InitUseHists();
    27  
     17    MPedestalPix();
     18
     19    void Clear(Option_t *o="");
     20
     21    // Using histograms
     22    void InitUseHists();
     23
    2824    // Setters
    29   void SetPedestal(const Float_t f)         { fPedestal = f; }
    30   void SetPedestalRms(const Float_t f)      { fPedestalRms = f; }
    31   void SetPedestalABoffset(const Float_t f) { fPedestalABoffset = f; }
    32   void SetNumEvents(const UInt_t n)         { fNumEvents = n; }
     25    void SetPedestal(const Float_t f)         { fPedestal = f; }
     26    void SetPedestalRms(const Float_t f)      { fPedestalRms = f; }
     27    void SetPedestalABoffset(const Float_t f) { fPedestalABoffset = f; }
     28    void SetNumEvents(const UInt_t n)         { fNumEvents = n; }
    3329
    34   void Set(const Float_t m, const Float_t r, const Float_t offs=0, const UInt_t n=0);
    35   void SetValid(const Bool_t b=kTRUE)    { fValid = b;  }
    36  
    37   // Getters
    38   Float_t GetPedestal()    const { return fPedestal; }
    39   Float_t GetPedestalRms() const { return fPedestalRms; }
    40   Float_t GetPedestalABoffset() const { return fPedestalABoffset; }
    41   Float_t GetPedestalError()    const { return fNumEvents>0 ? fPedestalRms/TMath::Sqrt((Float_t)fNumEvents)   : 0; }
    42   Float_t GetPedestalRmsError() const { return fNumEvents>0 ? fPedestalRms/TMath::Sqrt((Float_t)fNumEvents/2) : 0; }
    43  
    44   Bool_t IsValid()         const;
     30    void Set(const Float_t m, const Float_t r, const Float_t offs=0, const UInt_t n=0);
    4531
    46   ClassDef(MPedestalPix, 2)     // Storage Container for Pedestal information of one pixel
     32    // Getters
     33    Float_t GetPedestal()    const { return fPedestal; }
     34    Float_t GetPedestalRms() const { return fPedestalRms; }
     35    Float_t GetPedestalABoffset() const { return fPedestalABoffset; }
     36    Float_t GetPedestalError()    const { return fNumEvents>0 ? fPedestalRms/TMath::Sqrt((Float_t)fNumEvents)   : 0; }
     37    Float_t GetPedestalRmsError() const { return fNumEvents>0 ? fPedestalRms/TMath::Sqrt((Float_t)fNumEvents/2) : 0; }
     38
     39    Bool_t IsValid() const;
     40
     41    ClassDef(MPedestalPix, 3) // Storage Container for Pedestal information of one pixel
    4742};
    4843
    4944#endif
    50 
Note: See TracChangeset for help on using the changeset viewer.