#include <CombinedMassUncertaintyComponent.h>

Inheritance diagram for jet::CombinedMassUncertaintyComponent:

Collaboration diagram for jet::CombinedMassUncertaintyComponent:

Public Member Functions
	CombinedMassUncertaintyComponent (const ComponentHelper &component)

	CombinedMassUncertaintyComponent (const CombinedMassUncertaintyComponent &toCopy)

virtual CombinedMassUncertaintyComponent *	clone () const

virtual	~CombinedMassUncertaintyComponent ()

virtual StatusCode	setCaloTerm (UncertaintyGroup *caloComp)

virtual StatusCode	setTATerm (UncertaintyGroup *TAComp)

virtual StatusCode	setCaloWeights (const UncertaintyHistogram *caloWeights)

virtual StatusCode	setTAWeights (const UncertaintyHistogram *TAWeights)

virtual StatusCode	setCombWeightMassDefs (const CompMassDef::TypeEnum caloMassDef, const CompMassDef::TypeEnum TAMassDef)

virtual StatusCode	setCombWeightParam (const CompParametrization::TypeEnum param)

virtual StatusCode	initialize (TFile *histFile)

virtual CombMassComp::TypeEnum	getCombMassType () const

virtual bool	getValidityCalo (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const

virtual bool	getValidityTA (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const

virtual double	getUncertaintyCalo (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const

virtual double	getUncertaintyTA (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const

virtual bool	getValidUncertaintyCalo (double &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const

virtual bool	getValidUncertaintyTA (double &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const

virtual bool	isAlwaysZero () const

virtual TString	getName () const

virtual TString	getValidName () const

virtual CompScaleVar::TypeEnum	getScaleVar () const

virtual JetTopology::TypeEnum	getTopology () 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 Member Functions
	CombinedMassUncertaintyComponent (const std::string &name="")

double	readHistoFromParam (const xAOD::JetFourMom_t &jet4vec, const UncertaintyHistogram &histo, const CompParametrization::TypeEnum param, const double massShiftFactor) const

virtual double	getWeightFactorCalo (const xAOD::Jet &jet, const double shiftFactor) const

virtual double	getWeightFactorTA (const xAOD::Jet &jet, const double shiftFactor) const

StatusCode	calculateCombinedMass (const xAOD::Jet &jet, const double shiftFactorCalo, const double shiftFactorTA, double &combMass) const

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
const CombMassComp::TypeEnum	m_combMassType

bool	m_setWeightMassDefs

UncertaintyGroup *	m_caloMassComp

UncertaintyGroup *	m_TAMassComp

const UncertaintyHistogram *	m_caloMassWeight

const UncertaintyHistogram *	m_TAMassWeight

JetFourMomAccessor	m_caloMassScale_weights

JetFourMomAccessor	m_TAMassScale_weights

CompParametrization::TypeEnum	m_weightParam

std::string	m_truthLabelName

std::vector< LargeRJetTruthLabel::TypeEnum >	m_truthLabels

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 17 of file CombinedMassUncertaintyComponent.h.

Constructor & Destructor Documentation

◆ CombinedMassUncertaintyComponent() [1/3]

jet::CombinedMassUncertaintyComponent::CombinedMassUncertaintyComponent ( const ComponentHelper & component )

Definition at line 37 of file CombinedMassUncertaintyComponent.cxx.

     : UncertaintyComponent(component,0)
     , m_combMassType(component.combMassType)
     , m_setWeightMassDefs(false)
     , m_caloMassComp(nullptr)
     , m_TAMassComp(nullptr)
     , m_caloMassWeight(nullptr)
     , m_TAMassWeight(nullptr)
     , m_caloMassScale_weights("")
     , m_TAMassScale_weights("")
     , m_weightParam(CompParametrization::UNKNOWN)
     , m_truthLabelName(component.LargeRJetTruthLabelName)
     , m_truthLabels(component.LargeRJetTruthLabels)
 {
     ATH_MSG_DEBUG("Created CombinedMassUncertaintyComponent named " << getName().Data());
 }

◆ CombinedMassUncertaintyComponent() [2/3]

jet::CombinedMassUncertaintyComponent::CombinedMassUncertaintyComponent ( const CombinedMassUncertaintyComponent & toCopy )

Definition at line 54 of file CombinedMassUncertaintyComponent.cxx.

     : UncertaintyComponent(toCopy)
     , m_combMassType(toCopy.m_combMassType)
     , m_setWeightMassDefs(toCopy.m_setWeightMassDefs)
     , m_caloMassComp(nullptr)
     , m_TAMassComp(nullptr)
     , m_caloMassWeight(toCopy.m_caloMassWeight)
     , m_TAMassWeight(toCopy.m_TAMassWeight)
     , m_caloMassScale_weights(toCopy.m_caloMassScale_weights)
     , m_TAMassScale_weights(toCopy.m_TAMassScale_weights)
     , m_weightParam(toCopy.m_weightParam)
     , m_truthLabelName(toCopy.m_truthLabelName)
     , m_truthLabels(toCopy.m_truthLabels)
 {
     ATH_MSG_DEBUG("Creating copy of CombinedMassUncertaintyComponent named " << getName().Data());
     if (toCopy.m_caloMassComp)
         m_caloMassComp = new UncertaintyGroup(*toCopy.m_caloMassComp);
     if (toCopy.m_TAMassComp)
         m_TAMassComp = new UncertaintyGroup(*toCopy.m_TAMassComp);
 }

◆ ~CombinedMassUncertaintyComponent()

jet::CombinedMassUncertaintyComponent::~CombinedMassUncertaintyComponent ( )

virtual

Definition at line 80 of file CombinedMassUncertaintyComponent.cxx.

 {
     JESUNC_SAFE_DELETE(m_caloMassComp);
     JESUNC_SAFE_DELETE(m_TAMassComp);
 }

◆ CombinedMassUncertaintyComponent() [3/3]

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

private

Definition at line 20 of file CombinedMassUncertaintyComponent.cxx.

     : UncertaintyComponent(ComponentHelper(name),0)
     , m_combMassType(CombMassComp::UNKNOWN)
     , m_setWeightMassDefs(false)
     , m_caloMassComp(nullptr)
     , m_TAMassComp(nullptr)
     , m_caloMassWeight(nullptr)
     , m_TAMassWeight(nullptr)
     , m_caloMassScale_weights("")
     , m_TAMassScale_weights("")
     , m_weightParam(CompParametrization::UNKNOWN)
     , m_truthLabelName("")
     , m_truthLabels()
 {
     JESUNC_NO_DEFAULT_CONSTRUCTOR;
 }

Member Function Documentation

◆ calculateCombinedMass()

StatusCode jet::CombinedMassUncertaintyComponent::calculateCombinedMass	(	const xAOD::Jet &	jet,
		const double	shiftFactorCalo,
		const double	shiftFactorTA,
		double &	combMass
	)		const

private

Definition at line 313 of file CombinedMassUncertaintyComponent.cxx.

 {
     // Accessors for the scales we need
     static const JetFourMomAccessor caloMassScale(CompMassDef::getJetScaleString(CompMassDef::CaloMass).Data());
     static const JetFourMomAccessor TAMassScale(CompMassDef::getJetScaleString(CompMassDef::TAMass).Data());
     static const JetFourMomAccessor combMassScale(CompMassDef::getJetScaleString(CompMassDef::CombMassQCD).Data());
  
     // Get the weight factors
     const double factorCalo = getWeightFactorCalo(jet,shiftFactorCalo);
     const double factorTA   = getWeightFactorTA(jet,shiftFactorTA);
  
     // Watch for division by zero
     if (factorCalo+factorTA == 0)
     {
         if (combMassScale.m(jet) == 0)
         {
             // JetCalibTools sets the mass to zero when this situation occurs
             // This is therefore not an error state, rather we want to be consistent
             combMass = 0;
             return StatusCode::SUCCESS;
         }
         else
         {
             // We somehow have invalid calo and TA masses, but a "valid" combined mass
             // This is an error state that should result in a message to the user
             // If this occurs, most likely there is something wrong in the inputs
             ATH_MSG_ERROR("Encountered division by zero when calculating weights: mCalo = " << caloMassScale.m(jet) << ", mTA = " << TAMassScale.m(jet) << ", mComb = " << combMassScale.m(jet));
             return StatusCode::FAILURE;
         }
     }
  
     // Calculate the weights
     const double caloWeight = factorCalo/(factorCalo+factorTA);
     const double TAWeight   = factorTA/(factorCalo+factorTA);
  
     // Watch for zero masses
     // If one mass is zero, use the other without a weight
     // If both are zero, it doesn't matter, the combined mass is zero
     if (caloMassScale.m(jet) == 0)
         combMass = TAMassScale.m(jet)*shiftFactorTA;
     else if (TAMassScale.m(jet) == 0)
         combMass = caloMassScale.m(jet)*shiftFactorCalo;
     else
         combMass = (caloMassScale.m(jet)*shiftFactorCalo*caloWeight) + (TAMassScale.m(jet)*shiftFactorTA*TAWeight);
  
     return StatusCode::SUCCESS;
 }

◆ clone()

CombinedMassUncertaintyComponent * jet::CombinedMassUncertaintyComponent::clone ( ) const

virtual

Implements jet::UncertaintyComponent.

Definition at line 75 of file CombinedMassUncertaintyComponent.cxx.

 {
     return new CombinedMassUncertaintyComponent(*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;
 }

◆ getCombMassType()

virtual CombMassComp::TypeEnum jet::CombinedMassUncertaintyComponent::getCombMassType ( ) const

inlinevirtual

Definition at line 34 of file CombinedMassUncertaintyComponent.h.

34 { return m_combMassType; }

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

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

◆ getUncertaintyCalo()

double jet::CombinedMassUncertaintyComponent::getUncertaintyCalo	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo
	)		const

virtual

Definition at line 440 of file CombinedMassUncertaintyComponent.cxx.

 {
     return !m_caloMassComp ? 0 : m_caloMassComp->getUncertainty(jet,eInfo,CompScaleVar::Mass);
 }

◆ getUncertaintyImpl()

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

protectedvirtual

Implements jet::UncertaintyComponent.

Definition at line 361 of file CombinedMassUncertaintyComponent.cxx.

 {
     // Check if we need to do anything at all - this uncertainty may be zero based on the jet truth label
     // Truth labels are usually not expected for this component, so check if we need to do this
     if (!m_truthLabels.empty())
     {
         // Truth labels are specified, so we need to check if this jet is labelled appropriately or not
         const SG::AuxElement::ConstAccessor<int> accTruthLabel(m_truthLabelName);
         if (!accTruthLabel.isAvailable(jet) || accTruthLabel(jet) == LargeRJetTruthLabel::UNKNOWN)
         {
             ATH_MSG_ERROR("Unable to retrieve the LargeRJetTruthLabel: " << m_truthLabelName << " from the jet.  Please use JetTruthLabelingTool before calling this function.");
             return JESUNC_ERROR_CODE;
         }
         const LargeRJetTruthLabel::TypeEnum jetTruthLabel = LargeRJetTruthLabel::intToEnum(accTruthLabel(jet));
     
         // We now have the truth jet label, check if it matches one of the label(s) assigned to this component
         // The uncertainty is only applied to same-labelled jets (zero otherwise)
         bool labelApplies = false;
         for (const LargeRJetTruthLabel::TypeEnum aLabel : m_truthLabels)
         {
             if (aLabel == jetTruthLabel)
             {
                 labelApplies = true;
                 break;
             }
         }
         // If the jet is not of the relevant label, then there is no uncertainty for this jet
         if (!labelApplies)
             return 0;
     }
  
     // Get the per-part uncertainties
     double uncCalo = 0;
     if (m_caloMassComp && !m_caloMassComp->getValidUncertainty(uncCalo,jet,eInfo,CompScaleVar::Mass))
     {
         // Not valid
         ATH_MSG_ERROR("Combined mass is outside of the validity range (calo part)");
         return JESUNC_ERROR_CODE;
     }
     double uncTA = 0;
     if (m_TAMassComp && !m_TAMassComp->getValidUncertainty(uncTA,jet,eInfo,CompScaleVar::Mass))
     {
         // Not valid
         ATH_MSG_ERROR("Combined mass is outside of the validity range (TA part)");
         return JESUNC_ERROR_CODE;
     }
  
     // Get the mass values (both up and down shifts)
     // The resolution functions evaluated for masses shifted up and down may not be symmetric
     // For now, take the average of the up and down shifts
     // Note that we also only consider correlated shifts here
     // Uncorrelated shifts can be handled as two separate components
     // Anticorelated shifts are currently not supported (no need so far)
     double massDefault = 0;
     if (!calculateCombinedMass(jet,1,1,massDefault))            return JESUNC_ERROR_CODE;
     if (massDefault == 0) return 0; // This is a relative uncertainty
     double massUp = 0;
     if (!calculateCombinedMass(jet,1+uncCalo,1+uncTA,massUp))   return JESUNC_ERROR_CODE;
     double massDown = 0;
     if (!calculateCombinedMass(jet,1-uncCalo,1-uncTA,massDown)) return JESUNC_ERROR_CODE;
     
     const double massUncUp   = fabs((massUp-massDefault)/massDefault);
     const double massUncDown = fabs((massDown-massDefault)/massDefault);
  
     return (massUncUp+massUncDown)/2.;
 }

◆ getUncertaintyTA()

double jet::CombinedMassUncertaintyComponent::getUncertaintyTA	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo
	)		const

virtual

Definition at line 445 of file CombinedMassUncertaintyComponent.cxx.

 {
     return !m_TAMassComp ? 0 : m_TAMassComp->getUncertainty(jet,eInfo,CompScaleVar::Mass);
 }

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

◆ getValidityCalo()

bool jet::CombinedMassUncertaintyComponent::getValidityCalo	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo
	)		const

virtual

Definition at line 430 of file CombinedMassUncertaintyComponent.cxx.

 {
     return !m_caloMassComp ? true : m_caloMassComp->getValidity(jet,eInfo,CompScaleVar::Mass);
 }

◆ getValidityImpl()

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

protectedvirtual

Implements jet::UncertaintyComponent.

Definition at line 308 of file CombinedMassUncertaintyComponent.cxx.

 {
     return getValidityCalo(jet,eInfo) && getValidityTA(jet,eInfo);
 }

◆ getValidityTA()

bool jet::CombinedMassUncertaintyComponent::getValidityTA	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo
	)		const

virtual

Definition at line 435 of file CombinedMassUncertaintyComponent.cxx.

 {
     return !m_TAMassComp ? true : m_TAMassComp->getValidity(jet,eInfo,CompScaleVar::Mass);
 }

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

◆ getValidUncertaintyCalo()

bool jet::CombinedMassUncertaintyComponent::getValidUncertaintyCalo	(	double &	unc,
		const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo
	)		const

virtual

Definition at line 450 of file CombinedMassUncertaintyComponent.cxx.

 {
     return !m_caloMassComp ? true : m_caloMassComp->getValidUncertainty(unc,jet,eInfo,CompScaleVar::Mass);
 }

◆ getValidUncertaintyTA()

bool jet::CombinedMassUncertaintyComponent::getValidUncertaintyTA	(	double &	unc,
		const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo
	)		const

virtual

Definition at line 455 of file CombinedMassUncertaintyComponent.cxx.

 {
     return !m_TAMassComp ? true : m_TAMassComp->getValidUncertainty(unc,jet,eInfo,CompScaleVar::Mass);
 }

◆ getWeightFactorCalo()

double jet::CombinedMassUncertaintyComponent::getWeightFactorCalo	(	const xAOD::Jet &	jet,
		const double	shiftFactor
	)		const

privatevirtual

Definition at line 508 of file CombinedMassUncertaintyComponent.cxx.

 {
     if(m_caloMassScale_weights(jet).M() < 0.0) return 0;
     if(!m_caloMassWeight) return 0;
     return readHistoFromParam(m_caloMassScale_weights(jet),*m_caloMassWeight,m_weightParam,massShiftFactor);
 }

◆ getWeightFactorTA()

double jet::CombinedMassUncertaintyComponent::getWeightFactorTA	(	const xAOD::Jet &	jet,
		const double	shiftFactor
	)		const

privatevirtual

Definition at line 515 of file CombinedMassUncertaintyComponent.cxx.

 {
     if(m_TAMassScale_weights(jet).M() < 0.0) return 0;
     if(!m_TAMassWeight) return 0;
     return readHistoFromParam(m_TAMassScale_weights(jet),*m_TAMassWeight,m_weightParam,massShiftFactor);
 }

◆ initialize()

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

virtual

Reimplemented from jet::UncertaintyComponent.

Definition at line 203 of file CombinedMassUncertaintyComponent.cxx.

 {
     // We are completely different here than the normal case
     // Ignore the base component initialization procedure
     
     // Prevent double-initialization
     if (m_isInit)
     {
         ATH_MSG_ERROR("Component is already initialized: " << getName().Data());
         return StatusCode::FAILURE;
     }
     
     // Ensure that the combination weights exist
     if (!m_caloMassWeight)
     {
         ATH_MSG_ERROR("Calorimeter mass weights were not defined: " << getName().Data());
         return StatusCode::FAILURE;
     }
     if (!m_TAMassWeight)
     {
         ATH_MSG_ERROR("Track-assisted mass weights were not defined: " << getName().Data());
         return StatusCode::FAILURE;
     }
  
     // Ensure that the weight mass definitions were set
     if (!m_setWeightMassDefs)
     {
         ATH_MSG_ERROR("The mass definitions for the combination weight factors were not set: " << getName().Data());
         return StatusCode::FAILURE;
     }
  
     // Understand what situation we are in
     if      (m_combMassType == CombMassComp::UNKNOWN)
     {
         ATH_MSG_ERROR("Unknown combined mass uncertainty type: " << getName().Data());
         return StatusCode::FAILURE;
     }
     else if (m_combMassType == CombMassComp::Calo)
     {
         // Only the calo mass component should be specified
         if (!m_caloMassComp)
         {
             ATH_MSG_ERROR("Calo mass term was not specified for a CombMass_calo component: " << getName().Data());
             return StatusCode::FAILURE;
         }
         if (m_TAMassComp)
         {
             ATH_MSG_ERROR("TA mass term was specified for a CombMass_calo component: " << getName().Data());
             return StatusCode::FAILURE;
         }
     }
     else if (m_combMassType == CombMassComp::TA)
     {
         // Only the TA mass component should be specified
         if (m_caloMassComp)
         {
             ATH_MSG_ERROR("Calo mass term was specified for a CombMass_TA component: " << getName().Data());
             return StatusCode::FAILURE;
         }
         if (!m_TAMassComp)
         {
             ATH_MSG_ERROR("TA mass term was not specified for a CombMass_TA component: " << getName().Data());
             return StatusCode::FAILURE;
         }
     }
     else if (m_combMassType == CombMassComp::Both)
     {
         // Both components should be specified
         if (!m_caloMassComp)
         {
             ATH_MSG_ERROR("Calo mass term was not specified for a CombMass_both component: " << getName().Data());
             return StatusCode::FAILURE;
         }
         if (!m_TAMassComp)
         {
             ATH_MSG_ERROR("TA mass term was not specified for a CombMass_both component: " << getName().Data());
             return StatusCode::FAILURE;
         }
     }
  
     // Initialize the component(s)
     if (m_caloMassComp && m_caloMassComp->initialize(histFile).isFailure())
     {
         ATH_MSG_ERROR("Failed to initialize calo mass portion of a comb mass uncertainty: " << getName().Data());
         return StatusCode::FAILURE;
     }
     if (m_TAMassComp && m_TAMassComp->initialize(histFile).isFailure())
     {
         ATH_MSG_ERROR("Failed to initialize TA mass portion of a comb mass uncertainty: " << getName().Data());
         return StatusCode::FAILURE;
     }
  
  
     // Done!
     m_isInit = true;
     return StatusCode::SUCCESS;
 }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

 {
   m_imsg = Athena::getMessageSvc();
   m_lvl = m_imsg ?
     static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
     MSG::INFO;
 }

◆ isAlwaysZero()

bool jet::CombinedMassUncertaintyComponent::isAlwaysZero ( ) const

virtual

Reimplemented from jet::UncertaintyComponent.

Definition at line 530 of file CombinedMassUncertaintyComponent.cxx.

 {
     if (!m_isInit)
     {
         ATH_MSG_ERROR("Cannot call method before initialization, component: " << getName().Data());
         return false;
     }
  
     return (!m_caloMassComp || m_caloMassComp->isAlwaysZero()) && (!m_TAMassComp || m_TAMassComp->isAlwaysZero());
 }

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

◆ readHistoFromParam()

double jet::CombinedMassUncertaintyComponent::readHistoFromParam	(	const xAOD::JetFourMom_t &	jet4vec,
		const UncertaintyHistogram &	histo,
		const CompParametrization::TypeEnum	param,
		const double	massShiftFactor
	)		const

private

Definition at line 460 of file CombinedMassUncertaintyComponent.cxx.

 {
     double resolution = 0;
     switch (param)
     {
         case CompParametrization::Pt:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale);
             break;
         case CompParametrization::PtEta:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.Eta());
             break;
         case CompParametrization::PtAbsMass:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*m_energyScale*massShiftFactor);
             break;
         case CompParametrization::PtAbsEta:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,fabs(jet4vec.Eta()));
             break;
         case CompParametrization::PtMass:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*massShiftFactor/jet4vec.Pt());
             break;
         case CompParametrization::PtMassEta:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*massShiftFactor/jet4vec.Pt(),jet4vec.Eta());
             break;
         case CompParametrization::PtMassAbsEta:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*massShiftFactor/jet4vec.Pt(),fabs(jet4vec.Eta()));
             break;
         case CompParametrization::PtAbsMassEta:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*m_energyScale*massShiftFactor,jet4vec.Eta());
             break;
         case CompParametrization::PtAbsMassAbsEta:
             resolution = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*m_energyScale*massShiftFactor,fabs(jet4vec.Eta()));
             break;
         case CompParametrization::eLOGmOe:
             resolution = histo.getValue(jet4vec.E()*m_energyScale,log(jet4vec.M()*massShiftFactor/jet4vec.E()));
             break;
         case CompParametrization::eLOGmOeEta:
             resolution = histo.getValue(jet4vec.E()*m_energyScale,log(jet4vec.M()*massShiftFactor/jet4vec.E()),jet4vec.Eta());
             break;
         case CompParametrization::eLOGmOeAbsEta:
             resolution = histo.getValue(jet4vec.E()*m_energyScale,log(jet4vec.M()*massShiftFactor/jet4vec.E()),fabs(jet4vec.Eta()));
             break;
         default:
             ATH_MSG_ERROR("Failed to read histogram due to unknown parametrization type in " << getName());
             break;
     }
     return resolution == 0 ? 0 : 1./(resolution*resolution);
 }

