jet::ValidityHistogram Class Reference

#include <ValidityHistogram.h>

Inheritance diagram for jet::ValidityHistogram:

Collaboration diagram for jet::ValidityHistogram:

Public Member Functions
	ValidityHistogram (const std::string &histName, const CompParametrization::TypeEnum parametrization, const float energyScale, const CompMassDef::TypeEnum massDef)
	ValidityHistogram (const TString &histName, const CompParametrization::TypeEnum parametrization, const float energyScale, const CompMassDef::TypeEnum massDef)
	ValidityHistogram (const char *histName, const CompParametrization::TypeEnum parametrization, const float energyScale, const CompMassDef::TypeEnum massDef)
	ValidityHistogram (const ValidityHistogram &toCopy)
virtual	~ValidityHistogram ()
virtual StatusCode	initialize (TFile *histFile)
CompParametrization::TypeEnum	getParam () const
bool	getValidity (const xAOD::Jet &jet) const
const TString &	getName () const
const TH1 *	getHisto () const
Interpolate::TypeEnum	getInterp () const
int	getNumDim () const
double	getValue (const double var1) const
double	getValue (const double var1, const double var2) const
double	getValue (const double var1, const double var2, const double var3) const
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Member Functions
StatusCode	cacheProjections ()
double	readHisto (const double var1, const double var2=0, const double var3=0) const
double	checkBoundariesByBin (const TAxis *axis, const int numBins, const double valInput) const
double	checkBoundaries (const TAxis *axis, const int numBins, const double valInput) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
bool	m_isInit
const CompParametrization::TypeEnum	m_param
const float	m_energyScale
const CompMassDef::TypeEnum	m_massDef
InfoHelper *	m_helper
const TString	m_name
const Interpolate::TypeEnum	m_interpolate
TH1 *	m_histo
int	m_nDim
std::vector< std::vector< std::unique_ptr< TH1 > > >	m_cachedProj
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 18 of file ValidityHistogram.h.

Constructor & Destructor Documentation

ValidityHistogram() [1/4]

jet::ValidityHistogram::ValidityHistogram	(	const std::string &	histName,
		const CompParametrization::TypeEnum	parametrization,
		const float	energyScale,
		const CompMassDef::TypeEnum	massDef )

Definition at line 280 of file ValidityHistogram.cxx.

    : UncertaintyHistogram(histName,Interpolate::None)
    , m_isInit(false)
    , m_param(parametrization)
    , m_energyScale(energyScale)
    , m_massDef(massDef)
    , m_helper(nullptr)
{
    ATH_MSG_DEBUG(Form("Creating ValidityHistogram named %s",getName().Data()));
}

ValidityHistogram() [2/4]

jet::ValidityHistogram::ValidityHistogram	(	const TString &	histName,
		const CompParametrization::TypeEnum	parametrization,
		const float	energyScale,
		const CompMassDef::TypeEnum	massDef )

Definition at line 291 of file ValidityHistogram.cxx.

    : ValidityHistogram(std::string(histName.Data()),parametrization,energyScale,massDef)
{ }

ValidityHistogram() [3/4]

jet::ValidityHistogram::ValidityHistogram	(	const char *	histName,
		const CompParametrization::TypeEnum	parametrization,
		const float	energyScale,
		const CompMassDef::TypeEnum	massDef )

Definition at line 295 of file ValidityHistogram.cxx.

    : ValidityHistogram(std::string(histName),parametrization,energyScale,massDef)
{ }

ValidityHistogram() [4/4]

jet::ValidityHistogram::ValidityHistogram

(

const ValidityHistogram &

toCopy

)

Definition at line 299 of file ValidityHistogram.cxx.

    : UncertaintyHistogram(toCopy)
    , m_isInit(toCopy.m_isInit)
    , m_param(toCopy.m_param)
    , m_energyScale(toCopy.m_energyScale)
    , m_massDef(toCopy.m_massDef)
    , m_helper(nullptr)
{
    ATH_MSG_DEBUG("Creating copy of ValidityHistogram named " << getName().Data());
    m_helper = toCopy.m_helper->clone();
}

~ValidityHistogram()

jet::ValidityHistogram::~ValidityHistogram ( )

virtual

Definition at line 311 of file ValidityHistogram.cxx.

{
    JESUNC_SAFE_DELETE(m_helper);
}

Member Function Documentation

cacheProjections()

