#include <ResolutionHelper.h>

Inheritance diagram for jet::ResolutionHelper:

Collaboration diagram for jet::ResolutionHelper:

Public Member Functions
	ResolutionHelper (const std::string &name, const std::string &jetDef)

	ResolutionHelper (const ResolutionHelper &toCopy)

virtual StatusCode	initialize (TEnv &settings, TFile *histFile, const TString &MCtype)

virtual	~ResolutionHelper ()

std::tuple< const UncertaintyHistogram *, CompParametrization::TypeEnum, CompMassDef::TypeEnum >	getNominalResolution (const CompScaleVar::TypeEnum smearType, const JetTopology::TypeEnum topology, const bool readMC) const

bool	smearOnlyMC () const

bool	smearDataAndMC () const

bool	hasRelevantInfo (const CompScaleVar::TypeEnum type, const JetTopology::TypeEnum topology) const

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Private Member Functions
StatusCode	parseInput (TEnv &settings, TFile histFile, const TString &key, const TString &defaultValue, UncertaintyHistogram &hist, CompParametrization::TypeEnum &param, CompMassDef::TypeEnum &massDef, const TString &MCtype)

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

Private Attributes
std::string	m_name

std::string	m_jetDef

bool	m_isInit

bool	m_smearOnlyMC

UncertaintyHistogram *	m_ptNomHistData

CompParametrization::TypeEnum	m_ptNomParamData

CompMassDef::TypeEnum	m_ptNomMassDefData

UncertaintyHistogram *	m_ptNomHistMC

CompParametrization::TypeEnum	m_ptNomParamMC

CompMassDef::TypeEnum	m_ptNomMassDefMC

UncertaintyHistogram *	m_fvNomHistData

CompParametrization::TypeEnum	m_fvNomParamData

CompMassDef::TypeEnum	m_fvNomMassDefData

UncertaintyHistogram *	m_fvNomHistMC

CompParametrization::TypeEnum	m_fvNomParamMC

CompMassDef::TypeEnum	m_fvNomMassDefMC

UncertaintyHistogram *	m_mQCDNomHistData

CompParametrization::TypeEnum	m_mQCDNomParamData

CompMassDef::TypeEnum	m_mQCDNomMassDefData

UncertaintyHistogram *	m_mQCDNomHistMC

CompParametrization::TypeEnum	m_mQCDNomParamMC

CompMassDef::TypeEnum	m_mQCDNomMassDefMC

UncertaintyHistogram *	m_mWZNomHistData

CompParametrization::TypeEnum	m_mWZNomParamData

CompMassDef::TypeEnum	m_mWZNomMassDefData

UncertaintyHistogram *	m_mWZNomHistMC

CompParametrization::TypeEnum	m_mWZNomParamMC

CompMassDef::TypeEnum	m_mWZNomMassDefMC

UncertaintyHistogram *	m_mHbbNomHistData

CompParametrization::TypeEnum	m_mHbbNomParamData

CompMassDef::TypeEnum	m_mHbbNomMassDefData

UncertaintyHistogram *	m_mHbbNomHistMC

CompParametrization::TypeEnum	m_mHbbNomParamMC

CompMassDef::TypeEnum	m_mHbbNomMassDefMC

UncertaintyHistogram *	m_mTopNomHistData

CompParametrization::TypeEnum	m_mTopNomParamData

CompMassDef::TypeEnum	m_mTopNomMassDefData

UncertaintyHistogram *	m_mTopNomHistMC

CompParametrization::TypeEnum	m_mTopNomParamMC

CompMassDef::TypeEnum	m_mTopNomMassDefMC

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 21 of file Reconstruction/Jet/JetUncertainties/JetUncertainties/ResolutionHelper.h.

Constructor & Destructor Documentation

◆ ResolutionHelper() [1/2]

jet::ResolutionHelper::ResolutionHelper	(	const std::string &	name,
		const std::string &	jetDef
	)

