TFCS1DFunctionSpline Class Reference

#include <TFCS1DFunctionSpline.h>

Inheritance diagram for TFCS1DFunctionSpline:

Collaboration diagram for TFCS1DFunctionSpline:

Public Member Functions
	TFCS1DFunctionSpline (TH1 *hist=nullptr, double maxdevgoal=0.01, double maxeffsiggoal=3, int maxnp=20)
	~TFCS1DFunctionSpline ()
double	Initialize (TH1 *hist, double maxdevgoal=0.01, double maxeffsiggoal=3, int maxnp=20)
double	InitializeFromSpline (TH1 *hist, const TSpline3 &sp, double maxdevgoal=0.01, double maxeffsiggoal=3)
double	InitializeEqualDistance (TH1 *hist, double maxdevgoal=0.01, double maxeffsiggoal=3, int nsplinepoints=5)
double	InitializeEqualProbability (TH1 *hist, double maxdevgoal=0.01, double maxeffsiggoal=3, int nsplinepoints=5)
virtual double	rnd_to_fct (double rnd) const
	Function gets random number rnd in the range [0,1) as argument and returns function value according to a histogram distribution.
const TSpline3 &	spline () const
TSpline3 &	spline ()
virtual void	rnd_to_fct (float value[], const float rnd[]) const
	Function gets array of random numbers rnd[] in the range [0,1) as arguments and returns function value in array value.
virtual int	ndim () const
	Return the number of dimensions for the function.
virtual bool	operator== (const TFCS1DFunction &ref) const
	The == operator compares the content of instances.
virtual std::size_t	MemorySize () const
	Gives the total memory size, including the size of additional memory allocated inside the class.
bool	msgLvl (const MSG::Level lvl) const
	Check whether the logging system is active at the provided verbosity level.
MsgStream &	msg () const
	Return a stream for sending messages directly (no decoration)
MsgStream &	msg (const MSG::Level lvl) const
	Return a decorated starting stream for sending messages.
MSG::Level	level () const
	Retrieve output level.
virtual void	setLevel (MSG::Level lvl)
	Update outputlevel.

Static Public Member Functions
static double	get_maxdev (const TH1 *hist, const TSpline3 &sp, double &maxeffsig, double &p_maxdev, double &p_maxeffsig, int ntoy=10000)
static void unit_test	ATLAS_NOT_THREAD_SAFE (TH1 *hist=nullptr)
static double	get_maxdev (TH1 *, TH1 *)
static double	CheckAndIntegrate1DHistogram (const TH1 *hist, std::vector< double > &integral_vec, int &first, int &last)
static TH1 *generate_histogram_random_slope	ATLAS_NOT_THREAD_SAFE (int nbinsx=50, double xmin=0, double xmax=1, double zerothreshold=0.1)
static TH1 *generate_histogram_random_gauss	ATLAS_NOT_THREAD_SAFE (int nbinsx=50, int ntoy=100000, double xmin=1, double xmax=5, double xpeak=1.5, double sigma=0.6)
static void unit_test	ATLAS_NOT_THREAD_SAFE (TH1 *hist, TFCS1DFunction *rtof, int nrnd=1000000, TH1 *histfine=nullptr)
static std::string	startMsg (MSG::Level lvl, const std::string &file, int line)
	Make a message to decorate the start of logging.

Static Protected Member Functions
static double	optimize (TSpline3 &sp_best, std::vector< double > &nprop, const TH1 *hist, TFCS1DFunctionInt32Histogram &hist_fct, double maxdevgoal=0.01, double maxeffsiggoal=3)

Protected Attributes
TSpline3	m_spline

Private Attributes
std::string	m_nm
	Message source name.

Static Private Attributes
static boost::thread_specific_ptr< MsgStream > m_msg_tls	ATLAS_THREAD_SAFE
	Do not persistify!

Detailed Description

Definition at line 17 of file TFCS1DFunctionSpline.h.