StatusCode jet::UncertaintyHistogram::cacheProjections ( )

privateinherited

Definition at line 322 of file UncertaintyHistogram.cxx.

{
    // Ensure the histogram exists
    if (!m_histo)
    {
        ATH_MSG_FATAL("Cannot cache histogram as it doesn't exist: " << m_name.Data());
        return StatusCode::FAILURE;
    }
 
    // Ensure the number of dimensions is sane
    if (m_histo->GetDimension() < 1 || m_histo->GetDimension() > 3)
    {
        ATH_MSG_FATAL("Unsupported histogram dimensionality for projection caching: " << m_histo->GetDimension());
        return StatusCode::FAILURE;
    }
 
    // Ensure the cache doesn't already exist
    if (!m_cachedProj.empty())
    {
        ATH_MSG_FATAL("Cannot cache histogram as the cache is non-empty: " << m_name.Data());
        return StatusCode::FAILURE;
    }
 
    // Protect vs Interpolate
    switch (m_interpolate)
    {
        case Interpolate::OnlyX:
            // Simple case of 1D
            if (m_histo->GetDimension() == 1)
                return StatusCode::SUCCESS;
            break;
 
        case Interpolate::OnlyY:
            //  Failure case of 1D
            if (m_histo->GetDimension() == 1)
            {
                ATH_MSG_FATAL("Cannot project in Y for a 1D histogram: " << m_name.Data());
                return StatusCode::FAILURE;
            }
            break;
 
        default:
            ATH_MSG_FATAL("The interpolation type is not supported for caching: " << m_name.Data());
            return StatusCode::FAILURE;
    }
    
    // If we got here, then the request makes sense
    // Start the projections
    // Intentionally include underflow and overflow bins
    // This keeps the same indexing scheme as root
    // Avoids confusion and problems later at cost of a small amount of RAM
    if (m_histo->GetDimension() == 2)
    {
        // Prepare to cache
        TH2* localHist = dynamic_cast<TH2*>(m_histo);
        m_cachedProj.resize(1); // 2D is a single slice of 3D
        if (!localHist)
        {
            ATH_MSG_FATAL("Failed to convert histogram to a TH2, please check inputs: " << m_name.Data());
            return StatusCode::FAILURE;
        }
 
        // Create the projections
        if (m_interpolate == Interpolate::OnlyX)
        {
            for (Long64_t binY = 0; binY < localHist->GetNbinsY()+1; ++binY)
            {
                // Single bin of Y, interpolate across X
                m_cachedProj.at(0).emplace_back(localHist->ProjectionX(Form("projx_%lld",binY),binY,binY));
            }
        }
        else if (m_interpolate == Interpolate::OnlyY)
        {
            for (Long64_t binX = 0; binX < localHist->GetNbinsX()+1; ++binX)
            {
                // Single bin of X, interpolate across Y
                m_cachedProj.at(0).emplace_back(localHist->ProjectionY(Form("projy_%lld",binX),binX,binX));
            }
        }
        else
        {
            // We shouldn't make it here due to earlier checks
            ATH_MSG_FATAL("Unexpected interpolation type, somehow escaped earlier checks: " << m_name.Data());
            return StatusCode::FAILURE;
        }
    }
    else if (m_histo->GetDimension() == 3)
    {
        // Prepare to cache
        TH3* localHist = dynamic_cast<TH3*>(m_histo);
        if (!localHist)
        {
            ATH_MSG_FATAL("Failed to convert histogram to a TH3, please check inputs: " << m_name.Data());
            return StatusCode::FAILURE;
        }
 
        // Create the projections
        if (m_interpolate == Interpolate::OnlyX)
        {
            m_cachedProj.resize(localHist->GetNbinsY()+1); // 3D is a full double-index scan
            for (Long64_t binY = 0; binY < localHist->GetNbinsY()+1; ++binY)
            {
                for (Long64_t binZ = 0; binZ < localHist->GetNbinsZ()+1; ++binZ)
                {
                    // Single bin of Y-Z, interpolate across X
                    m_cachedProj.at(binY).emplace_back(localHist->ProjectionX(Form("projx_%lld_%lld",binY,binZ),binY,binY,binZ,binZ));
                }
            }
        }
        else if (m_interpolate == Interpolate::OnlyY)
        {
            m_cachedProj.resize(localHist->GetNbinsX()+1); // 3D is a full double-index scan
            for (Long64_t binX = 0; binX < localHist->GetNbinsX()+1; ++binX)
            {
                for (Long64_t binZ = 0; binZ < localHist->GetNbinsZ()+1; ++binZ)
                {
                    // Single bin of X-Z, interpolate across Y
                    m_cachedProj.at(binX).emplace_back(localHist->ProjectionY(Form("projy_%lld_%lld",binX,binZ),binX,binX,binZ,binZ));
                }
            }
        }
        else
        {
            // We shouldn't make it here due to earlier checks
            ATH_MSG_FATAL("Unexpected interpolation type, somehow escaped earlier checks: " << m_name.Data());
            return StatusCode::FAILURE;
        }
    }
    else
    {
        // We shouldn't make it here due to earlier checks
        ATH_MSG_FATAL("Unexpected dimensionality: " << m_histo->GetDimension());
        return StatusCode::FAILURE;
    }
 
    // Ensure that ROOT doesn't try to take posession of any of the projections
    for (size_t index = 0; index < m_cachedProj.size(); ++index)
    {
        for (auto& hist : m_cachedProj.at(index))
        {
            hist->SetDirectory(nullptr);
        }
    }
 
    // All done
    return StatusCode::SUCCESS;
}