Definition at line 17 of file Reconstruction/Jet/JetUncertainties/Root/ResolutionHelper.cxx.

     : asg::AsgMessaging(name)
     , m_name(name)
     , m_jetDef(jetDef)
     , m_isInit(false)
     , m_smearOnlyMC(false)
     , m_ptNomHistData(nullptr)
     , m_ptNomParamData(CompParametrization::UNKNOWN)
     , m_ptNomMassDefData(CompMassDef::UNKNOWN)
     , m_ptNomHistMC(nullptr)
     , m_ptNomParamMC(CompParametrization::UNKNOWN)
     , m_ptNomMassDefMC(CompMassDef::UNKNOWN)
     , m_fvNomHistData(nullptr)
     , m_fvNomParamData(CompParametrization::UNKNOWN)
     , m_fvNomMassDefData(CompMassDef::UNKNOWN)
     , m_fvNomHistMC(nullptr)
     , m_fvNomParamMC(CompParametrization::UNKNOWN)
     , m_fvNomMassDefMC(CompMassDef::UNKNOWN)
     , m_mQCDNomHistData(nullptr)
     , m_mQCDNomParamData(CompParametrization::UNKNOWN)
     , m_mQCDNomMassDefData(CompMassDef::UNKNOWN)
     , m_mQCDNomHistMC(nullptr)
     , m_mQCDNomParamMC(CompParametrization::UNKNOWN)
     , m_mQCDNomMassDefMC(CompMassDef::UNKNOWN)
     , m_mWZNomHistData(nullptr)
     , m_mWZNomParamData(CompParametrization::UNKNOWN)
     , m_mWZNomMassDefData(CompMassDef::UNKNOWN)
     , m_mWZNomHistMC(nullptr)
     , m_mWZNomParamMC(CompParametrization::UNKNOWN)
     , m_mWZNomMassDefMC(CompMassDef::UNKNOWN)
     , m_mHbbNomHistData(nullptr)
     , m_mHbbNomParamData(CompParametrization::UNKNOWN)
     , m_mHbbNomMassDefData(CompMassDef::UNKNOWN)
     , m_mHbbNomHistMC(nullptr)
     , m_mHbbNomParamMC(CompParametrization::UNKNOWN)
     , m_mHbbNomMassDefMC(CompMassDef::UNKNOWN)
     , m_mTopNomHistData(nullptr)
     , m_mTopNomParamData(CompParametrization::UNKNOWN)
     , m_mTopNomMassDefData(CompMassDef::UNKNOWN)
     , m_mTopNomHistMC(nullptr)
     , m_mTopNomParamMC(CompParametrization::UNKNOWN)
     , m_mTopNomMassDefMC(CompMassDef::UNKNOWN)
 { }

◆ ResolutionHelper() [2/2]

jet::ResolutionHelper::ResolutionHelper ( const ResolutionHelper & toCopy )

