jet::FlavourUncertaintyComponent Class Reference

#include <FlavourUncertaintyComponent.h>

Inheritance diagram for jet::FlavourUncertaintyComponent:

Collaboration diagram for jet::FlavourUncertaintyComponent:

Public Member Functions
	FlavourUncertaintyComponent (const ComponentHelper &component, const TString &jetType, const TString &analysisRootFileName, const TString &defaultAnalysisRootFileName, const TString &path, const TString &calibArea, const bool absEtaGluonFraction, const TString &analysisHistPattern="", const TString &NjetAccessorName="Njet")
	FlavourUncertaintyComponent (const FlavourUncertaintyComponent &toCopy)
virtual FlavourUncertaintyComponent *	clone () const
virtual	~FlavourUncertaintyComponent ()
virtual StatusCode	initialize (TFile *histFile)
virtual FlavourComp::TypeEnum	getFlavourType () const
virtual TString	getName () const
virtual TString	getValidName () const
virtual CompScaleVar::TypeEnum	getScaleVar () const
virtual JetTopology::TypeEnum	getTopology () const
virtual bool	isAlwaysZero () const
virtual bool	getValidity (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual double	getUncertainty (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual bool	getValidUncertainty (double &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) 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.

Protected Member Functions
virtual bool	getValidityImpl (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual double	getUncertaintyImpl (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual bool	getValidBool (const double validity) const
virtual double	getSplitFactor (const xAOD::Jet &jet) const
virtual double	getAbsMass (const xAOD::Jet &jet, const CompMassDef::TypeEnum massDef) const
virtual double	getMassOverPt (const xAOD::Jet &jet, const CompMassDef::TypeEnum massDef) const
virtual double	getMassOverE (const xAOD::Jet &jet, const CompMassDef::TypeEnum massDef) const

Protected Attributes
bool	m_isInit {}
const TString	m_uncHistName
const TString	m_validHistName
const CompScaleVar::TypeEnum	m_scaleVar
const JetTopology::TypeEnum	m_topology
const float	m_energyScale {}
const Interpolate::TypeEnum	m_interpolate
const int	m_splitNumber {}
int	m_numExpectedHist {}
UncertaintyHistogram *	m_uncHist {}
UncertaintyHistogram *	m_validHist {}

Private Types
enum	FlavourRespType { FlavourResp_UNKNOWN , FlavourResp_GLUON , FlavourResp_QUARK }

Private Member Functions
	FlavourUncertaintyComponent (const std::string &name="")
double	getFlavourResponseUncertainty (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
double	getFlavourCompositionUncertainty (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
double	getBJESUncertainty (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
double	getGluonFraction (const double pT, const double eta, const int nJets) const
double	getGluonFractionError (const double pT, const double eta, const int nJets) const
double	getGluonResponseDifference (const double pT, const double eta) const
double	getGluonResponseBaseline (const double pT, const double eta) const
double	getQuarkResponseBaseline (const double pT, const double eta) const
StatusCode	readNjetsHistograms (std::vector< UncertaintyHistogram * > &hists, const std::vector< TString > &histKeys)
StatusCode	getNjetFromKey (const TString &key, int &nJets) const
StatusCode	checkNjetsInput (int &nJets) const
bool	isBjet (const xAOD::Jet &jet) const
void	getGluonKeys (TFile *analysisFile, std::vector< TString > &gluonFractionKeys, std::vector< TString > &gluonFractionErrorKeys) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
const FlavourComp::TypeEnum	m_flavourType
const TString	m_jetType
const TString	m_analysisFileName
const TString	m_analysisHistPattern
const TString	m_defAnaFileName
const TString	m_path
const TString	m_calibArea
const bool	m_absEta
const bool	m_absEtaGluonFraction
const TString	m_secondUncName
std::string	m_largeRJetTruthLabelName
std::vector< LargeRJetTruthLabel::TypeEnum >	m_largeRJetTruthLabels
UncertaintyHistogram *	m_secondUncHist
FlavourRespType	m_respType
FlavourRespType	m_secondRespType
SG::AuxElement::Accessor< char >	m_BjetAccessor
SG::AuxElement::Accessor< int >	m_NjetAccessor
SG::AuxElement::Accessor< int >	m_largeRJetTruthLabelAccessor
std::vector< UncertaintyHistogram * >	m_gluonFractionHists
std::vector< UncertaintyHistogram * >	m_gluonFractionErrorHists
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 13 of file FlavourUncertaintyComponent.h.

Member Enumeration Documentation

FlavourRespType

enum jet::FlavourUncertaintyComponent::FlavourRespType

private

Enumerator
FlavourResp_UNKNOWN
FlavourResp_GLUON
FlavourResp_QUARK

Definition at line 45 of file FlavourUncertaintyComponent.h.

{ FlavourResp_UNKNOWN, FlavourResp_GLUON, FlavourResp_QUARK };

Constructor & Destructor Documentation

FlavourUncertaintyComponent() [1/3]

jet::FlavourUncertaintyComponent::FlavourUncertaintyComponent	(	const ComponentHelper &	component,
		const TString &	jetType,
		const TString &	analysisRootFileName,
		const TString &	defaultAnalysisRootFileName,
		const TString &	path,
		const TString &	calibArea,
		const bool	absEtaGluonFraction,
		const TString &	analysisHistPattern = "",
		const TString &	NjetAccessorName = "Njet" )

Definition at line 45 of file FlavourUncertaintyComponent.cxx.

    : UncertaintyComponent(component,component.flavourType == FlavourComp::Composition ? 2 : 1)
    , m_flavourType(component.flavourType)
    , m_jetType(jetType)
    , m_analysisFileName(analysisRootFileName)
    , m_analysisHistPattern(analysisHistPattern)
    , m_defAnaFileName(defaultAnalysisRootFileName)
    , m_path(path)
    , m_calibArea(calibArea)
    , m_absEta(CompParametrization::isAbsEta(component.parametrization))
    , m_absEtaGluonFraction(absEtaGluonFraction)
    , m_secondUncName(component.uncNames.size()>1 ? component.uncNames.at(1) : "")
    , m_largeRJetTruthLabelName(component.LargeRJetTruthLabelName)
    , m_largeRJetTruthLabels(component.LargeRJetTruthLabels)
    , m_secondUncHist(nullptr)
    , m_respType(FlavourResp_UNKNOWN)
    , m_secondRespType(FlavourResp_UNKNOWN)
    , m_BjetAccessor("IsBjet")
    , m_NjetAccessor(NjetAccessorName.Data())
    , m_largeRJetTruthLabelAccessor(m_largeRJetTruthLabelName)
    , m_gluonFractionHists()
    , m_gluonFractionErrorHists()
{
    ATH_MSG_DEBUG("Created FlavourUncertaintyComponent named" << m_uncHistName.Data());
    
    // Ensure that the flavour type and ref values are sensible
    if (m_flavourType == FlavourComp::UNKNOWN)
        ATH_MSG_FATAL("Flavour type is UNKNOWN: " << m_uncHistName.Data());
}

FlavourUncertaintyComponent() [2/3]

jet::FlavourUncertaintyComponent::FlavourUncertaintyComponent

(

const FlavourUncertaintyComponent &

toCopy

)

Definition at line 84 of file FlavourUncertaintyComponent.cxx.

    : UncertaintyComponent(toCopy)
    , m_flavourType(toCopy.m_flavourType)
    , m_jetType(toCopy.m_jetType)
    , m_analysisFileName(toCopy.m_analysisFileName)
    , m_analysisHistPattern(toCopy.m_analysisHistPattern)
    , m_defAnaFileName(toCopy.m_defAnaFileName)
    , m_path(toCopy.m_path)
    , m_calibArea(toCopy.m_calibArea)
    , m_absEta(toCopy.m_absEta)
    , m_absEtaGluonFraction(toCopy.m_absEtaGluonFraction)
    , m_secondUncName(toCopy.m_secondUncName)
    , m_largeRJetTruthLabelName(toCopy.m_largeRJetTruthLabelName)
    , m_largeRJetTruthLabels(toCopy.m_largeRJetTruthLabels)
    , m_secondUncHist(nullptr)
    , m_respType(toCopy.m_respType)
    , m_secondRespType(toCopy.m_secondRespType)
    , m_BjetAccessor(toCopy.m_BjetAccessor)
    , m_NjetAccessor(toCopy.m_NjetAccessor)
    , m_largeRJetTruthLabelAccessor(toCopy.m_largeRJetTruthLabelAccessor)
    , m_gluonFractionHists()
    , m_gluonFractionErrorHists()
{
    ATH_MSG_DEBUG(Form("Creating copy of FlavourUncertaintyComponent named %s",m_uncHistName.Data()));
    
    if (toCopy.m_secondUncHist)
        m_secondUncHist = new UncertaintyHistogram(*toCopy.m_secondUncHist);
 
    for (size_t iHist = 0; iHist < toCopy.m_gluonFractionHists.size(); ++iHist)
        if (toCopy.m_gluonFractionHists.at(iHist))
            m_gluonFractionHists.push_back(new UncertaintyHistogram(*toCopy.m_gluonFractionHists.at(iHist)));
 
    for (size_t iHist = 0; iHist < toCopy.m_gluonFractionErrorHists.size(); ++iHist)
        if (toCopy.m_gluonFractionErrorHists.at(iHist))
            m_gluonFractionErrorHists.push_back(new UncertaintyHistogram(*toCopy.m_gluonFractionErrorHists.at(iHist)));
}

~FlavourUncertaintyComponent()

jet::FlavourUncertaintyComponent::~FlavourUncertaintyComponent ( )

virtual

Definition at line 126 of file FlavourUncertaintyComponent.cxx.

{
    JESUNC_SAFE_DELETE(m_secondUncHist);
 
    for (size_t iHisto = 0; iHisto < m_gluonFractionHists.size(); ++iHisto)
    {
        JESUNC_SAFE_DELETE(m_gluonFractionHists.at(iHisto));
        JESUNC_SAFE_DELETE(m_gluonFractionErrorHists.at(iHisto));
    }
    m_gluonFractionHists.clear();
    m_gluonFractionErrorHists.clear();
}

FlavourUncertaintyComponent() [3/3]

jet::FlavourUncertaintyComponent::FlavourUncertaintyComponent ( const std::string & name = "" )

private

Definition at line 21 of file FlavourUncertaintyComponent.cxx.

    : UncertaintyComponent(ComponentHelper(name),0)
    , m_flavourType(FlavourComp::UNKNOWN)
    , m_jetType("")
    , m_analysisFileName("")
    , m_analysisHistPattern("")
    , m_defAnaFileName("")
    , m_absEta(false)
    , m_absEtaGluonFraction(true)
    , m_secondUncName("")
    , m_largeRJetTruthLabelName("")
    , m_largeRJetTruthLabels()
    , m_secondUncHist(nullptr)
    , m_respType(FlavourResp_UNKNOWN)
    , m_secondRespType(FlavourResp_UNKNOWN)
    , m_BjetAccessor("IsBjet")
    , m_NjetAccessor("Njet")
    , m_largeRJetTruthLabelAccessor(m_largeRJetTruthLabelName)
    , m_gluonFractionHists()
    , m_gluonFractionErrorHists()
{
    JESUNC_NO_DEFAULT_CONSTRUCTOR;
}

Member Function Documentation

checkNjetsInput()

StatusCode jet::FlavourUncertaintyComponent::checkNjetsInput ( int & nJets ) const

private

Definition at line 632 of file FlavourUncertaintyComponent.cxx.

{
    // nJets = 0 is the inclusive composition
    // nJets = # is the composition for # jets
    // nJets < 0 uses default if available
    // nJets > MAX uses default if available
    // nJets = #, but # is NULL uses default if available
    
    // Case of no histograms is checked in initialization, no need to repeat here
    // Initialization also ensures gluonFractionHists and gluonFractionErrorHists are consistent
 
    // Check if we need to use the default histogram
    if (nJets < 0 || nJets >= static_cast<int>(m_gluonFractionHists.size()) || m_gluonFractionHists.at(nJets) == nullptr)
    {
        // Check if we can fall back on the default bin (does it exist?)
        if (m_gluonFractionHists.at(0) == nullptr)
        {
            ATH_MSG_ERROR("nJets of " << nJets << " is invalid, and default does not exist to fall back on, for " << getName().Data());
            return StatusCode::FAILURE;
        }
        // Fall back on the default bin
        nJets = 0;
    }
    // Otherwise, the specified nJets value is fine and doesn't need to be touched
 
 
    return StatusCode::SUCCESS;
}

clone()

FlavourUncertaintyComponent * jet::FlavourUncertaintyComponent::clone ( ) const

virtual

Implements jet::UncertaintyComponent.

Definition at line 121 of file FlavourUncertaintyComponent.cxx.

{
    return new FlavourUncertaintyComponent(*this);
}

getAbsMass()

double jet::UncertaintyComponent::getAbsMass ( const xAOD::Jet & jet, const CompMassDef::TypeEnum massDef ) const

protectedvirtualinherited

Definition at line 309 of file UncertaintyComponent.cxx.

{
    // Check for the simple case (where we want the default four-vector itself)
    if (massDef == CompMassDef::UNKNOWN || massDef == CompMassDef::FourVecMass)
        return jet.m();
    
    // Not the simple case, check for the specified four-vector instead and return it if it is available
    JetFourMomAccessor scale(CompMassDef::getJetScaleString(massDef).Data());
    if (scale.isAvailable(jet))
        return scale(jet).M();
 
    // Fall-back on the TA moment as a float if applicable (legacy support)
    SG::AuxElement::ConstAccessor<float> scaleTAMoment("JetTrackAssistedMassCalibrated");
    if (massDef == CompMassDef::TAMass && scaleTAMoment.isAvailable(jet))
        return scaleTAMoment(jet);
 
    // Fall-back on the calo mass as the 4-vec if applicable (legacy support)
    if (massDef == CompMassDef::CaloMass)
        return jet.m();
 
    // Specified scale is not available, error
    ATH_MSG_ERROR("Failed to retrieve the " << CompMassDef::enumToString(massDef).Data() << " mass from the jet");
    return JESUNC_ERROR_CODE;
}

getBJESUncertainty()

double jet::FlavourUncertaintyComponent::getBJESUncertainty ( const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

private

Definition at line 517 of file FlavourUncertaintyComponent.cxx.

{
    // Ensure this is a b-jet
    if (!isBjet(jet))
        return 0;
    return m_uncHist->getValue(jet.pt()*m_energyScale,m_absEta ? fabs(jet.eta()) : jet.eta());
}

getFlavourCompositionUncertainty()

double jet::FlavourUncertaintyComponent::getFlavourCompositionUncertainty ( const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

private

Definition at line 457 of file FlavourUncertaintyComponent.cxx.

{
    //  Returns the flavor composition uncertainty using the formula:
    //    
    //  Uncertainty = df * | Rq - Rg | / ( fg * Rg + (1 - fg) * Rq )
    //  with
    //      Rs = fg * Rg + (1 - fg) * Rq as heavy q uncertainties accounted separately
    //      df = error on fg
    //      fg = fraction of gluons
    //      Rq = light quark response
    //      Rg = gluon response
    
    // Check if this is a b-jet
    if (isBjet(jet))
        return 0;
 
    // Get the number of jets
    int nJets = 0;
    if (m_gluonFractionHists.size() > 1)
    {
        if (m_NjetAccessor.isAvailable(eInfo))
            nJets = m_NjetAccessor(eInfo);
        else
        {
            ATH_MSG_ERROR("Specified Njets treatment, but did not decorate EventInfo object");
            return JESUNC_ERROR_CODE;
        }
    }
 
 
    if (checkNjetsInput(nJets).isFailure())
        return JESUNC_ERROR_CODE;
 
    const double pT  = jet.pt()*m_energyScale;
    const double eta = m_absEta ? fabs(jet.eta()) : jet.eta();
    
    //calculating the sample response:
    //fg*Rg + (1-fg)*Rq
    const double gluonFrac = getGluonFraction(pT,eta,nJets);
    const double Rg = getGluonResponseBaseline(pT,eta);
    const double Rq = getQuarkResponseBaseline(pT,eta);
     
    const double Rsample = gluonFrac * Rg + (1-gluonFrac) * Rq;
    
    //this should never happen (it means the Rg == Rq == 0), but checking anyway
    if (Rsample==0)
    {
        ATH_MSG_ERROR(Form("R(sample) = 0 for pT=%.1f, eta=%.2f",pT,eta));
        return JESUNC_ERROR_CODE;
    }
    
    //calculating the uncertainty
    const double gluonFracError = getGluonFractionError(pT,eta,nJets);
    //coverity[divide_by_zero]
    const double flavorCompUnc  = gluonFracError*fabs(Rq-Rg)/Rsample;
    
    return flavorCompUnc;
 
}

getFlavourResponseUncertainty()

double jet::FlavourUncertaintyComponent::getFlavourResponseUncertainty ( const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

private

Definition at line 421 of file FlavourUncertaintyComponent.cxx.

{
    //  Assumption:
    //      dR(q) = JES uncertainty (measured in gamma/Z+jet)
    //      dR(g) = JES uncertainty (+) additional gluon response component
    //  component to be added to JES uncertainty: 
    //      fg*dR(gluon response modelling uncertainty)
    //      where gluon response modelling uncertainty is taken as difference between gluon response in Pythia and Herwig++
    
    // Check if this is a b-jet
    if (isBjet(jet))
        return 0;
 
    // Get the number of jets
    int nJets = 0;
    if (m_gluonFractionHists.size() > 1)
    {
        if (m_NjetAccessor.isAvailable(eInfo))
            nJets = m_NjetAccessor(eInfo);
        else
        {
            ATH_MSG_ERROR("Specified Njets treatment, but did not decorate EventInfo object");
            return JESUNC_ERROR_CODE;
        }
    }
    
    if (checkNjetsInput(nJets).isFailure())
        return JESUNC_ERROR_CODE;
 
    const double pT  = jet.pt()*m_energyScale;
    const double eta = m_absEta ? fabs(jet.eta()) : jet.eta();
    
    // return the uncertainty
    return getGluonResponseDifference(pT,eta) * getGluonFraction(pT,eta,nJets);
}

getFlavourType()

virtual FlavourComp::TypeEnum jet::FlavourUncertaintyComponent::getFlavourType ( ) const

inlinevirtual

Definition at line 33 of file FlavourUncertaintyComponent.h.

{ return m_flavourType; }

getGluonFraction()

double jet::FlavourUncertaintyComponent::getGluonFraction ( const double pT, const double eta, const int nJets ) const

private

Definition at line 532 of file FlavourUncertaintyComponent.cxx.

{
    // nJets value checking is done in checkNjetsInput
    return m_gluonFractionHists.at(nJets)->getValue(pT,m_absEtaGluonFraction ? std::abs(eta) : eta);
}

getGluonFractionError()

double jet::FlavourUncertaintyComponent::getGluonFractionError ( const double pT, const double eta, const int nJets ) const

private

Definition at line 538 of file FlavourUncertaintyComponent.cxx.

{
    // nJets value checking is done in checkNjetsInput
    return m_gluonFractionErrorHists.at(nJets)->getValue(pT,m_absEtaGluonFraction ? std::abs(eta) : eta);
}

getGluonKeys()

void jet::FlavourUncertaintyComponent::getGluonKeys ( TFile * analysisFile, std::vector< TString > & gluonFractionKeys, std::vector< TString > & gluonFractionErrorKeys ) const

private

Definition at line 671 of file FlavourUncertaintyComponent.cxx.

{
    TList* keys = analysisFile->GetListOfKeys();
    TIter nextkey(keys);
    if (m_analysisHistPattern != "")
    {
        ATH_MSG_DEBUG("Ignoring histograms which don't contain pattern " << m_analysisHistPattern.Data());
    }
    while (TKey* key = dynamic_cast<TKey*>(nextkey()))
    {
        const TString keyName = key->GetName();
        //Ignoring histograms which doesn't contain user-defined pattern
        if (m_analysisHistPattern != "" && !keyName.Contains(m_analysisHistPattern)) continue;
        if (keyName.Contains(m_jetType) && !keyName.Contains("valid"))
        {
            if (keyName.Contains("gluonFractionError"))
                gluonFractionErrorKeys.push_back(keyName);
            else if (keyName.Contains("gluonFraction"))
                gluonFractionKeys.push_back(keyName);
        }
    }
}

getGluonResponseBaseline()

double jet::FlavourUncertaintyComponent::getGluonResponseBaseline ( const double pT, const double eta ) const

private

Definition at line 554 of file FlavourUncertaintyComponent.cxx.

{
    if (m_flavourType != FlavourComp::Composition)
    {
        ATH_MSG_ERROR("This method is only useable for FlavourComposition uncertainties, not " << getName().Data());
        return JESUNC_ERROR_CODE;
    }
 
    if (m_respType == FlavourResp_GLUON)
        return m_uncHist->getValue(pT,eta);
    else if (m_secondRespType == FlavourResp_GLUON)
        return m_secondUncHist->getValue(pT,eta);
    ATH_MSG_ERROR("Unexpected flavour response parametrization: " << getName().Data());
    return JESUNC_ERROR_CODE;
}

getGluonResponseDifference()

double jet::FlavourUncertaintyComponent::getGluonResponseDifference ( const double pT, const double eta ) const

private

Definition at line 544 of file FlavourUncertaintyComponent.cxx.

{
    if (m_flavourType != FlavourComp::Response)
    {
        ATH_MSG_ERROR("This method is only useable for FlavourResponse uncertainties, not " << getName().Data());
        return JESUNC_ERROR_CODE;
    }
    return m_uncHist->getValue(pT,eta);
}

getMassOverE()

double jet::UncertaintyComponent::getMassOverE ( const xAOD::Jet & jet, const CompMassDef::TypeEnum massDef ) const

protectedvirtualinherited

Definition at line 360 of file UncertaintyComponent.cxx.

{
    // Check for the simple case (where we want the default four-vector itself)
    if (massDef == CompMassDef::UNKNOWN || massDef == CompMassDef::FourVecMass)
        return jet.m()/jet.e();
 
    // Not the simple case, check for the specified four-vector instead and return it if it is available
    JetFourMomAccessor scale(CompMassDef::getJetScaleString(massDef).Data());
    if (scale.isAvailable(jet))
        return scale(jet).M()/scale(jet).E();
    
    // Fall-back on the TA moment as a float if applicable (legacy support)
    SG::AuxElement::ConstAccessor<float> scaleTAMoment("JetTrackAssistedMassCalibrated");
    if (massDef == CompMassDef::TAMass && scaleTAMoment.isAvailable(jet))
        return scaleTAMoment(jet)/jet.e();
    
    // Fall-back on the calo mass as the 4-vec if applicable (legacy support)
    if (massDef == CompMassDef::CaloMass)
        return jet.m()/jet.e();
 
    // Specified scale is not available, error
    ATH_MSG_ERROR("Failed to retrieve the " << CompMassDef::enumToString(massDef).Data() << " mass from the jet");
    return JESUNC_ERROR_CODE;
 
}

getMassOverPt()

double jet::UncertaintyComponent::getMassOverPt ( const xAOD::Jet & jet, const CompMassDef::TypeEnum massDef ) const

protectedvirtualinherited

Definition at line 334 of file UncertaintyComponent.cxx.

{
    // Check for the simple case (where we want the default four-vector itself)
    if (massDef == CompMassDef::UNKNOWN || massDef == CompMassDef::FourVecMass)
        return jet.m()/jet.pt();
    
    // Not the simple case, check for the specified four-vector instead and return it if it is available
    JetFourMomAccessor scale(CompMassDef::getJetScaleString(massDef).Data());
    if (scale.isAvailable(jet))
        return scale(jet).M()/scale(jet).Pt();
    
    // Fall-back on the TA moment as a float if applicable (legacy support)
    SG::AuxElement::ConstAccessor<float> scaleTAMoment("JetTrackAssistedMassCalibrated");
    if (massDef == CompMassDef::TAMass && scaleTAMoment.isAvailable(jet))
        return scaleTAMoment(jet)/jet.pt();
    
    // Fall-back on the calo mass as the 4-vec if applicable (legacy support)
    if (massDef == CompMassDef::CaloMass)
        return jet.m()/jet.pt();
 
    // Specified scale is not available, error
    ATH_MSG_ERROR("Failed to retrieve the " << CompMassDef::enumToString(massDef).Data() << " mass from the jet");
    return JESUNC_ERROR_CODE;
 
}

getName()

virtual TString jet::UncertaintyComponent::getName ( ) const

inlinevirtualinherited

Definition at line 35 of file UncertaintyComponent.h.

{ return m_uncHistName;   }

getNjetFromKey()

StatusCode jet::FlavourUncertaintyComponent::getNjetFromKey ( const TString & key, int & nJets ) const

private

Definition at line 615 of file FlavourUncertaintyComponent.cxx.

{
    std::vector<TString> tokens = utils::vectorize<TString>(key,"_");
    if (tokens.size() > 2 && tokens.at(tokens.size()-1).Contains("nJet",TString::kIgnoreCase))
    {
        TString nJetStr = tokens.at(tokens.size()-1).ReplaceAll("nJet","");
        nJetStr = nJetStr.ReplaceAll("njet","");
        nJetStr = nJetStr.ReplaceAll("Njet","");
        if (!utils::getTypeObjFromString<int>(nJetStr,nJets))
        {
            ATH_MSG_ERROR("Found nJets histogram, but failed to parse the index: " << key.Data());
            return StatusCode::FAILURE;
        }
    }
    return StatusCode::SUCCESS;
}

getQuarkResponseBaseline()

double jet::FlavourUncertaintyComponent::getQuarkResponseBaseline ( const double pT, const double eta ) const

private

Definition at line 570 of file FlavourUncertaintyComponent.cxx.

{
    if (m_flavourType != FlavourComp::Composition)
    {
        ATH_MSG_ERROR("This method is only useable for FlavourComposition uncertainties, not " << getName().Data());
        return JESUNC_ERROR_CODE;
    }
    if (m_respType == FlavourResp_QUARK)
        return m_uncHist->getValue(pT,eta);
    else if (m_secondRespType == FlavourResp_QUARK)
        return m_secondUncHist->getValue(pT,eta);
    ATH_MSG_ERROR("Unexpected flavour response parametrization: " << getName().Data());
    return JESUNC_ERROR_CODE;
}

getScaleVar()

virtual CompScaleVar::TypeEnum jet::UncertaintyComponent::getScaleVar ( ) const

inlinevirtualinherited

Definition at line 37 of file UncertaintyComponent.h.

{ return m_scaleVar;      }

getSplitFactor()

double jet::UncertaintyComponent::getSplitFactor ( const xAOD::Jet & jet ) const

protectedvirtualinherited

Definition at line 196 of file UncertaintyComponent.cxx.

{
    // Immediate return for the most common case
    if (!m_splitNumber)
        return 1;
 
    // SplitNumber was specified, we have to calculate the factor
    double splitFactor = 1;
    const TH1* histo = m_uncHist->getHisto();
 
    if (m_splitNumber == 1 || m_splitNumber == -1)
    {
        // Straight line in log(pT) from 0 to 1
        // y = mx+b
        // m = 1/[log(max)-log(min)]
        // x = log(min) --> b = -m*log(min)
 
        const double minPt = histo->GetXaxis()->GetBinLowEdge(1);
        const double maxPt = histo->GetXaxis()->GetBinLowEdge(histo->GetNbinsX()+1);
        const double valPt = jet.pt()*m_energyScale;
 
        const double slope = 1./(log(maxPt)-log(minPt));
        const double intercept = -slope*log(minPt);
 
        splitFactor = slope*log(valPt <= minPt ? minPt+1.e-3 : valPt >= maxPt ? maxPt-1.e-3 : valPt)+intercept;
    }
    else if (m_splitNumber == 2 || m_splitNumber == -2)
    {
        // Straight line in |eta| from 0 to 1
        // y = mx + b
        // m = 1/(max - min)
        // x = min --> b = -m*min
        const double minEta = 0;
        const double maxEta = 4.5;
        const double absEta = fabs(jet.eta());
 
        const double slope = 1./(maxEta - minEta);
        const double intercept = -slope*minEta;
 
        splitFactor = slope*(absEta <= minEta ? minEta+1.e-3 : absEta >= maxEta ? maxEta-1.e-3 : absEta)+intercept;
    }
    else if (m_splitNumber == 3 || m_splitNumber == -3)
    {
        // Increasing with log(pT) and increasing with |eta|
        // z = mx + ny + c
        // z(min,min) = 0
        // z(max,max) = 1
        // Linear in both dimensions means need factor of 1/2 in a single dimension
        // m = 0.5/[log(maxPt)-log(minPt)]
        // n = 0.5/(maxEta - minEta)
        // c = -minPt*m - minEta*n
        // 2*z = (logx-logxmin)/(logxmax-logxmin) + (y-ymin)/(ymax-ymin)
        const double minPt = histo->GetXaxis()->GetBinLowEdge(1);
        const double maxPt = histo->GetXaxis()->GetBinLowEdge(histo->GetNbinsX()+1);
        const double valPt = jet.pt()*m_energyScale;
 
        const double minEta = 0;
        const double maxEta = 4.5;
        const double absEta = fabs(jet.eta());
 
        const double slopePt = 1./(log(maxPt)-log(minPt));
        const double slopeEta = 1./(maxEta-minEta);
        
        const double fixedPt  = valPt <= minPt ? minPt+1.e-3 : valPt >= maxPt ? maxPt - 1.e-3 : valPt;
        const double fixedEta = absEta <= minEta ? minEta+1.e-3 : absEta >= maxEta ? maxEta-1.e-3 : absEta;
 
        splitFactor = (slopePt*(log(fixedPt)-log(minPt)) + slopeEta*(fixedEta-minEta))/2.;
    }
    else if (m_splitNumber == 4 || m_splitNumber == -4)
    {
        // Increasing with log(pT) and decreasing with |eta|
        // See description above, follows similarly
        // 2*z = (logx-logxmin)/(logxmax-logxmin) + (ymax-y)/(ymax-ymin)
        const double minPt = histo->GetXaxis()->GetBinLowEdge(1);
        const double maxPt = histo->GetXaxis()->GetBinLowEdge(histo->GetNbinsX()+1);
        const double valPt = jet.pt()*m_energyScale;
 
        const double minEta = 0;
        const double maxEta = 4.5;
        const double absEta = fabs(jet.eta());
 
        const double slopePt = 1./(log(maxPt)-log(minPt));
        const double slopeEta = 1./(maxEta-minEta);
        
        const double fixedPt  = valPt <= minPt ? minPt+1.e-3 : valPt >= maxPt ? maxPt - 1.e-3 : valPt;
        const double fixedEta = absEta <= minEta ? minEta+1.e-3 : absEta >= maxEta ? maxEta-1.e-3 : absEta;
 
        splitFactor = (slopePt*(log(fixedPt)-log(minPt)) + slopeEta*(maxEta-fixedEta))/2.;
    }
 
 
    // Now check if this is the functional part or the complementary part
    if (m_splitNumber < 0)
        splitFactor = sqrt(1-splitFactor*splitFactor);
 
    return splitFactor;
}

getTopology()

virtual JetTopology::TypeEnum jet::UncertaintyComponent::getTopology ( ) const

inlinevirtualinherited

Definition at line 38 of file UncertaintyComponent.h.

{ return m_topology;      }

getUncertainty()

double jet::UncertaintyComponent::getUncertainty ( const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

virtualinherited

Definition at line 169 of file UncertaintyComponent.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_ERROR("Component hasn't been initialized: " << getName().Data());
        return JESUNC_ERROR_CODE;
    }
    return getUncertaintyImpl(jet,eInfo)*getSplitFactor(jet);
}

getUncertaintyImpl()

double jet::FlavourUncertaintyComponent::getUncertaintyImpl ( const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

protectedvirtual

Implements jet::UncertaintyComponent.

Definition at line 368 of file FlavourUncertaintyComponent.cxx.

{
    // First, check if we even want to apply the uncertainty (large-R specific break-out)
    // Check if we are supposed to only use given truth labels
    if (!m_largeRJetTruthLabels.empty())
    {
        // If we are asking to check truth labels, then retrieve the truth jet label from the jet
        if (!m_largeRJetTruthLabelAccessor.isAvailable(jet))
        {
            // Unable to retrieve truth label, but we were told to look for it, error
            ATH_MSG_ERROR("Unable to retrieve LargeRJetTruthLabel: " + m_largeRJetTruthLabelName + " from the jet.  Please use JetTruthLabeling before calling this function.");
            return JESUNC_ERROR_CODE;
        }
        // Ok, the label exists, now check what it is
        const LargeRJetTruthLabel::TypeEnum largeRJetTruthLabel = LargeRJetTruthLabel::intToEnum(m_largeRJetTruthLabelAccessor(jet));
        if (largeRJetTruthLabel == LargeRJetTruthLabel::UNKNOWN)
        {
            // This is an error - the label exists but it is unrecognized
            ATH_MSG_ERROR("UNKNOWN LargeRJetTruthLabel on the jet.  Please use JetTruthLabeling before calling this function or check the jet for irregularities.");
            return JESUNC_ERROR_CODE;
        }
        // Not unknown, now check if it is one of the labels we want to apply this uncertainty for
        bool relevantLabel = false;
        for (const LargeRJetTruthLabel::TypeEnum aLabel : m_largeRJetTruthLabels)
        {
            if (aLabel == largeRJetTruthLabel)
                relevantLabel = true;
        }
        
        // If we don't want to apply an uncertainty to jets with this label, then return 0 here (no uncertainty)
        if (!relevantLabel)
            return 0;
        // Otherwise, continue as usual
    }
    
 
    // Now, we do want t o apply the uncertainty, so do it
    double unc = JESUNC_ERROR_CODE;
    if (m_flavourType == FlavourComp::Response)
        unc = getFlavourResponseUncertainty(jet,eInfo);
    else if (m_flavourType == FlavourComp::Composition)
        unc = getFlavourCompositionUncertainty(jet,eInfo);
    else if (m_flavourType == FlavourComp::bJES)
        unc = getBJESUncertainty(jet,eInfo);
    else
    {
        ATH_MSG_ERROR("Unknown flavour type for " << getName().Data());
        return unc;
    }
    
    return unc;
}

getValidBool()

bool jet::UncertaintyComponent::getValidBool ( const double validity ) const

protectedvirtualinherited

Definition at line 301 of file UncertaintyComponent.cxx.

{
    if (validity < 1.e-5 && validity > -1.e-5) return false;
    if (validity < 1+1.e-5 && validity > 1-1.e-5) return true;
    ATH_MSG_ERROR(Form("Validity value not in expected range: %lf for histogram %s",validity,getValidName().Data()));
    return false;
}

getValidity()

bool jet::UncertaintyComponent::getValidity ( const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

virtualinherited

Definition at line 159 of file UncertaintyComponent.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_ERROR("Component hasn't been initialized: " << getName().Data());
        return false;
    }
    return getValidityImpl(jet,eInfo);
}

getValidityImpl()

bool jet::FlavourUncertaintyComponent::getValidityImpl ( const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

protectedvirtual

Implements jet::UncertaintyComponent.

Definition at line 345 of file FlavourUncertaintyComponent.cxx.

{
    // Currently only one validity histogram exists
    // Might need to expand in the future
    
    return !m_validHist ? true : getValidBool(m_validHist->getValue(jet.pt()*m_energyScale,m_absEta ? fabs(jet.eta()) : jet.eta()));
 
//    // Valid only if all histogram(s) are valid
//    // Histograms to consider varies by flavour type
//    // Start with the standard histograms
//    for (size_t iHisto = 0; iHisto < m_histos.size(); ++iHisto)
//        if (!m_histos.at(iHisto)->getValidity(jet.pt()*m_energyScale,m_absEta ? fabs(jet.eta()) : jet.eta()))
//            return false;
//
//    // Now do analysis histograms
//    for (size_t iHisto = 0; iHisto < m_gluonFractionHists.size(); ++iHisto)
//        if (!m_gluonFractionHists.at(iHisto)->getValidity(jet.pt()*m_energyScale,m_absEta ? fabs(jet.eta()) : jet.eta()) || 
//            !m_gluonFractionErrorHists.at(iHisto)->getValidity(jet.pt()*m_energyScale,m_absEta ? fabs(jet.eta()) : jet.eta()) )
//            return false;
//    
//    return true;
}

getValidName()

virtual TString jet::UncertaintyComponent::getValidName ( ) const

inlinevirtualinherited

Definition at line 36 of file UncertaintyComponent.h.

{ return m_validHistName; }

getValidUncertainty()

bool jet::UncertaintyComponent::getValidUncertainty ( double & unc, const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

virtualinherited

Definition at line 179 of file UncertaintyComponent.cxx.

{
    if (getValidity(jet,eInfo))
    {
        unc = getUncertainty(jet,eInfo);
        return true;
    }
    return false;
}

initialize()

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

virtual

Reimplemented from jet::UncertaintyComponent.

Definition at line 141 of file FlavourUncertaintyComponent.cxx.

{
    // Call the base class first
    if (UncertaintyComponent::initialize(histFile).isFailure())
        return StatusCode::FAILURE;
    
    // Ensure that the number of histograms matches what is expected for Flavour components
    if (m_flavourType == FlavourComp::Response)
    {
        if (m_secondUncName != "")
        {
            ATH_MSG_ERROR("Expected one histogram for FlavourResponse: " << getName().Data());
            return StatusCode::FAILURE;
        }
    }
    else if (m_flavourType == FlavourComp::Composition && m_secondUncName == "")
    {
        ATH_MSG_ERROR("Expected two histograms for FlavourComposition: " << getName().Data());
        return StatusCode::FAILURE;
    }
    else if (m_flavourType == FlavourComp::bJES && m_secondUncName != "")
    {
        ATH_MSG_ERROR("Expected one histogram for bJES uncertainty: " << getName().Data());
        return StatusCode::FAILURE;
    }
 
    // Get the flavour response types if applicable
    if (m_flavourType == FlavourComp::Composition)
    {
        if      ( m_uncHistName.Contains("glu",TString::kIgnoreCase) && (m_secondUncName.Contains("light",TString::kIgnoreCase) || m_secondUncName.Contains("quark",TString::kIgnoreCase)) )
        {
            m_respType = FlavourResp_GLUON;
            m_secondRespType = FlavourResp_QUARK;
        }
        else if ( (m_uncHistName.Contains("light",TString::kIgnoreCase) || m_uncHistName.Contains("quark",TString::kIgnoreCase)) && m_secondUncName.Contains("glu",TString::kIgnoreCase) )
        {
            m_respType = FlavourResp_QUARK;
            m_secondRespType = FlavourResp_GLUON;
        }
        else
        {
            // Unexpected inputs
            ATH_MSG_ERROR("Component is FlavourComposition, but histogram names are unexpected (need to discriminate gluon vs quark response histograms): "  << m_uncHistName.Data() << " and " << m_secondUncName.Data());
            return StatusCode::FAILURE;
        }
 
    }
 
    // Create the second histogram if applicable
    if (m_flavourType == FlavourComp::Composition)
    {
        m_secondUncHist = new UncertaintyHistogram(m_secondUncName,m_interpolate);
        if (!m_secondUncHist)
        {
            ATH_MSG_ERROR("Failed to create second uncertainty histogram for component: " << getName().Data());
            return StatusCode::FAILURE;
        }
        if (m_secondUncHist->initialize(histFile).isFailure()) return StatusCode::FAILURE;
    }
 
    // Now read the analysis input histograms if this is not a bJES component
    if (m_flavourType != FlavourComp::bJES)
    {
        TFile* analysisFile = utils::readRootFile(m_analysisFileName,m_path,m_calibArea);
        if (!analysisFile || analysisFile->IsZombie())
        {
            ATH_MSG_ERROR("Cannot open analysis histogram file: " << m_analysisFileName.Data());
            return StatusCode::FAILURE;
        }
 
        // Retrieve the gluon fraction(s) and gluon fraction uncertainty(ies)
        // May be a single histogram (default) or specified by nJet bins
        // Store all of the key names for now, retrieval will happen later
        std::vector<TString> gluonFractionKeys;
        std::vector<TString> gluonFractionErrorKeys;
        getGluonKeys(analysisFile,gluonFractionKeys,gluonFractionErrorKeys);
 
 
        // Ensure we found histograms...
        if (gluonFractionKeys.empty() || gluonFractionErrorKeys.empty())
        {
            ATH_MSG_ERROR(Form("Failed to find gluon fraction histogram(s), found %zu nominal and %zu error hists in file %s",gluonFractionKeys.size(),gluonFractionErrorKeys.size(),m_analysisFileName.Data()));
            return StatusCode::FAILURE;
        }
 
        // Determine the max nJet value
        int nJetsMax = -1;
        for (size_t iKey = 0; iKey < gluonFractionKeys.size(); ++iKey)
        {
            int nJets = -1;
            if (getNjetFromKey(gluonFractionKeys.at(iKey),nJets).isFailure())
                return StatusCode::FAILURE;
            if (nJets > nJetsMax && nJets < 1000)
                nJetsMax = nJets;
        }
 
        // If there is only one histogram and it's not an nJets histogram, this is trivial
        if (nJetsMax < 0 && gluonFractionKeys.size() == 1 && gluonFractionErrorKeys.size() == 1)
        {
            m_gluonFractionHists.push_back(new UncertaintyHistogram(gluonFractionKeys.at(0),m_interpolate));
            m_gluonFractionErrorHists.push_back(new UncertaintyHistogram(gluonFractionErrorKeys.at(0),m_interpolate));
        }
        // If there is more than one histogram and they are not nJets histograms, this is a problem
        else if (nJetsMax < 0 && gluonFractionKeys.size() > 1)
        {
            ATH_MSG_ERROR(Form("Found %zu gluon fraction histograms, but they do not appear to be binned by nJets:",gluonFractionKeys.size()));
            for (size_t iKey = 0; iKey < gluonFractionKeys.size(); ++iKey)
                ATH_MSG_ERROR(Form("\tKey %zu: %s",iKey,gluonFractionKeys.at(iKey).Data()));
            return StatusCode::FAILURE;
        }
        else
        {
            // Fill the actual vectors now, in proper order
            for (int nJets = 0; nJets <= nJetsMax; ++nJets)
            {
                m_gluonFractionHists.push_back(nullptr);
                m_gluonFractionErrorHists.push_back(nullptr);
            }
            if (readNjetsHistograms(m_gluonFractionHists,gluonFractionKeys).isFailure())
                return StatusCode::FAILURE;
            if (readNjetsHistograms(m_gluonFractionErrorHists,gluonFractionErrorKeys).isFailure())
                return StatusCode::FAILURE;
            
            // Ensure that every non-NULL gluon fraction has a non-NULL gluon fraction error
            // (Note that not all indices must be filled, as maybe an analyis is only 4 and 5 jets)
            for (size_t iJet = 0; iJet < m_gluonFractionHists.size(); ++iJet)
            {
                if (m_gluonFractionHists.at(iJet) && !m_gluonFractionErrorHists.at(iJet))
                {
                    ATH_MSG_ERROR(Form("nJets = %zu was specified for the gluon fraction, but not the error",iJet));
                    return StatusCode::FAILURE;
                }
                else if (!m_gluonFractionHists.at(iJet) && m_gluonFractionErrorHists.at(iJet))
                {
                    ATH_MSG_ERROR(Form("nJets = %zu was specified for the error, but not the gluon fraction",iJet));
                    return StatusCode::FAILURE;
                }
            }
        }
        
        // Initialize the non-NULL histograms
        for (size_t iHist = 0; iHist < m_gluonFractionHists.size(); ++iHist)
        {
            if (m_gluonFractionHists.at(iHist)      && m_gluonFractionHists.at(iHist)->initialize(analysisFile).isFailure())
                return StatusCode::FAILURE;
            if (m_gluonFractionErrorHists.at(iHist) && m_gluonFractionErrorHists.at(iHist)->initialize(analysisFile).isFailure())
                return StatusCode::FAILURE;
        }
 
        // We're finally done reading that file...
        analysisFile->Close();
 
 
        // If nJets treatment is specified, and a default analysis file is specified, use this to fill the zero-bin
        // The zero-bin is used whenever a multiplicity that is not explicitly specified is requested
        if (m_defAnaFileName != "" && m_gluonFractionHists.size() > 1 && m_gluonFractionHists.at(0) == nullptr)
        {
            // Open the default file
            TFile* defAnaFile = utils::readRootFile(m_defAnaFileName,m_path,m_calibArea);
            if (!defAnaFile || defAnaFile->IsZombie())
            {
                ATH_MSG_ERROR("Cannot open default analysis histogram file: " << m_defAnaFileName.Data());
                return StatusCode::FAILURE;
            }
 
            // Retrieve the gluon fraction(s) and gluon fraction uncertainty(ies)
            // May be a single histogram (default) or specified by nJet bins
            // Store all of the key names for now, retrieval will happen later
            std::vector<TString> gluonFractionDefaultKeys;
            std::vector<TString> gluonFractionErrorDefaultKeys;
            getGluonKeys(defAnaFile,gluonFractionDefaultKeys,gluonFractionErrorDefaultKeys);
 
            // Ensure that there is exactly one histogram (not another nJets file, not missing)
            if (gluonFractionDefaultKeys.size() != 1 || gluonFractionErrorDefaultKeys.size() != 1)
            {
                ATH_MSG_ERROR(Form("When using the default file to fill unspecified nJets histograms, exactly one gluon fraction and one gluon fraction uncertainty histogram are required.  Instead, we found %zu and %zu respectively in the file %s",gluonFractionDefaultKeys.size(),gluonFractionErrorDefaultKeys.size(),m_defAnaFileName.Data()));
                return StatusCode::FAILURE;
            }
 
            // Fill the empty zero-bin histograms
            m_gluonFractionHists.at(0) = new UncertaintyHistogram(gluonFractionDefaultKeys.at(0),m_interpolate);
            m_gluonFractionErrorHists.at(0) = new UncertaintyHistogram(gluonFractionErrorDefaultKeys.at(0),m_interpolate);
 
            // Now initialize them
            if (m_gluonFractionHists.at(0)->initialize(defAnaFile).isFailure())
                return StatusCode::FAILURE;
            if (m_gluonFractionErrorHists.at(0)->initialize(defAnaFile).isFailure())
                return StatusCode::FAILURE;
        
            // We're done reading that file now too
            defAnaFile->Close();
        }
 
    }
 
    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;
  }
}

isAlwaysZero()

bool jet::UncertaintyComponent::isAlwaysZero ( ) const

virtualinherited

Reimplemented in jet::CombinedMassUncertaintyComponent.

Definition at line 140 of file UncertaintyComponent.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_ERROR("Cannot call method before initialization, component: " << getName().Data());
        return false;
    }
 
    const TH1* histo = m_uncHist->getHisto();
    return !(fabs(histo->GetMinimum()) > 1.e-8 || fabs(histo->GetMaximum()) > 1.e-8);
}

isBjet()

bool jet::FlavourUncertaintyComponent::isBjet ( const xAOD::Jet & jet ) const

private

Definition at line 661 of file FlavourUncertaintyComponent.cxx.

{
    // If not specified, assume it's not a b-jet
    if (!m_BjetAccessor.isAvailable(jet)) return false;
 
    // If it's available, return the value (now a char, so check non-equality with 0)
    return m_BjetAccessor(jet) != 0;
}

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
   }

readNjetsHistograms()

StatusCode jet::FlavourUncertaintyComponent::readNjetsHistograms ( std::vector< UncertaintyHistogram * > & hists, const std::vector< TString > & histKeys )

private

Definition at line 592 of file FlavourUncertaintyComponent.cxx.

{
    for (size_t iKey = 0; iKey < histKeys.size(); ++iKey)
    {
        const TString& histName = histKeys.at(iKey);
        int nJets = -1;
        if (getNjetFromKey(histName,nJets).isFailure())
            return StatusCode::FAILURE;
        if (nJets < 0 || nJets >= static_cast<int>(hists.size()))
        {
            ATH_MSG_ERROR(Form("Unexpected gluon fraction nJet %d of index %zu: %s",nJets,iKey,histName.Data()));
            return StatusCode::FAILURE;
        }
        if (hists[nJets])
        {
            ATH_MSG_ERROR(Form("A histo for nJets of %d was already found, blocking double-creation of %s",nJets,histName.Data()));
            return StatusCode::FAILURE;
        }
        hists[nJets] = new UncertaintyHistogram(histName,m_interpolate);
    }
    return StatusCode::SUCCESS;
}

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_absEta

const bool jet::FlavourUncertaintyComponent::m_absEta

private

Definition at line 55 of file FlavourUncertaintyComponent.h.

m_absEtaGluonFraction

const bool jet::FlavourUncertaintyComponent::m_absEtaGluonFraction

private

Definition at line 56 of file FlavourUncertaintyComponent.h.

m_analysisFileName

const TString jet::FlavourUncertaintyComponent::m_analysisFileName

private

Definition at line 50 of file FlavourUncertaintyComponent.h.

m_analysisHistPattern

const TString jet::FlavourUncertaintyComponent::m_analysisHistPattern

private

Definition at line 51 of file FlavourUncertaintyComponent.h.

m_BjetAccessor

SG::AuxElement::Accessor<char> jet::FlavourUncertaintyComponent::m_BjetAccessor

private

Definition at line 67 of file FlavourUncertaintyComponent.h.

m_calibArea

const TString jet::FlavourUncertaintyComponent::m_calibArea

private

Definition at line 54 of file FlavourUncertaintyComponent.h.

m_defAnaFileName

const TString jet::FlavourUncertaintyComponent::m_defAnaFileName

private

Definition at line 52 of file FlavourUncertaintyComponent.h.

m_energyScale

const float jet::UncertaintyComponent::m_energyScale {}

protectedinherited

Definition at line 55 of file UncertaintyComponent.h.

{};

m_flavourType

const FlavourComp::TypeEnum jet::FlavourUncertaintyComponent::m_flavourType

private

Definition at line 48 of file FlavourUncertaintyComponent.h.

m_gluonFractionErrorHists

std::vector<UncertaintyHistogram*> jet::FlavourUncertaintyComponent::m_gluonFractionErrorHists

private

Definition at line 73 of file FlavourUncertaintyComponent.h.

m_gluonFractionHists

std::vector<UncertaintyHistogram*> jet::FlavourUncertaintyComponent::m_gluonFractionHists

private

Definition at line 72 of file FlavourUncertaintyComponent.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::UncertaintyComponent::m_interpolate

protectedinherited

Definition at line 56 of file UncertaintyComponent.h.

m_isInit

bool jet::UncertaintyComponent::m_isInit {}

protectedinherited

Definition at line 50 of file UncertaintyComponent.h.

{};

m_jetType

const TString jet::FlavourUncertaintyComponent::m_jetType

private

Definition at line 49 of file FlavourUncertaintyComponent.h.

m_largeRJetTruthLabelAccessor

SG::AuxElement::Accessor<int> jet::FlavourUncertaintyComponent::m_largeRJetTruthLabelAccessor

private

Definition at line 69 of file FlavourUncertaintyComponent.h.

m_largeRJetTruthLabelName

std::string jet::FlavourUncertaintyComponent::m_largeRJetTruthLabelName

private

Definition at line 59 of file FlavourUncertaintyComponent.h.

m_largeRJetTruthLabels

std::vector<LargeRJetTruthLabel::TypeEnum> jet::FlavourUncertaintyComponent::m_largeRJetTruthLabels

private

Definition at line 62 of file FlavourUncertaintyComponent.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_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_NjetAccessor

SG::AuxElement::Accessor<int> jet::FlavourUncertaintyComponent::m_NjetAccessor

private

Definition at line 68 of file FlavourUncertaintyComponent.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_numExpectedHist

int jet::UncertaintyComponent::m_numExpectedHist {}

protectedinherited

Definition at line 59 of file UncertaintyComponent.h.

{};

m_path

const TString jet::FlavourUncertaintyComponent::m_path

private

Definition at line 53 of file FlavourUncertaintyComponent.h.

m_respType

FlavourRespType jet::FlavourUncertaintyComponent::m_respType

private

Definition at line 65 of file FlavourUncertaintyComponent.h.

m_scaleVar

const CompScaleVar::TypeEnum jet::UncertaintyComponent::m_scaleVar

protectedinherited

Definition at line 53 of file UncertaintyComponent.h.

m_secondRespType

FlavourRespType jet::FlavourUncertaintyComponent::m_secondRespType

private

Definition at line 66 of file FlavourUncertaintyComponent.h.

m_secondUncHist

UncertaintyHistogram* jet::FlavourUncertaintyComponent::m_secondUncHist

private

Definition at line 64 of file FlavourUncertaintyComponent.h.

m_secondUncName

const TString jet::FlavourUncertaintyComponent::m_secondUncName

private

Definition at line 57 of file FlavourUncertaintyComponent.h.

m_splitNumber

const int jet::UncertaintyComponent::m_splitNumber {}

protectedinherited

Definition at line 57 of file UncertaintyComponent.h.

{};

m_topology

const JetTopology::TypeEnum jet::UncertaintyComponent::m_topology

protectedinherited

Definition at line 54 of file UncertaintyComponent.h.

m_uncHist

UncertaintyHistogram* jet::UncertaintyComponent::m_uncHist {}

protectedinherited

Definition at line 60 of file UncertaintyComponent.h.

{};

m_uncHistName

const TString jet::UncertaintyComponent::m_uncHistName

protectedinherited

Definition at line 51 of file UncertaintyComponent.h.

m_validHist

UncertaintyHistogram* jet::UncertaintyComponent::m_validHist {}

protectedinherited

Definition at line 61 of file UncertaintyComponent.h.

{};

m_validHistName

const TString jet::UncertaintyComponent::m_validHistName

protectedinherited

Definition at line 52 of file UncertaintyComponent.h.

---

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

• FlavourUncertaintyComponent.h
• FlavourUncertaintyComponent.cxx