IDPVM::ResolutionHelper Class Reference

#include <ResolutionHelper.h>

Inheritance diagram for IDPVM::ResolutionHelper:

Collaboration diagram for IDPVM::ResolutionHelper:

Classes
struct	resolutionResultInBin
	package the output of a single bin resolution measurement More...

Public Types
enum	methods { iterRMS_convergence , Gauss_fit , fusion_iterRMS_Gaussfit , iterGaussFit_convergence }
	methods acc to which mean&RMS can be evaluated More...

Public Member Functions
	ResolutionHelper ()
	~ResolutionHelper ()
void	makeResolutions (const TH2 *h_input2D, TH1 *hwidth, TH1 *hmean, TH1 *hproj[], bool saveProjections, IDPVM::ResolutionHelper::methods theMethod=IDPVM::ResolutionHelper::iterRMS_convergence)
	extract 1D resolution plots from a 2D "residual vs observable" histogram.
void	makeResolutions (const TH2 *h_input2D, TH1 *hwidth, TH1 *hmean, IDPVM::ResolutionHelper::methods theMethod=IDPVM::ResolutionHelper::iterRMS_convergence)
	extract 1D resolution plots from a 2D "residual vs observable" histogram.
resolutionResultInBin	ResolutionHelperResultsModUnits (TH1D *p_input_hist, IDPVM::ResolutionHelper::methods theMethod=IDPVM::ResolutionHelper::iterRMS_convergence)
	single-bin resolution evaluation, also internally used by makeResolutions
void	setResults (TH1 *p_input_hist, methods p_method)
	wrapper to set mean,rms,and fraction of events in tails nb: some of the methods are allowed to modify input histogram
double	getMean ()
	results getters
double	getMeanError ()
double	getRMS ()
double	getRMSError ()
double	getFracOut ()
	fraction of events that is within the range of input histogram, but goes out-of range during width and mean evaluation if this is large, you should refine the method for width and mean evaluation can be done during post-processing, does not require new InDetPVM run
double	getFracOutUnc ()
double	getFracUOflow ()
	fraction of events in under- and over-flow bins of input histogram if this is large, the input histogram range needs to be increased requires InDetPVM code-change and re-run
const std::vector< std::string > &	getDebugs ()
	return accumulated messages
const std::vector< std::string > &	getInfos ()
const std::vector< std::string > &	getWarnings ()
const std::vector< std::string > &	getErrors ()
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Static Public Member Functions
static std::string	reportUOBinVal (const std::string &p_histName, const std::vector< std::pair< unsigned int, double > > &p_vecBinVal)
	helper to report bin and fraction of under-/over- flow events, as accumulated by top-level pull or resolution histogram

Private Member Functions
int	setGaussFit (TH1 *p_input_hist)
int	setIterativeConvergence (TH1 *p_input_hist)
	iteratively change histogram range, until convergence return # remaining iterations before hitting the max.
int	setIterativeGaussFitConvergence (TH1 *p_input_hist)
	same as above but performs a gaussian fit at avery iteration, until convergence
void	setFout (double p_nsig, double p_ntot)
	evaluate the fraction of evens out of signal region and its uncertainty
void	setLargeError ()
	set large mean and RMS errors in case we eg. exclude too many events during evaluation
bool	initialize (TH1 *p_input_hist)
	helper to fill-in starting values of the results vector
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static void	cloneHistogram (TH1D *h, TH1 *hcopy)

Private Attributes
double	m_mean {0.}
	results/outputs:
double	m_meanError {0.}
double	m_RMS {0.}
double	m_RMSError {0.}
double	m_FracOut {0.}
double	m_FracOutUnc {0.}
double	m_FracUOflow {0.}
std::vector< std::string >	m_debugs
std::vector< std::string >	m_infos
std::vector< std::string >	m_warnings
std::vector< std::string >	m_errors
std::string	m_inHistName {""}
double	m_largeErrorFact {10.}
double	m_maxUOflowFrac {0.05}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 28 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

Member Enumeration Documentation

methods

enum IDPVM::ResolutionHelper::methods

methods acc to which mean&RMS can be evaluated

Enumerator
iterRMS_convergence
Gauss_fit
fusion_iterRMS_Gaussfit
iterGaussFit_convergence

