Changeset 3614


Ignore:
Timestamp:
03/30/04 22:48:35 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r3613 r3614  
    2525   * mcalib/MHCalibrationChargeHiGainPix.[h,cc]
    2626   * mcalib/MHCalibrationChargeLoGainPix.[h,cc]
     27   * mcalib/MHCalibrationChargeBlindPix.[h,cc]
    2728     - updated and enlarged documentation
    2829

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

    r3551 r3614  
    2727//  MHCalibrationChargeBlindPix
    2828//
    29 //  Performs all the Single Photo-Electron Fit to extract
    30 //  the mean number of photons and to derive the light flux
    31 //
    32 // The fit result is accepted under condition that:
    33 // 1) the Probability is greater than gkProbLimit (default 0.001 == 99.7%)
    34 // 2) at least 100 events are in the single Photo-electron peak
    35 //
    36 // Used numbers are the following:
    37 //
    38 // Electronic conversion factor:
     29//  Histogram container for the calibration Blind Pixel information
     30//  Performs the Single Photo-electron fit to extract the Poisson mean and its errors
     31//
     32//  Different fits can be chosen with the function ChangeFitFunc()
     33//
     34//  The fit result is accepted under condition that:
     35//  1) the Probability is greater than fProbLimit (default 0.001 == 99.7%)
     36//  2) at least fNumSinglePheLimit events are found in the single Photo-electron peak
     37//
     38//  The single FADC slice entries are averaged and stored in fASinglePheFADCSlices, if
     39//  their sum exceeds fSinglePheCut, otherwise in fAPedestalFADCSlices.
     40//
     41//  Used numbers are the following:
     42//
     43//  Electronic conversion factor:
    3944//   Assume, we have N_e electrons at the anode,
    4045//   thus a charge of N_e*e (e = electron charge) Coulomb.
    … …  
    9297const Axis_t   MHCalibrationChargeBlindPix::fgChargeFirst        = -100.5;
    9398const Axis_t   MHCalibrationChargeBlindPix::fgChargeLast         = 5199.5;
    94 
    9599const Float_t  MHCalibrationChargeBlindPix::fgSinglePheCut       = 200.;
    96100const Float_t  MHCalibrationChargeBlindPix::fgNumSinglePheLimit  =  50.;
    … …  
    99103// Default Constructor.
    100104//
     105// Sets:
     106// - the default number for fChargeNbins  (fgChargeNbins)
     107// - the default number for fChargeFirst  (fgChargeFirst)
     108// - the default number for fChargeLast   (fgChargeLast)
     109// - the default number for fSinglePheCut (fgSingePheCut)
     110// - the default number for fNumSinglePheLimit (fgNumSinglePheLimit)
     111//
     112// - the default name of the  fHGausHist ("HCalibrationChargeBlindPix")
     113// - the default title of the fHGausHist ("Distribution of Summed FADC slices Blind Pixel ")
     114// - the default x-axis title for fHGausHist ("Sum FADC Slices")
     115// - the default y-axis title for fHGausHist ("Nr. of events")
     116//
     117// Initializes:
     118// - all pointers to NULL
     119// - all variables to 0., except the fit result variables to -999.
     120// - all flags to kFALSE
     121// - the default Fit function to kEPoisson5
     122//
    101123MHCalibrationChargeBlindPix::MHCalibrationChargeBlindPix(const char *name, const char *title)
    102     :  fBlindPix(NULL), fSignal(NULL),  fRawEvt(NULL),
    103        fASinglePheFADCSlices(30), fAPedestalFADCSlices(30),
     124    :  fBlindPix(NULL), fSignal(NULL), fRawEvt(NULL),
    104125       fSinglePheFit(NULL),
    105126       fFitLegend(NULL),
    … …  
    127148}
    128149
     150// --------------------------------------------------------------------------
     151//
     152// Default Destructor.
     153//
     154// Deletes (if Pointer is not NULL):
     155//
     156// - fSinglePheFit
     157// - fFitLegend
     158// - fHSinglePheFADCSlices
     159// - fHPedestalFADCSlices   
     160//
    129161MHCalibrationChargeBlindPix::~MHCalibrationChargeBlindPix()
    130162{
    … …  
    144176}
    145177
     178// --------------------------------------------------------------------------
     179//
     180// Sets:
     181// - fHGausHist.SetBins(fChargeNbins,fChargeFirst,fChargeLast);
     182//
    146183void MHCalibrationChargeBlindPix::Init()
    147184{
    148 
    149185  fHGausHist.SetBins( fChargeNbins, fChargeFirst, fChargeLast);
    150186}
    151187
     188// --------------------------------------------------------------------------
     189//
     190// Sets:
     191// - all variables to 0., except the fit result variables to -999.
     192// - all flags to kFALSE
     193// - all pointers to NULL
     194//
     195// Deletes:
     196// - all pointers unequal NULL
     197//
     198// Executes MHCalibrationChargePix::Clear()
     199//
    152200void MHCalibrationChargeBlindPix::Clear(Option_t *o)
    153201{
    … …  
    168216  fLambdaCheckErr = -999.;
    169217 
    170   fMeanPedestal     = 0.;
    171   fMeanPedestalErr  = 0.;
    172   fSigmaPedestal    = 0.;
    173   fSigmaPedestalErr = 0.;
    174 
    175218  fFitFunc = kEPoisson5;
    176 
    177   fExtractSlices    = 0;
    178   fNumSinglePhes    = 0;
    179   fNumPedestals     = 0;
    180219
    181220  fNumSinglePhes    = 0;
    … …  
    238277}
    239278 
     279// --------------------------------------------------------------------------
     280//
     281// Gets the pointers to:
     282// - MRawEvtData
     283// - MExtractedSignalBlindPixel
     284//
     285// Initializes:
     286// - fASinglePheFADCSlices(0);
     287// - fAPedestalFADCSlices(0);
     288//
     289// Calls Init()
     290//
    240291Bool_t MHCalibrationChargeBlindPix::SetupFill(const MParList *pList)
    241292{
    242    fRawEvt = (MRawEvtData*)pList->FindObject("MRawEvtData");
    243     if (!fRawEvt)
     293
     294  fRawEvt = (MRawEvtData*)pList->FindObject("MRawEvtData");
     295  if (!fRawEvt)
    244296    {
    245297      *fLog << err << "MRawEvtData not found... aborting." << endl;
    246298      return kFALSE;
    247299    }
    248 
     300 
    249301  fSignal  = (MExtractedSignalBlindPixel*)pList->FindObject("MExtractedSignalBlindPixel");
    250302  if (!fSignal)
    251   {
     303    {
    252304      *fLog << err << "MExtractedSignalBlindPixel not found... aborting " << endl;
    253305      return kFALSE;
    254   }
    255 
     306    }
     307 
     308  fASinglePheFADCSlices(0);
     309  fAPedestalFADCSlices(0);
     310 
    256311  Init();
    257312 
    … …  
    259314}
    260315
     316// --------------------------------------------------------------------------
     317//
     318// Gets or creates the pointers to:
     319// - MCalibrationChargeBlindPix
     320//
     321// Resizes:
     322// - fASinglePheFADCSlices to sum of HiGain and LoGain samples
     323// - fAPedestalFADCSlices to sum of HiGain and LoGain samples
     324//
    261325Bool_t MHCalibrationChargeBlindPix::ReInit(MParList *pList)
    262326{
    … …  
    266330      return kFALSE;
    267331
     332  Int_t samples = (Int_t)fRawEvt->GetNumHiGainSamples()+(Int_t)fRawEvt->GetNumLoGainSamples();
     333
     334  if (fASinglePheFADCSlices.GetNrows() != samples)
     335    {
     336      fASinglePheFADCSlices.ResizeTo(samples);
     337      fAPedestalFADCSlices.ResizeTo(samples);
     338    }
     339 
     340
    268341  return kTRUE;
    269342}
    270343
     344// --------------------------------------------------------------------------
     345//
     346// Retrieves from MExtractedSignalBlindPixel:
     347// - number of FADC samples
     348// - extracted signal
     349// - blind Pixel ID
     350//
     351// Executes MHGausEvents::FillHistAndArray(signal)
     352//
     353// Creates MRawEvtPixelIter, jumps to blind pixel ID,
     354// fills the vectors fASinglePheFADCSlices and fAPedestalFADCSlices
     355// with the full FADC slices, depending on the size of the signal w.r.t. fSinglePheCut
     356//
    271357Bool_t MHCalibrationChargeBlindPix::Fill(const MParContainer *par, const Stat_t w)
    272358{
    … …  
    281367    }
    282368 
    283   if (fExtractSlices != 0. && slices != fExtractSlices )
    284     {
    285       *fLog << err << "Number of used signal slices changed in MExtractedSignalCam  ... abort."
    286             << endl;
    287       return kFALSE;
    288     }
    289   fExtractSlices = slices;
    290 
    291369  //
    292370  // Signal extraction and histogram filling
    … …  
    298376  // IN order to study the single-phe posistion, we extract the slices
    299377  //
     378  const Int_t blindpixIdx = fSignal->GetBlindPixelIdx();
     379
    300380  MRawEvtPixelIter pixel(fRawEvt);
    301   pixel.Jump(fSignal->GetBlindPixelIdx());
     381  pixel.Jump(blindpixIdx);
    302382
    303383  if (signal > fSinglePheCut)
    … …  
    309389}
    310390
     391// --------------------------------------------------------------------------
     392//
     393// Returns kFALSE, if empty
     394//
     395// - Creates the fourier spectrum and sets bit IsFourierSpectrumOK()
     396// - Retrieves the pedestals from MExtractedSignalBlindPixel
     397// - Normalizes fASinglePheFADCSlices and fAPedestalFADCSlices
     398// - Executes FitPedestal()
     399// - Executes FitSinglePhe()
     400// - Retrieves fit results and stores them in MCalibrationChargeBlindPix
     401//
    311402Bool_t MHCalibrationChargeBlindPix::Finalize()
    312403{
    … …  
    355446}
    356447
     448
     449// --------------------------------------------------------------------------
     450//
     451// Checks again for the size and fills fASinglePheFADCSlices with the FADC slice entries
     452//
    357453void MHCalibrationChargeBlindPix::FillSinglePheFADCSlices(const MRawEvtPixelIter &iter)
    358454{
    … …  
    380476}
    381477
     478// --------------------------------------------------------------------------
     479//
     480// Checks again for the size and fills fAPedestalFADCSlices with the FADC slice entries
     481//
    382482void MHCalibrationChargeBlindPix::FillPedestalFADCSlices(const MRawEvtPixelIter &iter)
    383483{
    … …  
    405505
    406506
    407 
     507// --------------------------------------------------------------------------
     508//
     509// Task to simulate single phe spectrum with the given parameters
     510//
    408511Bool_t MHCalibrationChargeBlindPix::SimulateSinglePhe(Double_t lambda, Double_t mu0, Double_t mu1, Double_t sigma0, Double_t sigma1)
    409512{
    … …  
    427530}
    428531
     532// --------------------------------------------------------------------------
     533//
     534// - Get the ranges from the stripped histogram
     535// - choose reasonable start values for the fit
     536// - initialize the fit function depending on fFitFunc
     537// - initialize parameter names and limits depending on fFitFunc
     538//
    429539Bool_t MHCalibrationChargeBlindPix::InitFit()
    430540{
    … …  
    570680}
    571681
     682// --------------------------------------------------------------------------
     683//
     684// - Retrieve the parameters depending on fFitFunc
     685// - Retrieve probability, Chisquare and NDF
     686//
    572687void MHCalibrationChargeBlindPix::ExitFit()
    573688{
    … …  
    623738}
    624739
    625 
     740// --------------------------------------------------------------------------
     741//
     742// - Executes InitFit()
     743// - Fits the fHGausHist with fSinglePheFit
     744// - Executes ExitFit()
     745//
     746// The fit result is accepted under condition:
     747// 1) The results are not nan's
     748// 2) The NDF is not smaller than fNDFLimit (5)
     749// 3) The Probability is greater than fProbLimit (default 0.001 == 99.9%)
     750// 4) at least fNumSinglePheLimit events are in the single Photo-electron peak
     751//
    626752Bool_t MHCalibrationChargeBlindPix::FitSinglePhe(Option_t *opt)
    627753{
    … …  
    640766  // 3) The Probability is greater than fProbLimit (default 0.001 == 99.9%)
    641767  // 4) at least fNumSinglePheLimit events are in the single Photo-electron peak
     768  //
    642769  if (   TMath::IsNaN(fLambda)
    643770      || TMath::IsNaN(fLambdaErr)
    … …  
    671798}
    672799
     800// --------------------------------------------------------------------------
     801//
     802// - Retrieves limits for the fit
     803// - Fits the fHGausHist with Gauss
     804// - Retrieves the results to fLambdaCheck and fLambdaCheckErr
     805// - Sets a flag IsPedestalFitOK()
     806//
    673807void MHCalibrationChargeBlindPix::FitPedestal  (Option_t *opt)
    674808{
    … …  
    777911// Draw the histogram
    778912//
     913// The following options can be chosen:
     914//
     915// "": displays the fHGausHist, the legend and fASinglePheFADCSlices and fAPedestalFADCSlices
     916// "all": executes additionally MHGausEvents::Draw(), with option "fourierevents"
     917//
    779918void MHCalibrationChargeBlindPix::Draw(Option_t *opt)
    780919{

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

    r3289 r3614  
    2727private:
    2828
    29   MCalibrationChargeBlindPix *fBlindPix;  //! Storage container of the results 
    30   MExtractedSignalBlindPixel *fSignal;    //! Storage container of the extracted signal
    31   MRawEvtData                *fRawEvt;    //! Storage container of the raw data
    32 
    33   static const Int_t    fgChargeNbins;
    34   static const Axis_t   fgChargeFirst;
    35   static const Axis_t   fgChargeLast; 
    36 
    37   static const Float_t  fgSinglePheCut; 
    38 
    39   static const Float_t  fgNumSinglePheLimit;
    40 
    41   static const Double_t gkElectronicAmp;
    42   static const Double_t gkElectronicAmpErr;
    43 
    44   TVector fASinglePheFADCSlices;           // Array containing the averaged FADC slice entries for the supposed single-phe events
    45   TVector fAPedestalFADCSlices;            // Array containing the averaged FADC slice entries for the supposed pedestal   events
    46 
    47   TF1 *fSinglePheFit;                      //-> Single Phe Fit (Gaussians convoluted with Poisson) (needs to be a pointer, initialized later)
    48 
    49   UInt_t  fNumSinglePhes;
    50   UInt_t  fNumPedestals;
    51 
    52   Float_t fSinglePheCut; 
    53 
    54   Float_t fNumSinglePheLimit;
    55 
    56   Double_t  fLambda;
    57   Double_t  fMu0;
    58   Double_t  fMu1;
    59   Double_t  fSigma0;
    60   Double_t  fSigma1;
    61 
    62   Double_t  fLambdaErr;
    63   Double_t  fMu0Err;
    64   Double_t  fMu1Err;
    65   Double_t  fSigma0Err;
    66   Double_t  fSigma1Err;
    67 
    68   Double_t  fLambdaCheck;
    69   Double_t  fLambdaCheckErr;
    70 
    71   Double_t  fChisquare;
    72   Int_t     fNDF;
    73   Double_t  fProb;
    74 
    75   Double_t  fMeanPedestal;
    76   Double_t  fMeanPedestalErr;
    77   Double_t  fSigmaPedestal;
    78   Double_t  fSigmaPedestalErr;
    79 
    80   Float_t   fExtractSlices;
    81 
    82   Byte_t    fFlags;
    83 
    84   enum { kSinglePheFitOK, kPedestalFitOK };
    85 
    86   TPaveText *fFitLegend;                        //!
    87   TH1F      *fHSinglePheFADCSlices;             //!
    88   TH1F      *fHPedestalFADCSlices;              //!
    89 
     29  static const Int_t    fgChargeNbins;       // Default for fChargeNBins  (now set to: 5300   )
     30  static const Axis_t   fgChargeFirst;       // Default for fChargeFirst  (now set to: -100.5 )
     31  static const Axis_t   fgChargeLast;        // Default for fChargeLast   (now set to: 5199.5 )
     32  static const Float_t  fgSinglePheCut;      // Default for fSinglePheCut (now set to: 200   )
     33  static const Float_t  fgNumSinglePheLimit; // Default for fNumSinglePheLimit (now set to: 50  )
     34
     35  static const Double_t gkElectronicAmp;     // Electronic Amplification after the PMT (in FADC counts/N_e)
     36  static const Double_t gkElectronicAmpErr;  // Error of the electronic amplification
     37
     38  Float_t fSinglePheCut;                     // Value of summed FADC slices upon which event considered as single-phe
     39  Float_t fNumSinglePheLimit;                // Minimum number of single-phe events
     40
     41  MCalibrationChargeBlindPix *fBlindPix;     //! Storage container results 
     42  MExtractedSignalBlindPixel *fSignal;       //! Storage container extracted signal
     43  MRawEvtData                *fRawEvt;       //! Storage container raw data
     44 
     45  TVector fASinglePheFADCSlices;             // Averaged FADC slice entries supposed single-phe events
     46  TVector fAPedestalFADCSlices;              // Averaged FADC slice entries supposed pedestal   events
     47 
     48  TF1 *fSinglePheFit;                        //-> Single Phe Fit (Gaussians convoluted with Poisson)
     49
     50  UInt_t  fNumSinglePhes;                    // Number of entries in fASinglePheFADCSlices
     51  UInt_t  fNumPedestals;                     // Number of entries in fAPedestalFADCSlices
     52
     53  Double_t  fLambda;                         // Poisson mean from Single-phe fit
     54  Double_t  fLambdaCheck;                    // Poisson mean from Pedestal fit alone
     55  Double_t  fMu0;                            // Mean of the pedestal
     56  Double_t  fMu1;                            // Mean of single-phe peak
     57  Double_t  fSigma0;                         // Sigma of the pedestal
     58  Double_t  fSigma1;                         // Sigma of single-phe peak
     59
     60  Double_t  fLambdaErr;                      // Error of Poisson mean from Single-phe fit
     61  Double_t  fLambdaCheckErr;                 // Error of Poisson mean from Pedestal fit alone
     62  Double_t  fMu0Err;                         // Error of  Mean of the pedestal   
     63  Double_t  fMu1Err;                         // Error of  Mean of single-phe peak
     64  Double_t  fSigma0Err;                      // Error of  Sigma of the pedestal   
     65  Double_t  fSigma1Err;                      // Error of  Sigma of single-phe peak
     66 
     67  Double_t  fChisquare;                      // Chisquare of single-phe fit
     68  Int_t     fNDF;                            // Ndof of single-phe fit
     69  Double_t  fProb;                           // Probability of singleo-phe fit
     70 
     71  Double_t  fMeanPedestal;                   // Mean pedestal from pedestal run
     72  Double_t  fSigmaPedestal;                  // Sigma pedestal from pedestal run
     73
     74  Double_t  fMeanPedestalErr;                // Error of Mean pedestal from pedestal run
     75  Double_t  fSigmaPedestalErr;               // Error of Sigma pedestal from pedestal run
     76
     77  Byte_t    fFlags;                          // Bit-field for the flags
     78  enum { kSinglePheFitOK, kPedestalFitOK };  // Possible bits to be set
     79
     80  TPaveText *fFitLegend;                     //! Some legend to display the fit results
     81  TH1F      *fHSinglePheFADCSlices;          //! A histogram created and deleted only in Draw()
     82  TH1F      *fHPedestalFADCSlices;           //! A histogram created and deleted only in Draw()
    9083
    9184  // Fill histos
    … …  
    117110  void SetNumSinglePheLimit ( const Float_t lim =fgNumSinglePheLimit )    { fNumSinglePheLimit = lim;      }
    118111
    119   void SetMeanPedestal     ( const Float_t f )   { fMeanPedestal     = f;  }
    120   void SetMeanPedestalErr  ( const Float_t f )   { fMeanPedestalErr  = f;  }
    121   void SetSigmaPedestal    ( const Float_t f )   { fSigmaPedestal    = f;  }
    122   void SetSigmaPedestalErr ( const Float_t f )   { fSigmaPedestalErr = f;  }
    123 
    124   void SetSinglePheFitOK   ( const Bool_t b=kTRUE);
    125   void SetPedestalFitOK( const Bool_t b=kTRUE);
     112  void SetMeanPedestal      ( const Float_t f )   { fMeanPedestal     = f;  }
     113  void SetMeanPedestalErr   ( const Float_t f )   { fMeanPedestalErr  = f;  }
     114  void SetSigmaPedestal     ( const Float_t f )   { fSigmaPedestal    = f;  }
     115  void SetSigmaPedestalErr  ( const Float_t f )   { fSigmaPedestalErr = f;  }
     116
     117  void SetSinglePheFitOK    ( const Bool_t b=kTRUE);
     118  void SetPedestalFitOK     ( const Bool_t b=kTRUE);
    126119 
    127120  // Getters
    … …  
    140133  const Double_t GetSigma1Err()      const { return fSigma1Err;      }
    141134
    142   TVector &GetASinglePheFADCSlices()                { return fASinglePheFADCSlices;  }
    143   const TVector &GetASinglePheFADCSlices()    const { return fASinglePheFADCSlices;  }
    144 
    145   TVector &GetAPedestalFADCSlices()                 { return fAPedestalFADCSlices;  } 
    146   const TVector &GetAPedestalFADCSlices()     const { return fAPedestalFADCSlices;  } 
    147 
    148   const Bool_t  IsSinglePheFitOK()     const;
    149   const Bool_t  IsPedestalFitOK()  const;
     135  TVector &GetASinglePheFADCSlices()             { return fASinglePheFADCSlices;  }
     136  const TVector &GetASinglePheFADCSlices() const { return fASinglePheFADCSlices;  }
     137
     138  TVector &GetAPedestalFADCSlices()              { return fAPedestalFADCSlices;  } 
     139  const TVector &GetAPedestalFADCSlices()  const { return fAPedestalFADCSlices;  } 
     140
     141  const Bool_t  IsSinglePheFitOK()         const;
     142  const Bool_t  IsPedestalFitOK()          const;
    150143 
    151144  // Draws
    … …  
    157150  // Fits
    158151public:
    159   enum FitFunc_t  { kEPoisson4, kEPoisson5, kEPoisson6, kEPoisson7, kEPolya, kEMichele };
     152  enum FitFunc_t  { kEPoisson4, kEPoisson5, kEPoisson6, kEPoisson7, kEPolya, kEMichele }; // The possible fit functions
    160153
    161154private:
    … …  
    166159  void   FitPedestal  (Option_t *opt="RL0+Q");
    167160
    168   void   ChangeFitFunc(FitFunc_t func)                 { fFitFunc = func;  }
     161  void   ChangeFitFunc(const FitFunc_t func)  { fFitFunc = func;  }
    169162 
    170163  // Simulation
    171   Bool_t SimulateSinglePhe(Double_t lambda,
    172                            Double_t mu0,Double_t mu1,
    173                            Double_t sigma0,Double_t sigma1);
     164  Bool_t SimulateSinglePhe(const Double_t lambda,
     165                           const Double_t mu0,    const Double_t mu1,
     166                           const Double_t sigma0, const Double_t sigma1);
    174167 
    175168private:
    176 
    177   const static Double_t fNoWay = 10000000000.0;
    178169
    179170  inline static Double_t fFitFuncMichele(Double_t *x, Double_t *par)
    … …  
    194185     
    195186      if (mu1cat    < mu0)
    196         return fNoWay;
     187        return FLT_MAX;
    197188
    198189      if (sigma1cat < sigma0)
    199         return fNoWay;
     190        return FLT_MAX;
    200191
    201192      // if (sigma1cat < sigma1dyn)
    … …  
    269260     
    270261      if (mu1 < mu0)
    271         return fNoWay;
     262        return FLT_MAX;
    272263
    273264      Double_t sigma0 = par[3];
    … …  
    275266     
    276267      if (sigma1 < sigma0)
    277         return fNoWay;
     268        return FLT_MAX;
    278269     
    279270      Double_t mu2 = (2.*mu1)-mu0; 
    … …  
    326317     
    327318      if (mu1 < mu0)
    328         return fNoWay;
     319        return FLT_MAX;
    329320     
    330321      Double_t sigma0 = par[3];
    … …  
    332323     
    333324      if (sigma1 < sigma0)
    334         return fNoWay;
     325        return FLT_MAX;
    335326     
    336327     
    … …  
    391382     
    392383      if (mu1 < mu0)
    393         return fNoWay;
     384        return FLT_MAX;
    394385     
    395386      Double_t sigma0 = par[3];
    … …  
    397388     
    398389      if (sigma1 < sigma0)
    399         return fNoWay;
     390        return FLT_MAX;
    400391     
    401392     
    … …  
    515506
    516507 
    517   ClassDef(MHCalibrationChargeBlindPix, 1)  // Histograms from the Calibration Blind Pixel
     508  ClassDef(MHCalibrationChargeBlindPix, 1)  // Histogram class for the Calibration Blind Pixel
    518509};
    519510

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

    r3496 r3614  
    2727//  MHCalibrationChargeLoGainPix
    2828//
    29 //  Performs all the necessary fits to extract the mean number of summed FADC slices
     29//  Store the histogrammed Hi Gain summed FADC slices and the arrival times
    3030//
    3131//////////////////////////////////////////////////////////////////////////////
    … …  
    5959// Default Constructor.
    6060//
     61// Sets:
     62// - the default number for fChargeNbins  (fgChargeNbins)
     63// - the default number for fChargeFirst  (fgChargeFirst)
     64// - the default number for fChargeLast   (fgChargeLast)
     65// - the default number for fAbsTimeNbins (fgAbstTimeNbins)
     66// - the default number for fAbsTimeFirst (fgAbsTimeFirst)
     67// - the default number for fAbsTimeLast  (fgAbsTimeLast)
     68//
     69// - the default name of the  fHGausHist ("HCalibrationChargeLoGainPix")
     70// - the default title of the fHGausHist ("Distribution of Summed Lo Gain FADC slices Pixel ")
     71//
     72// - the default name of the  fHAbsTime ("HAbsTimeLoGainPix")
     73// - the default title of the fHAbsTime ("Distribution of Absolute Arrival Times Lo Gain Pixel ")
     74//
    6175MHCalibrationChargeLoGainPix::MHCalibrationChargeLoGainPix(const char *name, const char *title)
    6276{
     77
    6378  fName  = name  ? name  : "MHCalibrationChargeLoGainPix";
    6479  fTitle = title ? title : "Fill the FADC sums of the Low Gain events and perform the fits Pixel ";

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

    r3346 r3614  
    1111private:
    1212
    13   static const Int_t   fgChargeNbins;
    14   static const Axis_t  fgChargeFirst;
    15   static const Axis_t  fgChargeLast; 
    16 
    17   static const Int_t   fgAbsTimeNbins;
    18   static const Axis_t  fgAbsTimeFirst;
    19   static const Axis_t  fgAbsTimeLast;
     13  static const Int_t   fgChargeNbins;      // Default for fChargeNBins  (now set to: 200   )
     14  static const Axis_t  fgChargeFirst;      // Default for fChargeFirst  (now set to: -0.5  )
     15  static const Axis_t  fgChargeLast;       // Default for fChargeLast   (now set to: 199.5 )
     16  static const Int_t   fgAbsTimeNbins;     // Default for fAbsTimeNbins (now set to: 15    )
     17  static const Axis_t  fgAbsTimeFirst;     // Default for fAbsTimeFirst (now set to: -0.5  )
     18  static const Axis_t  fgAbsTimeLast;      // Default for fAbsTimeLast  (now set to: 14.5  )
    2019
    2120public:
    … …  
    3332  void SetAbsTimeLast (const Axis_t last =fgAbsTimeLast)         { fAbsTimeLast  = last;    }
    3433
    35   ClassDef(MHCalibrationChargeLoGainPix, 1)  // Histogram class for a Calibration Pixel with extracted Low Gain
     34  ClassDef(MHCalibrationChargeLoGainPix, 1)  // Histogram class for Low Gain Part of Calibration Pixel
    3635};
    3736

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

    r3611 r3614  
    278278//
    279279// Fills fHGausHist with f
    280 // Returns kFALSE, if overflow or underflow occurred
     280// Returns kFALSE, if overflow or underflow occurred, else kTRUE
    281281//
    282282Bool_t MHGausEvents::FillHist(const Float_t f)
Note: See TracChangeset for help on using the changeset viewer.