Constructor & Destructor Documentation

TFCS1DFunctionSpline()

TFCS1DFunctionSpline::TFCS1DFunctionSpline ( TH1 * hist = nullptr, double maxdevgoal = 0.01, double maxeffsiggoal = 3, int maxnp = 20 )

inline

Definition at line 21 of file TFCS1DFunctionSpline.h.

                                                                 {
    if (hist)
      Initialize(hist, maxdevgoal, maxeffsiggoal, maxnp);
  };

~TFCS1DFunctionSpline()

TFCS1DFunctionSpline::~TFCS1DFunctionSpline ( )

inline

Definition at line 26 of file TFCS1DFunctionSpline.h.

{};

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/4]

TH1 *generate_histogram_random_slope TFCS1DFunction::ATLAS_NOT_THREAD_SAFE ( int nbinsx = 50, double xmin = 0, double xmax = 1, double zerothreshold = 0.1 )

staticinherited

ATLAS_NOT_THREAD_SAFE() [2/4]

TH1 *generate_histogram_random_gauss TFCS1DFunction::ATLAS_NOT_THREAD_SAFE ( int nbinsx = 50, int ntoy = 100000, double xmin = 1, double xmax = 5, double xpeak = 1.5, double sigma = 0.6 )

staticinherited

ATLAS_NOT_THREAD_SAFE() [3/4]

void unit_test TFCS1DFunction::ATLAS_NOT_THREAD_SAFE ( TH1 * hist, TFCS1DFunction * rtof, int nrnd = 1000000, TH1 * histfine = nullptr )

staticinherited

ATLAS_NOT_THREAD_SAFE() [4/4]

void unit_test TFCS1DFunctionSpline::ATLAS_NOT_THREAD_SAFE ( TH1 * hist = nullptr )

static

CheckAndIntegrate1DHistogram()

double TFCS1DFunction::CheckAndIntegrate1DHistogram ( const TH1 * hist, std::vector< double > & integral_vec, int & first, int & last )

staticinherited

Definition at line 53 of file TFCS1DFunction.cxx.

                                                                             {
  ISF_FCS::MLogging logger;
  Int_t nbins = hist->GetNbinsX();
 
  float integral = 0;
  integral_vec.resize(nbins);
  for (int ix = 1; ix <= nbins; ix++) {
    float binval = hist->GetBinContent(ix);
    if (binval < 0) {
      // Can't work if a bin is negative, forcing bins to 0 in this case
      double fraction = binval / hist->Integral();
      if (std::abs(fraction) > 1e-5) {
        ATH_MSG_NOCLASS(logger, "Warning: bin content is negative in histogram "
                                    << hist->GetName() << " : "
                                    << hist->GetTitle() << " binval=" << binval
                                    << " " << fraction * 100
                                    << "% of integral=" << hist->Integral()
                                    << ". Forcing bin to 0.");
      }
      binval = 0;
    }
    integral += binval;
    integral_vec[ix - 1] = integral;
  }
 
  for (first = 0; first < nbins; first++)
    if (integral_vec[first] != 0)
      break;
  for (last = nbins - 1; last > 0; last--)
    if (integral_vec[last] != integral)
      break;
  last++;
 
  if (integral <= 0) {
    ATH_MSG_NOCLASS(logger, "Error: histogram "
                                << hist->GetName() << " : " << hist->GetTitle()
                                << " integral=" << integral << " is <=0");
  }
  return integral;
}

get_maxdev() [1/2]

double TFCS1DFunction::get_maxdev ( TH1 * h_input1, TH1 * h_approx1 )

staticinherited