Definition at line 36 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ iterRMS_convergence, Gauss_fit, fusion_iterRMS_Gaussfit, iterGaussFit_convergence };

Constructor & Destructor Documentation

ResolutionHelper()

IDPVM::ResolutionHelper::ResolutionHelper

(

)

Definition at line 25 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                     :
    AthMessaging("ResolutionHelper")
  {
  }

~ResolutionHelper()

IDPVM::ResolutionHelper::~ResolutionHelper ( )

inline

Definition at line 31 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

                        {
      // nop
    };

Member Function Documentation

cloneHistogram()

void IDPVM::ResolutionHelper::cloneHistogram ( TH1D * h, TH1 * hcopy )

staticprivate

Definition at line 417 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                    {
  unsigned int nbin = h->GetNbinsX();
 
  for (unsigned int ibin = 0; ibin < nbin; ibin++) {
    hcopy->SetBinContent(ibin + 1, h->GetBinContent(ibin + 1));
    hcopy->SetBinError(ibin + 1, h->GetBinError(ibin + 1));
  }
}

getDebugs()

const std::vector< std::string > & IDPVM::ResolutionHelper::getDebugs ( )

inline

return accumulated messages

Definition at line 100 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_debugs; };

getErrors()

const std::vector< std::string > & IDPVM::ResolutionHelper::getErrors ( )

inline

Definition at line 103 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_errors; };

getFracOut()

double IDPVM::ResolutionHelper::getFracOut ( )

inline

fraction of events that is within the range of input histogram, but goes out-of range during width and mean evaluation if this is large, you should refine the method for width and mean evaluation can be done during post-processing, does not require new InDetPVM run

Definition at line 87 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_FracOut; };

getFracOutUnc()

double IDPVM::ResolutionHelper::getFracOutUnc ( )

inline

Definition at line 88 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_FracOutUnc; };

getFracUOflow()

double IDPVM::ResolutionHelper::getFracUOflow ( )

inline

fraction of events in under- and over-flow bins of input histogram if this is large, the input histogram range needs to be increased requires InDetPVM code-change and re-run

Definition at line 93 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_FracUOflow; };

getInfos()

const std::vector< std::string > & IDPVM::ResolutionHelper::getInfos ( )

inline

Definition at line 101 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_infos; };

getMean()

double IDPVM::ResolutionHelper::getMean ( )

inline

results getters

Definition at line 78 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_mean; };

getMeanError()

double IDPVM::ResolutionHelper::getMeanError ( )

inline

Definition at line 79 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_meanError; };

getRMS()

double IDPVM::ResolutionHelper::getRMS ( )

inline

Definition at line 80 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_RMS; };

getRMSError()

double IDPVM::ResolutionHelper::getRMSError ( )

inline

Definition at line 81 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_RMSError; };

getWarnings()

const std::vector< std::string > & IDPVM::ResolutionHelper::getWarnings ( )

inline

Definition at line 102 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{ return m_warnings; };

initialize()

bool IDPVM::ResolutionHelper::initialize ( TH1 * p_input_hist )

private

helper to fill-in starting values of the results vector

Definition at line 30 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                     {
 
    if ( !m_debugs.empty())
      m_debugs.clear();     
    if ( !m_infos.empty())
      m_infos.clear();      
    if ( !m_warnings.empty())
      m_warnings.clear();
    if ( !m_errors.empty())
      m_errors.clear();
       
    if (!p_input_hist) {
      m_errors.emplace_back("ResolutionHelper::initialize: empty input histogram passed: ");
       m_mean=m_meanError=m_RMS=m_RMSError=m_FracOut=m_FracOutUnc=0.;
      return false;
    }
    
    m_inHistName = p_input_hist->GetName();
    
    if ( 0==p_input_hist->GetEntries() ) {
      m_debugs.push_back("ResolutionHelper::initialize: got input histogram with 0 entries: "+ m_inHistName);
      m_mean=m_meanError=m_RMS=m_RMSError=m_FracOut=m_FracOutUnc=0.;
      return false;
    }
 
    m_RMS = p_input_hist->GetRMS();
    m_RMSError = p_input_hist->GetRMSError();
    m_mean = p_input_hist->GetMean();
    m_meanError = p_input_hist->GetMeanError();   
    m_FracOut = 0.;
    m_FracOutUnc = 0.;
    double nExclUOflow = p_input_hist->Integral(1,p_input_hist->GetNbinsX());
    double nInclUOflow = p_input_hist->Integral(0,p_input_hist->GetNbinsX()+1);
    double fUOflow = (nExclUOflow>0.) ? (nInclUOflow-nExclUOflow)/nExclUOflow : -1.;
    m_FracUOflow = (fUOflow>m_maxUOflowFrac) ? fUOflow : -1;
    
    return true;
  }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