◆ setCaloTerm()

StatusCode jet::CombinedMassUncertaintyComponent::setCaloTerm ( UncertaintyGroup * caloComp )

virtual

Definition at line 86 of file CombinedMassUncertaintyComponent.cxx.

 {
     if (m_isInit)
     {
         ATH_MSG_ERROR("Can only set the calo mass term before initialization: " << getName().Data());
         return StatusCode::FAILURE;
     }
     if (m_caloMassComp != nullptr)
     {
         ATH_MSG_ERROR("Calo mass term has already been set, blocking double-init: " << getName().Data());
         return StatusCode::FAILURE;
     }
     m_caloMassComp = caloComp;
  
     return StatusCode::SUCCESS;
 }

◆ setCaloWeights()

StatusCode jet::CombinedMassUncertaintyComponent::setCaloWeights ( const UncertaintyHistogram * caloWeights )

virtual

Definition at line 120 of file CombinedMassUncertaintyComponent.cxx.

 {
     if (m_isInit)
     {
         ATH_MSG_ERROR("Can only set the calo mass weights before initialization: " << getName().Data());
         return StatusCode::FAILURE;
     }
     if (m_caloMassWeight != nullptr)
     {
         ATH_MSG_ERROR("Calo mass weights has already been set, blocking double-init: " << getName().Data());
         return StatusCode::FAILURE;
     }
     m_caloMassWeight = caloWeights;
  
     return StatusCode::SUCCESS;
 }