Definition at line 22 of file TFCS1DFunction.cxx.

                                                               {
  TH1D *h_input = (TH1D *)h_input1->Clone("h_input");
  TH1D *h_approx = (TH1D *)h_approx1->Clone("h_approx");
 
  double maxdev = 0.0;
 
  // normalize the histos to the same area:
  double integral_input = h_input->Integral();
  double integral_approx = 0.0;
  for (int b = 1; b <= h_input->GetNbinsX(); b++)
    integral_approx +=
        h_approx->GetBinContent(h_approx->FindBin(h_input->GetBinCenter(b)));
  h_approx->Scale(integral_input / integral_approx);
 
  double ymax = h_approx->GetBinContent(h_approx->GetNbinsX()) -
                h_approx->GetBinContent(h_approx->GetMinimumBin());
  for (int i = 1; i <= h_input->GetNbinsX(); i++) {
    double val = std::abs(h_approx->GetBinContent(
                          h_approx->FindBin(h_input->GetBinCenter(i))) -
                      h_input->GetBinContent(i)) /
                 ymax;
    if (val > maxdev)
      maxdev = val;
  }
 
  delete h_input;
  delete h_approx;
 
  return maxdev * 100.0;
}

get_maxdev() [2/2]

double TFCS1DFunctionSpline::get_maxdev ( const TH1 * hist, const TSpline3 & sp, double & maxeffsig, double & p_maxdev, double & p_maxeffsig, int ntoy = 10000 )

static

Definition at line 320 of file TFCS1DFunctionSpline.cxx.

                                                                       {
  double maxdev = 0;
  maxeffsig = 0;
 
  TH1 *hist_clone = (TH1 *)hist->Clone("hist_clone");
  hist_clone->SetDirectory(nullptr);
  hist_clone->Reset();
  double interr = 0;
  double integral = hist->IntegralAndError(1, hist->GetNbinsX(), interr);
  double effN = integral / interr;
  effN *= effN;
  // ATH_MSG_INFO("integral="<<integral<<" +- "<<interr<<"
  // relerr="<<interr/integral); ATH_MSG_INFO("effN="<<effN<<" +-
  // "<<TMath::Sqrt(effN)<<" relerr="<<1/TMath::Sqrt(effN));
  double toyweight = 1.0 / ntoy;
  for (int itoy = 0; itoy < ntoy; ++itoy) {
    double prop = itoy * toyweight;
    hist_clone->Fill(sp.Eval(prop), toyweight);
  }
 
  double int1 = 0;
  double int2 = 0;
  for (int i = 0; i <= hist->GetNbinsX() + 1; i++) {
    int1 += hist->GetBinContent(i) / integral;
    int2 += hist_clone->GetBinContent(i);
    double val = TMath::Abs(int1 - int2);
    if (val > maxdev) {
      maxdev = val;
      p_maxdev = int1;
    }
 
    // now view the normalized integral as selection efficiency from a total
    // sample of sizze effN
    double int1err = TMath::Sqrt(int1 * (1 - int1) / effN);
    double valsig = 0;
    if (int1err > 0)
      valsig = val / int1err;
    if (valsig > maxeffsig) {
      maxeffsig = valsig;
      p_maxeffsig = int1;
    }
 
    // ATH_MSG_INFO(i<<": diff="<<int1-int2<<" sig(diff)="<<valsig<<"
    // int1="<<int1<<" +- "<<int1err<<" int2="<<int2<<" maxdev="<<maxdev<<"
    // maxeffsig="<<maxeffsig);
  }
 
  delete hist_clone;
 
  return maxdev;
}

Initialize()

double TFCS1DFunctionSpline::Initialize	(	TH1 *	hist,
		double	maxdevgoal = 0.01,
		double	maxeffsiggoal = 3,
		int	maxnp = 20 )