makeResolutions() [1/2]

void IDPVM::ResolutionHelper::makeResolutions	(	const TH2 *	h_input2D,
		TH1 *	hwidth,
		TH1 *	hmean,
		IDPVM::ResolutionHelper::methods	theMethod = IDPVM::ResolutionHelper::iterRMS_convergence )

extract 1D resolution plots from a 2D "residual vs observable" histogram.

Parameters

[in]	h_input2D	input histogram (x = observable, y = residuals)
[out]	hwidth	output histogram, will be filled with the width of the residuals (-> resolution)
[out]	hmean	output histogram, will be filled with the mean of the residuals (-> bias)
[out]	hproj	array of histograms, will be populated by an array of 1-dimensional projections of Y within bins in X
[in]	saveProjections	steers the filling of hpoj
[in]	theMethod	the method used to extract the width and mean. Default is iterative RMS.

Definition at line 351 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                                                                                        {
 
  // warnings in case input histograms have large % events in under- and over- flow bins 
  std::vector< std::pair<unsigned int,double> > warnUOBinFrac;
 
  if (h_input2D->GetNbinsX() != hwidth->GetNbinsX() || h_input2D->GetNbinsX() != hmean->GetNbinsX()){
    ATH_MSG_ERROR("Inconsistent binnings between 1D and 2D histos - please fix your config!"); 
    return; 
  }
  for (int ibin = 0; ibin < h_input2D->GetNbinsX(); ibin++) {
    std::string tmpName = h_input2D->GetName() + std::string("py_bin") + std::to_string(ibin + 1);
    std::shared_ptr<TH1D> tmp {static_cast<TH1D*>(h_input2D->ProjectionY(tmpName.c_str(), ibin + 1, ibin + 1))}; 
    if (tmp->Integral() < 1) {
      continue;
    }
    const resolutionResultInBin & result = ResolutionHelperResultsModUnits(tmp.get(), theMethod);
    hwidth->SetBinContent(ibin + 1, result.width);
    hwidth->SetBinError(ibin + 1, result.widthError);
    hmean->SetBinContent(ibin + 1, result.mean);
    hmean->SetBinError(ibin + 1, result.meanError);
    if (result.outlierFrac > m_maxUOflowFrac) {
      warnUOBinFrac.emplace_back(ibin + 1,result.outlierFrac);
    }
  }    
  if (!warnUOBinFrac.empty()) {
    ATH_MSG_WARNING(reportUOBinVal(hwidth->GetName(),warnUOBinFrac));
    ATH_MSG_WARNING(reportUOBinVal(hwidth->GetName(),warnUOBinFrac));
  }
}

makeResolutions() [2/2]

void IDPVM::ResolutionHelper::makeResolutions	(	const TH2 *	h_input2D,
		TH1 *	hwidth,
		TH1 *	hmean,
		TH1 *	hproj[],
		bool	saveProjections,
		IDPVM::ResolutionHelper::methods	theMethod = IDPVM::ResolutionHelper::iterRMS_convergence )

extract 1D resolution plots from a 2D "residual vs observable" histogram.

Parameters

[in]	h_input2D	input histogram (x = observable, y = residuals)
[out]	hwidth	output histogram, will be filled with the width of the residuals (-> resolution)
[out]	hmean	output histogram, will be filled with the mean of the residuals (-> bias)
[out]	hproj	array of histograms, will be populated by an array of 1-dimensional projections of Y within bins in X
[in]	saveProjections	steers the filling of hpoj
[in]	theMethod	the method used to extract the width and mean. Default is iterative RMS.

