TFCS1DFunctionHistogram Class Reference

#include <TFCS1DFunctionHistogram.h>

Inheritance diagram for TFCS1DFunctionHistogram:

Collaboration diagram for TFCS1DFunctionHistogram:

Public Member Functions
	TFCS1DFunctionHistogram ()
	TFCS1DFunctionHistogram (TH1 *hist, double)
void	Initialize (TH1 *hist, double)
virtual double	rnd_to_fct (double rnd) const
	Function gets random number rnd in the range [0,1) as argument and returns function value.
TH1 *	vector_to_histo ()
double	get_inverse (double rnd) const
void	smart_rebin_loop (TH1 *hist, double)
double	sample_from_histovalues (double)
const std::vector< float > &	get_HistoBorders ()
const std::vector< float > &	get_HistoContents ()
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	linear (double y1, double y2, double x1, double x2, double x)
static double	non_linear (double y1, double y2, double x1, double x2, double x)
static double	get_maxdev (TH1 *, TH1D *)
static double	get_change (TH1 *)
static TH1D *	smart_rebin (TH1D *)
static std::unique_ptr< double[]>	histo_to_array (TH1 *)
static double	sample_from_histo (TH1 *hist, double)
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.

Protected Attributes
std::vector< float >	m_HistoBorders
std::vector< float >	m_HistoContents

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 13 of file TFCS1DFunctionHistogram.h.

Constructor & Destructor Documentation

TFCS1DFunctionHistogram() [1/2]

TFCS1DFunctionHistogram::TFCS1DFunctionHistogram ( )

inline

Definition at line 16 of file TFCS1DFunctionHistogram.h.

{};

TFCS1DFunctionHistogram() [2/2]

TFCS1DFunctionHistogram::TFCS1DFunctionHistogram	(	TH1 *	hist,
		double	cut_maxdev )

Definition at line 16 of file TFCS1DFunctionHistogram.cxx.

                                                                             {
  Initialize(hist, cut_maxdev);
}

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/3]

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/3]

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/3]

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

staticinherited

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_change()

double TFCS1DFunctionHistogram::get_change ( TH1 * histo )

static

Definition at line 151 of file TFCS1DFunctionHistogram.cxx.

                                                     {
  // return the smallest change between 2 bin contents, but don't check the last
  // bin, because that one never gets merged
  double minchange = 100.0;
  for (int b = 2; b < histo->GetNbinsX(); b++) {
    double diff = histo->GetBinContent(b) - histo->GetBinContent(b - 1);
    if (diff < minchange && diff > 0)
      minchange = diff;
  }
 
  return minchange;
}

get_HistoBorders()

const std::vector< float > & TFCS1DFunctionHistogram::get_HistoBorders ( )

inline

Definition at line 37 of file TFCS1DFunctionHistogram.h.

{ return m_HistoBorders; };

get_HistoContents()

const std::vector< float > & TFCS1DFunctionHistogram::get_HistoContents ( )

inline

Definition at line 38 of file TFCS1DFunctionHistogram.h.

{ return m_HistoContents; };

get_inverse()

double TFCS1DFunctionHistogram::get_inverse

(

double

rnd

)

const

Definition at line 260 of file TFCS1DFunctionHistogram.cxx.

                                                            {
 
  double value = 0.;
 
  if (rnd < m_HistoContents[0]) {
    double x1 = m_HistoBorders[0];
    double x2 = m_HistoBorders[1];
    double y1 = 0;
    double y2 = m_HistoContents[0];
    double x = non_linear(y1, y2, x1, x2, rnd);
    value = x;
  } else {
    // find the first HistoContent element that is larger than rnd:
    vector<float>::const_iterator larger_element =
        std::upper_bound(m_HistoContents.begin(), m_HistoContents.end(), rnd);
    size_t index = larger_element - m_HistoContents.begin();
    if (index >= m_HistoContents.size()) {
      --index;
    }
    double y = m_HistoContents[index];
    double x1 = m_HistoBorders[index];
    double x2 = m_HistoBorders[index + 1];
    double y1 = m_HistoContents[index - 1];
    double y2 = y;
    if ((index + 1) == (m_HistoContents.size() - 1)) {
      x2 = m_HistoBorders[m_HistoBorders.size() - 1];
      y2 = m_HistoContents[m_HistoContents.size() - 1];
    }
    double x = non_linear(y1, y2, x1, x2, rnd);
    value = x;
  }
 
  return value;
}

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 TFCS1DFunctionHistogram::get_maxdev ( TH1 * h_in, TH1D * h_out )

static

Definition at line 139 of file TFCS1DFunctionHistogram.cxx.

                                                                 {
 
  double maxdev = 0;
  for (int i = 1; i <= h_in->GetNbinsX(); i++) {
    int bin = h_out->FindBin(h_in->GetBinCenter(i));
    double val = fabs(h_out->GetBinContent(bin) - h_in->GetBinContent(i));
    if (val > maxdev)
      maxdev = val;
  }
  return maxdev;
}

