Ignore:
Timestamp:
02/15/04 18:37:08 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/manalysis
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r3101 r3160  
    1717
    1818#pragma link C++ class MPedestalPix+;
    19 #pragma link C++ class MHPedestalPixel+;
     19#pragma link C++ class MHPedestalPix+;
    2020#pragma link C++ class MPedestalCam+;
     21#pragma link C++ class MHPedestalCam+;
    2122#pragma link C++ class MPedCalcPedRun+;
    2223#pragma link C++ class MPedPhotCalc+;

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

    r3157 r3160  
    5555// Default Constructor.
    5656//
    57 MHPedestalPix::MHPedestalPix() : fPixId(-1)
     57MHPedestalPix::MHPedestalPix(const char *name, const char *title)
     58    : fPixId(-1)
    5859{
     60
     61  fName  = name  ? name  : "MHPedestalPix";
     62  fTitle = title ? title : "Histogrammed Pedestal events";
    5963
    6064  SetChargeNbins();

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

    r3157 r3160  
    66#endif
    77
    8 class TObject;
    9 class TH1F;
    10 class MBinning;
    118class MHPedestalPix : public MHGausEvents
    129{
    … …  
    2421  Int_t fPixId;                  // Pixel Nr
    2522
    26   Int_t fTotalEntries;
    27 
    2823public:
    2924
    30   MHPedestalPix();
     25  MHPedestalPix(const char *name=NULL, const char *title=NULL);
    3126  ~MHPedestalPix();
    3227
    … …  
    3833  void SetChargeLast( const Axis_t last =fgChargeLast)     { fChargeLast  = last; }
    3934 
    40   // Getters
    41   const Int_t GetTotalEntries() const   { return fTotalEntries;    }     
    42 
    4335  // Others
    4436  void ChangeHistId(Int_t i);

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

    r3064 r3160  
    4141#include "MParList.h"
    4242
    43 #include "MExtractedSignalCam.h"
    44 #include "MExtractedSignalPix.h"
    45 
    4643#include "MGeomCam.h"
    4744
    … …  
    5047using namespace std;
    5148
    52 const UInt_t MPedestalCam::gkBlindPixelId = 559;
    5349// --------------------------------------------------------------------------
    5450//
    … …  
    5652//
    5753MPedestalCam::MPedestalCam(const char *name, const char *title)
    58     : fTotalEntries(0), fExtractSlices(0.)
     54    : fTotalEntries(0)
    5955{
    6056    fName  = name  ? name  : "MPedestalCam";
    … …  
    6359    fArray = new TClonesArray("MPedestalPix", 1);
    6460   
    65     //
    66     // loop over all Pixels and create two histograms
    67     // one for the Low and one for the High gain
    68     // connect all the histogram with the container fHist
    69     //
    70     fHArray = new TObjArray;
    71     fHArray->SetOwner();
    72 
    7361}
    7462
    … …  
    8068{
    8169  delete fArray;
    82   delete fHArray;
    8370}
    8471
    … …  
    10491}
    10592
    106 Int_t MPedestalCam::GetHistSize() const
    107 {
    108   return fHArray->GetEntriesFast();
    109 }
    110 
    111 
    11293// --------------------------------------------------------------------------
    11394//
    … …  
    123104// Get i-th pixel (pixel number)
    124105//
    125 MPedestalPix &MPedestalCam::operator[](Int_t i) const
     106const MPedestalPix &MPedestalCam::operator[](Int_t i) const
    126107{
    127108  return *static_cast<MPedestalPix*>(fArray->UncheckedAt(i));
    128109}
    129110
    130 // --------------------------------------------------------------------------
    131 //
    132 // Get i-th pixel (pixel number)
    133 //
    134 MHPedestalPixel &MPedestalCam::operator()(UInt_t i)
    135 {
    136   return *static_cast<MHPedestalPixel*>(fHArray->UncheckedAt(i));
    137 }
    138 
    139 // --------------------------------------------------------------------------
    140 //
    141 // Get i-th pixel (pixel number)
    142 //
    143 MHPedestalPixel &MPedestalCam::operator()(UInt_t i) const
    144 {
    145   return *static_cast<MHPedestalPixel*>(fHArray->UncheckedAt(i));
    146 }
    147 
    148 
    149111// -------------------------------------------------------------------------
    150112//
    … …  
    155117
    156118    fTotalEntries     = 0;
    157     fExtractSlices    = 0.;
    158 }
    159 
    160 
    161 // --------------------------------------------------------------------------
    162 //
    163 // Our own clone function is necessary since root 3.01/06 or Mars 0.4
    164 // I don't know the reason
    165 //
    166 TObject *MPedestalCam::Clone(const char *) const
    167 {
    168 
    169   const Int_t n1 = fArray->GetSize();
    170   const Int_t n2 = fHArray->GetSize();
    171  
    172   //
    173   // FIXME, this might be done faster and more elegant, by direct copy.
    174   //
    175   MPedestalCam *cam = new MPedestalCam;
    176  
    177   cam->fArray->Expand(n1);
    178   cam->fHArray->Expand(n2);
    179  
    180   for (int i=0; i<n1; i++)
    181     {
    182       delete (*cam->fArray)[i];
    183       (*cam->fArray)[i] = (*fArray)[i]->Clone();
    184     }
    185 
    186   for (int i=0; i<n2; i++)
    187     {
    188       delete (*cam->fHArray)[i];
    189       (*cam->fHArray)[i] = (*fHArray)[i]->Clone();
    190     }
    191   return cam;
    192 }
    193 
    194 
    195 
    196 // --------------------------------------------------------------------------
    197 //
    198 // To setup the object we get the number of pixels from a MGeomCam object
    199 // in the Parameter list.
    200 // MPedestalPix sets its parameters to 0. (other than default which is -1.)
    201 //
    202 Bool_t MPedestalCam::SetupFill(const MParList *pList)
    203 {
    204 
    205   fHArray->Delete();
    206 
    207   return kTRUE;
    208 
    209 }
    210 
    211 // --------------------------------------------------------------------------
    212 //
    213 Bool_t MPedestalCam::Fill(const MParContainer *par, const Stat_t w)
    214 {
    215 
    216   MExtractedSignalCam *signal = (MExtractedSignalCam*)par;
    217   if (!signal)
    218     {
    219       gLog << err << "No argument in MExtractedSignalCam::Fill... abort." << endl;
    220       return kFALSE;
    221     }
    222  
    223 
    224   Float_t slices = (Float_t)signal->GetNumUsedFADCSlices();
    225 
    226   if (slices == 0.)
    227     {
    228       gLog << err << "Number of used signal slices in MExtractedSignalCam is zero  ... abort."
    229            << endl;
    230       return kFALSE;
    231     }
    232 
    233   if (fExtractSlices != 0. && slices != fExtractSlices )
    234     {
    235       gLog << err << "Number of used signal slices changed in MExtractedSignalCam  ... abort."
    236            << endl;
    237       return kFALSE;
    238     }
    239 
    240   fExtractSlices = slices;
    241 
    242   const Int_t n = signal->GetSize();
    243  
    244   if (fHArray->GetEntries()==0)
    245     {
    246       fHArray->Expand(n);
    247      
    248       for (Int_t i=0; i<n; i++)
    249         {
    250           (*fHArray)[i] = new MHPedestalPixel;
    251           MHPedestalPixel &hist = (*this)(i);
    252           hist.ChangeHistId(i);
    253           MPedestalPix &pix = (*this)[i];
    254           pix.InitUseHists();
    255         }
    256     }
    257  
    258   if (fHArray->GetEntries() != n)
    259     {
    260       gLog << err << "ERROR - Size mismatch... abort." << endl;
    261       return kFALSE;
    262     }
    263  
    264   for (Int_t i=0; i<n; i++)
    265     {
    266 
    267       const MExtractedSignalPix &pix = (*signal)[i];
    268      
    269       const Float_t sig = pix.GetExtractedSignalHiGain();
    270 
    271       MHPedestalPixel &hist = (*this)(i);
    272       //
    273       // Don't fill signal per slice, we get completely screwed up
    274       // with the sigma. Better fill like it is and renorm later
    275       //
    276       //      const Float_t sigPerSlice = sig/fExtractSlices;
    277       //      hist.FillCharge(sigPerSlice);
    278       //      hist.FillChargevsN(sigPerSlice);
    279       const Float_t signal = sig;
    280       hist.FillCharge(signal);
    281       hist.FillChargevsN(signal);
    282     }
    283  
    284   return kTRUE;
    285 }
    286 
    287 Bool_t MPedestalCam::Finalize()
    288 {
    289     for (Int_t i=0; i<fHArray->GetSize(); i++)
    290     {
    291 
    292         MHPedestalPixel &hist = (*this)(i);
    293 
    294         //
    295         // 1) Return if the charge distribution is already succesfully fitted
    296         //    or if the histogram is empty
    297         //
    298         if (hist.IsFitOK() || hist.IsEmpty())
    299             continue;
    300 
    301         hist.CutAllEdges();
    302      
    303         //
    304         // 2) Fit the Hi Gain histograms with a Gaussian
    305         //
    306         hist.FitCharge();
    307         hist.Renorm(fExtractSlices);
    308 
    309     }
    310     return kTRUE;
    311 }
     119}
     120
    312121
    313122
    … …  
    381190    return kFALSE;
    382191
    383   if (!(*this)[idx].IsValid())
    384     return kFALSE;
    385 
    386   if ((UInt_t)idx == gkBlindPixelId)
    387     return kFALSE;
    388 
    389192  const Float_t ped      = (*this)[idx].GetPedestal();
    390193  const Float_t rms      = (*this)[idx].GetPedestalRms();
    391194
    392195  const Float_t pederr   = rms/TMath::Sqrt((Float_t)fTotalEntries);
    393   const Float_t rmserr   = rms/TMath::Sqrt((Float_t)fTotalEntries*2.);
    394 
    395   Float_t mean     = 0.;
    396   Float_t meanerr  = 0.;
    397   Float_t sigma    = 0.;
    398   Float_t sigmaerr = 0.;
    399   Float_t prob     = 0.;
    400  
    401   if (type > 3)
    402     if (GetHistSize() != 0)
    403       {
    404         if (!(*this)(idx).IsFitOK())
    405           return kFALSE;
    406 
    407         const MHPedestalPixel &hist = (*this)(idx);
    408         mean     = hist.GetChargeMean();
    409         meanerr  = hist.GetChargeMeanErr();
    410         sigma    = hist.GetChargeSigma() ;
    411         sigmaerr = hist.GetChargeSigmaErr();
    412         prob     = hist.GetChargeProb();
    413       }
    414     else
    415       return kFALSE;
     196  const Float_t rmserr   = rms/TMath::Sqrt((Float_t)fTotalEntries)/2.;
    416197
    417198  switch (type)
    … …  
    429210      val = rmserr;
    430211      break;
    431     case 4:
    432       if (!(*this)(idx).IsFitOK())
    433         return kFALSE;
    434       val = mean;
    435       break;
    436     case 5:
    437       if (!(*this)(idx).IsFitOK())
    438         return kFALSE;
    439       val = meanerr;
    440       break;
    441     case 6:
    442       if (!(*this)(idx).IsFitOK())
    443         return kFALSE;
    444       val = sigma;
    445       break;
    446     case 7:
    447       if (!(*this)(idx).IsFitOK())
    448         return kFALSE;
    449       val = sigmaerr;
    450       break;
    451     case 8:
    452       if (!(*this)(idx).IsFitOK())
    453         return kFALSE;
    454       val = prob;
    455       break;
    456     case 9:
    457       if (!(*this)(idx).IsFitOK())
    458         return kFALSE;
    459       val = 2.*(ped-mean)/(ped+mean);
    460       break;
    461     case 10:
    462       if (!(*this)(idx).IsFitOK())
    463         return kFALSE;
    464       val = TMath::Sqrt((pederr*pederr + meanerr*meanerr) * (ped*ped + mean*mean))
    465             *2./(ped+mean)/(ped+mean);
    466       break;
    467     case 11:
    468       if (!(*this)(idx).IsFitOK())
    469         return kFALSE;
    470       val = 2.*(pederr - meanerr)/(pederr + meanerr);
    471       break;
    472     case 12:
    473       if (!(*this)(idx).IsFitOK())
    474         return kFALSE;
    475       val = 2.*(sigma-rms)/(sigma+rms);
    476       break;
    477     case 13:
    478       if (!(*this)(idx).IsFitOK())
    479         return kFALSE;
    480       val = TMath::Sqrt((rmserr*rmserr + sigmaerr*sigmaerr) * (rms*rms + sigma*sigma))
    481             *2./(rms+sigma)/(rms+sigma);
    482       break;
    483     case 14:
    484       if (!(*this)(idx).IsFitOK())
    485         return kFALSE;
    486       val = 2.*(sigmaerr - rmserr)/(sigmaerr + rmserr);
    487       break;
    488212    default:
    489213      return kFALSE;
    … …  
    494218void MPedestalCam::DrawPixelContent(Int_t idx) const
    495219{
    496   (*this)(idx).Draw();
    497 }
     220  *fLog << warn << "MPedestalCam::DrawPixelContent - not available." << endl;
     221}

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

    r3034 r3160  
    22#define MARS_MPedestalCam
    33
    4 #ifndef ROOT_TObjArray
    5 #include <TObjArray.h>
    6 #endif
    7 
    8 #ifndef MARS_MH
    9 #include "MH.h"
    10 #endif
    114#ifndef MARS_MParContainer
    125#include "MParContainer.h"
    … …  
    2013class MGeomCam;
    2114class MPedestalPix;
    22 class MHPedestalPixel;
    23 
    24 class MPedestalCam : public MH, public MCamEvent
     15class MPedestalCam : public MCamEvent, public MParContainer
    2516{
    2617
    27  private:
     18private:
    2819
    29   static const UInt_t gkBlindPixelId;
    30  
    3120  TClonesArray *fArray;  // FIXME: Change TClonesArray away from a pointer?
    3221 
    33   TObjArray    *fHArray; //-> List of Lo/Hi gain Histograms
    34  
    3522  ULong_t fTotalEntries;
    36   Float_t fExtractSlices;
    3723 
    3824public:
    … …  
    4531 
    4632  MPedestalPix &operator[](Int_t i);
    47   MPedestalPix &operator[](Int_t i) const;
    48  
    49   MHPedestalPixel &operator()(UInt_t i);
    50   MHPedestalPixel &operator()(UInt_t i) const;
    51  
    52   Bool_t SetupFill(const MParList *pList);
    53   Bool_t Fill(const MParContainer *par, const Stat_t w=1);
    54   Bool_t Finalize();
    55  
    56   TObject *Clone(const char *) const;
    57  
     33  const MPedestalPix &operator[](Int_t i) const;
     34
    5835  // Setters
    59   void SetTotalEntries(ULong_t n)    { fTotalEntries = n; }
     36  void SetTotalEntries(const ULong_t n)    { fTotalEntries = n; }
    6037
    6138  // Getters
    6239  Int_t   GetSize()                          const;
    63   Int_t   GetHistSize()                      const; 
    6440  ULong_t GetTotalEntries()                  const { return fTotalEntries; }
     41
    6542  Float_t GetPedestalMin(const MGeomCam *cam) const;
    6643  Float_t GetPedestalMax(const MGeomCam *cam) const;

  • trunk/MagicSoft/Mars/manalysis/Makefile

    r3101 r3160  
    3333
    3434SRCFILES = MPedestalPix.cc \
    35            MHPedestalPixel.cc \
     35           MHPedestalPix.cc \
    3636           MPedestalCam.cc \
     37           MHPedestalCam.cc \
    3738           MPedPhotPix.cc \
    3839           MPedPhotCam.cc \
Note: See TracChangeset for help on using the changeset viewer.