checkBoundaries()

double jet::UncertaintyHistogram::checkBoundaries ( const TAxis * axis, const int numBins, const double valInput ) const

privateinherited

Definition at line 293 of file UncertaintyHistogram.cxx.

{
    const static int maxNumWarn = 0; //100
    static std::atomic<int> numWarn = 0;
    
    // Bins are structured for [lowEdge,highEdge)
    // As such, do not need to worry about equality sign for low edge
    // However, do need to check equality sign for high edge
    // High edge is expected and supported (no warning needed)
    float val = valInput;
    const double lowVal  = axis->GetBinLowEdge(1);
    const double highVal = axis->GetBinLowEdge(numBins+1);
    if (val < lowVal || val >= highVal)
    {
        if (val != highVal && ++numWarn < maxNumWarn)
            ATH_MSG_WARNING(Form("Variable value is %f, outside of the axis range of (%f,%f) for %s. "
                                 "Using closest valid value.",val,lowVal,highVal,getName().Data())
                            << " (Only first " << maxNumWarn << " instances printed, this is " << numWarn << ")");
    
        // Watch for the boundary sign (controls the scale factor)
        if (val < lowVal)
            val = lowVal>0  ? (1.0+1.e-4)*lowVal  : (1.0-1.e-4)*lowVal;
        else
            val = highVal>0 ? (1.0-1.e-4)*highVal : (1.0+1.e-4)*highVal;
    }
 
    return val;
}

checkBoundariesByBin()

double jet::UncertaintyHistogram::checkBoundariesByBin ( const TAxis * axis, const int numBins, const double valInput ) const

privateinherited

Definition at line 270 of file UncertaintyHistogram.cxx.

{
    double val = valInput;
 
    // Root histogram binning:
    //  bin 0 = underflow bin
    //  bin 1 = first actual bin
    //  bin N = last actual bin
    //  bin N+1 = overflow bin
    const int binIndex = axis->FindBin(valInput);
    if (binIndex < 1)
        val = axis->GetBinLowEdge(1);
    else if (binIndex > numBins)
    {
        // Don't use the upper edge as floating point can make it roll into the next bin (which is overflow)
        // Instead, use the last bin width to go slightly within the boundary
        // An offset of 1.e-3*binWidth is negligible for physics as the values don't change fast, but above floating point precision
        val = (1.-1.e-3)*axis->GetBinWidth(numBins)+axis->GetBinLowEdge(numBins);
    }
    
    return val;
}

getHisto()

const TH1 * jet::UncertaintyHistogram::getHisto ( ) const

inlineinherited

Definition at line 37 of file UncertaintyHistogram.h.

{ return m_histo;       }

getInterp()

Interpolate::TypeEnum jet::UncertaintyHistogram::getInterp ( ) const

inlineinherited

Definition at line 38 of file UncertaintyHistogram.h.

{ return m_interpolate; }

getName()

const TString & jet::UncertaintyHistogram::getName ( ) const

inlineinherited

Definition at line 36 of file UncertaintyHistogram.h.

{ return m_name;        }

getNumDim()

int jet::UncertaintyHistogram::getNumDim ( ) const