Definition at line 19 of file TFCS1DFunctionSpline.cxx.

                                                                         {
  double max_penalty_best = -1;
  TSpline3 sp_best;
  for (int np = 3; np <= maxnp; ++np) {
    ATH_MSG_INFO("========== Spline #=" << np << " ==============");
    double max_penalty;
    if (max_penalty_best > 0) {
      max_penalty =
          InitializeFromSpline(hist, sp_best, maxdevgoal, maxeffsiggoal);
      if (max_penalty_best < 0 || max_penalty < max_penalty_best) {
        max_penalty_best = max_penalty;
        sp_best = m_spline;
      }
    }
 
    max_penalty = InitializeEqualDistance(hist, maxdevgoal, maxeffsiggoal, np);
    if (max_penalty_best < 0 || max_penalty < max_penalty_best) {
      max_penalty_best = max_penalty;
      sp_best = m_spline;
    }
 
    max_penalty =
        InitializeEqualProbability(hist, maxdevgoal, maxeffsiggoal, np);
    if (max_penalty_best < 0 || max_penalty < max_penalty_best) {
      max_penalty_best = max_penalty;
      sp_best = m_spline;
    }
 
    ATH_MSG_INFO("========== Spline #=" << np << " max_penalty_best="
                                        << max_penalty_best
                                        << " ==============");
    ATH_MSG(INFO) << "==== Best spline init | ";
    for (int i = 0; i < sp_best.GetNp(); ++i) {
      double p, x;
      sp_best.GetKnot(i, p, x);
      ATH_MSG(INFO) << i << " : p=" << p << " x=" << x << " ; ";
    }
    ATH_MSG(INFO) << " =====" << END_MSG(INFO);
 
    if (max_penalty_best < 2)
      break;
  }
  m_spline = sp_best;
 
  return max_penalty_best;
}

InitializeEqualDistance()

double TFCS1DFunctionSpline::InitializeEqualDistance	(	TH1 *	hist,
		double	maxdevgoal = 0.01,
		double	maxeffsiggoal = 3,
		int	nsplinepoints = 5 )

Definition at line 136 of file TFCS1DFunctionSpline.cxx.

                                                                        {
  TFCS1DFunctionInt32Histogram hist_fct(hist);
 
  double xmin = 0;
  double xmax = 0;
  for (int i = 1; i <= hist->GetNbinsX(); i++) {
    xmin = hist->GetXaxis()->GetBinLowEdge(i);
    if (hist->GetBinContent(i) > 0)
      break;
  }
  for (int i = hist->GetNbinsX(); i >= 1; i--) {
    xmax = hist->GetXaxis()->GetBinUpEdge(i);
    if (hist->GetBinContent(i) > 0)
      break;
  }
  // ATH_MSG_INFO("xmin="<<xmin<<" xmax="<<xmax);
 
  double dx = (xmax - xmin) / (nsplinepoints - 1);
 
  std::vector<double> nprop(nsplinepoints);
  std::vector<double> nx(nsplinepoints);
  nprop[0] = 0;
  nx[0] = hist_fct.rnd_to_fct(nprop[0]);
  // ATH_MSG_INFO(0<<" p="<<nprop[0]<<" x="<<nx[0]);
  for (int i = 1; i < nsplinepoints; ++i) {
    nx[i] = xmin + i * dx;
    double p_min = 0;
    double p_max = 1;
    double p_test;
    double tx;
    do {
      p_test = 0.5 * (p_min + p_max);
      tx = hist_fct.rnd_to_fct(p_test);
      if (nx[i] < tx)
        p_max = p_test;
      else
        p_min = p_test;
      if ((p_max - p_min) < 0.0000001)
        break;
    } while (TMath::Abs(tx - nx[i]) > dx / 10);
    // ATH_MSG_INFO(i<<" p="<<p_test<<" x="<<tx);
    nprop[i] = p_test;
  }
 
  double max_penalty =
      optimize(m_spline, nprop, hist, hist_fct, maxdevgoal, maxeffsiggoal);
  double maxeffsig;
  double p_maxdev;
  double p_maxeffsig;
  double maxdev = get_maxdev(hist, m_spline, maxeffsig, p_maxdev, p_maxeffsig);
  ATH_MSG_INFO("Spline init equ. dist. #=" << nsplinepoints << " : maxdev="
                                           << maxdev << " p_maxdev=" << p_maxdev
                                           << " maxeffsig=" << maxeffsig
                                           << " p_maxeffsig=" << p_maxeffsig
                                           << " max_penalty=" << max_penalty);
  ATH_MSG(INFO) << "  ";
  for (int i = 0; i < m_spline.GetNp(); ++i) {
    double p, x;
    m_spline.GetKnot(i, p, x);
    ATH_MSG(INFO) << i << " : p=" << p << " x=" << x << " ; ";
  }
  ATH_MSG(INFO) << END_MSG(INFO);
  return max_penalty;
}