Definition at line 382 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                                                                                                                           {
  
  // warnings in case input histograms have large % events in under- and over- flow bins 
  std::vector< std::pair<unsigned int,double> > warnUOBinFrac;
  
  if (h_input2D->GetNbinsX() != hwidth->GetNbinsX() || h_input2D->GetNbinsX() != hmean->GetNbinsX()){
    ATH_MSG_ERROR("Inconsistent binnings between 1D and 2D histos - please fix your config!"); 
    return; 
  }
 
  for (int ibin = 0; ibin < hwidth->GetNbinsX(); ibin++) {
    std::string tmpName = h_input2D->GetName() + std::string("py_bin") + std::to_string(ibin + 1);
    std::shared_ptr<TH1D> tmp {static_cast<TH1D*>(h_input2D->ProjectionY(tmpName.c_str(), ibin+1, ibin+1))};
    if (tmp->Integral() < 1) {
      continue;
    }
    if (saveProjections) {
      cloneHistogram(tmp.get(), hproj[ibin]);
    }
    const resolutionResultInBin & result = ResolutionHelperResultsModUnits(tmp.get(), theMethod);
    hwidth->SetBinContent(ibin + 1, result.width);
    hwidth->SetBinError(ibin + 1, result.widthError);
    hmean->SetBinContent(ibin + 1, result.mean);
    hmean->SetBinError(ibin + 1, result.meanError);
    if (result.outlierFrac>m_maxUOflowFrac){
      warnUOBinFrac.emplace_back(ibin + 1,result.outlierFrac);
    }      
  }
  if (!warnUOBinFrac.empty()) {
    ATH_MSG_WARNING(reportUOBinVal(hwidth->GetName(),warnUOBinFrac));
    ATH_MSG_WARNING(reportUOBinVal(hwidth->GetName(),warnUOBinFrac));
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

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

reportUOBinVal()

std::string IDPVM::ResolutionHelper::reportUOBinVal ( const std::string & p_histName, const std::vector< std::pair< unsigned int, double > > & p_vecBinVal )

static

helper to report bin and fraction of under-/over- flow events, as accumulated by top-level pull or resolution histogram

Definition at line 78 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                                                                                                      {
    std::ostringstream reportl;
    if (!p_vecBinVal.empty())  {
      reportl << "Errors scaled up for resol. hist. with large % of events in over- and under-flow: "
          << p_histName<<": ";
      for ( auto it : p_vecBinVal )
    reportl << "bin"<<it.first << ": " << std::setprecision(2) << it.second*100. << "%, ";
    }
    return reportl.str();
  }

ResolutionHelperResultsModUnits()

ResolutionHelper::resolutionResultInBin IDPVM::ResolutionHelper::ResolutionHelperResultsModUnits	(	TH1D *	p_input_hist,
		IDPVM::ResolutionHelper::methods	theMethod = IDPVM::ResolutionHelper::iterRMS_convergence )

single-bin resolution evaluation, also internally used by makeResolutions

Parameters

p_input_hist	input histogram, 1D distribution of the residual
theMethod	method to use (default: iterative RMS)

Returns

resolutionResultInBin object packaging the mean and width of the distribution determined using the specified method as well as outlier bin fractions.

Definition at line 332 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                                                                            {
  // LM: reason for using this function:
  //   orignial code was set up to only have resolution resuls in um,
  //   while inputs are in mm. Do not want to do a substantial rewrite.
  TString vari = p_input_hist->GetName();
  bool isInMicrons = ( !vari.Contains("pull") &&
       (vari.Contains("d0") || vari.Contains("z0")) );
  const double unitConversionFactor = isInMicrons ? 1000. : 1.;   // mm measurements to um outputs 
  setResults(p_input_hist, theMethod);
 
  return {getRMS()*unitConversionFactor, 
          getRMSError()*unitConversionFactor,
          getMean()*unitConversionFactor,
          getMeanError()*unitConversionFactor,
          getFracOut(),
          getFracOutUnc()}; 
}

setFout()

void IDPVM::ResolutionHelper::setFout ( double p_nsig, double p_ntot )

private

evaluate the fraction of evens out of signal region and its uncertainty

Definition at line 89 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                            {
    m_FracOut=0.;
    m_FracOutUnc=0.;
    if (p_ntot>0.) {
      double nout=p_ntot-p_nsig;
      if (nout / p_ntot > 0.9) {
    nout = 0.;
      }
      if (nout > 0.) {
    m_FracOut=nout/p_nsig;
    m_FracOutUnc=(nout / p_ntot) * std::sqrt(1. / nout + 1. / p_ntot);
      }
    }
     }

setGaussFit()

int IDPVM::ResolutionHelper::setGaussFit ( TH1 * p_input_hist )

private

Definition at line 104 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                    {
 
    int ret=0;
 
    // evaluate mean and with via the Gauss fit
    TFitResultPtr r = p_input_hist->Fit("gaus", "QS0");
    if ( r.Get() and (0 == (r->Status()%1000)) ) {
      m_RMS=r->Parameter(2);//RMS
      m_RMSError=r->ParError(2);//RMS_error
      m_mean=r->Parameter(1);//mean
      m_meanError=r->ParError(1);//mean_error
    }
    else
      ret=1;
 
    // get fraction of events outside 3*RMS + its ~ uncertainty
    double nSig = p_input_hist->Integral(p_input_hist->GetXaxis()->FindBin(-3.0 * m_RMS),
                     p_input_hist->GetXaxis()->FindBin(3.0 * m_RMS));
    double nTot = p_input_hist->Integral(1,p_input_hist->GetNbinsX());
    setFout(nSig,nTot);
 
    // return fit status
    return ret;
  }

setIterativeConvergence()

int IDPVM::ResolutionHelper::setIterativeConvergence ( TH1 * p_input_hist )

private

iteratively change histogram range, until convergence return # remaining iterations before hitting the max.

allowed

Definition at line 130 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                                 {
    
    // evaluate  mean and RMS using iterative converfgence:
    double mean=p_input_hist->GetMean();
    double RMS = p_input_hist->GetRMS();
    
    // iteration parameters:
    // max iteration steps
    unsigned int ntries_max = 100;
    // width of cutting range in [RMS]
    double nRMS_width = 3.0;
    
    // iteration counters and helpers: 
    // min and max range of the histogram:
    double xmin=0.;
    double xmax=0.;
    // min and max bins of the histogram in previous iteration
    // 0-th iteration: range of the original histogram
    int binmin_was = 1;
    int binmax_was = p_input_hist->GetNbinsX();
    // initial number of iteration steps
    unsigned int ntries = 0;
 
    // iteratively cut tails untill the RMS gets stable about mean
    // RMS stable: when input histogram range after cutting by 
    // +- 3*RMS is same as the range before cutting
    while ( ntries<ntries_max ) {    
      ++ntries;
      RMS = p_input_hist->GetRMS();
      mean = p_input_hist->GetMean();
      xmin = -1.0*nRMS_width*RMS + mean;
      xmax = nRMS_width*RMS + mean;
      // find bins corresponding to new range, disregard underflow
      int binmin=std::max(1,p_input_hist->GetXaxis()->FindFixBin(xmin));
      // find bins corresponding to new range, disregard overflow
      int binmax=std::min(p_input_hist->GetNbinsX(),p_input_hist->GetXaxis()->FindFixBin(xmax));
      // end iteration if these are same bins as in prev. iteration
      if ( binmin_was==binmin && binmax_was==binmax ) {
    break;
      }
      else {
    // else set the new range and continue iteration 
    p_input_hist->GetXaxis()->SetRange(binmin,binmax);
    binmin_was=binmin;
    binmax_was=binmax;
      }
    } // end of ( ntries<ntries_max ) ; iterative convergence loop
    
    // set the iteration results that are accessible to clients: 
    m_RMS=RMS;
    m_RMSError= p_input_hist->GetRMSError();    
    m_mean=mean;
    m_meanError=p_input_hist->GetMeanError();
    
    // get fraction of excluded events + its ~ uncertainty
    double nSig = p_input_hist->Integral(p_input_hist->GetXaxis()->FindBin(xmin),
                     p_input_hist->GetXaxis()->FindBin(xmax));
    // disregard under- and over- flow
    double nTot = p_input_hist->Integral(1,p_input_hist->GetNbinsX());
    setFout(nSig,nTot);
    
    // return number of remaining allowed iteration steps
    return(ntries_max-ntries);
  }

setIterativeGaussFitConvergence()

int IDPVM::ResolutionHelper::setIterativeGaussFitConvergence ( TH1 * p_input_hist )

private

same as above but performs a gaussian fit at avery iteration, until convergence

First intialise mean and RMS to 0

iteration parameters: max iteration steps

width of cutting range in [RMS]

first perform a single Gauss fit across full range of histogram or in a specified range

performs a second fit with range determined by first fit i.e. mean +/- nRMS_width * RMS

now iteratively perform gaus fits until recomputed mean and RMS stabilise (differ by <= 0.0005 )

update fit results

refitting adjusting new range

refitting

set the iteration results that are accessible to clients:

get fraction of excluded events + its ~ uncertainty

disregard under- and over- flow

return number of remaining allowed iteration steps

Definition at line 196 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                                         {
    double mean       = 0.;
    double meanError  = 0.;
    double RMS        = 0.;
    double RMSError   = 0.;

    unsigned int ntries_max = 50;
    double nRMS_width = 2.0;

    double xmin = p_input_hist->GetBinLowEdge(1);
    double xmax = ( p_input_hist->GetBinLowEdge( p_input_hist->GetNbinsX() ) ) +
                  ( p_input_hist->GetBinWidth( p_input_hist->GetNbinsX() ) );
    std::shared_ptr<TF1> fitA = std::make_shared<TF1>( "fitA", "gaus", xmin, xmax );
    p_input_hist->Fit( "fitA", "ORQN", "same" );
    mean      = fitA->GetParameter(1);
    meanError = fitA->GetParError(1);
    RMS       = fitA->GetParameter(2);
    RMSError  = fitA->GetParError(2);

    xmin = mean - ( RMS * nRMS_width );
    xmax = mean + ( RMS * nRMS_width );
    std::shared_ptr<TF1> fitB = std::make_shared<TF1>( "fitB", "gaus", xmin, xmax );
    p_input_hist->Fit( "fitB", "ORQN", "same" );
    mean      = fitB->GetParameter(1);
    meanError = fitB->GetParError(1);
    RMS       = fitB->GetParameter(2);
    RMSError  = fitB->GetParError(2);

    xmin = mean - ( RMS * nRMS_width );
    xmax = mean + ( RMS * nRMS_width );
    std::shared_ptr<TF1> fit = std::make_shared<TF1>( "fit", "gaus", xmin, xmax );
    double mean_new       = 99999.;
    double meanError_new  = 99999.;
    double RMS_new        = 99999.;
    double RMSError_new   = 99999.;
    unsigned int ntries = 0;
    while( std::abs( mean - mean_new ) > 0.0005 or std::abs( RMS - RMS_new ) > 0.0005 ) {
      if( ntries > 0 ) {
        mean      = mean_new;
        meanError = meanError_new;
        RMS       = RMS_new;
        RMSError  = RMSError_new;
      }

      xmin = mean - ( RMS * nRMS_width );
      xmax = mean + ( RMS * nRMS_width );
      fit->SetRange( xmin, xmax );
      p_input_hist->Fit( "fit", "ORQN", "same" );
      mean_new      = fit->GetParameter(1);
      meanError_new = fit->GetParError(1);
      RMS_new       = fit->GetParameter(2);
      RMSError_new  = fit->GetParError(2);
 
      if( ntries > 50 ) {
        ATH_MSG_WARNING( "terminate iterative gaus fit because of convergence problems" );
        break;
      }
      ntries++;
    } // end while

    m_RMS       = RMS;
    m_RMSError  = RMSError;
    m_mean      = mean;
    m_meanError = meanError;

    double nSig = p_input_hist->Integral( p_input_hist->GetXaxis()->FindBin(xmin),
                     p_input_hist->GetXaxis()->FindBin(xmax) );
    double nTot = p_input_hist->Integral( 1, p_input_hist->GetNbinsX() );
    setFout( nSig, nTot );

    return( ntries_max - ntries );
  }

setLargeError()

void IDPVM::ResolutionHelper::setLargeError ( )

private

set large mean and RMS errors in case we eg. exclude too many events during evaluation

Definition at line 69 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                       {
    std::ostringstream debugl;
    debugl << __FILE__ << "\t\t" << m_inHistName
       << ": scaling mean and RMS errors by factor: " << m_largeErrorFact;
    m_debugs.push_back(debugl.str());
    m_meanError*=m_largeErrorFact;
    m_RMSError*=m_largeErrorFact;
  }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setResults()

void IDPVM::ResolutionHelper::setResults	(	TH1 *	p_input_hist,
		methods	p_method )

wrapper to set mean,rms,and fraction of events in tails nb: some of the methods are allowed to modify input histogram

Definition at line 287 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx.

                                                                      {
 
    // set start values of the results vector
    // mean RMS etc as in the input histo prior to trimming
    if (!initialize(p_input_hist))
      return;
    
    if (iterRMS_convergence == p_method) {
      if ( !setIterativeConvergence(p_input_hist) ) 
    m_warnings.push_back("\t\t\t* ResolutionHelper::setIterativeConvergence did not converge for "+ m_inHistName);
    }
    else if (Gauss_fit == p_method) {
      if ( !setGaussFit(p_input_hist) ) 
    m_warnings.push_back("\t\t\t* ResolutionHelper::setGaussFit: fit failed for "+ m_inHistName);
    }
    else if (fusion_iterRMS_Gaussfit == p_method) {
      if ( !setIterativeConvergence(p_input_hist) &&
       !setGaussFit(p_input_hist) ) 
    m_warnings.push_back("\t\t\t* ResolutionHelper::fusion_iterRMS_Gaussfit both methods failed for "+ m_inHistName);
    }
    else if ( iterGaussFit_convergence == p_method ) {
      if ( !setIterativeGaussFitConvergence( p_input_hist ) ) 
    m_warnings.push_back("\t\t\t* ResolutionHelper::setIterativeGaussFitConvergence: iter gauss fit did not converge for "+ m_inHistName);
    }
    else {
      m_errors.push_back("\t\t\t* ResolutionHelper::setResults: method not supported. No evaluation for "+ m_inHistName);
    }
 
    // check if large fraction of events was in over- and under-flow
    if ( m_FracUOflow > 0. ) {
      std::ostringstream debugl;
      debugl << "\tResolutionHelper::setResults: too large fraction of out-of-range events for histogram ";
      debugl << m_inHistName << ": " << m_FracUOflow << " > " << m_maxUOflowFrac;
      m_debugs.push_back(debugl.str());      
      setLargeError();
      m_debugs.push_back("\t\t\t* ResolutionHelper::setResults: scaling errors up for "
             +m_inHistName+". Too many under- and over- flows.");
    }
 
    // reset range metadata to state prior to iteration
    // this gets changed in iterative or fusion)
    p_input_hist->GetXaxis()->SetRange(1,p_input_hist->GetNbinsX());
 }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_debugs

std::vector<std::string> IDPVM::ResolutionHelper::m_debugs

private

Definition at line 131 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

m_errors

std::vector<std::string> IDPVM::ResolutionHelper::m_errors

private

Definition at line 134 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

m_FracOut

double IDPVM::ResolutionHelper::m_FracOut {0.}

private

Definition at line 127 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.};

m_FracOutUnc

double IDPVM::ResolutionHelper::m_FracOutUnc {0.}

private

Definition at line 128 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.};