Definition at line 61 of file Reconstruction/Jet/JetUncertainties/Root/ResolutionHelper.cxx.

     : asg::AsgMessaging(toCopy.m_name)
     , m_name(toCopy.m_name)
     , m_jetDef(toCopy.m_jetDef)
     , m_isInit(toCopy.m_isInit)
     , m_smearOnlyMC(toCopy.m_smearOnlyMC)
     , m_ptNomHistData(!toCopy.m_ptNomHistData ? nullptr : new UncertaintyHistogram(*toCopy.m_ptNomHistData))
     , m_ptNomParamData(toCopy.m_ptNomParamData)
     , m_ptNomMassDefData(toCopy.m_ptNomMassDefData)
     , m_ptNomHistMC(!toCopy.m_ptNomHistMC ? nullptr : new UncertaintyHistogram(*toCopy.m_ptNomHistMC))
     , m_ptNomParamMC(toCopy.m_ptNomParamMC)
     , m_ptNomMassDefMC(toCopy.m_ptNomMassDefMC)
     , m_fvNomHistData(!toCopy.m_fvNomHistData ? nullptr : new UncertaintyHistogram(*toCopy.m_fvNomHistData))
     , m_fvNomParamData(toCopy.m_fvNomParamData)
     , m_fvNomMassDefData(toCopy.m_fvNomMassDefData)
     , m_fvNomHistMC(!toCopy.m_fvNomHistMC ? nullptr : new UncertaintyHistogram(*toCopy.m_fvNomHistMC))
     , m_fvNomParamMC(toCopy.m_fvNomParamMC)
     , m_fvNomMassDefMC(toCopy.m_fvNomMassDefMC)
     , m_mQCDNomHistData(!toCopy.m_mQCDNomHistData ? nullptr : new UncertaintyHistogram(*toCopy.m_mQCDNomHistData))
     , m_mQCDNomParamData(toCopy.m_mQCDNomParamData)
     , m_mQCDNomMassDefData(toCopy.m_mQCDNomMassDefData)
     , m_mQCDNomHistMC(!toCopy.m_mQCDNomHistMC ? nullptr : new UncertaintyHistogram(*toCopy.m_mQCDNomHistMC))
     , m_mQCDNomParamMC(toCopy.m_mQCDNomParamMC)
     , m_mQCDNomMassDefMC(toCopy.m_mQCDNomMassDefMC)
     , m_mWZNomHistData(!toCopy.m_mWZNomHistData ? nullptr : new UncertaintyHistogram(*toCopy.m_mWZNomHistData))
     , m_mWZNomParamData(toCopy.m_mWZNomParamData)
     , m_mWZNomMassDefData(toCopy.m_mWZNomMassDefData)
     , m_mWZNomHistMC(!toCopy.m_mWZNomHistMC ? nullptr : new UncertaintyHistogram(*toCopy.m_mWZNomHistMC))
     , m_mWZNomParamMC(toCopy.m_mWZNomParamMC)
     , m_mWZNomMassDefMC(toCopy.m_mWZNomMassDefMC)
     , m_mHbbNomHistData(!toCopy.m_mHbbNomHistData ? nullptr : new UncertaintyHistogram(*toCopy.m_mHbbNomHistData))
     , m_mHbbNomParamData(toCopy.m_mHbbNomParamData)
     , m_mHbbNomMassDefData(toCopy.m_mHbbNomMassDefData)
     , m_mHbbNomHistMC(!toCopy.m_mHbbNomHistMC ? nullptr : new UncertaintyHistogram(*toCopy.m_mHbbNomHistMC))
     , m_mHbbNomParamMC(toCopy.m_mHbbNomParamMC)
     , m_mHbbNomMassDefMC(toCopy.m_mHbbNomMassDefMC)
     , m_mTopNomHistData(!toCopy.m_mTopNomHistData ? nullptr : new UncertaintyHistogram(*toCopy.m_mTopNomHistData))
     , m_mTopNomParamData(toCopy.m_mTopNomParamData)
     , m_mTopNomMassDefData(toCopy.m_mTopNomMassDefData)
     , m_mTopNomHistMC(!toCopy.m_mTopNomHistMC ? nullptr : new UncertaintyHistogram(*toCopy.m_mTopNomHistMC))
     , m_mTopNomParamMC(toCopy.m_mTopNomParamMC)
     , m_mTopNomMassDefMC(toCopy.m_mTopNomMassDefMC)
 { }

◆ ~ResolutionHelper()

jet::ResolutionHelper::~ResolutionHelper ( )

virtual

Definition at line 105 of file Reconstruction/Jet/JetUncertainties/Root/ResolutionHelper.cxx.

 {
     JESUNC_SAFE_DELETE(m_ptNomHistData);
     JESUNC_SAFE_DELETE(m_ptNomHistMC);
     JESUNC_SAFE_DELETE(m_fvNomHistData);
     JESUNC_SAFE_DELETE(m_fvNomHistMC);
     JESUNC_SAFE_DELETE(m_mQCDNomHistData);
     JESUNC_SAFE_DELETE(m_mQCDNomHistMC);
     JESUNC_SAFE_DELETE(m_mWZNomHistData);
     JESUNC_SAFE_DELETE(m_mWZNomHistMC);
     JESUNC_SAFE_DELETE(m_mHbbNomHistData);
     JESUNC_SAFE_DELETE(m_mHbbNomHistMC);
     JESUNC_SAFE_DELETE(m_mTopNomHistData);
     JESUNC_SAFE_DELETE(m_mTopNomHistMC);
 }

Member Function Documentation

◆ getNominalResolution()

std::tuple< const UncertaintyHistogram *, CompParametrization::TypeEnum, CompMassDef::TypeEnum > jet::ResolutionHelper::getNominalResolution	(	const CompScaleVar::TypeEnum	smearType,
		const JetTopology::TypeEnum	topology,
		const bool	readMC
	)		const