histo_to_array()

std::unique_ptr< double[]> TFCS1DFunctionHistogram::histo_to_array ( TH1 * hist )

static

Definition at line 25 of file TFCS1DFunctionHistogram.cxx.

                                                 {
 
  TH1D *h_clone = (TH1D *)hist->Clone("h_clone");
  h_clone->Scale(1.0 / h_clone->Integral());
 
  auto histoVals = std::make_unique<double[]>(h_clone->GetNbinsX());
  histoVals[0] = h_clone->GetBinContent(1);
  for (int i = 1; i < h_clone->GetNbinsX(); i++) {
    histoVals[i] = histoVals[i - 1] + h_clone->GetBinContent(i + 1);
  }
  delete h_clone;
  return histoVals;
}

Initialize()

void TFCS1DFunctionHistogram::Initialize	(	TH1 *	hist,
		double	cut_maxdev )

Definition at line 20 of file TFCS1DFunctionHistogram.cxx.

                                                                     {
  smart_rebin_loop(hist, cut_maxdev);
}

level()

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

inlineinherited

Retrieve output level.

Definition at line 201 of file MLogging.h.

{ return msg().level(); }

linear()

double TFCS1DFunctionHistogram::linear ( double y1, double y2, double x1, double x2, double x )

static

Definition at line 230 of file TFCS1DFunctionHistogram.cxx.

                                                            {
  double x = -1;
 
  double eps = 0.0000000001;
  if ((y2 - y1) < eps)
    x = x1;
  else {
    double m = (y2 - y1) / (x2 - x1);
    double n = y1 - m * x1;
    x = (y - n) / m;
  }
 
  return x;
}

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; };

non_linear()

double TFCS1DFunctionHistogram::non_linear ( double y1, double y2, double x1, double x2, double x )

static

Definition at line 246 of file TFCS1DFunctionHistogram.cxx.

                                                                {
  double x = -1;
  double eps = 0.0000000001;
  if ((y2 - y1) < eps)
    x = x1;
  else {
    double b = (x1 - x2) / (sqrt(y1) - sqrt(y2));
    double a = x1 - b * sqrt(y1);
    x = a + b * sqrt(y);
  }
  return x;
}

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;
  };

rnd_to_fct() [1/2]

double TFCS1DFunctionHistogram::rnd_to_fct ( double rnd ) const

virtual

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

Implements TFCS1DFunction.

Definition at line 223 of file TFCS1DFunctionHistogram.cxx.

                                                           {
 
  double value2 = get_inverse(rnd);
 
  return value2;
}

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]);
}

sample_from_histo()

double TFCS1DFunctionHistogram::sample_from_histo ( TH1 * hist, double random )

static

Definition at line 39 of file TFCS1DFunctionHistogram.cxx.

                                                                          {
 
  auto histoVals = histo_to_array(hist);
  double value = 0.0;
  int chosenBin =
      (int)TMath::BinarySearch(hist->GetNbinsX(), histoVals.get(), random);
  value = hist->GetBinCenter(chosenBin + 2);
 
  // cleanup
 
  return value;
}

sample_from_histovalues()

double TFCS1DFunctionHistogram::sample_from_histovalues

(

double

random

)

Definition at line 52 of file TFCS1DFunctionHistogram.cxx.

                                                                     {
  double value = 0.0;
 
  TH1 *hist = vector_to_histo();
  hist->SetName("hist");
  auto histoVals = histo_to_array(hist);
  int chosenBin =
      (int)TMath::BinarySearch(hist->GetNbinsX(), histoVals.get(), random);
  value = hist->GetBinCenter(chosenBin + 2);
 
  return value;
}

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);
}

smart_rebin()

TH1D * TFCS1DFunctionHistogram::smart_rebin ( TH1D * h_input )

static