m_FracUOflow

double IDPVM::ResolutionHelper::m_FracUOflow {0.}

private

Definition at line 129 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_infos

std::vector<std::string> IDPVM::ResolutionHelper::m_infos

private

Definition at line 132 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

m_inHistName

std::string IDPVM::ResolutionHelper::m_inHistName {""}

private

Definition at line 139 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{""};

m_largeErrorFact

double IDPVM::ResolutionHelper::m_largeErrorFact {10.}

private

Definition at line 142 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{10.};

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_maxUOflowFrac

double IDPVM::ResolutionHelper::m_maxUOflowFrac {0.05}

private

Definition at line 144 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.05};

m_mean

double IDPVM::ResolutionHelper::m_mean {0.}

private

results/outputs:

Definition at line 123 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.};

m_meanError

double IDPVM::ResolutionHelper::m_meanError {0.}

private

Definition at line 124 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.};

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

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

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_RMS

double IDPVM::ResolutionHelper::m_RMS {0.}

private

Definition at line 125 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.};

m_RMSError

double IDPVM::ResolutionHelper::m_RMSError {0.}

private

Definition at line 126 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

{0.};

m_warnings

std::vector<std::string> IDPVM::ResolutionHelper::m_warnings

private

Definition at line 133 of file InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h.

---

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

• InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h
• InnerDetector/InDetValidation/InDetPhysValMonitoring/src/ResolutionHelper.cxx