KVCalibrator.h

#ifndef __KV_CALIBRATOR__
#define __KV_CALIBRATOR__
 
#include "KVBase.h"
#include "TRef.h"
#include "KVDetector.h"
#include "TF1.h"
#include "KVValueRange.h"
 
 
class KVCalibrator: public KVBase {
 
    KVDetector* fDetector;
    TF1* fCalibFunc;
    Bool_t fReady;
    TString fInputSignal;
    TString fOutputSignal;
    Bool_t fUseInverseFunction;
    Double_t fInputMin;
    Double_t fInputMax;
    mutable Bool_t fInversionFail;
 
protected:
   void SetCalibFunction(TF1* f)
   {
      SafeDelete(fCalibFunc);
      fCalibFunc = f;
   }
   TF1* GetCalibFunction() const
   {
      return fCalibFunc;
   }
   Double_t do_inversion(Double_t x) const
   {
 
      int status;
      Double_t res = ProtectedGetX(fCalibFunc, x, status); // fCalibFunc->GetX(x);
      fInversionFail = (status != 0);
      return res;
   }
   bool in_range(double X, double Xmin, double Xmax)
   {
      return (X >= Xmin) && (X <= Xmax);
   }
   void adjust_range_of_inverse_calibration();
public:
   KVCalibrator()
      : KVBase("Calibrator", "KVCalibrator"), fDetector(nullptr), fCalibFunc(nullptr), fReady(kFALSE), fUseInverseFunction(kFALSE), fInputMin(99), fInputMax(-1), fInversionFail(kFALSE) {}
   KVCalibrator(const TString& formula, const TString& type)
      : KVBase("Calibrator", type), fDetector(nullptr), fCalibFunc(new TF1("KVCalibrator::fCalibFunc", formula)), fReady(kFALSE), fUseInverseFunction(kFALSE), fInputMin(99), fInputMax(-1), fInversionFail(kFALSE)
   {
   }
   virtual ~KVCalibrator()
   {
      SafeDelete(fCalibFunc);
   }
 
   Int_t GetNumberParams() const
   {
      return (fCalibFunc ? fCalibFunc->GetNpar() : 0);
   }
   void SetParameter(int i, Double_t par_val) const
   {
      if (fCalibFunc) fCalibFunc->SetParameter(i, par_val);
   }
   Double_t GetParameter(int i) const
   {
      return (fCalibFunc ? fCalibFunc->GetParameter(i) : 0);
   }
   void SetStatus(Bool_t ready)
   {
      fReady = ready;
      if (ready)
         if (IsUseInverseFunction())
            adjust_range_of_inverse_calibration();
   }
   Bool_t GetStatus() const
   {
      return fReady;
   }
   virtual void Print(Option_t* opt = "") const;
   virtual void Reset()
   {
      for (Int_t i = 0; i < GetNumberParams(); i++) {
         SetParameter(i, 0.0);
      }
      SetStatus(kFALSE);
   }
   virtual Double_t Compute(Double_t x, const KVNameValueList&) const
   {
 
      return (fUseInverseFunction ? do_inversion(x) : fCalibFunc->Eval(x));
   }
   virtual Double_t Invert(Double_t x, const KVNameValueList&) const
   {
 
      return (!fUseInverseFunction ? do_inversion(x) : fCalibFunc->Eval(x));
   }
   Double_t operator()(Double_t x, const KVNameValueList& par = "")
   {
      return Compute(x, par);
   }
   virtual Bool_t IsAvailableFor(const KVNameValueList&) const
   {
 
      return kTRUE;
   }
 
   static KVCalibrator* MakeCalibrator(const Char_t* type);
 
   virtual void SetOptions(const KVNameValueList&);
   void SetInputSignalType(const TString& type)
   {
      fInputSignal = type;
   }
   void SetOutputSignalType(const TString& type)
   {
      fOutputSignal = type;
   }
   TString GetInputSignalType() const
   {
      return fInputSignal;
   }
   TString GetOutputSignalType() const
   {
      return fOutputSignal;
   }
   void SetDetector(KVDetector* d)
   {
      fDetector = d;
   }
   KVDetector* GetDetector() const
   {
      return fDetector;
   }
 
   void SetUseInverseFunction(Bool_t yes = kTRUE)
   {
      fUseInverseFunction = yes;
   }
   Bool_t IsUseInverseFunction() const
   {
      return fUseInverseFunction;
   }
   Bool_t InversionFailure() const
   {
      return fInversionFail;
   }
 
   TGraph* GetGraphOfCalibration(int npts,  KVValueRange<double> input_range, const KVNameValueList& par = "");
 
   ClassDef(KVCalibrator, 2)//Base class for calibration of detectors
};
 
#endif