Definition at line 354 of file Reconstruction/Jet/JetUncertainties/Root/ResolutionHelper.cxx.

 {
     // First get the resolution histogram and parametrization
     const jet::UncertaintyHistogram* resolution = nullptr;
     CompParametrization::TypeEnum param         = CompParametrization::UNKNOWN;
     CompMassDef::TypeEnum massDef               = CompMassDef::UNKNOWN;
     
     if (!m_isInit)
     {
         ATH_MSG_ERROR("Asking for the nominal resolution before initialization");
         return std::tuple<const UncertaintyHistogram*,CompParametrization::TypeEnum,CompMassDef::TypeEnum>(NULL,CompParametrization::UNKNOWN,CompMassDef::UNKNOWN);
     }
  
  
     switch (smearType)
     {
         case CompScaleVar::MassRes:
         case CompScaleVar::MassResAbs:
             switch (topology)
             {
                 case JetTopology::QCD:
                     if (readMC)
                     {
                         resolution = m_mQCDNomHistMC;
                         param      = m_mQCDNomParamMC;
                         massDef    = m_mQCDNomMassDefMC;
                     }
                     else
                     {
                         resolution = m_mQCDNomHistData;
                         param      = m_mQCDNomParamData;
                         massDef    = m_mQCDNomMassDefData;
                     }
                     break;
  
                 case JetTopology::WZ:
                     if (readMC)
                     {
                         resolution = m_mWZNomHistMC;
                         param      = m_mWZNomParamMC;
                         massDef    = m_mWZNomMassDefMC;
                     }
                     else
                     {
                         resolution = m_mWZNomHistData;
                         param      = m_mWZNomParamData;
                         massDef    = m_mWZNomMassDefData;
                     }
                     break;
  
                 case JetTopology::Hbb:
                     if (readMC)
                     {
                         resolution = m_mHbbNomHistMC;
                         param      = m_mHbbNomParamMC;
                         massDef    = m_mHbbNomMassDefMC;
                     }
                     else
                     {
                         resolution = m_mHbbNomHistData;
                         param      = m_mHbbNomParamData;
                         massDef    = m_mHbbNomMassDefData;
                     }
                     break;
  
                 case JetTopology::Top:
                     if (readMC)
                     {
                         resolution = m_mTopNomHistMC;
                         param      = m_mTopNomParamMC;
                         massDef    = m_mTopNomMassDefMC;
                     }
                     else
                     {
                         resolution = m_mTopNomHistData;
                         param      = m_mTopNomParamData;
                         massDef    = m_mTopNomMassDefData;
                     }
                     break;
  
                 case JetTopology::MIXED:
                     // We shouldn't read this, as it was checked at a higher level
                     // Just to be safe, check it and return error code
                     ATH_MSG_ERROR("Mass resolution depends on a single jet topology, not a mixed topology");
                     return std::tuple<const UncertaintyHistogram*,CompParametrization::TypeEnum,CompMassDef::TypeEnum>(NULL,CompParametrization::UNKNOWN,CompMassDef::UNKNOWN);
  
                 default:
                     // We shouldn't read this, as it was checked at a higher level
                     // Just to be safe, check it and return error code
                     ATH_MSG_ERROR("Mass resolution depends on the jet topology, which was not specified");
                     return std::tuple<const UncertaintyHistogram*,CompParametrization::TypeEnum,CompMassDef::TypeEnum>(NULL,CompParametrization::UNKNOWN,CompMassDef::UNKNOWN);
             }
             break;
  
         case CompScaleVar::PtRes:
         case CompScaleVar::PtResAbs:
             if (readMC)
             {
                 resolution = m_ptNomHistMC;
                 param      = m_ptNomParamMC;
                 massDef    = m_ptNomMassDefMC;
             }
             else
             {
                 resolution = m_ptNomHistData;
                 param      = m_ptNomParamData;
                 massDef    = m_ptNomMassDefData;
             }
             break;
         
         case CompScaleVar::FourVecRes:
         case CompScaleVar::FourVecResAbs:
             if (readMC)
             {
                 resolution = m_fvNomHistMC;
                 param      = m_fvNomParamMC;
                 massDef    = m_fvNomMassDefMC;
             }
             else
             {
                 resolution = m_fvNomHistData;
                 param      = m_fvNomParamData;
                 massDef    = m_fvNomMassDefData;
             }
             break;
  
         default:
             // This is not a resolution uncertainty component
             // We should not get here
             // Print an erorr and return error code
             ATH_MSG_ERROR("Asked for the smearing factor for a non-resolution component");
             return std::tuple<const UncertaintyHistogram*,CompParametrization::TypeEnum,CompMassDef::TypeEnum>(NULL,CompParametrization::UNKNOWN,CompMassDef::UNKNOWN);
     }
     return std::tuple<const UncertaintyHistogram*,CompParametrization::TypeEnum,CompMassDef::TypeEnum>(resolution,param,massDef);
 }