◆ setCombWeightMassDefs()

StatusCode jet::CombinedMassUncertaintyComponent::setCombWeightMassDefs	(	const CompMassDef::TypeEnum	caloMassDef,
		const CompMassDef::TypeEnum	TAMassDef
	)

virtual

Definition at line 154 of file CombinedMassUncertaintyComponent.cxx.

 {
     if (m_isInit)
     {
         ATH_MSG_ERROR("Can only set the weight mass definitions before initialization: " << getName().Data());
         return StatusCode::FAILURE;
     }
     if (m_setWeightMassDefs)
     {
         ATH_MSG_ERROR("Already set the weights, blocking double-setting: " << getName().Data());
         return StatusCode::FAILURE;
     }
     switch (caloMassDef)
     {
         case CompMassDef::CaloMass:
         case CompMassDef::TAMass:
             m_caloMassScale_weights = JetFourMomAccessor(CompMassDef::getJetScaleString(caloMassDef).Data());
             break;
         default:
             ATH_MSG_ERROR("Unsupported mass parametrization for the combined mass calo weights: " << getName().Data());
             return StatusCode::FAILURE;
     }
     switch (TAMassDef)
     {
         case CompMassDef::CaloMass:
         case CompMassDef::TAMass:
             m_TAMassScale_weights = JetFourMomAccessor(CompMassDef::getJetScaleString(TAMassDef).Data());
             break;
         default:
             ATH_MSG_ERROR("Unsupported mass parametrization for the combined mass TA weights: " << getName().Data());
             return StatusCode::FAILURE;
     }
  
     m_setWeightMassDefs = true;
     return StatusCode::SUCCESS;
 }

