#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="")

	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. More...

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. More...

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. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

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 44 of file FlavourUncertaintyComponent.h.

44 { 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 = `""`
	)

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("Njet")
     , 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 83 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 125 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 630 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 120 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 515 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 456 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);
     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 420 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 32 of file FlavourUncertaintyComponent.h.

32 { return m_flavourType; }

◆ getGluonFraction()

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

private

Definition at line 530 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 536 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 669 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()))
     {
         if (!key) continue;
         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 552 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 542 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.

35 { return m_uncHistName; }

◆ getNjetFromKey()

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

private

Definition at line 613 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 568 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.

37 { 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.

38 { 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 367 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 344 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.

36 { 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 140 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)
                 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();
   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 659 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 590 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 54 of file FlavourUncertaintyComponent.h.

◆ m_absEtaGluonFraction

const bool jet::FlavourUncertaintyComponent::m_absEtaGluonFraction

private

Definition at line 55 of file FlavourUncertaintyComponent.h.

◆ m_analysisFileName

const TString jet::FlavourUncertaintyComponent::m_analysisFileName

private

Definition at line 49 of file FlavourUncertaintyComponent.h.

◆ m_analysisHistPattern

const TString jet::FlavourUncertaintyComponent::m_analysisHistPattern

private

Definition at line 50 of file FlavourUncertaintyComponent.h.

◆ m_BjetAccessor

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

private

Definition at line 66 of file FlavourUncertaintyComponent.h.

◆ m_calibArea

const TString jet::FlavourUncertaintyComponent::m_calibArea

private

Definition at line 53 of file FlavourUncertaintyComponent.h.

◆ m_defAnaFileName

const TString jet::FlavourUncertaintyComponent::m_defAnaFileName

private

Definition at line 51 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 47 of file FlavourUncertaintyComponent.h.

◆ m_gluonFractionErrorHists

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

private

Definition at line 72 of file FlavourUncertaintyComponent.h.

◆ m_gluonFractionHists

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

private

Definition at line 71 of file FlavourUncertaintyComponent.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ 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 48 of file FlavourUncertaintyComponent.h.

◆ m_largeRJetTruthLabelAccessor

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

private

Definition at line 68 of file FlavourUncertaintyComponent.h.

◆ m_largeRJetTruthLabelName

std::string jet::FlavourUncertaintyComponent::m_largeRJetTruthLabelName

private

Definition at line 58 of file FlavourUncertaintyComponent.h.

◆ m_largeRJetTruthLabels

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

private

Definition at line 61 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.

◆ 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 67 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 52 of file FlavourUncertaintyComponent.h.

◆ m_respType

FlavourRespType jet::FlavourUncertaintyComponent::m_respType

private

Definition at line 64 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 65 of file FlavourUncertaintyComponent.h.

◆ m_secondUncHist

UncertaintyHistogram* jet::FlavourUncertaintyComponent::m_secondUncHist

private

Definition at line 63 of file FlavourUncertaintyComponent.h.

◆ m_secondUncName

const TString jet::FlavourUncertaintyComponent::m_secondUncName

private

Definition at line 56 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:

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ FlavourRespType

Constructor & Destructor Documentation

◆ FlavourUncertaintyComponent() [1/3]

◆ FlavourUncertaintyComponent() [2/3]

◆ ~FlavourUncertaintyComponent()

◆ FlavourUncertaintyComponent() [3/3]

Member Function Documentation

◆ checkNjetsInput()

◆ clone()

◆ getAbsMass()

◆ getBJESUncertainty()

◆ getFlavourCompositionUncertainty()

◆ getFlavourResponseUncertainty()

◆ getFlavourType()

◆ getGluonFraction()

◆ getGluonFractionError()

◆ getGluonKeys()

◆ getGluonResponseBaseline()

◆ getGluonResponseDifference()

◆ getMassOverE()

◆ getMassOverPt()

◆ getName()

◆ getNjetFromKey()

◆ getQuarkResponseBaseline()

◆ getScaleVar()

◆ getSplitFactor()

◆ getTopology()

◆ getUncertainty()

◆ getUncertaintyImpl()

◆ getValidBool()

◆ getValidity()

◆ getValidityImpl()

◆ getValidName()

◆ getValidUncertainty()

◆ initialize()

◆ initMessaging()

◆ isAlwaysZero()

◆ isBjet()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ readNjetsHistograms()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_absEta

◆ m_absEtaGluonFraction

◆ m_analysisFileName

◆ m_analysisHistPattern

◆ m_BjetAccessor

◆ m_calibArea

◆ m_defAnaFileName

◆ m_energyScale

◆ m_flavourType

◆ m_gluonFractionErrorHists

◆ m_gluonFractionHists

◆ m_imsg

◆ m_interpolate

◆ m_isInit

◆ m_jetType

◆ m_largeRJetTruthLabelAccessor

◆ m_largeRJetTruthLabelName

◆ m_largeRJetTruthLabels

◆ m_lvl

◆ m_msg_tls

◆ m_NjetAccessor

◆ m_nm

◆ m_numExpectedHist

◆ m_path

◆ m_respType

◆ m_scaleVar

◆ m_secondRespType