InitializeEqualProbability()

double TFCS1DFunctionSpline::InitializeEqualProbability	(	TH1 *	hist,
		double	maxdevgoal = 0.01,
		double	maxeffsiggoal = 3,
		int	nsplinepoints = 5 )

Definition at line 204 of file TFCS1DFunctionSpline.cxx.

                                                                           {
  TFCS1DFunctionInt32Histogram hist_fct(hist);
 
  double dprop = 1.0 / (nsplinepoints - 1);
  std::vector<double> nprop(nsplinepoints);
  for (int i = 0; i < nsplinepoints; ++i) {
    nprop[i] = i * dprop;
  }
 
  double max_penalty =
      optimize(m_spline, nprop, hist, hist_fct, maxdevgoal, maxeffsiggoal);
  double maxeffsig;
  double p_maxdev;
  double p_maxeffsig;
  double maxdev = get_maxdev(hist, m_spline, maxeffsig, p_maxdev, p_maxeffsig);
  ATH_MSG_INFO("Spline init equ. prob. #=" << nsplinepoints << " : maxdev="
                                           << maxdev << " p_maxdev=" << p_maxdev
                                           << " maxeffsig=" << maxeffsig
                                           << " p_maxeffsig=" << p_maxeffsig
                                           << " max_penalty=" << max_penalty);
  ATH_MSG(INFO) << "  ";
  for (int i = 0; i < m_spline.GetNp(); ++i) {
    double p, x;
    m_spline.GetKnot(i, p, x);
    ATH_MSG(INFO) << i << " : p=" << p << " x=" << x << " ; ";
  }
  ATH_MSG(INFO) << END_MSG(INFO);
  return max_penalty;
}

InitializeFromSpline()

double TFCS1DFunctionSpline::InitializeFromSpline	(	TH1 *	hist,
		const TSpline3 &	sp,
		double	maxdevgoal = 0.01,
		double	maxeffsiggoal = 3 )

