JCALIBRATE::JFit Class Reference

Fit. More...

#include <JFitK40.hh>

Classes
struct	result_type
	Result type. More...

Public Types
typedef std::shared_ptr< JMEstimator >	estimator_type

Public Member Functions
	JFit (const int option, const int debug)
	Constructor.
result_type	operator() (const data_type &data)
	Fit.

Public Attributes
int	debug
estimator_type	estimator
	M-Estimator function.
double	lambda
JModel	value
JModel_t	error
int	numberOfIterations
JMATH::JMatrixNS	V
bool	TEST = false

Static Public Attributes
static constexpr int	MAXIMUM_ITERATIONS = 100000
	maximal number of iterations.
static constexpr double	EPSILON = 1.0e-3
	maximal distance to minimum.
static constexpr double	LAMBDA_MIN = 1.0e-2
	minimal value control parameter
static constexpr double	LAMBDA_MAX = 1.0e+4
	maximal value control parameter
static constexpr double	LAMBDA_UP = 10.0
	multiplication factor control parameter
static constexpr double	LAMBDA_DOWN = 10.0
	multiplication factor control parameter
static constexpr double	PIVOT = std::numeric_limits<double>::epsilon()
	minimal value diagonal element of matrix

Private Member Functions
void	evaluate (const data_type &data)
	Evaluation of fit.
void	seterr (const data_type &data)
	Set errors.

Private Attributes
JMATH::JVectorND	Y
double	successor
JModel	previous
std::vector< double >	h

Detailed Description

Fit.

Definition at line 1257 of file JFitK40.hh.

Member Typedef Documentation

estimator_type

std::shared_ptr<JMEstimator> JCALIBRATE::JFit::estimator_type

Definition at line 1268 of file JFitK40.hh.

Constructor & Destructor Documentation

JFit()

JCALIBRATE::JFit::JFit ( const int option, const int debug )

inline

Constructor.

Parameters

option	M-estimator
debug	debug

Definition at line 1277 of file JFitK40.hh.

                                            :
      debug(debug)
    {
      using namespace JPP;
 
      estimator.reset(getMEstimator(option));
    }

Member Function Documentation

operator()()

result_type JCALIBRATE::JFit::operator() ( const data_type & data )

inline

Fit.

Parameters

data

data

Returns

chi2, NDF