◆ setCombWeightParam()

StatusCode jet::CombinedMassUncertaintyComponent::setCombWeightParam ( const CompParametrization::TypeEnum param )

virtual

Definition at line 191 of file CombinedMassUncertaintyComponent.cxx.

 {
     if (m_isInit)
     {
         ATH_MSG_ERROR("Can only set the weight parametrization before initialization: " << getName().Data());
         return StatusCode::FAILURE;
     }
     m_weightParam = param;
  
     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;
 }

◆ setTATerm()

StatusCode jet::CombinedMassUncertaintyComponent::setTATerm ( UncertaintyGroup * TAComp )

virtual

Definition at line 103 of file CombinedMassUncertaintyComponent.cxx.

 {
     if (m_isInit)
     {
         ATH_MSG_ERROR("Can only set the TA mass term before initialization: " << getName().Data());
         return StatusCode::FAILURE;
     }
     if (m_TAMassComp != nullptr)
     {
         ATH_MSG_ERROR("TA mass term has already been set, blocking double-init: " << getName().Data());
         return StatusCode::FAILURE;
     }
     m_TAMassComp = TAComp;
  
     return StatusCode::SUCCESS;
 }

◆ setTAWeights()

StatusCode jet::CombinedMassUncertaintyComponent::setTAWeights ( const UncertaintyHistogram * TAWeights )

