Line data    Source code

       1             : // -*- mode: c++ -*-
       2             : #ifndef ALICALOFITRESULTS_H
       3             : #define ALICALOFITRESULTS_H
       4             : /**************************************************************************
       5             :  * This file is property of and copyright by                              *
       6             :  * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009     *
       7             :  *                                                                        *
       8             :  * Primary Author: Per Thomas Hille <p.t.hille@fys.uio.no>                *
       9             :  *                                                                        *
      10             :  * Contributors are mentioned in the code where appropriate.              *
      11             :  * Please report bugs to p.t.hille@fys.uio.no                             *
      12             :  *                                                                        *
      13             :  * Permission to use, copy, modify and distribute this software and its   *
      14             :  * documentation strictly for non-commercial purposes is hereby granted   *
      15             :  * without fee, provided that the above copyright notice appears in all   *
      16             :  * copies and that both the copyright notice and this permission notice   *
      17             :  * appear in the supporting documentation. The authors make no claims     *
      18             :  * about the suitability of this software for any purpose. It is          *
      19             :  * provided "as is" without express or implied warranty.                  *
      20             :  **************************************************************************/
      21             : 
      22             : #include "Rtypes.h"
      23             : #include "AliCaloFitSubarray.h"
      24             : #include "AliCaloConstants.h"
      25             : 
      26           0 : class  AliCaloFitResults
      27             : {
      28             :  public:
      29             :   //  enum kReturnCode {kFitPar=1, kDummy=-1, kCrude=-9, kNoFit=-99, kInvalid=-9999};// possible return values
      30             :   // kFitPar: method fit or parametrization was used
      31             :   // kDummy: just a filler parameter, if e.g. chi2 not available
      32             :   // kCrude: maximum was used
      33             :   // kNoFit: maximum was used, exception handling for fit invoked
      34             :   // kInvalid: could not even look for maximum
      35             : 
      36             :   
      37             :   explicit AliCaloFitResults( const Int_t maxSig, 
      38             :                               const Float_t ped, 
      39             :                               const Short_t fitStatus, 
      40             :                               const Float_t  amp, 
      41             :                               const double time,
      42             :                               const Int_t maxTimebin,
      43             :                               //   const Float_t chi, 
      44             :                               const Float_t chi,  
      45             :                               const Int_t ndf, 
      46             :                               const Int_t minSig, 
      47             :                               const AliCaloFitSubarray fitSubarray  ); 
      48             :   
      49             : 
      50             :   explicit AliCaloFitResults( const Int_t maxSig, 
      51             :                               const Float_t ped, 
      52             :                               const Short_t fitStatus, 
      53             :                               const Float_t  amp, 
      54             :                               const double time,
      55             :                               const Int_t maxTimebin,
      56             :                               //   const Float_t chi, 
      57             :                               const Float_t chi, 
      58             :                               const Int_t ndf, 
      59             :                               const Int_t minSig = Ret::kDummy);  
      60             :   //                          const Int_t minSig = CaloConstants::ReturnCodes::kDummy); 
      61             : 
      62             : 
      63             :   // shorter interface when no fit is done
      64             : 
      65             :   
      66             :   explicit AliCaloFitResults( const Int_t maxSig, 
      67             :                               const Float_t ped, 
      68             :                               const Short_t fitStatus, 
      69             :                               const Float_t  amp, 
      70             :                               const Int_t maxTimebin); 
      71             :   
      72             : 
      73             :   // minimum interface
      74             :   explicit AliCaloFitResults( const Int_t maxSig, const Int_t minSig );
      75             : 
      76             :   AliCaloFitResults();
      77             :   virtual  ~AliCaloFitResults();
      78           0 :   UShort_t  GetMaxSig() const  { return fMaxSig;};
      79           0 :   Float_t   GetPed() const { return fPed;};
      80           0 :   UShort_t  GetMinSig() const { return fMinSig;};
      81           0 :   Int_t  GetStatus() const  { return fStatus;};
      82         232 :   Float_t   GetAmp() const {  return fAmpSig; };
      83           0 :   Float_t   GetTof() const {  return fTime; }; 
      84         116 :   double   GetTime() const {  return fTime; };
      85           0 :   Int_t   GetMaxTimebin() const {  return fMaxTimebin; };
      86         116 :   Float_t   GetChi2() const { return fChi2Sig;};
      87         116 :   UShort_t  GetNdf() const { return fNdfSig; };
      88           0 :   AliCaloFitSubarray  GetFitSubarray() const { return fFitSubarray; };
      89           0 :   void SetTime(Float_t time ) { fTime = time; };
      90           0 :   void SetAmp(Float_t amp ) { fAmpSig = amp; };
      91             : 
      92             :  private:
      93             :   // AliCaloFitResults();
      94             :   UShort_t   fMaxSig;      //Maximum sample value ( 0 - 1023 )
      95             :   Float_t    fPed;      //Pedestal 
      96             :   Int_t   fStatus;      //Sucess or failure of fitting pocedure
      97             :   Float_t    fAmpSig;   //Amplitude in entities of ADC counts
      98             :   double    fTime;     //peak/max time of signal in entities of sample intervals 
      99             :   Int_t    fMaxTimebin; //timebin with maximum ADC value
     100             :   Float_t    fChi2Sig;  //Chi Square of fit 
     101             :   UShort_t   fNdfSig;      //Number of degrees of freedom of fit
     102             :   UShort_t   fMinSig;      //Pedestal 
     103             :   AliCaloFitSubarray fFitSubarray; // info on time-bin array used for the fitting
     104             : };
     105             : 
     106             : #endif