inlineinherited

Definition at line 39 of file UncertaintyHistogram.h.

{ return m_nDim;        }

getParam()

CompParametrization::TypeEnum jet::ValidityHistogram::getParam ( ) const

inline

Definition at line 30 of file ValidityHistogram.h.

{ return m_param; }

getValidity()

bool jet::ValidityHistogram::getValidity

(

const xAOD::Jet &

jet

)

const

Definition at line 431 of file ValidityHistogram.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_ERROR("You must initialize the ValidityHistogram before calling getIsValid: " << getName().Data());
        return false;
    }
 
    const double validity = m_helper->isValid(jet);
    if (validity < 1.e-5 && validity > -1.e-5)
        return false;
    if (validity < 1+1.e-5 && validity > 1-1.e-5)
        return true;
    
    // Validity is neither 0 nor 1
    ATH_MSG_ERROR("ValidityHistogram \"" << getName().Data() << "\" out of expected range: " << validity);
    return false;
}

getValue() [1/3]

double jet::UncertaintyHistogram::getValue ( const double var1 ) const

inherited

Definition at line 141 of file UncertaintyHistogram.cxx.

{
    if (m_nDim != 1)
    {
        ATH_MSG_ERROR(Form("Wrong dimensionality - asked for 1D for a %dD histo (%s)",m_nDim,getName().Data()));
        return false;
    }
    return readHisto(var1);
}

getValue() [2/3]

double jet::UncertaintyHistogram::getValue ( const double var1, const double var2 ) const

inherited

Definition at line 151 of file UncertaintyHistogram.cxx.

{
    if (m_nDim != 2)
    {
        ATH_MSG_ERROR(Form("Wrong dimensionality - asked for 2D for a %dD histo (%s)",m_nDim,getName().Data()));
        return false;
    }
    return readHisto(var1,var2);
}

getValue() [3/3]

double jet::UncertaintyHistogram::getValue ( const double var1, const double var2, const double var3 ) const

inherited

Definition at line 161 of file UncertaintyHistogram.cxx.

{
    if (m_nDim != 3)
    {
        ATH_MSG_ERROR(Form("Wrong dimensionality - asked for 3D for a %dD histo (%s)",m_nDim,getName().Data()));
        return false;
    }
    return readHisto(var1,var2,var3);
}

initialize()

StatusCode jet::ValidityHistogram::initialize ( TFile * histFile )

virtual

Reimplemented from jet::UncertaintyHistogram.

Definition at line 316 of file ValidityHistogram.cxx.

