Ignore:
Timestamp:
10/15/02 17:02:46 (22 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/manalysis
Files:
19 edited

Legend:

Unmodified
Added
Removed

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

    r1438 r1540  
    3434
    3535#include "MGeomCam.h"
    36 #include "MGeomPix.h"
    3736
    3837ClassImp(MCerPhotEvt);
    … …  
    159158        return -5.;
    160159
    161     const Float_t A0 = geom ? (*geom)[0].GetA() : 0;
    162 
    163160    Float_t minval = (*this)[0].GetNumPhotons();
    164161
    … …  
    170167
    171168        if (geom)
    172             testval *= A0/(*geom)[pix.GetPixId()].GetA();
     169            testval *= geom->GetPixRatio(pix.GetPixId());
    173170
    174171        if (testval < minval)
    … …  
    190187        return 50.;
    191188
    192     const Float_t A0 = geom ? (*geom)[0].GetA() : 0;
    193189    Float_t maxval = (*this)[0].GetNumPhotons();
    194190
    … …  
    200196
    201197        if (geom)
    202             testval *= A0/(*geom)[pix.GetPixId()].GetA();
     198            testval *= geom->GetPixRatio(pix.GetPixId());
    203199
    204200        if (testval > maxval)
    … …  
    208204}
    209205
     206// --------------------------------------------------------------------------
     207//
     208// get the minimum ratio of photons/error
     209//
     210Float_t MCerPhotEvt::GetRatioMin() const
     211{
     212    if (fNumPixels <= 0)
     213        return -5.;
     214
     215    Float_t minval = (*this)[0].GetNumPhotons()/(*this)[0].GetErrorPhot();
     216
     217    for (UInt_t i=1; i<fNumPixels; i++)
     218    {
     219        const MCerPhotPix &pix = (*this)[i];
     220
     221        Float_t testval = pix.GetNumPhotons()/pix.GetErrorPhot();
     222        if (testval < minval)
     223            minval = testval;
     224    }
     225
     226    return minval;
     227}
     228
     229// --------------------------------------------------------------------------
     230//
     231// get the maximum ratio of photons/error
     232//
     233Float_t MCerPhotEvt::GetRatioMax() const
     234{
     235    if (fNumPixels <= 0)
     236        return -5.;
     237
     238    Float_t maxval = (*this)[0].GetNumPhotons()/(*this)[0].GetErrorPhot();
     239
     240    for (UInt_t i=1; i<fNumPixels; i++)
     241    {
     242        const MCerPhotPix &pix = (*this)[i];
     243
     244        Float_t testval = pix.GetNumPhotons()/pix.GetErrorPhot();
     245        if (testval > maxval)
     246            maxval = testval;
     247    }
     248
     249    return maxval;
     250}
     251
     252// --------------------------------------------------------------------------
     253//
     254// get the minimum of error
     255// If you specify a geometry the number of photons is weighted with the
     256// area of the pixel
     257//
     258Float_t MCerPhotEvt::GetErrorPhotMin(const MGeomCam *geom) const
     259{
     260    if (fNumPixels <= 0)
     261        return 50.;
     262
     263    Float_t minval = (*this)[0].GetErrorPhot();
     264
     265    for (UInt_t i=1; i<fNumPixels; i++)
     266    {
     267        const MCerPhotPix &pix = (*this)[i];
     268
     269        Float_t testval = pix.GetErrorPhot();
     270
     271        if (geom)
     272            testval *= geom->GetPixRatio(pix.GetPixId());
     273
     274        if (testval < minval)
     275            minval = testval;
     276    }
     277    return minval;
     278}
     279
     280// --------------------------------------------------------------------------
     281//
     282// get the maximum ratio of photons/error
     283// If you specify a geometry the number of photons is weighted with the
     284// area of the pixel
     285//
     286Float_t MCerPhotEvt::GetErrorPhotMax(const MGeomCam *geom) const
     287{
     288    if (fNumPixels <= 0)
     289        return 50.;
     290
     291    Float_t maxval = (*this)[0].GetErrorPhot();
     292
     293    for (UInt_t i=1; i<fNumPixels; i++)
     294    {
     295        const MCerPhotPix &pix = (*this)[i];
     296
     297        Float_t testval = pix.GetErrorPhot();
     298
     299        if (geom)
     300            testval *= geom->GetPixRatio(pix.GetPixId());
     301
     302        if (testval > maxval)
     303            maxval = testval;
     304    }
     305    return maxval;
     306}
     307

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

    r1268 r1540  
    3838    Float_t GetNumPhotonsMax(const MGeomCam *geom=NULL) const;
    3939
     40    Float_t GetRatioMin() const;
     41    Float_t GetRatioMax() const;
     42
     43    Float_t GetErrorPhotMin(const MGeomCam *geom=NULL) const;
     44    Float_t GetErrorPhotMax(const MGeomCam *geom=NULL) const;
     45
    4046    MCerPhotPix &operator[](int i)       { return *(MCerPhotPix*)(fPixels->UncheckedAt(i)); }
    4147    MCerPhotPix &operator[](int i) const { return *(MCerPhotPix*)(fPixels->UncheckedAt(i)); }

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

    r1528 r1540  
    220220// In case you don't call Calc from within an eventloop make sure, that
    221221// you call the Reset member function before.
    222 //
    223 Bool_t MHillas::Calc(const MGeomCam &geom, const MCerPhotEvt &evt)
     222// Returns:
     223//   0  no error
     224//   1  number of pixels < 3
     225//   2  size==0
     226//   3  number of used pixel < 3
     227//   4  CorrXY == 0
     228//
     229Int_t MHillas::Calc(const MGeomCam &geom, const MCerPhotEvt &evt)
    224230{
    225231    const UInt_t npixevt = evt.GetNumPixels();
    … …  
    228234    // sanity check
    229235    //
    230     if (npixevt <= 2)
    231     {
    232         *fLog << warn << "MHillas::Calc: Event has less than two pixels... skipped." << endl;
    233         return kFALSE;
     236    if (npixevt < 3)
     237    {
     238        //*fLog << warn << "MHillas::Calc: Event has less than three pixels... skipped." << endl;
     239        return 1;
    234240    }
    235241
    … …  
    280286    {
    281287        //*fLog << inf << GetDescriptor() << ": Event has zero cerenkov photons... skipped." << endl;
    282         return kFALSE;
     288        return 2;
    283289    }
    284290
    … …  
    286292    {
    287293        //*fLog << inf << GetDescriptor() << ": Event has less than 3 used pixels... skipped." << endl;
    288         return kFALSE;
     294        return 3;
    289295    }
    290296
    … …  
    334340    if (corrxy==0)
    335341    {
    336         *fLog << inf << GetDescriptor() << ": Event has CorrXY==0... skipped." << endl;
    337         return kFALSE;
     342        //*fLog << inf << GetDescriptor() << ": Event has CorrXY==0... skipped." << endl;
     343        return 4;
    338344    }
    339345
    … …  
    375381    SetReadyToSave();
    376382
    377     return kTRUE;
     383    return 0;
    378384}
    379385

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

    r1524 r1540  
    4545    void Reset();
    4646
    47     virtual Bool_t Calc(const MGeomCam &geom, const MCerPhotEvt &pix);
     47    virtual Int_t Calc(const MGeomCam &geom, const MCerPhotEvt &pix);
    4848
    4949    virtual void Print(Option_t *opt=NULL) const;

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

    r1211 r1540  
    8888        return kFALSE;
    8989
     90    memset(fErrors, 0, sizeof(fErrors));
     91
    9092    return kTRUE;
    9193}
    … …  
    100102Bool_t MHillasCalc::Process()
    101103{
    102     return fHillas->Calc(*fGeomCam, *fCerPhotEvt) ? kTRUE : kCONTINUE;
     104    const Int_t rc = fHillas->Calc(*fGeomCam, *fCerPhotEvt);
     105    if (rc<0 || rc>4)
     106    {
     107        *fLog << err << dbginf << "MHillas::Calc returned unknown error code!" << endl;
     108        return kFALSE;
     109    }
     110    fErrors[rc]++;
     111
     112    return rc==0 ? kTRUE : kCONTINUE;
    103113}
    104114
     115// --------------------------------------------------------------------------
     116//
     117//  Prints some statistics about the hillas calculation. The percentage
     118//  is calculated with respect to the number of executions of this task.
     119//
     120Bool_t MHillasCalc::PostProcess()
     121{
     122    if (GetNumExecutions()==0)
     123        return kTRUE;
     124
     125    *fLog << inf << endl;
     126    *fLog << GetDescriptor() << " execution statistics:" << endl;
     127    *fLog << " " << setw(7) << fErrors[1] << " (" << setw(3) << (int)(fErrors[1]*100/GetNumExecutions()) << "%) Evts skipped due to: Event has less than 3 pixels" << endl;
     128    *fLog << " " << setw(7) << fErrors[2] << " (" << setw(3) << (int)(fErrors[2]*100/GetNumExecutions()) << "%) Evts skipped due to: Calculated Size == 0" << endl;
     129    *fLog << " " << setw(7) << fErrors[3] << " (" << setw(3) << (int)(fErrors[3]*100/GetNumExecutions()) << "%) Evts skipped due to: Number of used pixels < 3" << endl;
     130    *fLog << " " << setw(7) << fErrors[4] << " (" << setw(3) << (int)(fErrors[4]*100/GetNumExecutions()) << "%) Evts skipped due to: CorrXY==0" << endl;
     131    *fLog << " " << fErrors[0] << " (" << (int)(fErrors[0]*100/GetNumExecutions()) << "%) Evts survived Hillas calculation!" << endl;
     132    *fLog << endl;
     133
     134    return kTRUE;
     135}

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

    r1203 r1540  
    2424          MHillas     *fHillas;     // ouput container to store result
    2525
    26     TString fHilName;
    27 public:
    28     MHillasCalc(const char *hil="MHillas", const char *name=NULL, const char *title=NULL);
     26          TString      fHilName;
     27          Int_t        fErrors[5];
    2928
    3029    Bool_t PreProcess(MParList *pList);
    3130    Bool_t Process();
     31    Bool_t PostProcess();
     32
     33public:
     34    MHillasCalc(const char *hil="MHillas", const char *name=NULL, const char *title=NULL);
    3235
    3336    ClassDef(MHillasCalc, 0)   // Task to calculate Hillas parameters

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

    r1524 r1540  
    111111// and the cerenkov photon event
    112112//
    113 Bool_t MHillasExt::Calc(const MGeomCam &geom, const MCerPhotEvt &evt)
    114 {
    115     if (!MHillas::Calc(geom, evt))
    116         return kFALSE;
     113Int_t MHillasExt::Calc(const MGeomCam &geom, const MCerPhotEvt &evt)
     114{
     115    const Int_t rc = MHillas::Calc(geom, evt);
     116    if (rc>0)
     117        return rc;
    117118
    118119    //
    … …  
    237238    SetReadyToSave();
    238239
    239     return kTRUE;
     240    return 0;
    240241}
    241242

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

    r1524 r1540  
    3030    Float_t GetM3Trans() const { return fM3Trans; }
    3131
    32     Bool_t Calc(const MGeomCam &geom, const MCerPhotEvt &pix);
     32    Int_t Calc(const MGeomCam &geom, const MCerPhotEvt &pix);
    3333
    3434    void Print(Option_t *opt=NULL) const;

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

    r1524 r1540  
    113113    if (dist==0)
    114114    {
    115         *fLog << warn << GetDescriptor() << ": Event has Dist==0... skipped." << endl;
     115        //*fLog << warn << GetDescriptor() << ": Event has Dist==0... skipped." << endl;
    116116        return kFALSE;
    117117    }

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

    r1487 r1540  
    9191    fHillasSrc->SetSrcPos(fSrcPos);
    9292
     93    fErrors = 0;
     94
    9395    return kTRUE;
    9496}
    … …  
    98100Bool_t MHillasSrcCalc::Process()
    99101{
    100     return fHillasSrc->Calc(fHillas) ? kTRUE : kCONTINUE;
     102
     103    if (!fHillasSrc->Calc(fHillas))
     104    {
     105        fErrors++;
     106        return kCONTINUE;
     107
     108    }
     109    return kTRUE;
    101110}
    102111
     112// --------------------------------------------------------------------------
     113//
     114//  Prints some statistics about the hillas calculation. The percentage
     115//  is calculated with respect to the number of executions of this task.
     116//
     117Bool_t MHillasSrcCalc::PostProcess()
     118{
     119    if (GetNumExecutions()==0)
     120        return kTRUE;
     121
     122    *fLog << inf << endl;
     123    *fLog << GetDescriptor() << " execution statistics:" << endl;
     124    *fLog << " " << fErrors << " (" << (int)(fErrors*100/GetNumExecutions()) << "%) Evts skipped due to: Dist==0" << endl;
     125    *fLog << endl;
     126
     127    return kTRUE;
     128}
    103129
    104130// --------------------------------------------------------------------------

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

    r1487 r1540  
    2020    TString     fHillasName;
    2121
     22    Int_t       fErrors;
     23
    2224    void StreamPrimitive(ofstream &out) const;
     25
     26    Bool_t PreProcess(MParList *plist);
     27    Bool_t Process();
     28    Bool_t PostProcess();
    2329
    2430public:
    … …  
    2632                   const char *name=NULL, const char *title=NULL);
    2733
    28     Bool_t PreProcess(MParList *plist);
    29     Bool_t Process();
    30 
    3134    ClassDef(MHillasSrcCalc, 1) // task to calculate the source position depandant hillas parameters
    3235};

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

    r1503 r1540  
    159159        // check if pixel is in use, if not goto next pixel in list
    160160        //
     161#if 0
    161162        if (!pix.IsPixelUsed())
    162163            continue;
     164#endif
    163165
    164166        //
    … …  
    168170
    169171        //
    170         // count number of next neighbors of this pixel which
    171         // state is 'used'
     172        // check for 'used' neighbors this pixel which
    172173        //
    173174        const MGeomPix &gpix  = (*fCam)[id];
    174175        const Int_t     nnmax = gpix.GetNumNeighbors();
    175176
     177#if 0
    176178        Bool_t cnt = kFALSE;
    177179        for (Int_t j=0; j<nnmax; j++)
    … …  
    179181            const Int_t id2 = gpix.GetNeighbor(j);
    180182
    181             if (!ispixused[id2])
     183            if (id2>max || !ispixused[id2])
    182184                continue;
    183185
    … …  
    187189        if (cnt)
    188190            continue;
     191#else
     192        Int_t cnt = 0;
     193        for (Int_t j=0; j<nnmax; j++)
     194        {
     195            const Int_t id2 = gpix.GetNeighbor(j);
     196
     197            if (id2>max || !ispixused[id2])
     198                continue;
     199
     200            if (cnt++>nnmax-4)
     201                break;
     202        }
     203        if (cnt==nnmax-2 && nnmax>=4)
     204        {
     205            pix.SetPixelUsed();
     206            continue;
     207        }
     208        if (cnt>0)
     209            continue;
     210#endif
    189211
    190212        //
    … …  
    238260        const Float_t noise = pix.GetErrorPhot();
    239261
    240         if (entry <= fCleanLvl2 * noise )
     262        if (entry <= fCleanLvl2 * noise)
    241263            continue;
    242264

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

    r1477 r1540  
    3636    void Print(Option_t *o="") const;
    3737
     38    Float_t GetCleanLvl1() const { return fCleanLvl1; }
     39    Float_t GetCleanLvl2() const { return fCleanLvl2; }
     40
    3841    Bool_t ProcessMessage(Int_t msg, Int_t submsg, Long_t param1, Long_t param2);
    3942

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

    r1173 r1540  
    4646#include "MLogManip.h"
    4747
     48#include "MPedestalPix.h"
    4849#include "MPedestalCam.h"
     50
    4951#include "MRawRunHeader.h"
    5052#include "MMcFadcHeader.hxx"
    … …  
    113115// --------------------------------------------------------------------------
    114116//
    115 // Check for the runtype. (not yet: If the check fails the eventloop is
    116 // stopped.)
     117// Check for the runtype.
    117118// Initialize the size of MPedestalCam to the number of pixels from
    118119// MMcFadcHeader.

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

    r1186 r1540  
    2626//                                                                         //
    2727//  MMcPedestalNSBAdd                                                      //
     28//  -----------------                                                      //
    2829//                                                                         //
    2930//  This Task adds the contribution of the diffuse NSB to the FADC         //
    3031//  pedestals. We assume that NSB introduces larger fluctuation but does   //
    3132//  not change the mean value.                                             //
    32 //  To be precise we add quadratically to the rms that is already in       //
    33 //  MPedestalCam the NSB contribution.                                     //
     33//  To be precise we add quadratically to the rms, which is already in     //
     34//  MPedestalCam, the NSB contribution.                                    //
    3435//  The number of photons from the diffuse NSB follows a poisson           //
    3536//  distribution with expected mean value X, then its standard deviation   //
    … …  
    5051//                                                                         //
    5152/////////////////////////////////////////////////////////////////////////////
    52 
    5353#include "MMcPedestalNSBAdd.h"
    5454
    … …  
    5858#include "MLogManip.h"
    5959
     60#include "MGeomCam.h"
     61#include "MGeomPix.h"
     62
     63#include "MPedestalPix.h"
    6064#include "MPedestalCam.h"
     65
    6166#include "MRawRunHeader.h"
    6267#include "MMcRunHeader.hxx"
    6368#include "MMcFadcHeader.hxx"
    64 #include "MGeomCam.h"
    65 #include "MGeomPix.h"
    6669
    6770ClassImp(MMcPedestalNSBAdd);

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

    r1155 r1540  
    3131/////////////////////////////////////////////////////////////////////////////
    3232#include "MPedestalCam.h"
     33#include "MPedestalPix.h"
     34
     35#include <TClonesArray.h>
    3336
    3437#include "MLog.h"
     38#include "MLogManip.h"
     39
     40#include "MGeomCam.h"
     41
    3542
    3643ClassImp(MPedestalCam);
    … …  
    6269// --------------------------------------------------------------------------
    6370//
     71// Set the size of the camera
     72//
     73inline void MPedestalCam::InitSize(const UInt_t i)
     74{
     75    fArray->ExpandCreate(i);
     76}
     77
     78// --------------------------------------------------------------------------
     79//
     80// Get the size of the MPedestalCam
     81//
     82inline Int_t MPedestalCam::GetSize() const
     83{
     84    return fArray->GetEntries();
     85}
     86
     87// --------------------------------------------------------------------------
     88//
     89// Get i-th pixel (pixel number)
     90//
     91inline MPedestalPix &MPedestalCam::operator[](Int_t i)
     92{
     93    return *(MPedestalPix*)fArray->UncheckedAt(i);
     94}
     95
     96// --------------------------------------------------------------------------
     97//
     98// Get i-th pixel (pixel number)
     99//
     100inline MPedestalPix &MPedestalCam::operator[](Int_t i) const
     101{
     102    return *(MPedestalPix*)fArray->UncheckedAt(i);
     103}
     104
     105// --------------------------------------------------------------------------
     106//
    64107// Check if position i is inside bounds
    65108//
    … …  
    69112}
    70113
     114void MPedestalCam::Clear(Option_t *o)
     115{
     116    fArray->ForEach(TObject, Clear)();
     117}
    71118
     119void MPedestalCam::Print(Option_t *o="") const
     120{
     121    *fLog << all << GetDescriptor() << ":" << endl;
     122    int id = 0;
     123
     124    TIter Next(fArray);
     125    MPedestalPix *pix;
     126    while ((pix=(MPedestalPix*)Next()))
     127    {
     128        id++;
     129
     130        if (!pix->IsValid())
     131            continue;
     132
     133        *fLog << id-1 << ": ";
     134        *fLog << pix->GetMean() << " " << pix->GetSigma() << " ";
     135        *fLog << pix->GetMeanRms() << " " << pix->GetSigmaRms() << endl;
     136    }
     137}
     138
     139Float_t MPedestalCam::GetMeanMin(const MGeomCam *geom) const
     140{
     141    if (fArray->GetEntries() <= 0)
     142        return 50.;
     143
     144    Float_t minval = (*this)[0].GetMean();
     145
     146    for (Int_t i=1; i<fArray->GetEntries(); i++)
     147    {
     148        const MPedestalPix &pix = (*this)[i];
     149
     150        Float_t testval = pix.GetMean();
     151
     152        if (geom)
     153            testval *= geom->GetPixRatio(i);
     154
     155        if (testval < minval)
     156            minval = testval;
     157    }
     158    return minval;
     159}
     160
     161Float_t MPedestalCam::GetMeanMax(const MGeomCam *geom) const
     162{
     163    if (fArray->GetEntries() <= 0)
     164        return 50.;
     165
     166    Float_t maxval = (*this)[0].GetMean();
     167
     168    for (Int_t i=1; i<fArray->GetEntries(); i++)
     169    {
     170        const MPedestalPix &pix = (*this)[i];
     171
     172        Float_t testval = pix.GetMean();
     173
     174        if (geom)
     175            testval *= geom->GetPixRatio(i);
     176
     177        if (testval > maxval)
     178            maxval = testval;
     179    }
     180    return maxval;
     181}

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

    r1268 r1540  
    66#endif
    77
    8 #ifndef MARS_MPedestalPix
    9 #include "MPedestalPix.h"
    10 #endif
     8class TClonesArray;
    119
    12 #ifndef ROOT_TClonesArray
    13 #include <TClonesArray.h>
    14 #endif
     10class MGeomCam;
     11class MPedestalPix;
    1512
    1613class MPedestalCam : public MParContainer
    … …  
    2320    ~MPedestalCam();
    2421
    25     void InitSize(const UInt_t i) { fArray->ExpandCreate(i); }
     22    void Clear(Option_t *o="");
    2623
    27     MPedestalPix &operator[](Int_t i)       { return *(MPedestalPix*)fArray->UncheckedAt(i); }
    28     MPedestalPix &operator[](Int_t i) const { return *(MPedestalPix*)fArray->UncheckedAt(i); }
     24    void InitSize(const UInt_t i);
     25    Int_t GetSize() const;
     26
     27    MPedestalPix &operator[](Int_t i);
     28    MPedestalPix &operator[](Int_t i) const;
     29
     30    Float_t GetMeanMin(const MGeomCam *cam) const;
     31    Float_t GetMeanMax(const MGeomCam *cam) const;
    2932
    3033    Bool_t CheckBounds(Int_t i);
     34
     35    void Print(Option_t *o="") const;
    3136
    3237    ClassDef(MPedestalCam, 1)   // Storage Container for all pedestal information of the camera

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

    r1081 r1540  
    3838
    3939MPedestalPix::MPedestalPix()
    40     : fMean(0.0), fSigma(0.0), fMeanRms(0.0), fSigmaRms(0.0)
    4140{
     41    Clear();
    4242}
    4343
     44// ------------------------------------------------------------------------
     45//
     46// Invalidate values
     47//
     48void MPedestalPix::Clear(Option_t *o)
     49{
     50    fMean = -1;
     51    fSigma = -1;
     52    fMeanRms = -1;
     53    fSigmaRms = -1;
     54}
     55

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

    r1014 r1540  
    1717    MPedestalPix();
    1818
     19    void Clear(Option_t *o="");
     20
    1921    Float_t GetMean() const     { return fMean;     }
    2022    Float_t GetSigma() const    { return fSigma;    }
    … …  
    3032    void SetPedestalRms(Float_t m, Float_t s) { fMeanRms = m; fSigmaRms = s; }
    3133
     34    Bool_t IsValid() const { return fMean>=0||fSigma>=0||fMeanRms>=0||fSigmaRms>=0; }
     35
    3236    ClassDef(MPedestalPix, 1)   // Storage Container for Pedestal information of one pixel
    3337};
Note: See TracChangeset for help on using the changeset viewer.