CalibrationClasses.h

Go to the documentation of this file.

#ifndef _CALIB_CLASSES_H_
#define _CALIB_CLASSES_H_
//project includes
#include "NSDPhysicsCalcs.h"
//c++ includes
#include <iostream>
#include <cstdint>
#include <vector>
#include <map>
 
enum CalibType
{
  scalar,
  offset,
  linear,
  quadratic,
};
 
//abstract base class for managing detector calibrations
class DetectorCalib
{
public:
  //default constructor sets the tDiv to 1800;
  DetectorCalib();
  virtual double applyCalib(double a_value) const = 0;
  virtual DetectorCalib* clone() = 0;
  virtual double invertCalib(double a_value) const;
  virtual std::ostream& print( std::ostream& a_stream =std::cout) const;
  CalibType getCalibType();
  void setTime(uint32_t a_t);
  void setTDiv(int a_timeDiv);
  virtual ~DetectorCalib();
protected:
  CalibType m_type;
  uint32_t  m_t;
  int       m_tDiv;
};
class ScalarCalib : public DetectorCalib
{
public:
  ScalarCalib();
  inline double applyCalib(double a_value) const;
 
  void setScalar(double a_scalar);
 
  virtual ScalarCalib* clone();
private:
  double m_scalar;
};
class OffsetCalib : public DetectorCalib
{
public:
  OffsetCalib();
  inline double applyCalib(double a_value) const;
  void setOffset(double a_offset);
  virtual std::ostream& print( std::ostream& a_stream = std::cout) const;
  virtual OffsetCalib* clone();
protected:
  double m_offset;
};
 
class LinearCalib : public DetectorCalib
{
public:
  LinearCalib();
  virtual inline double applyCalib(double a_value) const;
  inline double invertCalib(double a_value) const;
  void setCalibration(double a_scalar, double a_offset);
  void setScalar(double a_scalar);
  void setOffset(double a_offset);
  virtual std::ostream& print( std::ostream& a_stream = std::cout) const;
  virtual LinearCalib* clone();
protected:
  double m_scalar;
  double m_offset;
};
class QuadraticCalib : public DetectorCalib
{
public:
  QuadraticCalib();
  inline double applyCalib(double a_value) const;
  void setCalibration(double a_quadScalar,double a_scalar, double a_offset);
  void setQuadScalar(double a_quadScalar);
  void setScalar(double a_scalar);
  void setOffset(double a_offset);
  virtual std::ostream& print( std::ostream& a_stream = std::cout) const;
  virtual QuadraticCalib* clone();
protected:
  //
  double m_quadScalar;
  double m_scalar;
  double m_offset;
};
class PolyCalib : public DetectorCalib 
{
public:
  PolyCalib();
  inline double applyCalib(double a_value) const;
  void setCoeffs(std::vector<double> a_calibCoeffs);
  virtual std::ostream& print( std::ostream& a_stream = std::cout) const;
  virtual PolyCalib* clone();
private:
  std::vector< double > m_calibCoeff;
};
class TDepLinearCalib : public LinearCalib
{
public:
  TDepLinearCalib();
  inline double applyCalib(double a_value) const;
 
  void setGainCorrectionFactors(const std::map<uint32_t, double>& a_gcMap);
  virtual std::ostream& print( std::ostream& a_stream = std::cout) const;
  virtual TDepLinearCalib* clone();
private:
  std::map<uint32_t,double> m_gcFactorMap;
};
 
class TDepOffsetCalib : public OffsetCalib
{
public:
  TDepOffsetCalib();
  inline double applyCalib(double a_value) const;
 
  void setOffsetCorrectionFactors(const std::map<uint32_t, double>& a_tdMap);
  virtual std::ostream& print( std::ostream& a_stream = std::cout) const;
  virtual TDepOffsetCalib* clone();
private:
  std::map<uint32_t,double> m_tdOffset;
};
 
 
class TDepPolyCalib : public PolyCalib 
{
public:
  TDepPolyCalib();
  inline double applyCalib(double a_value) const;
 
  void setGainCorrectionFactors(const std::map<uint32_t, double>& a_gcMap);
  virtual std::ostream& print( std::ostream& a_stream = std::cout) const;
  virtual TDepPolyCalib* clone();
private:
  std::map<uint32_t,double> m_gcFactorMap;
};
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//implementations to allow for compiler to respect inline attempt
double ScalarCalib::applyCalib(double a_value) const
{
  return a_value*m_scalar;
}
double OffsetCalib::applyCalib(double a_value) const
{
  return a_value + m_offset;
}
double LinearCalib::applyCalib(double a_value) const
{
  return a_value*m_scalar+m_offset;
}
double LinearCalib::invertCalib(double a_value) const
{
  return (a_value-m_offset)/m_scalar;
}
double QuadraticCalib::applyCalib(double a_value) const
{
  return a_value*a_value*m_quadScalar + a_value*m_scalar;
}
double PolyCalib::applyCalib(double a_value) const
{
  return NSDPhysicsCalcs::GenExtraCalcs::polyEval(m_calibCoeff,a_value);
}
 
double TDepLinearCalib::applyCalib(double a_value) const 
{
  auto mpIter = m_gcFactorMap.find(m_t);
  if(mpIter!=m_gcFactorMap.end())
  {
    double factor = mpIter->second;
    return a_value * factor * m_scalar + m_offset;
 
  }
  return a_value* m_scalar+m_offset;
}
double TDepOffsetCalib::applyCalib(double a_value) const 
{
  auto mpIter = m_tdOffset.upper_bound(m_t);
  auto secondIter = m_tdOffset.begin();
  secondIter++;
  
  if(mpIter != m_tdOffset.end() //it is contained in the map
      //&& mpIter != secondIter //its not the second element ?? why?
      && mpIter != m_tdOffset.begin()
      )
  {
    double tAfter = mpIter->first;
    double offsetAfter = mpIter->second;
    mpIter--;
    double tBefore = mpIter->first;
    double offsetBefore = mpIter->second;
    double dt = tAfter-tBefore;
    double slope = (offsetAfter-offsetBefore)/dt;
    double step = m_t-tBefore;
    double additionalOffset = step*slope;
    return a_value + m_offset+additionalOffset+offsetBefore;
  }
 
  //implicit else due to return ie if we aren't within the range of the 
  //specified time series
  return a_value + m_offset;
}
 
double TDepPolyCalib::applyCalib(double a_value) const 
{
  auto mpIter = m_gcFactorMap.find(m_t);
  if(mpIter!=m_gcFactorMap.end())
  {
    double factor = mpIter->second;
    //time dependent corrected value
    double cV = factor*a_value;
    return PolyCalib::applyCalib(cV);
 
  }
  return PolyCalib::applyCalib(a_value);
}
 
#endif