virtual

Definition at line 137 of file CombinedMassUncertaintyComponent.cxx.

 {
     if (m_isInit)
     {
         ATH_MSG_ERROR("Can only set the TA mass weights before initialization: " << getName().Data());
         return StatusCode::FAILURE;
     }
     if (m_TAMassWeight != nullptr)
     {
         ATH_MSG_ERROR("TA mass weights has already been set, blocking double-init: " << getName().Data());
         return StatusCode::FAILURE;
     }
     m_TAMassWeight = TAWeights;
  
     return StatusCode::SUCCESS;
 }

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_caloMassComp

UncertaintyGroup* jet::CombinedMassUncertaintyComponent::m_caloMassComp

private

Definition at line 61 of file CombinedMassUncertaintyComponent.h.

◆ m_caloMassScale_weights

JetFourMomAccessor jet::CombinedMassUncertaintyComponent::m_caloMassScale_weights

private

Definition at line 67 of file CombinedMassUncertaintyComponent.h.

◆ m_caloMassWeight

const UncertaintyHistogram* jet::CombinedMassUncertaintyComponent::m_caloMassWeight

private

Definition at line 64 of file CombinedMassUncertaintyComponent.h.

◆ m_combMassType

const CombMassComp::TypeEnum jet::CombinedMassUncertaintyComponent::m_combMassType