◆ hasRelevantInfo()

bool jet::ResolutionHelper::hasRelevantInfo	(	const CompScaleVar::TypeEnum	type,
		const JetTopology::TypeEnum	topology
	)		const

Definition at line 490 of file Reconstruction/Jet/JetUncertainties/Root/ResolutionHelper.cxx.

 {
     if (!m_isInit)
     {
         throw std::runtime_error("Asking for nominal resolution information before initialization");
         return false;
     }
  
     // Check that the nominal MC histograms for the specified type exist
     //      We have already checked that the parametrizations exist for each histogram
     //      We have already checked that the data histograms exist for each MC if relevant
     switch (type)
     {
         case CompScaleVar::PtRes:
         case CompScaleVar::PtResAbs:
             return m_ptNomHistMC != nullptr;
  
         case CompScaleVar::FourVecRes:
         case CompScaleVar::FourVecResAbs:
             return m_fvNomHistMC != nullptr;
  
         case CompScaleVar::MassRes:
         case CompScaleVar::MassResAbs:
             switch (topology)
             {
                 case JetTopology::QCD:
                     return m_mQCDNomHistMC != nullptr;
  
                 case JetTopology::WZ:
                     return m_mWZNomHistMC  != nullptr;
  
                 case JetTopology::Hbb:
                     return m_mHbbNomHistMC != nullptr;
  
                 case JetTopology::Top:
                     return m_mTopNomHistMC != nullptr;
  
                 default:
                     throw std::runtime_error(Form("Unexpected topology type, cannot determine if relevant info exists: %s",JetTopology::enumToString(topology).Data()));
                     return false;
             }
  
         default:
             throw std::runtime_error(Form("Unexpected variable type, cannot determine if relevant info exists: %s",CompScaleVar::enumToString(type).Data()));
             return false;
     }
 }

◆ initialize()

StatusCode jet::ResolutionHelper::initialize	(	TEnv &	settings,
		TFile *	histFile,
		const TString &	MCtype
	)

virtual