{
    // Ensure it wasn't already initialized
    if (m_isInit)
    {
        ATH_MSG_ERROR("ValidityHistogram was already initialized: " << getName().Data());
        return StatusCode::FAILURE;
    }
 
    // Initialize the base class
    if (UncertaintyHistogram::initialize(histFile).isFailure())
        return StatusCode::FAILURE;
 
    // Ensure that the parametrization is sensible
    switch (m_param)
    {
        case CompParametrization::UNKNOWN:
            ATH_MSG_ERROR("ValidityHistogram parametrization is UNKNOWN: " << getName().Data());
            return StatusCode::FAILURE;
        case CompParametrization::Pt:
            //1D
            if (getNumDim() != 1)
            {
                ATH_MSG_ERROR("ValidityHistogram is " << getNumDim() << "D, but parametrization is 1D: " << CompParametrization::enumToString(m_param).Data());
                return StatusCode::FAILURE;
            }
            break;
        case CompParametrization::PtEta:
        case CompParametrization::PtAbsEta:
        case CompParametrization::PtAbsMass:
        case CompParametrization::PtMass:
        case CompParametrization::eLOGmOe:
        case CompParametrization::PtLOGPtMassForTagSF:
            // 2D
            if (getNumDim() != 2)
            {
                ATH_MSG_ERROR("ValidityHistogram is " << getNumDim() << "D, but parametrization is 2D: " << CompParametrization::enumToString(m_param).Data());
                return StatusCode::FAILURE;
            }
            break;
        case CompParametrization::PtMassEta:
        case CompParametrization::PtMassAbsEta:
        case CompParametrization::PtAbsMassEta:
        case CompParametrization::PtAbsMassAbsEta:
        case CompParametrization::eLOGmOeEta:
        case CompParametrization::eLOGmOeAbsEta:
            // 3D
            if (getNumDim() != 3)
            {
                ATH_MSG_ERROR("ValidityHistogram is " << getNumDim() << "D, but parametrization is 3D: " << CompParametrization::enumToString(m_param).Data());
                return StatusCode::FAILURE;
            }
            break;
        default:
            ATH_MSG_ERROR("ValidityHistogram named \"" << getName().Data() << "\" had an unpexted parametrization: " << CompParametrization::enumToString(m_param).Data());
            return StatusCode::FAILURE;
    }
 
    // Figure out which function helper we want once, right now, so we don't need to switch every time
    switch (m_param)
    {
        case CompParametrization::Pt:
            m_helper = new InfoHelperPt(*this,m_energyScale);
            break;
        case CompParametrization::PtEta:
            m_helper = new InfoHelperPtEta(*this,m_energyScale);
            break;
        case CompParametrization::PtAbsEta:
            m_helper = new InfoHelperPtAbsEta(*this,m_energyScale);
            break;
        case CompParametrization::PtAbsMass:
        m_helper = new InfoHelperPtAbsMass(*this,m_energyScale,m_massDef);
        break;
        case CompParametrization::PtMass:
            m_helper = new InfoHelperPtMass(*this,m_energyScale,m_massDef);
            break;
        case CompParametrization::PtMassEta:
            m_helper = new InfoHelperPtMassEta(*this,m_energyScale,m_massDef);
            break;
        case CompParametrization::PtMassAbsEta:
            m_helper = new InfoHelperPtMassAbsEta(*this,m_energyScale,m_massDef);
            break;
        case CompParametrization::PtAbsMassEta:
        m_helper = new InfoHelperPtAbsMassEta(*this,m_energyScale,m_massDef);
        break;
        case CompParametrization::PtAbsMassAbsEta:
        m_helper = new InfoHelperPtAbsMassAbsEta(*this,m_energyScale,m_massDef);
        break;
        case CompParametrization::eLOGmOe:
            m_helper = new InfoHelpereLOGmOe(*this,m_energyScale,m_massDef);
            break;
        case CompParametrization::eLOGmOeEta:
            m_helper = new InfoHelpereLOGmOeEta(*this,m_energyScale,m_massDef);
            break;
        case CompParametrization::eLOGmOeAbsEta:
            m_helper = new InfoHelpereLOGmOeAbsEta(*this,m_energyScale,m_massDef);
            break;
        default:
            ATH_MSG_ERROR("ValidityHistogram named \"" << getName().Data() << "\" was not prepared to handle the provided parametrization: " << CompParametrization::enumToString(m_param).Data());
            return StatusCode::FAILURE;
    }
 
    // Done
    m_isInit = true;
    return StatusCode::SUCCESS;
}

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

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

readHisto()

double jet::UncertaintyHistogram::readHisto ( const double var1, const double var2 = 0, const double var3 = 0 ) const

privateinherited

Definition at line 178 of file UncertaintyHistogram.cxx.

