JFitK40.hh

Go to the documentation of this file.

#ifndef __JCALIBRATE_JFITK40__
#define __JCALIBRATE_JFITK40__
 
#include "TMath.h"
#include "TString.h"
#include "TF2.h"
#include "TH2.h"
#include "TFitResult.h"
 
#include "km3net-dataformat/online/JDAQ.hh"
#include "JROOT/JRootToolkit.hh"
#include "JDetector/JModule.hh"
#include "JMath/JMathToolkit.hh"
#include "JLang/JException.hh"
#include "JCalibrate/JCalibrateK40.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JCALIBRATE {}
namespace JPP { using namespace JCALIBRATE; }
 
namespace JCALIBRATE {
 
  using JLANG::JIndexOutOfRange;
  using JROOT::JFitParameter_t;
  using KM3NETDAQ::NUMBER_OF_PMTS;
  using JDETECTOR::JModule;
 
 
  static const double FITK40_QE_MIN      =  0.0;   //!< Minimal quantum efficiency [unit]
  static const double FITK40_QE_MAX      = 10.0;   //!< Maximal quantum efficiency [unit]
  static const double FITK40_TTS_MIN_NS  =  0.0;   //!< Minimal transition-time spread [ns] 
  static const double FITK40_TTS_MAX_NS  =  3.5;   //!< Maximal transition-time spread [ns]
 
 
  /**
   * Fit parameters for single PMT.
   */
  struct JPMTParameters_t {
    /**
     * Default constructor.
     */
    JPMTParameters_t() :
      QE (1.0),
      TTS(2.0),
      t0 (0.0)
    {}
 
 
    Double_t  QE;             //!< quantum efficiency [unit]
    Double_t  TTS;            //!< transition-time spread [ns]
    Double_t  t0;             //!< time offset [ns]
  };
 
 
  /**
   * Fit parameters for two-fold coincidence rate due to K40.
   */
  struct JFitK40Parameters {
    /**
     * Default constructor.
     *
     * The default parameter values are set to those obtained from a designated simulation
     * of K40 decays (see http://wiki.km3net.de/index.php/OMGsim_simulations_for_K40_fit).\n
     * If you change these values, you may also want to change the corresponding values in JK40DefaultSimulator.hh.
     */
    JFitK40Parameters() :
      Rate_Hz(16.304),               // [Hz]
      p1     ( 2.85261),
      p2     (-0.949097),
      p3     ( 0.182419),
      p4     ( 1.23075),
      bg     ( 1.0e-3),
      cc     ( 1.0e-3)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  data         data
     */
    JFitK40Parameters(const Double_t* data) 
    {
      if (data != NULL) {
        setModelParameters(data);
      }
    }
 
 
    /** 
     * Get number of model parameters.
     *
     * \return              number of parameters
     */
    static Int_t getNumberOfModelParameters()
    {
      return sizeof(JFitK40Parameters) / sizeof(Double_t);
    }
 
 
    /**
     * Get model parameters.
     *
     * \return              pointer to parameters
     */
    const Double_t* getModelParameters() const
    {
      return &Rate_Hz;
    }
 
 
    /**
     * Get model parameters.
     *
     * \return              pointer to parameters
     */
    Double_t* getModelParameters()
    {
      return &Rate_Hz;
    }
 
 
    /**
     * Set model parameters.
     *
     * \param  data         pointer to parameters
     */
    void setModelParameters(const Double_t* data)
    {
      for (Int_t i = 0; i != getNumberOfModelParameters(); ++i) {
        getModelParameters()[i] = data[i];
      }
    }
 
 
    /**
     * Get model parameter.
     *
     * \param  i            parameter index
     * \return              parameter value
     */
    Double_t getModelParameter(Int_t i) const
    {
      return getModelParameters()[i];
    }
 
 
    /**
     * Get model parameter.
     *
     * \param  p            pointer to data member
     * \return              parameter index and value
     */
    JFitParameter_t getModelParameter(Double_t JFitK40Parameters::*p) const
    {
      const Int_t i = &(this->*p) - getModelParameters();
 
      return JFitParameter_t(i, getModelParameter(i));
    }
 
 
    /**
     * Get model parameter.
     *
     * \param  pmt          PMT number
     * \param  p            pointer to data member of PMT parameters 
     * \return              parameter index and value
     */
    JFitParameter_t getModelParameter(Int_t pmt, Double_t JPMTParameters_t::*p) const
    {
      const Int_t i = &(parameters[pmt].*p) - getModelParameters();
 
      return JFitParameter_t(i, getModelParameter(i));
    }
 
 
    /**
     * Get QE of given PMT.
     *
     * \param  pmt          pmt address
     * \return              QE
     */
    Double_t getQE(const int pmt) const
    {
      return parameters[pmt].QE;
    }
 
 
    /**
     * Set QE of given PMT.
     *
     * \param  pmt          pmt address
     * \param  QE           QE
     */
    void setQE(const int pmt, const Double_t QE)
    {
      parameters[pmt].QE = QE;
    }
 
 
    /**
     * Get time resolution of given PMT.
     *
     * \param  pmt          pmt address
     * \return              TTS [ns]
     */
    Double_t getTTS(const int pmt) const
    {
      return parameters[pmt].TTS;
    }
 
 
    /**
     * Set time resolution of given PMT.
     *
     * \param  pmt          pmt address
     * \param  TTS          TTS [ns]
     */
    void setTTS(const int pmt, const Double_t TTS)
    {
      parameters[pmt].TTS = TTS;
    }
 
  
    /**
     * Get time offset of given PMT.
     * Note that the time offset of each PMT is corrected by 
     * the average time offset of all PMTs.
     *
     * \param  pmt          pmt address
     * \return              time offset [ns]
     */
    Double_t getT0(const int pmt) const
    {
      return parameters[pmt].t0;
    }
 
  
    /**
     * Set time offset of given PMT.
     *
     * \param  pmt          pmt address
     * \param  t0           time offset [ns]
     */
    void setT0(const int pmt, const Double_t t0)
    {
      parameters[pmt].t0 = t0;
    }
 
 
    /**
     * Get K40 coincidence rate as a function of cosine angle between PMT axes.
     *
     * \param  ct           cosine angle between PMT axes
     * \return              rate [Hz]
     */
    Double_t getValue(const Double_t ct) const
    {
      return Rate_Hz * TMath::Exp(-(p1+p2+p3+p4)) * TMath::Exp(ct*(p1+ct*(p2+ct*(p3+ct*p4))));
    }
    
 
    // fit parameters
 