Definition at line 199 of file Reconstruction/Jet/JetUncertainties/Root/ResolutionHelper.cxx.

 {
     if (m_isInit)
     {
         ATH_MSG_ERROR("Blocking double-initialization: " << m_name);
         return StatusCode::FAILURE;
     }
     
     // Read nominal resolution information from the configuration file
     // In many cases (especially configs before summer 2018), there are no inputs to find
     // As such, it is perfectly normal behaviour to read zero inputs from the file
     // However, there are some expectations
     //  There should be no cases of data resolution without MC resolution
     //  There can be cases of MC resolution without data resolution
     //  Histograms and their parametrizations must be paired (potentially also with mass)
  
     // Expected format:
     //      KeyString: HistName,Parametrization
     //      KeyString: HistName,Parametrization,MassDef
     //  Example:
     //      NominalPtResData: PtResData,PtAbsEta
     //          Histogram name is PtResData_JETDEF
     //          Parametrization is pT vs |eta|
     //      NominalMassResMC: MassResMC,PtMass,Calo
     //          Histogram name is MassResMC_JETDEF
     //          Parametrization is pT vs m/pt
     //          Mass definition is calorimeter (not track-assisted or combined)
  
  
     // Start with nominal pT resolution
     if (parseInput(settings,histFile,"NominalPtResData","",m_ptNomHistData,m_ptNomParamData,m_ptNomMassDefData,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (parseInput(settings,histFile,"NominalPtResMC","",m_ptNomHistMC,m_ptNomParamMC,m_ptNomMassDefMC,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (m_ptNomHistData && !m_ptNomHistMC)
     {
         ATH_MSG_ERROR("There should never be a nominal data resolution without a nominal MC resolution (pT)");
         return StatusCode::FAILURE;
     }
  
     // Now the nominal four-vector resolution
     if (parseInput(settings,histFile,"NominalFourVecResData","",m_fvNomHistData,m_fvNomParamData,m_fvNomMassDefData,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (parseInput(settings,histFile,"NominalFourVecResMC","",m_fvNomHistMC,m_fvNomParamMC,m_fvNomMassDefMC,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (m_fvNomHistData && !m_fvNomHistMC)
     {
         ATH_MSG_ERROR("There should never be a nominal data resolution without a nominal MC resolution (four-vector)");
         return StatusCode::FAILURE;
     }
  
     // Now the nominal mass resolution (topology-dependent)
     // For simplicity, this is done with separate histograms for each one
     // Lots of code duplication, but time is of the essence, and it works
  
     // QCD topology
     if (parseInput(settings,histFile,"NominalMassResDataQCD","",m_mQCDNomHistData,m_mQCDNomParamData,m_mQCDNomMassDefData,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (parseInput(settings,histFile,"NominalMassResMCQCD","",m_mQCDNomHistMC,m_mQCDNomParamMC,m_mQCDNomMassDefMC,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (m_mQCDNomHistData && !m_mQCDNomHistMC)
     {
         ATH_MSG_ERROR("There should never be a nominal data resolution without a nominal MC resolution (four-vector)");
         return StatusCode::FAILURE;
     }
  
     // WZ topology
     if (parseInput(settings,histFile,"NominalMassResDataWZ","",m_mWZNomHistData,m_mWZNomParamData,m_mWZNomMassDefData,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (parseInput(settings,histFile,"NominalMassResMCWZ","",m_mWZNomHistMC,m_mWZNomParamMC,m_mWZNomMassDefMC,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (m_mWZNomHistData && !m_mWZNomHistMC)
     {
         ATH_MSG_ERROR("There should never be a nominal data resolution without a nominal MC resolution (four-vector)");
         return StatusCode::FAILURE;
     }
  
     // Hbb topology
     if (parseInput(settings,histFile,"NominalMassResDataHbb","",m_mHbbNomHistData,m_mHbbNomParamData,m_mHbbNomMassDefData,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (parseInput(settings,histFile,"NominalMassResMCHbb","",m_mHbbNomHistMC,m_mHbbNomParamMC,m_mHbbNomMassDefMC,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (m_mHbbNomHistData && !m_mHbbNomHistMC)
     {
         ATH_MSG_ERROR("There should never be a nominal data resolution without a nominal MC resolution (four-vector)");
         return StatusCode::FAILURE;
     }
  
     // Top topology
     if (parseInput(settings,histFile,"NominalMassResDataTop","",m_mTopNomHistData,m_mTopNomParamData,m_mTopNomMassDefData,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (parseInput(settings,histFile,"NominalMassResMCTop","",m_mTopNomHistMC,m_mTopNomParamMC,m_mTopNomMassDefMC,MCtype).isFailure())
         return StatusCode::FAILURE;
     if (m_mTopNomHistData && !m_mTopNomHistMC)
     {
         ATH_MSG_ERROR("There should never be a nominal data resolution without a nominal MC resolution (four-vector)");
         return StatusCode::FAILURE;
     }
  
     // Check if the user has specified if this is full correlations or MC-only
     TString smearType = settings.GetValue("ResolutionSmearOnlyMC","");
     if (smearType != "")
     {
         if (!smearType.CompareTo("true",TString::kIgnoreCase))
             m_smearOnlyMC = true;
         else if (!smearType.CompareTo("false",TString::kIgnoreCase))
             m_smearOnlyMC = false;
         else
         {
             ATH_MSG_ERROR("The value of ResolutionSmearOnlyMC doesn't look like the expected boolean: " << smearType.Data());
             return StatusCode::FAILURE;
         }
         ATH_MSG_INFO(Form("  ResolutionSmearOnlyMC: \"%s\"",m_smearOnlyMC ? "true" : "false"));
     }
  
     // If we are also smearing data, we need the data histograms for any MC histogram
     if (!m_smearOnlyMC)
     {
         if (m_ptNomHistMC && !m_ptNomHistData)
         {
             ATH_MSG_ERROR("Requested full smearing correlations (both data and MC), but only provided the MC nominal histogram for pT");
             return StatusCode::FAILURE;
         }
         if (m_fvNomHistMC && !m_fvNomHistData)
         {
             ATH_MSG_ERROR("Requested full smearing correlations (both data and MC), but only provided the MC nominal histogram for fourvec");
             return StatusCode::FAILURE;
         }
         if (m_mQCDNomHistMC && !m_mQCDNomHistData)
         {
             ATH_MSG_ERROR("Requested full smearing correlations (both data and MC), but only provided the MC nominal histogram for mQCD");
             return StatusCode::FAILURE;
         }
         if (m_mWZNomHistMC && !m_mWZNomHistData)
         {
             ATH_MSG_ERROR("Requested full smearing correlations (both data and MC), but only provided the MC nominal histogram for mWZ");
             return StatusCode::FAILURE;
         }
         if (m_mHbbNomHistMC && !m_mHbbNomHistData)
         {
             ATH_MSG_ERROR("Requested full smearing correlations (both data and MC), but only provided the MC nominal histogram for mHbb");
             return StatusCode::FAILURE;
         }
         if (m_mTopNomHistMC && !m_mTopNomHistData)
         {
             ATH_MSG_ERROR("Requested full smearing correlations (both data and MC), but only provided the MC nominal histogram for mTop");
             return StatusCode::FAILURE;
         }
     }
  
  
     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;
 }

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

◆ parseInput()

StatusCode jet::ResolutionHelper::parseInput	(	TEnv &	settings,
		TFile *	histFile,
		const TString &	key,
		const TString &	defaultValue,
		UncertaintyHistogram *&	hist,
		CompParametrization::TypeEnum &	param,
		CompMassDef::TypeEnum &	massDef,
		const TString &	MCtype
	)

private

Definition at line 121 of file Reconstruction/Jet/JetUncertainties/Root/ResolutionHelper.cxx.

 {
     // Get the string
     TString value = settings.GetValue(key,defaultValue);
  
     // Check the trivial case
     if (value == "")
         return StatusCode::SUCCESS;
  
     // Ensure it matches the expected format
     if (!value.Contains(","))
     {
         ATH_MSG_ERROR("Key of " << key.Data() << " has an unexpected value format (missing comma): " << value.Data());
         return StatusCode::FAILURE;
     }
  
     // Split the string
     std::vector<TString> splitValue = utils::vectorize<TString>(value,", ");
     if (splitValue.size() < 3)
     {
         ATH_MSG_ERROR("Key of " << key.Data() << " has unexpected value format (less than 3 strings): " << value.Data());
         return StatusCode::FAILURE;
     }
     else if (splitValue.size() > 4)
     {
         ATH_MSG_ERROR("Key of " << key.Data() << " has unexpected value format (more than 4 strings): " << value.Data());
         return StatusCode::FAILURE;
     }
     
     // Ensure that the parametrization is valid
     param = CompParametrization::stringToEnum(splitValue.at(1));
     if (param == CompParametrization::UNKNOWN)
     {
         ATH_MSG_ERROR("Key of " << key.Data() << " has unexpected parametrization value: " << splitValue.at(1));
         return StatusCode::FAILURE;
     }
  
     // Ensure that the interpolation type is valid
     Interpolate::TypeEnum interp = Interpolate::stringToEnum(splitValue.at(2));
     if (interp == Interpolate::UNKNOWN)
     {
         ATH_MSG_ERROR("Key of " << key.Data() << " has unexpected interpolation type: " << splitValue.at(2));
         return StatusCode::FAILURE;
     }
  
     // If this is a mass parametrization, ensure that a mass definition was specified
     if (CompParametrization::includesMass(param))
     {
         if (splitValue.size() != 4)
         {
             ATH_MSG_ERROR("Key of " << key.Data() << " has unexpected value format (missing mass definition): " << value.Data());
             return StatusCode::FAILURE;
         }
         massDef = CompMassDef::stringToEnum(splitValue.at(3));
         if (massDef == CompMassDef::UNKNOWN)
         {
             ATH_MSG_ERROR("Key of " << key.Data() << " has unexpected mass definition: " << splitValue.at(3));
             return StatusCode::FAILURE;
         }
     }
  
     // Replace generic MCTYPE string with the user-specified type if applicable
     TString histName = splitValue.at(0);
     histName.ReplaceAll("MCTYPE",MCtype);
  
     // Create the histogram
     hist = new UncertaintyHistogram(histName+"_"+m_jetDef.c_str(),interp);
  
     // Initialize the histogram
     if (hist->initialize(histFile).isFailure())
         return StatusCode::FAILURE;
  
     // Print out that we successfully read the input
     ATH_MSG_INFO(Form("  %s: \"%s\"",key.Data(),value.Data()));
  
     return StatusCode::SUCCESS;
 }