Definition at line 67 of file TFCS1DFunctionSpline.cxx.

                                                                        {
  TFCS1DFunctionInt32Histogram hist_fct(hist);
 
  double maxeffsig;
  double p_maxdev;
  double p_maxeffsig;
  double maxdev = get_maxdev(hist, sp, maxeffsig, p_maxdev, p_maxeffsig);
  double p_improve;
  if (maxdev / maxdevgoal > maxeffsig / maxeffsiggoal)
    p_improve = p_maxdev;
  else
    p_improve = p_maxeffsig;
 
  int nsplinepoints = sp.GetNp();
  std::vector<double> nprop(nsplinepoints + 1);
  int ind = 0;
  ATH_MSG(INFO) << "Spline init p_improve=" << p_improve << " | ";
  for (int i = 0; i < nsplinepoints; ++i) {
    double p, x;
    sp.GetKnot(i, p, x);
    if (i == 0 && p_improve < p) {
      nprop[ind] = (0 + p) / 2;
      ATH_MSG(INFO) << ind << " : pi=" << nprop[ind] << " ; ";
      ++ind;
    }
 
    nprop[ind] = p;
    ATH_MSG(INFO) << ind << " : p=" << nprop[ind] << " ; ";
    ++ind;
 
    if (i == nsplinepoints - 1 && p_improve > p) {
      nprop[ind] = (1 + p) / 2;
      ATH_MSG(INFO) << ind << " : pi=" << nprop[ind] << " ; ";
      ++ind;
    }
    if (i < nsplinepoints - 1) {
      double pn, xn;
      sp.GetKnot(i + 1, pn, xn);
      if (p_improve > p && p_improve < pn) {
        nprop[ind] = (p + pn) / 2;
        ATH_MSG(INFO) << ind << " : pi=" << nprop[ind] << " ; ";
        ++ind;
      }
    }
  }
  ATH_MSG(INFO) << END_MSG(INFO);
  nsplinepoints = ind;
  nprop.resize(nsplinepoints);
 
  double max_penalty =
      optimize(m_spline, nprop, hist, hist_fct, maxdevgoal, maxeffsiggoal);
  maxdev = get_maxdev(hist, m_spline, maxeffsig, p_maxdev, p_maxeffsig);
  ATH_MSG_INFO("Spline init spline #=" << nsplinepoints << " : maxdev="
                                       << maxdev << " p_maxdev=" << p_maxdev
                                       << " maxeffsig=" << maxeffsig
                                       << " p_maxeffsig=" << p_maxeffsig
                                       << " max_penalty=" << max_penalty);
  ATH_MSG(INFO) << "  ";
  for (int i = 0; i < m_spline.GetNp(); ++i) {
    double p, x;
    m_spline.GetKnot(i, p, x);
    ATH_MSG(INFO) << i << " : p=" << p << " x=" << x << " ; ";
  }
  ATH_MSG(INFO) << END_MSG(INFO);
  return max_penalty;
}

level()

MSG::Level ISF_FCS::MLogging::level ( ) const

inlineinherited

Retrieve output level.

Definition at line 201 of file MLogging.h.

{ return msg().level(); }

MemorySize()

virtual std::size_t TFCSFunction::MemorySize ( ) const

inlinevirtualinherited

Gives the total memory size, including the size of additional memory allocated inside the class.

Reimplemented in TFCS1DFunctionTemplateHistogram< Txvec, Ty, Trandom >, TFCS1DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, uint16_t, float >, TFCS1DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, uint32_t, float >, TFCS1DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, uint32_t, float >, TFCS1DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, uint16_t, float >, TFCS1DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, uint32_t, float >, TFCS1DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, uint8_t, float >, TFCS1DFunctionTemplateHistogram< Txvec, Ty, float >, TFCS2DFunctionTemplateHistogram< Txvec, Tyvec, Tz, Trandom >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt16BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt32BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt16BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt32BinEdges, uint8_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint16_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint32_t, float >, TFCS2DFunctionTemplateHistogram< TFCS1DFunction_HistogramInt8BinEdges, TFCS1DFunction_HistogramInt8BinEdges, uint8_t, float >, and TFCS2DFunctionTemplateHistogram< Txvec, Tyvec, Tz, float >.

Definition at line 19 of file TFCSFunction.h.

{ return sizeof(*this); };

msg() [1/2]

MsgStream & ISF_FCS::MLogging::msg ( ) const

inlineinherited

Return a stream for sending messages directly (no decoration)

Definition at line 231 of file MLogging.h.

                                      {
  MsgStream *ms = m_msg_tls.get();
  if (!ms) {
    ms = new MsgStream(Athena::getMessageSvc(), m_nm);
    m_msg_tls.reset(ms);
  }
  return *ms;
}

msg() [2/2]

MsgStream & ISF_FCS::MLogging::msg ( const MSG::Level lvl ) const

inlineinherited

Return a decorated starting stream for sending messages.

Definition at line 240 of file MLogging.h.

                                                        {
  return msg() << lvl;
}

msgLvl()

bool ISF_FCS::MLogging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Check whether the logging system is active at the provided verbosity level.