Definition at line 1292 of file JFitK40.hh.

    {
      using namespace std;
      using namespace JPP;
 
 
      value.setIndex();
 
      const size_t N = value.getN();
 
      V.resize(N);
      Y.resize(N);
      h.resize(N);
 
      double xmax = numeric_limits<double>::lowest();
      double xmin = numeric_limits<double>::max();
 
      int ndf = 0;
 
      for (data_type::const_iterator ix = data.begin(); ix != data.end(); ++ix) {
 
        const pair_type& pair = ix->first;
 
        if (value.parameters[pair.first ].status &&
            value.parameters[pair.second].status) {
 
          ndf += ix->second.size();
 
          for (const rate_type& iy : ix->second) {
            if (iy.dt_ns > xmax) { xmax = iy.dt_ns; }
            if (iy.dt_ns < xmin) { xmin = iy.dt_ns; }
          }
        }
      }
 
      ndf -= value.getN();
 
      if (ndf < 0) {
        return { 0.0, ndf };
      }
 
      for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
        if (value.parameters[pmt].t0.isFree()) {
          value.parameters[pmt].t0.setLimits(xmin, xmax);
        }
      }
 
      lambda    = LAMBDA_MIN;
 
      double precessor = numeric_limits<double>::max();
 
      for (numberOfIterations = 0; numberOfIterations != MAXIMUM_ITERATIONS; ++numberOfIterations) {
 
        DEBUG("step:     " << numberOfIterations << endl);
 
        evaluate(data);
 
        DEBUG("lambda:   " << FIXED(12,5) << lambda    << endl);
        DEBUG("chi2:     " << FIXED(12,3) << successor << endl);
 
        if (successor < precessor) {
 
          if (numberOfIterations != 0) {
 
            if (fabs(precessor - successor) < EPSILON) {
 
              seterr(data);
 
              return { successor / estimator->getRho(1.0), ndf };
            }
 
            if (lambda > LAMBDA_MIN) {
              lambda /= LAMBDA_DOWN;
            }
          }
 
          precessor = successor;
          previous  = value;
 
        } else {
 
          value   = previous;
          lambda *= LAMBDA_UP;
 
          if (lambda > LAMBDA_MAX) {
            break;
          }
 
          evaluate(data);
        }
 
        if (debug >= debug_t) {
 
          size_t row = 0;
 
          if (value.R .isFree()) { cout << "R  " << FIXED(12,5) << Y[row] << endl; ++row; }
          if (value.p1.isFree()) { cout << "p1 " << FIXED(12,5) << Y[row] << endl; ++row; }
          if (value.p2.isFree()) { cout << "p2 " << FIXED(12,5) << Y[row] << endl; ++row; }
          if (value.p3.isFree()) { cout << "p3 " << FIXED(12,5) << Y[row] << endl; ++row; }
          if (value.p4.isFree()) { cout << "p4 " << FIXED(12,5) << Y[row] << endl; ++row; }
          if (value.cc.isFree()) { cout << "cc " << FIXED(12,3) << Y[row] << endl; ++row; }
 
          for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
            if (value.parameters[pmt].QE .isFree()) { cout << "PMT[" << setw(2) << pmt << "].QE  " << FIXED(12,5) << Y[row] << endl; ++row; }
            if (value.parameters[pmt].TTS.isFree()) { cout << "PMT[" << setw(2) << pmt << "].TTS " << FIXED(12,5) << Y[row] << endl; ++row; }
            if (value.parameters[pmt].t0 .isFree()) { cout << "PMT[" << setw(2) << pmt << "].t0  " << FIXED(12,5) << Y[row] << endl; ++row; }
            if (value.parameters[pmt].bg .isFree()) { cout << "PMT[" << setw(2) << pmt << "].bg  " << FIXED(12,5) << Y[row] << endl; ++row; }
          }
        }
 
        // force definite positiveness
 
        for (size_t i = 0; i != N; ++i) {
 
          if (V(i,i) < PIVOT) {
            V(i,i) = PIVOT;
          }
 
          h[i] = 1.0 / sqrt(V(i,i));
        }
 
        // normalisation
 
        for (size_t i = 0; i != N; ++i) {
          for (size_t j = 0; j != i; ++j) {
            V(j,i) *= h[i] * h[j];
            V(i,j)  = V(j,i);
          }
        }
 
        for (size_t i = 0; i != N; ++i) {
          V(i,i) = 1.0 + lambda;
        }
 
        // solve A x = b
 
        for (size_t col = 0; col != N; ++col) {
          Y[col] *= h[col];
        }
 
        try {
          V.solve(Y);
        }
        catch (const exception& error) {
 
          ERROR("JGandalf: " << error.what() << endl << V << endl);
 
          break;
        }
 
        // update value
 
        const double factor = 2.0;
 
        size_t row = 0;
 
        if (value.R .isFree()) { value.R  -= factor * h[row] * Y[row];  ++row; }
        if (value.p1.isFree()) { value.p1 -= factor * h[row] * Y[row];  ++row; }
        if (value.p2.isFree()) { value.p2 -= factor * h[row] * Y[row];  ++row; }
        if (value.p3.isFree()) { value.p3 -= factor * h[row] * Y[row];  ++row; }
        if (value.p4.isFree()) { value.p4 -= factor * h[row] * Y[row];  ++row; }
        if (value.cc.isFree()) { value.cc -= factor * h[row] * Y[row];  ++row; }
        if (value.bc.isFree()) { value.bc -= factor * h[row] * Y[row];  ++row; }
        
        for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
          if (value.parameters[pmt].QE .isFree()) { value.parameters[pmt].QE  -= factor * h[row] * Y[row];  ++row; }
          if (value.parameters[pmt].TTS.isFree()) { value.parameters[pmt].TTS -= factor * h[row] * Y[row];  ++row; }
          if (value.parameters[pmt].t0 .isFree()) { value.parameters[pmt].t0  -= factor * h[row] * Y[row];  ++row; }
          if (value.parameters[pmt].bg .isFree()) { value.parameters[pmt].bg  -= factor * h[row] * Y[row];  ++row; }
        }
      }
 
      seterr(data);
 
      return { precessor / estimator->getRho(1.0), ndf };
    }