private

Definition at line 57 of file CombinedMassUncertaintyComponent.h.

◆ m_energyScale

const float jet::UncertaintyComponent::m_energyScale {}

protectedinherited

Definition at line 55 of file UncertaintyComponent.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_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_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_scaleVar

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

protectedinherited

Definition at line 53 of file UncertaintyComponent.h.

◆ m_setWeightMassDefs

bool jet::CombinedMassUncertaintyComponent::m_setWeightMassDefs

private

Definition at line 58 of file CombinedMassUncertaintyComponent.h.

◆ m_splitNumber

const int jet::UncertaintyComponent::m_splitNumber {}

protectedinherited

Definition at line 57 of file UncertaintyComponent.h.

◆ m_TAMassComp

UncertaintyGroup* jet::CombinedMassUncertaintyComponent::m_TAMassComp

private

Definition at line 62 of file CombinedMassUncertaintyComponent.h.

◆ m_TAMassScale_weights

JetFourMomAccessor jet::CombinedMassUncertaintyComponent::m_TAMassScale_weights

private

Definition at line 68 of file CombinedMassUncertaintyComponent.h.

◆ m_TAMassWeight

const UncertaintyHistogram* jet::CombinedMassUncertaintyComponent::m_TAMassWeight

private

Definition at line 65 of file CombinedMassUncertaintyComponent.h.