Definition at line 164 of file TFCS1DFunctionHistogram.cxx.

                                                        {
 
  TH1D *h_out1 = (TH1D *)h_input->Clone("h_out1");
 
  // get the smallest change
  double change = get_change(h_out1) * 1.00001;
 
  vector<double> content;
  vector<double> binborder;
 
  binborder.push_back(h_out1->GetXaxis()->GetXmin());
 
  int merged = 0;
  int skip = 0;
  int secondlastbin_merge = 0;
  for (int b = 1; b < h_out1->GetNbinsX() - 1; b++) // never touch the last bin
  {
    double thisBin = h_out1->GetBinContent(b);
    double nextBin = h_out1->GetBinContent(b + 1);
    double width = h_out1->GetBinWidth(b);
    double nextwidth = h_out1->GetBinWidth(b + 1);
    double diff = fabs(nextBin - thisBin);
    if (!skip && (diff > change || merged)) {
      binborder.push_back(h_out1->GetBinLowEdge(b + 1));
      content.push_back(thisBin);
    }
    skip = 0;
    if (diff <= change && !merged) {
      double sum = thisBin * width + nextBin * nextwidth;
      double sumwidth = width + nextwidth;
      binborder.push_back(h_out1->GetBinLowEdge(b + 2));
      content.push_back(sum / sumwidth);
      merged = 1;
      skip = 1;
      if (b == (h_out1->GetNbinsX() - 2))
        secondlastbin_merge = 1;
    }
  } // for b
  if (!secondlastbin_merge) {
    binborder.push_back(h_out1->GetBinLowEdge(h_out1->GetNbinsX()));
    content.push_back(h_out1->GetBinContent(h_out1->GetNbinsX() - 1));
  }
  binborder.push_back(h_out1->GetXaxis()->GetXmax());
  content.push_back(h_out1->GetBinContent(h_out1->GetNbinsX()));
 
  double *bins = new double[content.size() + 1];
  for (unsigned int i = 0; i < binborder.size(); i++)
    bins[i] = binborder[i];
 
  TH1D *h_out2 = new TH1D("h_out2", "h_out2", content.size(), bins);
  for (unsigned int b = 1; b <= content.size(); b++)
    h_out2->SetBinContent(b, content[b - 1]);
 
  delete[] bins;
  delete h_out1;
 
  return h_out2;
}

smart_rebin_loop()

void TFCS1DFunctionHistogram::smart_rebin_loop	(	TH1 *	hist,
		double	cut_maxdev )

Definition at line 80 of file TFCS1DFunctionHistogram.cxx.

                                                                           {
 
  m_HistoContents.clear();
  m_HistoBorders.clear();
 
  double change =
      get_change(hist) * 1.000001; // increase slighlty for comparison of floats
 
  double maxdev = -1;
 
  TH1D *h_input = (TH1D *)hist->Clone("h_input");
  TH1D *h_output = nullptr;
 
  int i = 0;
  while (1) {
 
    TH1D *h_out;
    if (i == 0) {
      h_out = (TH1D *)h_input->Clone("h_out");
    } else {
      h_out = smart_rebin(h_input);
      h_out->SetName("h_out");
    }
 
    maxdev = get_maxdev(hist, h_out);
    maxdev *= 100.0;
 
    if (i % 100 == 0)
      ATH_MSG_INFO("Iteration nr. " << i << " -----> change " << change
                                    << " bins " << h_out->GetNbinsX()
                                    << " -> maxdev=" << maxdev);
 
    if (maxdev < cut_maxdev && h_out->GetNbinsX() > 5 && i < 1000) {
      delete h_input;
      h_input = (TH1D *)h_out->Clone("h_input");
      change = get_change(h_input) * 1.000001;
      delete h_out;
      i++;
    } else {
      h_output = (TH1D *)h_input->Clone("h_output");
      delete h_out;
      break;
    }
  }
 
  ATH_MSG_INFO("Info: Rebinned histogram has " << h_output->GetNbinsX()
                                               << " bins.");
 
  // store:
 
  for (int b = 1; b <= h_output->GetNbinsX(); b++)
    m_HistoBorders.push_back((float)h_output->GetBinLowEdge(b));
  m_HistoBorders.push_back((float)h_output->GetXaxis()->GetXmax());
 
  for (int b = 1; b < h_output->GetNbinsX(); b++)
    m_HistoContents.push_back(h_output->GetBinContent(b));
  m_HistoContents.push_back(1);
}

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();
}

vector_to_histo()

TH1 * TFCS1DFunctionHistogram::vector_to_histo

(

)

Definition at line 65 of file TFCS1DFunctionHistogram.cxx.

                                              {
 
  double *bins = new double[m_HistoBorders.size()];
  for (unsigned int i = 0; i < m_HistoBorders.size(); i++)
    bins[i] = m_HistoBorders[i];
 
  TH1 *h_out = new TH1D("h_out", "h_out", m_HistoBorders.size() - 1, bins);
  for (int b = 1; b <= h_out->GetNbinsX(); b++)
    h_out->SetBinContent(b, m_HistoContents[b - 1]);
 
  delete[] bins;
 
  return h_out;
}

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_HistoBorders

std::vector<float> TFCS1DFunctionHistogram::m_HistoBorders

protected

Definition at line 41 of file TFCS1DFunctionHistogram.h.

m_HistoContents

std::vector<float> TFCS1DFunctionHistogram::m_HistoContents

protected

Definition at line 42 of file TFCS1DFunctionHistogram.h.

m_nm

std::string ISF_FCS::MLogging::m_nm

privateinherited

Message source name.

Definition at line 211 of file MLogging.h.

---

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

• TFCS1DFunctionHistogram.h
• TFCS1DFunctionHistogram.cxx