evaluate()

void JCALIBRATE::JFit::evaluate ( const data_type & data )

inlineprivate

Evaluation of fit.

Parameters

data

data

Definition at line 1495 of file JFitK40.hh.

    {
      using namespace std;
      using namespace JPP;
      
      typedef JModel::real_type real_type;
 
 
      successor = 0.0;
 
      V.reset();
      Y.reset();
 
 
      // model parameter indices
 
      const struct M_t {
        M_t(const JModel& model)
        {
          R  = model.getIndex(&JK40Parameters_t::R);
          p1 = model.getIndex(&JK40Parameters_t::p1);
          p2 = model.getIndex(&JK40Parameters_t::p2);
          p3 = model.getIndex(&JK40Parameters_t::p3);
          p4 = model.getIndex(&JK40Parameters_t::p4);
          cc = model.getIndex(&JK40Parameters_t::cc);
          bc = model.getIndex(&JK40Parameters_t::bc);
        }
 
        int R;
        int p1;
        int p2;
        int p3;
        int p4;
        int cc;
        int bc;
 
      } M(value);
 
 
      // PMT parameter indices
 
      struct i_t {
        i_t() :
          QE (INVALID_INDEX),
          TTS(INVALID_INDEX),
          t0 (INVALID_INDEX),
          bg (INVALID_INDEX)
        {}
 
        int QE;
        int TTS;
        int t0;
        int bg;
      };
 
      const struct I_t : public std::array<i_t, NUMBER_OF_PMTS> {
        I_t(const JModel& value)
        {
          int N = value.JK40Parameters::getN();
 
          for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
            if (value.parameters[i].QE .isFree()) { (*this)[i].QE  = N; ++N; }
            if (value.parameters[i].TTS.isFree()) { (*this)[i].TTS = N; ++N; }
            if (value.parameters[i].t0 .isFree()) { (*this)[i].t0  = N; ++N; }
            if (value.parameters[i].bg .isFree()) { (*this)[i].bg  = N; ++N; }
          }
        }
 
      } I(value);
 
 
 
      struct buffer_type : public vector< pair<int, double> > {
        double operator[](const int index) const
        {
          for (const_iterator i = this->begin(); i != this->end(); ++i) {
            if (i->first == index) {
              return i->second;
            }
          }
 
          THROW(JValueOutOfRange, "Invalid index " << index);
        }
      };
 
      buffer_type  buffer;
 