◆ m_topology

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

protectedinherited

Definition at line 54 of file UncertaintyComponent.h.

◆ m_truthLabelName

std::string jet::CombinedMassUncertaintyComponent::m_truthLabelName

private

Definition at line 73 of file CombinedMassUncertaintyComponent.h.

◆ m_truthLabels

std::vector<LargeRJetTruthLabel::TypeEnum> jet::CombinedMassUncertaintyComponent::m_truthLabels

private

Definition at line 74 of file CombinedMassUncertaintyComponent.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.

◆ m_weightParam

CompParametrization::TypeEnum jet::CombinedMassUncertaintyComponent::m_weightParam

private

Definition at line 70 of file CombinedMassUncertaintyComponent.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CombinedMassUncertaintyComponent() [1/3]

◆ CombinedMassUncertaintyComponent() [2/3]

◆ ~CombinedMassUncertaintyComponent()

◆ CombinedMassUncertaintyComponent() [3/3]

Member Function Documentation

◆ calculateCombinedMass()

◆ clone()

◆ getAbsMass()

◆ getCombMassType()

◆ getMassOverE()

◆ getMassOverPt()

◆ getName()

◆ getScaleVar()

◆ getSplitFactor()

◆ getTopology()

◆ getUncertainty()

◆ getUncertaintyCalo()