Definition at line 222 of file MLogging.h.

                                                     {
  if (msg().level() <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

ndim()

virtual int TFCS1DFunction::ndim ( ) const

inlinevirtualinherited

Return the number of dimensions for the function.

Reimplemented from TFCSFunction.

Definition at line 22 of file TFCS1DFunction.h.

{ return 1; };

operator==()

virtual bool TFCS1DFunction::operator== ( const TFCS1DFunction & ref ) const

inlinevirtualinherited

The == operator compares the content of instances.

The implementation in the base class only returns true for a comparison with itself

Reimplemented in TFCS1DFunctionInt32Histogram.

Definition at line 36 of file TFCS1DFunction.h.

                                                           {
    return this == &ref;
  };

optimize()

double TFCS1DFunctionSpline::optimize ( TSpline3 & sp_best, std::vector< double > & nprop, const TH1 * hist, TFCS1DFunctionInt32Histogram & hist_fct, double maxdevgoal = 0.01, double maxeffsiggoal = 3 )

staticprotected

Definition at line 237 of file TFCS1DFunctionSpline.cxx.

                                                                               {
  int nsplinepoints = (int)nprop.size();
  // double xmin=hist->GetXaxis()->GetXmin();
  // double xmax=hist->GetXaxis()->GetXmax();
  std::vector<double> nx(nsplinepoints);
  std::vector<double> nprop_try = nprop;
  double max_penalty = -1;
  double p_gotobest = 0.5 / nsplinepoints;
  int ntry = 200 / p_gotobest;
  // int itrytot=0;
  for (double dproploop = 0.4 / nsplinepoints; dproploop > 0.02 / nsplinepoints;
       dproploop /= 2) {
    double dprop = dproploop;
    int n_nogain = 0;
    for (int itry = 0; itry < ntry; ++itry) {
      // itrytot++;
      for (int i = 0; i < nsplinepoints; ++i) {
        nx[i] = hist_fct.rnd_to_fct(nprop_try[i]);
      }
      TSpline3 sp("1Dspline", nprop_try.data(), nx.data(), nsplinepoints,
                  "b2e2", 0, 0);
      double maxeffsig;
      double p_maxdev;
      double p_maxeffsig;
      double maxdev = get_maxdev(hist, sp, maxeffsig, p_maxdev, p_maxeffsig);
      double penalty = maxdev / maxdevgoal + maxeffsig / maxeffsiggoal;
      if (max_penalty < 0 || penalty < max_penalty) {
        max_penalty = penalty;
        nprop = nprop_try;
        sp_best = sp;
        /*
        ATH_MSG(INFO) <<"#="<<nsplinepoints<<" try="<<itrytot-1<<" | ";
        for(int i=0;i<nsplinepoints;++i) {
          ATH_MSG(INFO) <<i<<":p="<<nprop_try[i]<<" x="<<nx[i]<<" ; ";
        }
        ATH_MSG(INFO) <<"new maxdev="<<maxdev<<" maxeffsig="<<maxeffsig<<"
        max_penalty="<<max_penalty<<END_MSG(INFO);
        */
        n_nogain = 0;
      } else {
        if (gRandom->Rndm() < p_gotobest)
          nprop_try = nprop;
        ++n_nogain;
        // allow ~20 times retrying from the best found spline before aborting
        if (n_nogain > 20 / p_gotobest)
          break;
      }
      int ip = 1 + gRandom->Rndm() * (nsplinepoints - 1);
      if (ip > nsplinepoints - 1)
        ip = nsplinepoints - 1;
      double d = dprop;
      if (gRandom->Rndm() > 0.5)
        d = -dprop;
      double nprop_new = nprop_try[ip] + d;
      if (ip > 0)
        if (nprop_try[ip - 1] + dprop / 2 > nprop_new) {
          nprop_new = nprop_try[ip];
          dprop /= 2;
        }
      if (ip < nsplinepoints - 1)
        if (nprop_new > nprop_try[ip + 1] - dprop / 2) {
          nprop_new = nprop_try[ip];
          dprop /= 2;
        }
      if (nprop_new < 0) {
        nprop_new = 0;
        dprop /= 2;
      }
      if (nprop_new > 1) {
        nprop_new = 1;
        dprop /= 2;
      }
      nprop_try[ip] = nprop_new;
    }
    nprop_try = nprop;
  }
  return max_penalty;
}

rnd_to_fct() [1/2]

double TFCS1DFunctionSpline::rnd_to_fct ( double rnd ) const

virtual

Function gets random number rnd in the range [0,1) as argument and returns function value according to a histogram distribution.

Implements TFCS1DFunction.

Definition at line 374 of file TFCS1DFunctionSpline.cxx.

                                                        {
  return m_spline.Eval(rnd);
}

rnd_to_fct() [2/2]

void TFCS1DFunction::rnd_to_fct ( float value[], const float rnd[] ) const

virtual

Function gets array of random numbers rnd[] in the range [0,1) as arguments and returns function value in array value.

For a n-dimensional function, value and rnd should both have n elements.

Reimplemented from TFCS1DFunction.

Definition at line 27 of file TFCS1DFunction.cxx.

                                                                      {
  value[0] = rnd_to_fct(rnd[0]);
}

setLevel()

void ISF_FCS::MLogging::setLevel ( MSG::Level lvl )

virtualinherited

Update outputlevel.

Definition at line 105 of file MLogging.cxx.

                                    {
  lvl = (lvl >= MSG::NUM_LEVELS) ? MSG::ALWAYS
        : (lvl < MSG::NIL)       ? MSG::NIL
                                 : lvl;
  msg().setLevel(lvl);
}

spline() [1/2]

TSpline3 & TFCS1DFunctionSpline::spline ( )

inline

Definition at line 52 of file TFCS1DFunctionSpline.h.

{ return m_spline; };

spline() [2/2]

const TSpline3 & TFCS1DFunctionSpline::spline ( ) const

inline

Definition at line 51 of file TFCS1DFunctionSpline.h.

{ return m_spline; };

startMsg()

std::string ISF_FCS::MLogging::startMsg ( MSG::Level lvl, const std::string & file, int line )

staticinherited

Make a message to decorate the start of logging.

Print a message for the start of logging.

Definition at line 116 of file MLogging.cxx.

                                                                          {
  int col1_len = 20;
  int col2_len = 5;
  int col3_len = 10;
  auto last_slash = file.find_last_of('/');
  int path_len = last_slash == std::string::npos ? 0 : last_slash;
  int trim_point = path_len;
  int total_len = file.length();
  if (total_len - path_len > col1_len)
    trim_point = total_len - col1_len;
  std::string trimmed_name = file.substr(trim_point);
  const char *LevelNames[MSG::NUM_LEVELS] = {
      "NIL", "VERBOSE", "DEBUG", "INFO", "WARNING", "ERROR", "FATAL", "ALWAYS"};
  std::string level = LevelNames[lvl];
  std::string level_string = std::string("(") + level + ") ";
  std::stringstream output;
  output << std::setw(col1_len) << std::right << trimmed_name << ":"
         << std::setw(col2_len) << std::left << line << std::setw(col3_len)
         << std::right << level_string;
  return output.str();
}

Member Data Documentation

ATLAS_THREAD_SAFE

boost::thread_specific_ptr<MsgStream> m_msg_tls ISF_FCS::MLogging::ATLAS_THREAD_SAFE

inlinestaticprivateinherited

Do not persistify!

MsgStream instance (a std::cout like with print-out levels)

Definition at line 215 of file MLogging.h.

m_nm

std::string ISF_FCS::MLogging::m_nm

privateinherited

Message source name.

Definition at line 211 of file MLogging.h.

m_spline

TSpline3 TFCS1DFunctionSpline::m_spline

protected

Definition at line 62 of file TFCS1DFunctionSpline.h.

---

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

• TFCS1DFunctionSpline.h
• TFCS1DFunctionSpline.cxx