#define PUSH_BACK(i,v) if (i != INVALID_INDEX) { buffer.push_back({i, v}); }
 
 
      size_t number_of_errors = 0;
 
      for (data_type::const_iterator ix = data.begin(); ix != data.end(); ++ix) {
 
        const pair_type& pair = ix->first;
 
        if (value.parameters[pair.first ].status &&
            value.parameters[pair.second].status) {
 
          const real_type& real = value.getReal(pair);
 
          const JBell bell(real.t0, real.sigma, real.signal, 0.0, BELL_SHAPE);
 
          const double            R1  = value.getValue   (real.ct);
          const JK40Parameters_t& R1p = value.getGradient(real.ct);
 
          for (const rate_type& iy : ix->second) {
 
            const double   R2  = bell.getValue   (iy.dt_ns);
            const JBell_t& R2p = bell.getGradient(iy.dt_ns);        
 
            const double  R   = real.bc  +  real.background  +  R1 * (real.cc + R2);
            const double  u   =  (iy.value - R)       / iy.error;
            const double  w   = -estimator->getPsi(u) / iy.error;
 
            successor += estimator->getRho(u);
 
            buffer.clear();
 
            PUSH_BACK(M.R,  w * (real.cc + R2) * R1p.R () * value.R .getDerivative());
            PUSH_BACK(M.p1, w * (real.cc + R2) * R1p.p1() * value.p1.getDerivative());
            PUSH_BACK(M.p2, w * (real.cc + R2) * R1p.p2() * value.p2.getDerivative());
            PUSH_BACK(M.p3, w * (real.cc + R2) * R1p.p3() * value.p3.getDerivative());
            PUSH_BACK(M.p4, w * (real.cc + R2) * R1p.p4() * value.p4.getDerivative());
            PUSH_BACK(M.cc, w *  real.signal   * R1p.cc() * value.cc.getDerivative());
            PUSH_BACK(M.bc, w *                  R1p.bc() * value.bc.getDerivative());
 
            PUSH_BACK(I[pair.first] .QE,  w * R1 * R2p.signal * value.parameters[pair.second].QE () * value.parameters[pair.first ].QE .getDerivative());
            PUSH_BACK(I[pair.second].QE,  w * R1 * R2p.signal * value.parameters[pair.first ].QE () * value.parameters[pair.second].QE .getDerivative());
            PUSH_BACK(I[pair.first] .TTS, w * R1 * R2p.sigma  * value.parameters[pair.first ].TTS() * value.parameters[pair.first ].TTS.getDerivative() / real.sigma);
            PUSH_BACK(I[pair.second].TTS, w * R1 * R2p.sigma  * value.parameters[pair.second].TTS() * value.parameters[pair.second].TTS.getDerivative() / real.sigma);
            PUSH_BACK(I[pair.first] .t0,  w * R1 * R2p.mean                                         * value.parameters[pair.first ].t0 .getDerivative() * +1.0);
            PUSH_BACK(I[pair.second].t0,  w * R1 * R2p.mean                                         * value.parameters[pair.second].t0 .getDerivative() * -1.0);
            PUSH_BACK(I[pair.first] .bg,  w                                                         * value.parameters[pair.first ].bg .getDerivative());
            PUSH_BACK(I[pair.second].bg,  w                                                         * value.parameters[pair.second].bg .getDerivative());
 
            if (TEST) {
 
              DEBUG("PMT pair(" << setw(2) << pair.first << "," << setw(2) << pair.second << ") " << FIXED(7,3) << iy.dt_ns << " [ns]" << endl);
 
              const double PRECISION = 1.0e-5;
 
#define MAKE_TEST(i,v) if (i != INVALID_INDEX) {                        \
                                                                        \
                const bool status  =  fabs(buffer[i] - v) <= PRECISION; \
                                                                        \
                DEBUG((status ? GREEN : RED)                            \
                      << setw(20)    << left << #i << right << ' '      \
                      << setw(3)     << i                   << ' '      \
                      << FIXED(12,5) << buffer[i]           << ' '      \
                      << FIXED(12,5) << v                   << ' '      \
                      << (!status ? "***" : "")                         \
                      << RESET << endl);                                \
                                                                        \
                if (!status) {                                          \
                  number_of_errors += 1;                                \
                }                                                       \
              }
 
              struct JTest_t : public JModel
              {
                JTest_t& operator=(const JModel& model)
                {
                  static_cast<JModel&>(*this) = model;
 
                  R .relax();
                  p1.relax();
                  p2.relax();
                  p3.relax();
                  p4.relax();
                  cc.relax();
                  bc.relax();
 
                  for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
                    parameters[i].QE .relax();
                    parameters[i].TTS.relax();
                    parameters[i].t0 .relax();
                    parameters[i].bg .relax();
                  }
 
                  return *this;
                }
 
                double operator()(const pair_type& pair, const rate_type& iy) const
                {
                  return (iy.value - getValue(pair, iy.dt_ns)) / iy.error;
                }
              };
 
              const double DX =  1.0e-8;         // dx
              JTest_t      m1, m2;               // y1, y2
 
              // derivative
 
              auto fp = [&DX = DX, &m1 = m1, &m2 = m2, &estimator = estimator](const pair_type& pair, const rate_type& iy)
              {
                return (estimator->getRho(m2(pair, iy)) - estimator->getRho(m1(pair, iy))) / DX;
              };
 
              { m1 = m2 = value; m2.R  += 0.5*DX; m1.R  -= 0.5*DX;  MAKE_TEST(M.R,  fp(pair, iy) * value.R .getDerivative()); }
              { m1 = m2 = value; m2.p1 += 0.5*DX; m1.p1 -= 0.5*DX;  MAKE_TEST(M.p1, fp(pair, iy) * value.p1.getDerivative()); }
              { m1 = m2 = value; m2.p2 += 0.5*DX; m1.p2 -= 0.5*DX;  MAKE_TEST(M.p2, fp(pair, iy) * value.p2.getDerivative()); }
              { m1 = m2 = value; m2.p3 += 0.5*DX; m1.p3 -= 0.5*DX;  MAKE_TEST(M.p3, fp(pair, iy) * value.p3.getDerivative()); }
              { m1 = m2 = value; m2.p4 += 0.5*DX; m1.p4 -= 0.5*DX;  MAKE_TEST(M.p4, fp(pair, iy) * value.p4.getDerivative()); }
              { m1 = m2 = value; m2.cc += 0.5*DX; m1.cc -= 0.5*DX;  MAKE_TEST(M.cc, fp(pair, iy) * value.cc.getDerivative()); }
              { m1 = m2 = value; m2.bc += 0.5*DX; m1.bc -= 0.5*DX;  MAKE_TEST(M.bc, fp(pair, iy) * value.bc.getDerivative()); }
 
              { m1 = m2 = value; m2.parameters[pair.first] .QE  += 0.5*DX; m1.parameters[pair.first] .QE  -= 0.5*DX;  MAKE_TEST(I[pair.first] .QE,  fp(pair, iy) * value.parameters[pair.first] .QE .getDerivative()); }
              { m1 = m2 = value; m2.parameters[pair.second].QE  += 0.5*DX; m1.parameters[pair.second].QE  -= 0.5*DX;  MAKE_TEST(I[pair.second].QE,  fp(pair, iy) * value.parameters[pair.second].QE .getDerivative()); }
              { m1 = m2 = value; m2.parameters[pair.first] .TTS += 0.5*DX; m1.parameters[pair.first] .TTS -= 0.5*DX;  MAKE_TEST(I[pair.first] .TTS, fp(pair, iy) * value.parameters[pair.first] .TTS.getDerivative()); }
              { m1 = m2 = value; m2.parameters[pair.second].TTS += 0.5*DX; m1.parameters[pair.second].TTS -= 0.5*DX;  MAKE_TEST(I[pair.second].TTS, fp(pair, iy) * value.parameters[pair.second].TTS.getDerivative()); }
              if (pair.first  != value.getIndex()) {
                m1 = m2 = value; m2.parameters[pair.first] .t0  += 0.5*DX; m1.parameters[pair.first] .t0  -= 0.5*DX;  MAKE_TEST(I[pair.first] .t0,  fp(pair, iy) * value.parameters[pair.first] .t0 .getDerivative());
              }
              if (pair.second != value.getIndex()) {
                m1 = m2 = value; m2.parameters[pair.second].t0  += 0.5*DX; m1.parameters[pair.second].t0  -= 0.5*DX;  MAKE_TEST(I[pair.second].t0,  fp(pair, iy) * value.parameters[pair.second].t0 .getDerivative());
              }
              { m1 = m2 = value; m2.parameters[pair.first] .bg  += 0.5*DX; m1.parameters[pair.first] .bg  -= 0.5*DX;  MAKE_TEST(I[pair.first] .bg,  fp(pair, iy) * value.parameters[pair.first] .bg .getDerivative()); }
              { m1 = m2 = value; m2.parameters[pair.second].bg  += 0.5*DX; m1.parameters[pair.second].bg  -= 0.5*DX;  MAKE_TEST(I[pair.second].bg,  fp(pair, iy) * value.parameters[pair.second].bg .getDerivative()); }
 
              cout << endl;
            }
 
            for (buffer_type::const_iterator row = buffer.begin(); row != buffer.end(); ++row) {
 
              Y[row->first] += row->second;
 
              V[row->first][row->first] += row->second * row->second;
 
              for (buffer_type::const_iterator col = buffer.begin(); col != row; ++col) {
                V[row->first][col->first] += row->second * col->second;
                V[col->first][row->first]  = V[row->first][col->first];
              }
            }
          }
        }
      }
 