{
    // Ensure the component was initialized
    if (!m_isInit)
    {
        ATH_MSG_ERROR(Form("Component was not initialized (%s)",getName().Data()));
        return JESUNC_ERROR_CODE;
    }
 
    
    // Ensure that the histogram exists
    if (!m_histo)
    {
        ATH_MSG_ERROR(Form("Histogram to read is NULL (%s)",getName().Data()));
        return JESUNC_ERROR_CODE;
    }
 
    // Check first dimension boundaries, always applicable
    const double valX = checkBoundariesByBin(std::as_const(*m_histo).GetXaxis(),m_histo->GetNbinsX(),var1);
    if (m_nDim == 1)
    {
        switch (m_interpolate)
        {
            case Interpolate::Full:
            case Interpolate::OnlyX:
                return JetHelpers::Interpolate(m_histo,valX);
 
            case Interpolate::None:
                return m_histo->GetBinContent(std::as_const(*m_histo).GetXaxis()->FindFixBin(valX));
 
            default:
                ATH_MSG_ERROR("Unsupported histogram interpolation type of \"" << Interpolate::enumToString(m_interpolate).Data() << " for 1D histogram named " << m_name.Data());
                return JESUNC_ERROR_CODE;
        }
    }
 
    // Check second dimension boundaries, if applicable
    const double valY = checkBoundariesByBin(std::as_const(*m_histo).GetYaxis(),m_histo->GetNbinsY(),var2);
    if (m_nDim == 2)
    {
        // We need a 2D histogram for the projection calls
        switch (m_interpolate)
        {
            case Interpolate::Full:
                return JetHelpers::Interpolate(m_histo,valX,valY);
 
            case Interpolate::OnlyX:
                // Interpolate on the x projection for a given Y bin
                return JetHelpers::Interpolate(m_cachedProj.at(0).at(std::as_const(*m_histo).GetYaxis()->FindFixBin(valY)).get(),valX);
 
            case Interpolate::OnlyY:
                // Interpolate on the y projection for a given X bin
                return JetHelpers::Interpolate(m_cachedProj.at(0).at(std::as_const(*m_histo).GetXaxis()->FindFixBin(valX)).get(),valY);
 
            case Interpolate::None:
                return m_histo->GetBinContent(std::as_const(*m_histo).GetXaxis()->FindFixBin(valX),
                                              std::as_const(*m_histo).GetYaxis()->FindFixBin(valY));
 
            default:
                ATH_MSG_ERROR("Unsupported histogram interpolation type of \"" << Interpolate::enumToString(m_interpolate).Data() << " for 1D histogram named " << m_name.Data());
                return JESUNC_ERROR_CODE;
        }
    }
 
    // Check third dimension boundaries, if applicable
    const double valZ = checkBoundariesByBin(std::as_const(*m_histo).GetZaxis(),m_histo->GetNbinsZ(),var3);
    
    switch (m_interpolate)
    {
        case Interpolate::Full:
            return JetHelpers::Interpolate(m_histo,valX,valY,valZ);
 
        case Interpolate::OnlyX:
            // Interpolate on the x projection for a given y,z bin
            return JetHelpers::Interpolate(m_cachedProj.at(std::as_const(*m_histo).GetYaxis()->FindFixBin(valY)).at(std::as_const(*m_histo).GetZaxis()->FindFixBin(valZ)).get(),valX);
 
        case Interpolate::OnlyY:
            // Interpolate on the y projection for a given x,z bin
            return JetHelpers::Interpolate(m_cachedProj.at(std::as_const(*m_histo).GetXaxis()->FindFixBin(valX)).at(std::as_const(*m_histo).GetZaxis()->FindFixBin(valZ)).get(),valY);
 
        case Interpolate::None:
            return m_histo->GetBinContent(std::as_const(*m_histo).GetXaxis()->FindFixBin(valX),
                                          std::as_const(*m_histo).GetYaxis()->FindFixBin(valY),
                                          std::as_const(*m_histo).GetZaxis()->FindFixBin(valZ));
 
        default:
            ATH_MSG_ERROR("Unsupported histogram interpolation type of \"" << Interpolate::enumToString(m_interpolate).Data() << " for 1D histogram named " << m_name.Data());
            return JESUNC_ERROR_CODE;
    }
}

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

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_cachedProj

std::vector< std::vector< std::unique_ptr<TH1> > > jet::UncertaintyHistogram::m_cachedProj

privateinherited

Definition at line 56 of file UncertaintyHistogram.h.

m_energyScale

const float jet::ValidityHistogram::m_energyScale

private

Definition at line 39 of file ValidityHistogram.h.

m_helper

InfoHelper* jet::ValidityHistogram::m_helper

private

Definition at line 41 of file ValidityHistogram.h.

m_histo

TH1* jet::UncertaintyHistogram::m_histo

privateinherited

Definition at line 51 of file UncertaintyHistogram.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_interpolate

const Interpolate::TypeEnum jet::UncertaintyHistogram::m_interpolate

privateinherited

Definition at line 50 of file UncertaintyHistogram.h.

m_isInit

bool jet::ValidityHistogram::m_isInit

private

Definition at line 37 of file ValidityHistogram.h.

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_massDef

const CompMassDef::TypeEnum jet::ValidityHistogram::m_massDef

private

Definition at line 40 of file ValidityHistogram.h.

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_name

const TString jet::UncertaintyHistogram::m_name

privateinherited

Definition at line 49 of file UncertaintyHistogram.h.

m_nDim

int jet::UncertaintyHistogram::m_nDim

privateinherited

Definition at line 52 of file UncertaintyHistogram.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_param

const CompParametrization::TypeEnum jet::ValidityHistogram::m_param

private

Definition at line 38 of file ValidityHistogram.h.

---

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

• ValidityHistogram.h
• ValidityHistogram.cxx