Ignore:
Timestamp:
12/20/03 13:46:17 (21 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/manalysis
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/manalysis/MCalibrate.cc

    r2726 r2728  
    2424
    2525//////////////////////////////////////////////////////////////////////////////
    26 //                                                                          //
    27 //   MCalibrate                                                             //
    28 //                                                                          //
    29 //   This task takes the integrated charge from MExtractedSignal and apply  //
    30 //   the calibration constants from MCalibraitionCam to the charge. Then    //
    31 //   stores number of photons obtained in MCerPhotEvt.                      //
    32 //                                                                          //
    33 //   Input Containers:                                                      //
    34 //                                                                          //     
    35 //   MGeomCam                                                               //
    36 //   MExtractedSingal                                                       //
    37 //   MCalibrationCam                                                        //
    38 //                                                                          //
    39 //   Output Containers:                                                     //
    40 //                                                                          //
    41 //   MCerPhotEvt                                                            //
    42 //                                                                          //
     26//
     27//   MCalibrate
     28//
     29//   This task takes the integrated charge from MExtractedSignal and apply
     30//   the calibration constants from MCalibraitionCam to the charge. Then
     31//   stores number of photons obtained in MCerPhotEvt.
     32//
     33//   Input Containers:
     34//    MExtractedSingal
     35//    MCalibrationCam
     36//
     37//   Output Containers:
     38//    MCerPhotEvt
     39//
    4340//////////////////////////////////////////////////////////////////////////////
    44 
    4541#include "MCalibrate.h"
    4642#include "MCalibrationConfig.h"
    … …  
    7470MCalibrate::MCalibrate(const char *name, const char *title)
    7571{
    76 
    7772    fName  = name  ? name  : "MCalibrate";
    7873    fTitle = title ? title : "Task to calculate the number of photons in one event";
    79 
    8074}
    8175
    … …  
    9488Int_t MCalibrate::PreProcess(MParList *pList)
    9589{
    96 
    97     fGeomCam = (MGeomCam*)pList->FindObject("MGeomCam");
    98     if (!fGeomCam)
    99       {
    100         *fLog << err << dbginf << "MGeomCam not found ... aborting." << endl;       
    101         return kFALSE;
    102       }
    103 
    10490    fSignals = (MExtractedSignalCam*)pList->FindObject("MExtractedSignalCam");
    10591    if (!fSignals)
    106       {
    107         *fLog << err << dbginf << "MExtractedSignalCam not found ... aborting" << endl;
     92    {
     93        *fLog << err << "MExtractedSignalCam not found ... aborting" << endl;
    10894        return kFALSE;
    109       }
     95    }
    11096
    11197    fCalibrations = (MCalibrationCam*)pList->FindObject("MCalibrationCam");
    11298    if (!fCalibrations)
    113       {
    114         *fLog << err << dbginf << "MCalibrationCam not found ... aborting." << endl;       
     99    {
     100        *fLog << err << "MCalibrationCam not found ... aborting." << endl;
    115101        return kFALSE;
    116       }
     102    }
    117103
    118104    fCerPhotEvt = (MCerPhotEvt*)pList->FindCreateObj("MCerPhotEvt");
    119105    if (!fCerPhotEvt)
    120       {
    121         *fLog << err << dbginf << "Cannot create MCerPhotEvt ... aborting" << endl;
    122106        return kFALSE;
    123       }
    124107   
    125108    return kTRUE;
    126109}
    127 
    128110
    129111// --------------------------------------------------------------------------
    … …  
    132114Int_t MCalibrate::Process()
    133115{
    134     UInt_t imaxnumpix = fGeomCam->GetNumPixels();
     116    if (fCalibrations->GetNumPixels() != (UInt_t)fSignals->GetSize())
     117    {
     118        // FIXME: MExtractedSignal must be of variable size -
     119        //        like MCerPhotEvt - because we must be able
     120        //        to reduce size by zero supression
     121        //        For the moment this check could be done in ReInit...
     122        *fLog << err << "MExtractedSignal and MCalibrationCam have different sizes... abort." << endl;
     123        return kFALSE;
     124    }
     125
     126    const UInt_t imaxnumpix = fSignals->GetSize();
    135127   
    136     for (UInt_t pixid = 0; pixid < imaxnumpix; pixid++)
     128    for (UInt_t pixidx=0; pixidx<imaxnumpix; pixidx++)
    137129    {
    138         MCalibrationPix &pix = (*fCalibrations)[pixid];
     130        const MCalibrationPix &pix = (*fCalibrations)[pixidx];
    139131
     132        if (!pix.IsBlindPixelMethodValid())
     133            continue;
    140134
    141         if (pix.IsBlindPixelMethodValid())
    142         {
    143             MExtractedSignalPix &sig =  (*fSignals)[pixid];
     135        MExtractedSignalPix &sig =  (*fSignals)[pixidx];
    144136
    145             Float_t signal;
    146             Float_t signalErr = 0.;
     137        Float_t signal;
     138        Float_t signalErr = 0.;
    147139
    148             if (sig.IsLoGainUsed())
    149               {
    150                 signal    = sig.GetExtractedSignalLoGain()*pix.GetConversionHiLo();
    151                 signalErr = signal*pix.GetConversionHiLoError();
    152               }
    153             else
    154               {
    155                 signal = sig.GetExtractedSignalHiGain();
    156               }
    157            
    158             //      Float_t calibrationConvertionFactor = pix.GetMeanConversionFFactorMethod();
    159             Float_t calibrationConversionFactor      = pix.GetMeanConversionBlindPixelMethod();
    160             Float_t calibrationConversionFactorError = pix.GetErrorConversionBlindPixelMethod();
     140        if (sig.IsLoGainUsed())
     141        {
     142            signal    = sig.GetExtractedSignalLoGain()*pix.GetConversionHiLo();
     143            signalErr = signal*pix.GetConversionHiLoError();
     144        }
     145        else
     146        {
     147            signal = sig.GetExtractedSignalHiGain();
     148        }
    161149
    162             Float_t nphot    = signal*calibrationConversionFactor;
    163             Float_t nphotErr = signal*calibrationConversionFactorError
    164                               *signal*calibrationConversionFactorError;
    165             nphotErr        += signalErr*calibrationConversionFactor
    166                               *signalErr*calibrationConversionFactor;
     150        //      Float_t calibrationConvertionFactor = pix.GetMeanConversionFFactorMethod();
     151        const Float_t calibrationConversionFactor      = pix.GetMeanConversionBlindPixelMethod();
     152        const Float_t calibrationConversionFactorError = pix.GetErrorConversionBlindPixelMethod();
    167153
    168             nphotErr  = TMath::Sqrt(nphotErr);
     154        const Float_t nphot = signal*calibrationConversionFactor;
     155        Float_t nphotErr    = signal*calibrationConversionFactorError
     156                             *signal*calibrationConversionFactorError;
     157        nphotErr += signalErr*calibrationConversionFactor
     158                   *signalErr*calibrationConversionFactor;
    169159
    170             fCerPhotEvt->AddPixel(pixid, nphot, nphotErr);
    171         }
    172         else
    173           {
    174             fCerPhotEvt->AddPixel(pixid, 0., 0.);
    175             (*fCerPhotEvt)[pixid].SetPixelUnused();
    176           }
     160        nphotErr  = TMath::Sqrt(nphotErr);
     161
     162        fCerPhotEvt->AddPixel(pixidx, nphot, nphotErr);
    177163    }
    178164
    … …  
    182168    return kTRUE;
    183169}
    184 

  • trunk/MagicSoft/Mars/manalysis/MCalibrate.h

    r2725 r2728  
    2525class MCalibrate : public MTask
    2626{
    27 
    28     MGeomCam            *fGeomCam;      // Geometry of the camera
     27private:
    2928    MCalibrationCam     *fCalibrations; // Calibration constants
    3029    MExtractedSignalCam *fSignals;      // Integrated charge in FADCs counts
    … …  
    4039    MCalibrate(const char *name=NULL, const char *title=NULL);
    4140
    42     void SetConversionHiLo(Float_t conv)         { fConversionHiLo = conv; }
     41    void SetConversionHiLo(Float_t conv) { fConversionHiLo = conv; }
    4342   
    4443    ClassDef(MCalibrate, 0)   // Task to calculate cerenkov photons using calibration constants

  • trunk/MagicSoft/Mars/manalysis/MCalibrationPix.h

    r2725 r2728  
    6868  void Clear(Option_t *o="");
    6969
    70   Float_t GetCharge()         const    { return fCharge;         }
    71   Float_t GetRSigmaSquare()   const    { return fRSigmaSquare;   }
     70  // Getter
     71  Bool_t IsFitValid()              const { return fFitValid;  }
     72  Bool_t IsFitted()                const { return fFitted;  }
     73  Bool_t IsBlindPixelMethodValid() const { return fBlindPixelMethodValid;  }
     74  Bool_t IsFFactorMethodValid()    const { return fFFactorMethodValid;  }
     75  Bool_t IsPINDiodeMethodValid()   const { return fPINDiodeMethodValid;  }
     76
     77  Float_t GetCharge()              const { return fCharge;         }
     78  Float_t GetRSigmaSquare()        const { return fRSigmaSquare;   }
    7279   
    73   Float_t GetErrCharge()      const    { return fErrCharge;      }
    74   Float_t GetChargeProb()     const    { return fChargeProb;     }   
     80  Float_t GetErrCharge()           const { return fErrCharge;      }
     81  Float_t GetChargeProb()          const { return fChargeProb;     }   
    7582 
    76   Float_t GetSigmaCharge()    const    { return fSigmaCharge;    }
    77   Float_t GetErrSigmaCharge() const    { return fErrSigmaCharge; }
    78   Float_t GetTime()           const    { return fTime;           }
    79   Float_t GetSigmaTime()      const    { return fSigmaTime;      }
    80   Float_t GetTimeChiSquare()  const    { return fTimeChiSquare;  }   
    81  
    82   Float_t GetPed()            const    { return fPed;            }
    83   Float_t GetPedRms()         const    { return fPedRms;         }   
     83  Float_t GetSigmaCharge()         const { return fSigmaCharge;    }
     84  Float_t GetErrSigmaCharge()      const { return fErrSigmaCharge; }
     85  Float_t GetTime()                const { return fTime;           }
     86  Float_t GetSigmaTime()           const { return fSigmaTime;      }
     87  Float_t GetTimeChiSquare()       const { return fTimeChiSquare;  }   
    8488
     89  Float_t GetConversionHiLo()                 const  { return fConversionHiLo;        }
     90  Float_t GetConversionHiLoError()            const  { return fConversionHiLoError;   }
     91
     92  Float_t GetMeanConversionBlindPixelMethod()  const { return fConversionBlindPixelMethod ; }
     93  Float_t GetErrorConversionBlindPixelMethod() const { return fConversionErrorBlindPixelMethod ; }
     94  Float_t GetSigmaConversionBlindPixelMethod() const { return fConversionSigmaBlindPixelMethod ; }
     95
     96  Float_t GetMeanConversionFFactorMethod()     const { return fConversionFFactorMethod ;       }
     97  Float_t GetErrorConversionFFactorMethod()    const { return fConversionErrorFFactorMethod ;  }
     98  Float_t GetSigmaConversionFFactorMethod()    const { return fConversionSigmaFFactorMethod ;  }
     99
     100  Float_t GetPheFFactorMethod()                const { return fPheFFactorMethod;               }
     101  Float_t GetPheFFactorMethodError()           const { return fPheFFactorMethodError;          }
     102
     103  Float_t GetMeanConversionPINDiodeMethod()    const { return fConversionPINDiodeMethod ;      }
     104  Float_t GetErrorConversionPINDiodeMethod()   const { return fConversionErrorPINDiodeMethod ; }
     105  Float_t GetSigmaConversionPINDiodeMethod()   const { return fConversionSigmaPINDiodeMethod ; }
     106
     107  // FIXME: Remove this from stored data members
     108  Float_t GetPed()    const { return fPed;    }
     109  Float_t GetPedRms() const { return fPedRms; }
     110
     111  // Setter
    85112  void SetPedestal(Float_t ped, Float_t pedrms);
    86   void SetHiGainSaturation()                               { fHiGainSaturation = kTRUE; fHist->SetUseLoGain(); }
     113  void SetHiGainSaturation()             { fHiGainSaturation = kTRUE; fHist->SetUseLoGain(); }
    87114
    88   void ApplyLoGainConversion();
     115  void SetConversionHiLo(Float_t c)      { fConversionHiLo      = c;    }
     116  void SetConversionHiLoError(Float_t e) { fConversionHiLoError = e;    }
    89117
    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  
    96   void SetConversionFFactorMethod(Float_t c, Float_t err, Float_t sig)     
    97                                                     {
    98                                                       fConversionFFactorMethod = c;
    99                                                       fConversionErrorFFactorMethod = err;
    100                                                       fConversionSigmaFFactorMethod = sig;
    101                                                     }
    102   void SetConversionBlindPixelMethod(Float_t c, Float_t err, Float_t sig)     
    103                                                     {
    104                                                       fConversionBlindPixelMethod = c;
    105                                                       fConversionErrorBlindPixelMethod = err;
    106                                                       fConversionSigmaBlindPixelMethod = sig;
    107                                                     }
     118  void SetConversionFFactorMethod(Float_t c, Float_t err, Float_t sig)
     119  {
     120      fConversionFFactorMethod = c;
     121      fConversionErrorFFactorMethod = err;
     122      fConversionSigmaFFactorMethod = sig;
     123  }
     124  void SetConversionBlindPixelMethod(Float_t c, Float_t err, Float_t sig)
     125  {
     126      fConversionBlindPixelMethod = c;
     127      fConversionErrorBlindPixelMethod = err;
     128      fConversionSigmaBlindPixelMethod = sig;
     129  }
    108130
    109131  void SetConversionPINDiodeMethod(Float_t c, Float_t err, Float_t sig)
    110                                                     {
    111                                                       fConversionPINDiodeMethod = c ;
    112                                                       fConversionErrorPINDiodeMethod = err;
    113                                                       fConversionSigmaPINDiodeMethod = sig;
    114                                                     }
     132  {
     133      fConversionPINDiodeMethod = c ;
     134      fConversionErrorPINDiodeMethod = err;
     135      fConversionSigmaPINDiodeMethod = sig;
     136  }
    115137
    116   Float_t GetMeanConversionBlindPixelMethod()   const  { return fConversionBlindPixelMethod ; }
    117   Float_t GetErrorConversionBlindPixelMethod()  const  { return fConversionErrorBlindPixelMethod ; }
    118   Float_t GetSigmaConversionBlindPixelMethod()  const  { return fConversionSigmaBlindPixelMethod ; }
     138  void SetFitValid()                            { fFitValid = kTRUE;  }
     139  void SetFitted()                              { fFitted = kTRUE;  }
     140  void SetBlindPixelMethodValid(Bool_t b=kTRUE) { fBlindPixelMethodValid = b;  }
     141  void SetFFactorMethodValid(Bool_t b=kTRUE)    { fFFactorMethodValid = b;  }
     142  void SetPINDiodeMethodValid(Bool_t b=kTRUE)   { fPINDiodeMethodValid = b;  }
    119143
    120   Float_t GetMeanConversionFFactorMethod()      const  { return fConversionFFactorMethod ;       }
    121   Float_t GetErrorConversionFFactorMethod()     const  { return fConversionErrorFFactorMethod ;  }
    122   Float_t GetSigmaConversionFFactorMethod()     const  { return fConversionSigmaFFactorMethod ;  }
    123 
    124   Float_t GetPheFFactorMethod()                 const  { return fPheFFactorMethod;               }
    125   Float_t GetPheFFactorMethodError()            const  { return fPheFFactorMethodError;          }   
    126  
    127   Float_t GetMeanConversionPINDiodeMethod()     const  { return fConversionPINDiodeMethod ;      }
    128   Float_t GetErrorConversionPINDiodeMethod()    const  { return fConversionErrorPINDiodeMethod ; }
    129   Float_t GetSigmaConversionPINDiodeMethod()    const  { return fConversionSigmaPINDiodeMethod ; }
     144  // Unknown
     145  void   ApplyLoGainConversion();
    130146
    131147  void   SetChargesInGraph(Float_t qhi,Float_t qlo) { fHist->SetPointInGraph(qhi,qlo); }
    … …  
    139155  Bool_t FillRChargevsTimeLoGain(Float_t rq, Int_t t)  { return fHist->FillChargevsNLoGain(rq,t); }   
    140156 
    141   Bool_t IsFitValid()                                  { return fFitValid;  }
    142   Bool_t IsFitted()                                    { return fFitted;  }
    143   Bool_t IsBlindPixelMethodValid()                     { return fBlindPixelMethodValid;  }
    144   Bool_t IsFFactorMethodValid()                        { return fFFactorMethodValid;  }
    145   Bool_t IsPINDiodeMethodValid()                       { return fPINDiodeMethodValid;  }
    146  
    147   void   SetFitValid()                                     { fFitValid = kTRUE;  }
    148   void   SetFitted()                                      { fFitted = 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;  }
    152  
     157  // FIXME: Not necessary -> pixidx (not id anyhow!) == index in array!
     158  //        Only needed n histograms which have to move to an MH-class anyhow!
    153159  Int_t  GetPixId()                              const  { return fPixId;   }
    154160  void   DefinePixId(Int_t i);

  • trunk/MagicSoft/Mars/manalysis/MExtractSignal.cc

    r2725 r2728  
    5656// Default constructor.
    5757//
    58 MExtractSignal::MExtractSignal(const Byte_t first, const Byte_t last, const Byte_t logainshift,
     58MExtractSignal::MExtractSignal(/*const Byte_t first, const Byte_t last, const Byte_t logainshift,*/
    5959                    const char *name, const char *title)
    60   : fNumHiGainSamples(last-first+1), fNumLoGainSamples(last-first+1),
     60  : /*fNumHiGainSamples(last-first+1), fNumLoGainSamples(last-first+1),*/
    6161    fSaturationLimit(254)
    6262{
    … …  
    6767    AddToBranchList("MRawEvtData.*");
    6868
     69    SetRange();
     70    /*
     71     fFirst       = first;
     72     fLoGainFirst = first+logainshift;
     73
     74     fSqrtHiGainSamples = TMath::Sqrt((Float_t)fNumHiGainSamples);
     75     fSqrtLoGainSamples = TMath::Sqrt((Float_t)fNumLoGainSamples);
     76     */
     77}
     78
     79void MExtractSignal::SetRange(Byte_t first, Byte_t last, Byte_t logainshift)
     80{
     81    fNumHiGainSamples = last-first+1;
     82    fNumLoGainSamples = last-first+1;
     83
    6984    fFirst       = first;
    7085    fLoGainFirst = first+logainshift;
    7186
    72     fSqrtHiGainSamples = TMath::Sqrt((Float_t)fNumHiGainSamples); 
    73     fSqrtLoGainSamples = TMath::Sqrt((Float_t)fNumLoGainSamples); 
     87    fSqrtHiGainSamples = TMath::Sqrt((Float_t)fNumHiGainSamples);
     88    fSqrtLoGainSamples = TMath::Sqrt((Float_t)fNumLoGainSamples);
    7489}
    7590
    … …  
    87102Int_t MExtractSignal::PreProcess(MParList *pList)
    88103{
    89 
    90104    fRawEvt = (MRawEvtData*)pList->FindObject("MRawEvtData");
    91105    if (!fRawEvt)
    92106    {
    93         *fLog << dbginf << "MRawEvtData not found... aborting." << endl;
     107        *fLog << err << "MRawEvtData not found... aborting." << endl;
    94108        return kFALSE;
    95109    }
    … …  
    103117    if (!fPedestals)
    104118      {
    105         *fLog << err << dbginf << "Cannot find MPedestalCam ... aborting" << endl;
     119        *fLog << err << "MPedestalCam not found... aborting" << endl;
    106120        return kFALSE;
    107121      }
    … …  
    118132Bool_t MExtractSignal::ReInit(MParList *pList )
    119133{
    120  
    121 
    122134    MGeomCam *cam = (MGeomCam*)pList->FindObject(AddSerialNumber("MGeomCam"));
    123135    if (!cam)
    … …  
    127139    }
    128140
     141    // FIXME: This solution may change in the future, MExtractedSignal
     142    //        must be similar to MCerPhotEvt not to MPedestalCam
     143    //        (Have to think about the mean size of both solutions)
    129144    fSignals->InitSize(cam->GetNumPixels());   
    130145
    131 
    132     fSignals->SetNumUsedFADCSlices(fNumHiGainSamples,fFirst,fFirst+fNumHiGainSamples-1,
    133                                    fNumLoGainSamples,fFirst,fFirst+fNumLoGainSamples-1);
     146    fSignals->SetNumUsedFADCSlices(fNumHiGainSamples, fFirst, fFirst+fNumHiGainSamples-1,
     147                                   fNumLoGainSamples, fFirst, fFirst+fNumLoGainSamples-1);
    134148
    135149    return kTRUE;
    … …  
    144158Int_t MExtractSignal::Process()
    145159{
    146 
    147160    MRawEvtPixelIter pixel(fRawEvt);
    148161    fSignals->Clear();
    149162
    150163    while (pixel.Next())
    151       {
    152 
     164    {
    153165        UShort_t satHi = 0;
    154166        UShort_t satLo = 0;
    … …  
    219231                               );
    220232
    221         pix.SetGainSaturation((satHi),satHi,satLo);
    222 
     233        pix.SetGainSaturation(satHi, satHi, satLo);
     234
     235        // FIXME: Arrival time has to be stored in MArrivalTime!
    223236        if (satHi)
    224237          pix.SetArrivalTimes((Float_t)(midlo+fFirst),0.,0.);
    … …  
    233246    return kTRUE;
    234247}
    235 
    236 Int_t MExtractSignal::PostProcess()
    237 {
    238 
    239   return kTRUE;
    240 
    241 }

  • trunk/MagicSoft/Mars/manalysis/MExtractedSignalCam.h

    r2699 r2728  
    77
    88class TClonesArray;
    9 
    10 class MGeomCam;
    119class MExtractedSignalPix;
    1210
    … …  
    1614    TClonesArray *fArray; // FIXME: Change TClonesArray away from a pointer?
    1715
     16    // FIXME: Is it necessary to store this information for each event?
    1817    Byte_t fNumUsedHiGainFADCSlices;
    1918    Byte_t fNumUsedLoGainFADCSlices;
    … …  
    2423    Byte_t fLastUsedSliceHiGain;
    2524    Byte_t fLastUsedSliceLoGain;
    26 
    2725
    2826public:
    … …  
    4745
    4846    void   SetNumUsedFADCSlices(Byte_t numh, Byte_t firsth, Byte_t lasth,
    49                         Byte_t numl, Byte_t firstl, Byte_t lastl)   
    50                                            {
    51                                              fNumUsedHiGainFADCSlices = numh;
    52                                              fFirstUsedSliceHiGain    = firsth;
    53                                              fLastUsedSliceHiGain     = lasth;
    54                                              fNumUsedLoGainFADCSlices = numl; 
    55                                              fFirstUsedSliceLoGain    = firstl;
    56                                              fLastUsedSliceLoGain     = lastl;
    57                                            }
     47                                Byte_t numl, Byte_t firstl, Byte_t lastl)
     48    {
     49        // FIXME: Calculate the number of used slices from first/last
     50        //        to make sure, that the stored values are always
     51        //        consistent!
     52        fNumUsedHiGainFADCSlices = numh;
     53        fFirstUsedSliceHiGain    = firsth;
     54        fLastUsedSliceHiGain     = lasth;
     55        fNumUsedLoGainFADCSlices = numl;
     56        fFirstUsedSliceLoGain    = firstl;
     57        fLastUsedSliceLoGain     = lastl;
     58    }
    5859
    5960    MExtractedSignalPix &operator[](Int_t i);

  • trunk/MagicSoft/Mars/manalysis/MExtractedSignalPix.h

    r2706 r2728  
    99{
    1010private:
    11 
     11    // FIXME: We can only store ONE signal. Everything else takes
     12    //        too much storage space - will change in the future.
    1213    Float_t fExtractedSignalHiGain;      // mean value of the extracted signal
    1314    Float_t fExtractedSignalHiGainError; // error of the mean value of the extracted signal
    1415    Float_t fExtractedSignalLoGain;      // mean value of the extracted signal
    1516    Float_t fExtractedSignalLoGainError; // error of the mean value of the extracted signal
     17
    1618    Bool_t fIsLoGainUsed;
    1719    Byte_t fNumHiGainSaturated;
    1820    Byte_t fNumLoGainSaturated;
    1921
     22    // FIXME: Will be removed. Must be stored in MArrivalTime
    2023    Float_t fMeanArrivalTime;
    2124    Float_t fWidthArrivalTime;
Note: See TracChangeset for help on using the changeset viewer.