#undef PUSH_BACK
 
      if (TEST) {
 
        STATUS("Test finished with " << number_of_errors << " errors." << endl);
 
        exit(number_of_errors == 0 ? 0 : 1);
      }
    }

seterr()

void JCALIBRATE::JFit::seterr ( const data_type & data )

inlineprivate

Set errors.

Parameters

data

data

Definition at line 1749 of file JFitK40.hh.

    {
      using namespace std;
 
      error.reset();
 
      evaluate(data);
      
      try {
        V.invert();
      }
      catch (const exception& error) {}
 
#define SQRT(X) (X >= 0.0 ? sqrt(X) : std::numeric_limits<double>::max())
 
      size_t i = 0;
 
      if (value.R .isFree()) { error.R  = SQRT(V(i,i));  ++i; }
      if (value.p1.isFree()) { error.p1 = SQRT(V(i,i));  ++i; }
      if (value.p2.isFree()) { error.p2 = SQRT(V(i,i));  ++i; }
      if (value.p3.isFree()) { error.p3 = SQRT(V(i,i));  ++i; }
      if (value.p4.isFree()) { error.p4 = SQRT(V(i,i));  ++i; }
      if (value.cc.isFree()) { error.cc = SQRT(V(i,i));  ++i; }
      if (value.bc.isFree()) { error.bc = SQRT(V(i,i));  ++i; }
 
      for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
        if (value.parameters[pmt].QE .isFree()) { error.parameters[pmt].QE  = SQRT(V(i,i));  ++i; }
        if (value.parameters[pmt].TTS.isFree()) { error.parameters[pmt].TTS = SQRT(V(i,i));  ++i; }
        if (value.parameters[pmt].t0 .isFree()) { error.parameters[pmt].t0  = SQRT(V(i,i));  ++i; }
        if (value.parameters[pmt].bg .isFree()) { error.parameters[pmt].bg  = SQRT(V(i,i));  ++i; }
      }
 