    Double_t Rate_Hz;            //!< maximal coincidence rate [Hz]
    Double_t p1;                 //!< angle dependence coincidence rate
    Double_t p2;                 //!< angle dependence coincidence rate
    Double_t p3;                 //!< angle dependence coincidence rate
    Double_t p4;                 //!< angle dependence coincidence rate
    Double_t bg;                 //!< remaining constant background
    Double_t cc;                 //!< fraction of signal correlated background
 
    JPMTParameters_t parameters[NUMBER_OF_PMTS];
  };
 
 
  /**
   * Parametrisation of two-fold coincidence rate due to K40 and other radioactive decays.
   *
   * Note that for use in ROOT fit operations, the member method JFitK40::getRate is static.\n
   */
  struct JFitK40 :
    public JFitK40Parameters,
    public TF2,
    public JModule,
    public JCombinatorics
  {
    using  JFitK40Parameters::getValue;
 
    /**
     * Data structure for a pair of addresses.
     */
    typedef JCombinatorics::pair_type       pair_type;
 
 
    /**
     * Constructor.
     *
     * \param  module       detector module
     * \param  xmin         minimal x
     * \param  xmax         maximal x
     * \param  ymin         minimal y
     * \param  ymax         maximal y
     * \param  option       true = fix average t0; false = free average t0
     */
    JFitK40(const JModule& module, 
            const Double_t xmin,
            const Double_t xmax,
            const Double_t ymin,
            const Double_t ymax,
            const bool     option) :
 
      TF2("fitk40",
          JFitK40::getRate,
          xmin, xmax, ymin, ymax,
          JFitK40::getNumberOfModelParameters()),
 
      sigmaK40_ns(0.54)
    {
      static_cast<JModule&>(*this) = module;
    
      this->configure(module.size());
      
      this->sort(JPairwiseComparator(module));
 
      index_of_average_t0 = (option ? 0 : -1);
 
      for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
        disable[i] = false;
      }
    }
 
 
    /**
     * Get intrinsic K40 arrival time spread.
     *
     * \return              sigma [ns]
     */
    Double_t getSigmaK40() const
    {
      return this->sigmaK40_ns;
    }
 
 
    /**
     * Set intrinsic K40 arrival time spread.
     *
     * \param  sigma        sigma [ns]
     */
    void setSigmaK40(const Double_t sigma)
    {
      this->sigmaK40_ns = sigma;
    }
 
 
    /**
     * Test PMT status.
     *
     * \param  pmt          pmt address
     * \return              true if given pmt is disabled; else false
     */
    bool is_disabled(int pmt) const
    {
      return disable[pmt];
    }
 
 
    /**
     * Test PMT status.
     *
     * \param  pmt          pmt address
     * \return              true if given pmt is used for average t0; else false
     */
    bool is_average_t0(int pmt) const
    {
      return pmt == index_of_average_t0;
    }
 
  
    /**
     * Get time offset of given PMT.
     *
     * Note that if the average time offset is constraint,
     * the time offset of each PMT is corrected by the average time offset of all PMTs.
     *
     * \param  pmt          pmt address
     * \return              time offset [ns]
     */
    Double_t getT0(const int pmt) const
    {
      if (index_of_average_t0 == -1) {
 
        return JFitK40Parameters::getT0(pmt);
 
      } else {
 
        if (disable[pmt]) {
 
          return parameters[pmt].t0;
 
        } else {        
 
          Int_t    n0  =  0;       // number  of non-fixed t0's
          Double_t t0  =  0.0;     // average of non-fixed t0's
          
          for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
            if (!disable[i] && i != index_of_average_t0) {
              n0  +=  1;
              t0  +=  parameters[i].t0;
            }
          }
          
          t0  /=  (n0 + 1);
 
          if (pmt != index_of_average_t0)
            return parameters[pmt].t0 - t0;
          else
            return -t0;
        }
      }
    }
 
 
    /**
     * Enable PMT.
     *
     * \param  pmt          pmt address
     */
    void enablePMT(const int pmt)
    {
      disable[pmt] = false;
    }
 
 
    /**
     * Disable PMT.
     *
     * Note that if the average time offset is constraint to zero,
     * the corresponding index may change.
     *
     * \param  pmt          pmt address
     */
    void disablePMT(const int pmt)
    {
      disable[pmt] = true;
 
      if (index_of_average_t0 == pmt) {
 
        for (index_of_average_t0 = 0; index_of_average_t0 != NUMBER_OF_PMTS; ++index_of_average_t0) {
          if (!disable[index_of_average_t0]) {
            break;
          }
        }
          
        if (index_of_average_t0 == NUMBER_OF_PMTS) {
          THROW(JIndexOutOfRange, "JFitK40::disable PMT: No free index for average t0.");
        }
      }
    }
 
 
    /**
     * Get cosine of space angle between PMT axes.
     *
     * \param  pair         pair of addresses
     * \return              cosine
     */
    double getDot(const pair_type& pair) const
    {
      return JMATH::getDot(this->getPMT(pair.first),
                           this->getPMT(pair.second));
    }
 
  
    /**
     * Get time resolution of given PMT pair.
     *
     * \param  pair         pair of addresses
     * \return              sigma [ns]
     */
    Double_t getSigma(const pair_type& pair) const
    {
      return TMath::Sqrt(getTTS(pair.first)  * getTTS(pair.first)  +
                         getTTS(pair.second) * getTTS(pair.second) +
                         getSigmaK40()       * getSigmaK40());
    }
 
 
    /**
     * Get time offset of given PMT pair.
     *
     * \param  pair         pair of addresses
     * \return              time offset [ns]
     */
    Double_t getT0(const pair_type& pair) const
    {
      if (index_of_average_t0 == -1) {
 
        return     parameters[pair.first].t0 - parameters[pair.second].t0;
 
      } else {
 
        if        (pair.first  == index_of_average_t0) {
          
          return  -parameters[pair.second].t0;
          
        } else if (pair.second == index_of_average_t0) {
          
          return   parameters[pair.first].t0;
        
        } else {
          
          return   parameters[pair.first].t0 - parameters[pair.second].t0;
        }
      }
    }
 
 
    /**
     * Get K40 coincidence rate.
     *
     * \param  pair         pair of addresses
     * \return              rate [Hz]
     */
    Double_t getValue(const pair_type& pair) const
    {
      const Double_t ct = getDot(pair);
 
      return (getValue(ct)         *
              getQE(pair.first)    *
              getQE(pair.second));
    }
 
 
    /**
     * Get K40 coincidence rate.
     *
     * \param  pair         pair of addresses
     * \param  dt_ns        time difference [ns]
     * \return              rate [Hz/ns]
     */
    Double_t getValue(const pair_type& pair, const Double_t dt_ns) const
    {
      const Double_t t0    = getT0   (pair);
      const Double_t sigma = getSigma(pair);
 
      return getValue(pair) * TMath::Gaus(dt_ns, t0, sigma, kTRUE);
    }
 
 
    /**
     * Fit histogram.
     *
     * Note that the PMT parameters which are part of the model are reset before the fit according the status of each PMT and
     * the obtained fit parameters are copied back to the model parameters after the fit.
     *
     * \param  h2           ROOT 2D-histogram
     * \param  option       fit option
     */
    TFitResultPtr operator()(TH2& h2, const std::string& option) 
    {
      for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
 
        parameters[pmt] = JPMTParameters_t();
 
        if (disable[pmt]) {
 
          parameters[pmt].QE = 0.0;
 
          fixParameter(*this, this->getModelParameter(pmt, &JPMTParameters_t::QE));
          fixParameter(*this, this->getModelParameter(pmt, &JPMTParameters_t::TTS));
          fixParameter(*this, this->getModelParameter(pmt, &JPMTParameters_t::t0));
 
        } else {
 
          // Note that setting limits to a parameter will also release it
 
          if (!isParameterFixed(*this, this->getModelParameter(pmt, &JPMTParameters_t::QE)))  {
            setParLimits(*this, this->getModelParameter(pmt, &JPMTParameters_t::QE),  FITK40_QE_MIN,            FITK40_QE_MAX);
          }
          if (!isParameterFixed(*this, this->getModelParameter(pmt, &JPMTParameters_t::TTS))) {
            setParLimits(*this, this->getModelParameter(pmt, &JPMTParameters_t::TTS), FITK40_TTS_MIN_NS,        FITK40_TTS_MAX_NS);
          }
          if (!isParameterFixed(*this, this->getModelParameter(pmt, &JPMTParameters_t::t0)))  {
            setParLimits(*this, this->getModelParameter(pmt, &JPMTParameters_t::t0),  h2.GetYaxis()->GetXmin(), h2.GetYaxis()->GetXmax());
          }
        }
      }
 
      if (index_of_average_t0 != -1) {
 
        this->setT0(index_of_average_t0, 0.0);
 
        fixParameter(*this, this->getModelParameter(index_of_average_t0, &JPMTParameters_t::t0));
      }
 
      this->SetParameters(this->getModelParameters());
 
      getInstance() = *this;
 
      const TFitResultPtr result = h2.Fit(this, option.c_str());
 
      this->setModelParameters(this->GetParameters());
 
      return result;
    }
 
 
    /**
     * Get K40 coincidence rate as a function of the fit parameters.
     *
     * To speed up the calculation, it is assumed that the parameter values do not
     * change unless also the x[0] value changes (i.e. the index of the PMT pair).
     *
     * \param  x            pointer to data
     * \param  data         pointer to parameter values
     * \return              rate [Hz/ns]
     */
    static Double_t getRate(const Double_t* x, const Double_t* data)
    {
      static int       id    =  -1;
      static Double_t  t0;
      static Double_t  sigma;
      static Double_t  rate;
      
      const int      ix    = (int) x[0];
      const Double_t dt_ns = x[1];
 
      if (ix != id) {
        
        getInstance().setModelParameters(data);
        
        const pair_type& pair = getInstance().getPair(ix);
 
        t0     =  getInstance().getT0   (pair);
        sigma  =  getInstance().getSigma(pair);
        rate   =  getInstance().getValue(pair);
        id     =  ix;
      }
 
      return getInstance().bg  +  rate * (getInstance().cc + TMath::Gaus(dt_ns, t0, sigma, kTRUE));
    }
 
  private:
 
    Double_t       sigmaK40_ns;                         //!< intrinsic K40 arrival time spread [ns]
    int            index_of_average_t0;                 //!< index of t0 used for average time offset
    bool           disable[NUMBER_OF_PMTS];             //!< disable PMT from fit
 
    /**
     * Default constructor.
     */
    JFitK40()
    {}
 
 
    /**
     * Get unique instance of fit object.
     *
     * \return              reference to fit object.
     */
    static JFitK40& getInstance()
    {
      static JFitK40 object;
 
      return object;
    }
  };
}
 
#endif