◆ getUncertaintyImpl()

◆ getUncertaintyTA()

◆ getValidBool()

◆ getValidity()

◆ getValidityCalo()

◆ getValidityImpl()

◆ getValidityTA()

◆ getValidName()

◆ getValidUncertainty()

◆ getValidUncertaintyCalo()

◆ getValidUncertaintyTA()

◆ getWeightFactorCalo()

◆ getWeightFactorTA()

◆ initialize()

◆ initMessaging()

◆ isAlwaysZero()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ readHistoFromParam()

◆ setCaloTerm()

◆ setCaloWeights()

◆ setCombWeightMassDefs()

◆ setCombWeightParam()

◆ setLevel()

◆ setTATerm()

◆ setTAWeights()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_caloMassComp

◆ m_caloMassScale_weights

◆ m_caloMassWeight

◆ m_combMassType

◆ m_energyScale

◆ m_imsg

◆ m_interpolate

◆ m_isInit

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_numExpectedHist

◆ m_scaleVar

◆ m_setWeightMassDefs

◆ m_splitNumber

◆ m_TAMassComp

◆ m_TAMassScale_weights

◆ m_TAMassWeight

◆ m_topology

◆ m_truthLabelName

◆ m_truthLabels

◆ m_uncHist

◆ m_uncHistName

◆ m_validHist

◆ m_validHistName

◆ m_weightParam