#undef SQRT
    }

Member Data Documentation

MAXIMUM_ITERATIONS

int JCALIBRATE::JFit::MAXIMUM_ITERATIONS = 100000

staticconstexpr

maximal number of iterations.

Definition at line 1470 of file JFitK40.hh.

EPSILON

double JCALIBRATE::JFit::EPSILON = 1.0e-3

staticconstexpr

maximal distance to minimum.

Definition at line 1471 of file JFitK40.hh.

LAMBDA_MIN

double JCALIBRATE::JFit::LAMBDA_MIN = 1.0e-2

staticconstexpr

minimal value control parameter

Definition at line 1472 of file JFitK40.hh.

LAMBDA_MAX

double JCALIBRATE::JFit::LAMBDA_MAX = 1.0e+4

staticconstexpr

maximal value control parameter

Definition at line 1473 of file JFitK40.hh.

LAMBDA_UP

double JCALIBRATE::JFit::LAMBDA_UP = 10.0

staticconstexpr

multiplication factor control parameter

Definition at line 1474 of file JFitK40.hh.

LAMBDA_DOWN

double JCALIBRATE::JFit::LAMBDA_DOWN = 10.0

staticconstexpr

multiplication factor control parameter

Definition at line 1475 of file JFitK40.hh.

PIVOT

double JCALIBRATE::JFit::PIVOT = std::numeric_limits<double>::epsilon()

staticconstexpr

minimal value diagonal element of matrix

Definition at line 1476 of file JFitK40.hh.

debug

int JCALIBRATE::JFit::debug

Definition at line 1478 of file JFitK40.hh.

estimator

estimator_type JCALIBRATE::JFit::estimator

M-Estimator function.

Definition at line 1479 of file JFitK40.hh.

lambda

double JCALIBRATE::JFit::lambda

Definition at line 1481 of file JFitK40.hh.

value

JModel JCALIBRATE::JFit::value

Definition at line 1482 of file JFitK40.hh.

error

JModel_t JCALIBRATE::JFit::error

Definition at line 1483 of file JFitK40.hh.

numberOfIterations

int JCALIBRATE::JFit::numberOfIterations

Definition at line 1484 of file JFitK40.hh.

V

JMATH::JMatrixNS JCALIBRATE::JFit::V

Definition at line 1485 of file JFitK40.hh.

TEST

bool JCALIBRATE::JFit::TEST = false

Definition at line 1487 of file JFitK40.hh.

Y

JMATH::JVectorND JCALIBRATE::JFit::Y

private

Definition at line 1785 of file JFitK40.hh.

successor

double JCALIBRATE::JFit::successor

private

Definition at line 1786 of file JFitK40.hh.

previous

JModel JCALIBRATE::JFit::previous

private

Definition at line 1787 of file JFitK40.hh.

h

std::vector<double> JCALIBRATE::JFit::h

private

Definition at line 1788 of file JFitK40.hh.

---

The documentation for this class was generated from the following file:

• JFitK40.hh