#include <JetSmearingCorrection.h>

Inheritance diagram for JetSmearingCorrection:

Collaboration diagram for JetSmearingCorrection:

Public Member Functions
	JetSmearingCorrection ()

	JetSmearingCorrection (const std::string &name, TEnv *config, TString jetAlgo, TString calibAreaTag, bool dev)

virtual	~JetSmearingCorrection ()

virtual StatusCode	initialize () override

virtual StatusCode	calibrate (xAOD::Jet &jet, JetEventInfo &) const override

virtual StatusCode	getNominalResolutionData (const xAOD::Jet &jet, double &resolution) const override

virtual StatusCode	getNominalResolutionMC (const xAOD::Jet &jet, double &resolution) const override

virtual void	setUnitsGeV (bool useGeV)

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

Protected Member Functions
virtual StatusCode	setStartP4 (xAOD::Jet &jet) const

Protected Attributes
double	m_GeV

std::string	m_jetStartScale

std::string	m_name

Private Types
enum	SmearType { SmearType::UNKNOWN =0, SmearType::Pt, SmearType::Mass, SmearType::FourVec }

enum	HistType { HistType::UNKNOWN =0, HistType::Pt, HistType::PtEta, HistType::PtAbsEta }

enum	InterpType { InterpType::UNKNOWN =0, InterpType::Full, InterpType::None, InterpType::OnlyX, InterpType::OnlyY }

Private Member Functions
StatusCode	getSigmaSmear (xAOD::Jet &jet, double &sigmaSmear) const

StatusCode	getNominalResolution (const xAOD::Jet &jet, const TH1 *histo, const std::vector< std::unique_ptr< TH1 > > &projections, double &resolution) const

StatusCode	readHisto (double &returnValue, const TH1 *histo, double x) const

StatusCode	readHisto (double &returnValue, const TH1 *histo, const std::vector< std::unique_ptr< TH1 > > &projections, double x, double y) const

StatusCode	cacheProjections (TH1 *fullHistogram, std::vector< std::unique_ptr< TH1 > > &cacheLocation, const std::string &type)

TRandom3 *	getTLSRandomGen (unsigned long seed) const

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

Private Attributes
TEnv *	m_config

const TString	m_jetAlgo

const TString	m_calibAreaTag

const bool	m_dev

boost::thread_specific_ptr< TRandom3 >	m_rand_tls

TString	m_jetOutScale

SmearType	m_smearType

HistType	m_histType

InterpType	m_interpType

std::unique_ptr< TH1 >	m_smearResolutionMC

std::unique_ptr< TH1 >	m_smearResolutionData

std::vector< std::unique_ptr< TH1 > >	m_cachedProjResMC

std::vector< std::unique_ptr< TH1 > >	m_cachedProjResData

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 22 of file JetSmearingCorrection.h.

Member Enumeration Documentation

◆ HistType

enum JetSmearingCorrection::HistType

strongprivate

Enumerator
UNKNOWN
Pt
PtEta
PtAbsEta

Definition at line 54 of file JetSmearingCorrection.h.

         {
             UNKNOWN=0,  // Unknown/unset/etc
             Pt,         // 1D histogram, binned in pT
             PtEta,      // 2D histogram, binned in x=pT y=eta
             PtAbsEta    // 2D histogram, binned in x=pT y=|eta|
         };

◆ InterpType

enum JetSmearingCorrection::InterpType

strongprivate

Enumerator
UNKNOWN
Full
None
OnlyX
OnlyY

Definition at line 61 of file JetSmearingCorrection.h.

         {
             UNKNOWN=0,  // Unknown/unset/etc
             Full,       // Full interpolation
             None,       // No interpolation
             OnlyX,      // Interpolate only in the x dimension
             OnlyY       // Interpolate only in the y dimension
         };

◆ SmearType

enum JetSmearingCorrection::SmearType

strongprivate

Enumerator
UNKNOWN
Pt
Mass
FourVec

Definition at line 47 of file JetSmearingCorrection.h.

         {
             UNKNOWN=0,  // Unknown/unset/etc
             Pt,         // pT smearing (JpTR)
             Mass,       // Mass smearing (JMR)
             FourVec     // Four-vector smearing (JER)
         };

Constructor & Destructor Documentation

◆ JetSmearingCorrection() [1/2]

JetSmearingCorrection::JetSmearingCorrection ( )

Definition at line 11 of file JetSmearingCorrection.cxx.

     : JetCalibrationStep()
     , m_config(nullptr)
     , m_jetAlgo("")
     , m_calibAreaTag("")
     , m_dev(false)
     , m_jetOutScale("")
     , m_smearType(SmearType::UNKNOWN)
     , m_histType(HistType::UNKNOWN)
     , m_interpType(InterpType::UNKNOWN)
     , m_smearResolutionMC()
     , m_smearResolutionData()
     , m_cachedProjResMC()
     , m_cachedProjResData()
 { }

◆ JetSmearingCorrection() [2/2]

JetSmearingCorrection::JetSmearingCorrection	(	const std::string &	name,
		TEnv *	config,
		TString	jetAlgo,
		TString	calibAreaTag,
		bool	dev
	)

Definition at line 27 of file JetSmearingCorrection.cxx.

     : JetCalibrationStep(name.c_str())
     , m_config(config)
     , m_jetAlgo(std::move(jetAlgo))
     , m_calibAreaTag(std::move(calibAreaTag))
     , m_dev(dev)
     , m_jetOutScale("")
     , m_smearType(SmearType::UNKNOWN)
     , m_histType(HistType::UNKNOWN)
     , m_interpType(InterpType::UNKNOWN)
     , m_smearResolutionMC()
     , m_smearResolutionData()
     , m_cachedProjResMC()
     , m_cachedProjResData()
 { }

◆ ~JetSmearingCorrection()

JetSmearingCorrection::~JetSmearingCorrection ( )

virtualdefault

Member Function Documentation

◆ cacheProjections()

StatusCode JetSmearingCorrection::cacheProjections	(	TH1 *	fullHistogram,
		std::vector< std::unique_ptr< TH1 > > &	cacheLocation,
		const std::string &	type
	)

private

Definition at line 476 of file JetSmearingCorrection.cxx.

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

◆ calibrate()

StatusCode JetSmearingCorrection::calibrate	(	xAOD::Jet &	jet,
		JetEventInfo &
	)		const

overridevirtual

Implements JetCalibrationStep.

Definition at line 424 of file JetSmearingCorrection.cxx.

 {
     // Apply the jet smearing correction
  
     // Calculate the smearing width to use
     double sigmaSmear = 0;
     if (getSigmaSmear(jet,sigmaSmear).isFailure())
         return StatusCode::FAILURE;
  
     // Set the random seed deterministically using jet phi
     unsigned long seed = static_cast<unsigned long>(1.e5*fabs(jet.phi()));
     // SetSeed(0) uses the clock, so avoid this
     if(seed == 0) seed = 45583453; // arbitrary number which the seed couldn't otherwise be
     TRandom3* rng = getTLSRandomGen(seed);
  
     // Get the Gaussian-distributed random number
     // Force this to be a positive value
     // Negative values should be extraordinarily rare, but they do exist
     double smearingFactor = -1;
     while (smearingFactor < 0)
         smearingFactor = rng->Gaus(1.,sigmaSmear);
  
     // Apply the smearing factor to the jet as appropriate
     xAOD::JetFourMom_t calibP4 = jet.jetP4();
     switch (m_smearType)
     {
         case SmearType::Pt:
             calibP4 = xAOD::JetFourMom_t(jet.pt()*smearingFactor,jet.eta(),jet.phi(),jet.m());
             break;
  
         case SmearType::Mass:
             calibP4 = xAOD::JetFourMom_t(jet.pt(),jet.eta(),jet.phi(),smearingFactor*jet.m());
             break;
  
         case SmearType::FourVec:
             calibP4 = xAOD::JetFourMom_t(jet.pt()*smearingFactor,jet.eta(),jet.phi(),jet.m()*smearingFactor);
             break;
  
         default:
             // We should never reach this, it was checked during initialization
             ATH_MSG_ERROR("Cannot smear the jet, the smearing type was not set");
             return StatusCode::FAILURE;
     }
  
     // Set the output scale
     jet.setAttribute<xAOD::JetFourMom_t>(m_jetOutScale.Data(),calibP4);
     jet.setJetP4(calibP4);
  
  
     return StatusCode::SUCCESS;
 }

◆ getNominalResolution()

StatusCode JetSmearingCorrection::getNominalResolution	(	const xAOD::Jet &	jet,
		const TH1 *	histo,
		const std::vector< std::unique_ptr< TH1 > > &	projections,
		double &	resolution
	)		const

private

Definition at line 371 of file JetSmearingCorrection.cxx.

 {
     double localRes = 0;
     switch (m_histType)
     {
         case HistType::Pt:
             if (readHisto(localRes,histo,jet.pt()/m_GeV).isFailure())
                 return StatusCode::FAILURE;
             break;
  
         case HistType::PtEta:
             if (readHisto(localRes,histo,projections,jet.pt()/m_GeV,jet.eta()).isFailure())
                 return StatusCode::FAILURE;
             break;
  
         case HistType::PtAbsEta:
             if (readHisto(localRes,histo,projections,jet.pt()/m_GeV,fabs(jet.eta())).isFailure())
                 return StatusCode::FAILURE;
             break;
  
         default:
             // We should never reach this, it was checked during initialization
             ATH_MSG_ERROR("Cannot get the nominal resolution, the smearing histogram type was not set");
             return StatusCode::FAILURE;
     }
  
     // If we got here, everything went well
     // Set the resolution and return success
     resolution = localRes;
     return StatusCode::SUCCESS;
 }

◆ getNominalResolutionData()

StatusCode JetSmearingCorrection::getNominalResolutionData	(	const xAOD::Jet &	jet,
		double &	resolution
	)		const

overridevirtual

Reimplemented from JetCalibrationStep.

Definition at line 403 of file JetSmearingCorrection.cxx.

 {
     return getNominalResolution(jet,m_smearResolutionData.get(),m_cachedProjResData,resolution);
 }

◆ getNominalResolutionMC()

StatusCode JetSmearingCorrection::getNominalResolutionMC	(	const xAOD::Jet &	jet,
		double &	resolution
	)		const

overridevirtual

Reimplemented from JetCalibrationStep.

Definition at line 408 of file JetSmearingCorrection.cxx.

 {
     return getNominalResolution(jet,m_smearResolutionMC.get(),m_cachedProjResMC,resolution);
 }

◆ getSigmaSmear()

StatusCode JetSmearingCorrection::getSigmaSmear	(	xAOD::Jet &	jet,
		double &	sigmaSmear
	)		const

private

Definition at line 336 of file JetSmearingCorrection.cxx.

 {
     /*
         Nominal jet smearing
             If sigma_data > sigma_MC, then we want to smear MC to match data
             If sigma_data < sigma_MC, then we do not want to smear data to match MC
             The second case is instead the source of an uncertainty (see JetUncertainties)
  
         To make MC agree with data:
             if (sigma_data > sigma_MC) then sigma_smear^2 = sigma_data^2 - sigma_MC^2
             if (sigma_data < sigma_MC) then do nothing
             Smearing using a Gaussian centered at 1 and with a width of sigma_smear
  
         Note that data is never smeared, as blocked in JetCalibrationTool.cxx
     */
  
     double resolutionMC = 0;
     if (getNominalResolutionMC(jet,resolutionMC).isFailure())
         return StatusCode::FAILURE;
  
     double resolutionData = 0;
     if (getNominalResolutionData(jet,resolutionData).isFailure())
         return StatusCode::FAILURE;
  
     // Nominal smearing only if data resolution is larger than MC resolution
     // This is because we want to smear the MC to match the data
     // if MC is larger than data, don't make the nominal data worse, so smear is 0
     if (resolutionMC < resolutionData)
         sigmaSmear = sqrt(resolutionData*resolutionData - resolutionMC*resolutionMC);
     else
         sigmaSmear = 0;
  
     return StatusCode::SUCCESS;
 }

◆ getTLSRandomGen()

TRandom3 * JetSmearingCorrection::getTLSRandomGen ( unsigned long seed ) const

private

Definition at line 413 of file JetSmearingCorrection.cxx.

 {
   TRandom3* random = m_rand_tls.get();
   if (!random) {
     random = new TRandom3();
     m_rand_tls.reset(random);
   }
   random->SetSeed(seed);
   return random;
 }

◆ initialize()

StatusCode JetSmearingCorrection::initialize ( )

overridevirtual

Implements JetCalibrationStep.

Definition at line 46 of file JetSmearingCorrection.cxx.

 {
     ATH_MSG_INFO("Initializing the jet smearing correction tool");
  
     if (!m_config)
     {
         ATH_MSG_FATAL("Config file not specified.  Aborting.");
         return StatusCode::FAILURE;
     }
     if (m_jetAlgo == "")
     {
         ATH_MSG_FATAL("No jet algorithm specified.  Aborting.");
         return StatusCode::FAILURE;
     }
  
     // Get the starting and ending jet scales
     m_jetStartScale = m_config->GetValue("JSCStartingScale","JetGSCScaleMomentum");
     m_jetOutScale   = m_config->GetValue("JSCOutScale","JetSmearedMomentum");
     ATH_MSG_INFO("Reading from " << m_jetStartScale.c_str() << " and writing to " << m_jetOutScale.Data());
  
     // Get information about how to smear
     TString smearType = m_config->GetValue("SmearType","");
     if (smearType == "")
     {
         ATH_MSG_FATAL("No jet smearing type was specified.  Aborting.");
         return StatusCode::FAILURE;
     }
     else if (!smearType.CompareTo("pt",TString::kIgnoreCase))
         m_smearType = SmearType::Pt;
     else if (!smearType.CompareTo("mass",TString::kIgnoreCase))
         m_smearType = SmearType::Mass;
     else if (!smearType.CompareTo("FourVec",TString::kIgnoreCase))
         m_smearType = SmearType::FourVec;
     else
     {
         ATH_MSG_FATAL("Unrecognized jet smearing type: " << smearType.Data());
         return StatusCode::FAILURE;
     }
  
     // Determine the histogram parametrization
     TString histType = m_config->GetValue("SmearingCorrectionHistType","");
     if (histType == "")
     {
         ATH_MSG_FATAL("No jet smearing histogram parametrization was specified.  Aborting.");
         return StatusCode::FAILURE;
     }
     else if (!histType.CompareTo("pt",TString::kIgnoreCase))
         m_histType = HistType::Pt;
     else if (!histType.CompareTo("PtEta",TString::kIgnoreCase))
         m_histType = HistType::PtEta;
     else if (!histType.CompareTo("PtAbsEta",TString::kIgnoreCase))
         m_histType = HistType::PtAbsEta;
     else
     {
         ATH_MSG_FATAL("Unrecognized jet smearing histogram parametrization: " << histType.Data());
         return StatusCode::FAILURE;
     }
  
     // Determine the histogram interpolation strategy
     TString interpType = m_config->GetValue("SmearingCorrectionInterpType","");
     if (interpType == "")
     {
         ATH_MSG_FATAL("No jet smearing histogram interpolation type was specified.  Aborting.");
         return StatusCode::FAILURE;
     }
     else if (!interpType.CompareTo("full",TString::kIgnoreCase))
         m_interpType = InterpType::Full;
     else if (!interpType.CompareTo("none",TString::kIgnoreCase))
         m_interpType = InterpType::None;
     else if (!interpType.CompareTo("onlyx",TString::kIgnoreCase))
         m_interpType = InterpType::OnlyX;
     else if (!interpType.CompareTo("onlyy",TString::kIgnoreCase))
         m_interpType = InterpType::OnlyY;
     else
     {
         ATH_MSG_FATAL("Unrecognized jet smearing interpolation type: " << interpType.Data());
         return StatusCode::FAILURE;
     }
  
     // Find the ROOT file containing the smearing histogram, path comes from the config file
     TString smearingFile = m_config->GetValue("SmearingCorrectionFile","");
     if (smearingFile == "")
     {
         ATH_MSG_FATAL("No jet smearing correction file specified.  Aborting.");
         return StatusCode::FAILURE;
     }
  
     // Find the name of the MC nominal resolution histogram, from the config file
     TString smearingHistNameMC = m_config->GetValue("SmearingHistNameResolutionMC","");
     if (smearingHistNameMC == "")
     {
         ATH_MSG_FATAL("No MC jet smearing histogram name specified.  Aborting.");
         return StatusCode::FAILURE;
     }
     TString smearingHistNameData = m_config->GetValue("SmearingHistNameResolutionData","");
     if (smearingHistNameData == "")
     {
         ATH_MSG_FATAL("No data jet smearing histogram name specified.  Aborting.");
         return StatusCode::FAILURE;
     }
  
     // Open the histogram file
     if (m_dev)
     {
         smearingFile.Remove(0,33);
         smearingFile.Insert(0,"JetCalibTools/");
     }
     else
         smearingFile.Insert(14,m_calibAreaTag);
     
     TString fileName = PathResolverFindCalibFile(smearingFile.Data());
     std::unique_ptr<TFile> inputFile(TFile::Open(fileName));
     if (!inputFile || inputFile->IsZombie())
     {
         ATH_MSG_FATAL("Cannot open jet smearing correction file: " << fileName);
         return StatusCode::FAILURE;
     }
  
     //  Retrieve the histogram froms the file
     m_smearResolutionMC = std::unique_ptr<TH1>(dynamic_cast<TH1*>(inputFile->Get(smearingHistNameMC)));
     if (!m_smearResolutionMC)
     {
         ATH_MSG_FATAL("Failed to get specified histogram from the file: " << smearingHistNameMC.Data());
         return StatusCode::FAILURE;
     }
     m_smearResolutionMC->SetDirectory(nullptr);
  
     m_smearResolutionData = std::unique_ptr<TH1>(dynamic_cast<TH1*>(inputFile->Get(smearingHistNameData)));
     if (!m_smearResolutionData)
     {
         ATH_MSG_FATAL("Failed to get specified histogram from the file: " << smearingHistNameData.Data());
         return StatusCode::FAILURE;
     }
     m_smearResolutionData->SetDirectory(nullptr);
  
     // Done with the input file, close it
     inputFile->Close();
  
     // Ensure that the histogram we retrieved has the right number of dimensions
     // It must match the dimensionality of the parametrization
     switch (m_histType)
     {
         case HistType::Pt:
             if (m_smearResolutionMC->GetDimension() != 1)
             {
                 ATH_MSG_FATAL("Specified MC histogram has " << m_smearResolutionMC->GetDimension() << " dimensions, but parametrization expects 1 dimension");
                 return StatusCode::FAILURE;
             }
             if (m_smearResolutionData->GetDimension() != 1)
             {
                 ATH_MSG_FATAL("Specified data histogram has " << m_smearResolutionData->GetDimension() << " dimensions, but parametrization expects 1 dimension");
                 return StatusCode::FAILURE;
             }
             break;
  
         case HistType::PtEta:
         case HistType::PtAbsEta:
             if (m_smearResolutionMC->GetDimension() != 2)
             {
                 ATH_MSG_FATAL("Specified MC histogram has " << m_smearResolutionMC->GetDimension() << " dimensions, but parametrization expects 2 dimensions");
                 return StatusCode::FAILURE;
             }
             if (m_smearResolutionData->GetDimension() != 2)
             {
                 ATH_MSG_FATAL("Specified data histogram has " << m_smearResolutionData->GetDimension() << " dimensions, but parametrization expects 2 dimensions");
                 return StatusCode::FAILURE;
             }
             break;
  
         default:
             ATH_MSG_FATAL("Read the histogram, but the parametrization is UNKNOWN");
             return StatusCode::FAILURE;
     }
  
     // Pre-cache the histogram file in 1D projections if relevant (depends on InterpType)
     if (m_interpType == InterpType::OnlyX || m_interpType == InterpType::OnlyY)
     {
         if (cacheProjections(m_smearResolutionMC.get(),  m_cachedProjResMC,"mc").isFailure())
             return StatusCode::FAILURE;
         if (cacheProjections(m_smearResolutionData.get(),m_cachedProjResData,"data").isFailure())
             return StatusCode::FAILURE;
     }
  
     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
    }

◆ readHisto() [1/2]

StatusCode JetSmearingCorrection::readHisto	(	double &	returnValue,
		const TH1 *	histo,
		const std::vector< std::unique_ptr< TH1 > > &	projections,
		double	x,
		double	y
	)		const

private

Definition at line 276 of file JetSmearingCorrection.cxx.

 {
     // Ensure that the histogram exists
     if (!histo)
     {
         ATH_MSG_ERROR("Unable to read histogram - address is NULL");
         return StatusCode::FAILURE;
     }
  
     // Check dimensionality just to be safe
     if (histo->GetDimension() != 2)
     {
         ATH_MSG_ERROR("Blocking reading of a " << histo->GetDimension() << "D histogram as a 2D histogram");
         return StatusCode::FAILURE;
     }
  
     // Ensure we are within boundaries
     const double minX = histo->GetXaxis()->GetBinLowEdge(1);
     const double maxX = histo->GetXaxis()->GetBinLowEdge(histo->GetNbinsX()+1);
     if ( x >= maxX )
         x = maxX - 1.e-6;
     else if ( x <= minX )
         x = minX + 1.e-6;
     const double minY = histo->GetYaxis()->GetBinLowEdge(1);
     const double maxY = histo->GetYaxis()->GetBinLowEdge(histo->GetNbinsY()+1);
     if ( y >= maxY )
         y = maxY - 1.e-6;
     else if ( y <= minY )
         y = minY + 1.e-6;
  
     // Get the result, interpolating as appropriate
     switch (m_interpType)
     {
         case InterpType::Full:
             returnValue = histo->Interpolate(x,y);
             break;
         
         case InterpType::None:
             returnValue = histo->GetBinContent(histo->GetXaxis()->FindBin(x),histo->GetYaxis()->FindBin(y));
             break;
  
         case InterpType::OnlyX:
             // Determine the y-bin and use the cached projection to interpolate x
             returnValue = projections.at(histo->GetYaxis()->FindBin(y))->Interpolate(x);
             break;
  
         case InterpType::OnlyY:
             // Determine the x-bin and use the cached projection to interpolate y
             returnValue = projections.at(histo->GetXaxis()->FindBin(x))->Interpolate(y);
             break;
  
         default:
             ATH_MSG_ERROR("Unsupported interpolation type for a 2D histogram");
             return StatusCode::FAILURE;
     }
  
     return StatusCode::SUCCESS;
 }

◆ readHisto() [2/2]

StatusCode JetSmearingCorrection::readHisto	(	double &	returnValue,
		const TH1 *	histo,
		double	x
	)		const

private

Definition at line 232 of file JetSmearingCorrection.cxx.

 {
     // Ensure that the histogram exists
     if (!histo)
     {
         ATH_MSG_ERROR("Unable to read histogram - address is NULL");
         return StatusCode::FAILURE;
     }
  
     // Check dimensionality just to be safe
     if (histo->GetDimension() != 1)
     {
         ATH_MSG_ERROR("Blocking reading of a " << histo->GetDimension() << "D histogram as a 1D histogram");
         return StatusCode::FAILURE;
     }
  
     // Ensure we are within boundaries
     const double minX = histo->GetXaxis()->GetBinLowEdge(1);
     const double maxX = histo->GetXaxis()->GetBinLowEdge(histo->GetNbinsX()+1);
     if ( x >= maxX )
         x = maxX - 1.e-6;
     else if ( x <= minX )
         x = minX + 1.e-6;
  
     // Get the result, interpolating as appropriate
     switch (m_interpType)
     {
         case InterpType::Full:
         case InterpType::OnlyX:
             returnValue = histo->Interpolate(x);
             break;
         
         case InterpType::None:
             returnValue = histo->GetBinContent(histo->GetXaxis()->FindBin(x));
             break;
  
         default:
             ATH_MSG_ERROR("Unsupported interpolation type for a 1D histogram");
             return StatusCode::FAILURE;
     }
  
     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;
 }

◆ setStartP4()

StatusCode JetCalibrationStep::setStartP4 ( xAOD::Jet & jet ) const

protectedvirtualinherited

Definition at line 21 of file JetCalibrationStep.cxx.

                                                             {
   xAOD::JetFourMom_t tmp;
   if ( m_jetStartScale.compare("Default") == 0 ) {
     return StatusCode::SUCCESS;
   } else if ( jet.getAttribute<xAOD::JetFourMom_t>(m_jetStartScale.c_str(),tmp) ) {
     jet.setJetP4(tmp);
     return StatusCode::SUCCESS;
   }
   ATH_MSG_WARNING("Jet does not have the requested momentum state: " << m_jetStartScale);
   return StatusCode::FAILURE;
 }

◆ setUnitsGeV()

virtual void JetCalibrationStep::setUnitsGeV ( bool useGeV )

inlinevirtualinherited

Definition at line 30 of file JetCalibrationStep.h.

30 { if (useGeV) m_GeV=1; else m_GeV=1000; }

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_cachedProjResData

std::vector< std::unique_ptr<TH1> > JetSmearingCorrection::m_cachedProjResData

private

Definition at line 87 of file JetSmearingCorrection.h.

◆ m_cachedProjResMC

std::vector< std::unique_ptr<TH1> > JetSmearingCorrection::m_cachedProjResMC

private

Definition at line 86 of file JetSmearingCorrection.h.

◆ m_calibAreaTag

const TString JetSmearingCorrection::m_calibAreaTag

private

Definition at line 73 of file JetSmearingCorrection.h.

◆ m_config

TEnv* JetSmearingCorrection::m_config

private

Definition at line 71 of file JetSmearingCorrection.h.

◆ m_dev

const bool JetSmearingCorrection::m_dev

private

Definition at line 74 of file JetSmearingCorrection.h.

◆ m_GeV

double JetCalibrationStep::m_GeV

protectedinherited

Definition at line 40 of file JetCalibrationStep.h.

◆ m_histType

HistType JetSmearingCorrection::m_histType

private

Definition at line 80 of file JetSmearingCorrection.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_interpType

InterpType JetSmearingCorrection::m_interpType

private

Definition at line 81 of file JetSmearingCorrection.h.

◆ m_jetAlgo

const TString JetSmearingCorrection::m_jetAlgo

private

Definition at line 72 of file JetSmearingCorrection.h.

◆ m_jetOutScale

TString JetSmearingCorrection::m_jetOutScale

private

Definition at line 78 of file JetSmearingCorrection.h.

◆ m_jetStartScale

std::string JetCalibrationStep::m_jetStartScale

protectedinherited

Definition at line 41 of file JetCalibrationStep.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_name

std::string JetCalibrationStep::m_name

protectedinherited

Definition at line 42 of file JetCalibrationStep.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_rand_tls

boost::thread_specific_ptr<TRandom3> JetSmearingCorrection::m_rand_tls

mutableprivate

Definition at line 75 of file JetSmearingCorrection.h.

◆ m_smearResolutionData

std::unique_ptr<TH1> JetSmearingCorrection::m_smearResolutionData

private

Definition at line 83 of file JetSmearingCorrection.h.

◆ m_smearResolutionMC

std::unique_ptr<TH1> JetSmearingCorrection::m_smearResolutionMC

private

Definition at line 82 of file JetSmearingCorrection.h.

◆ m_smearType

SmearType JetSmearingCorrection::m_smearType

private

Definition at line 79 of file JetSmearingCorrection.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

◆ HistType

◆ InterpType

◆ SmearType

Constructor & Destructor Documentation

◆ JetSmearingCorrection() [1/2]

◆ JetSmearingCorrection() [2/2]

◆ ~JetSmearingCorrection()

Member Function Documentation

◆ cacheProjections()

◆ calibrate()

◆ getNominalResolution()

◆ getNominalResolutionData()

◆ getNominalResolutionMC()

◆ getSigmaSmear()

◆ getTLSRandomGen()

◆ initialize()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ readHisto() [1/2]

◆ readHisto() [2/2]

◆ setLevel()

◆ setStartP4()

◆ setUnitsGeV()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_cachedProjResData

◆ m_cachedProjResMC

◆ m_calibAreaTag

◆ m_config

◆ m_dev

◆ m_GeV

◆ m_histType

◆ m_imsg

◆ m_interpType

◆ m_jetAlgo

◆ m_jetOutScale

◆ m_jetStartScale

◆ m_lvl

◆ m_msg_tls

◆ m_name

◆ m_nm

◆ m_rand_tls

◆ m_smearResolutionData

◆ m_smearResolutionMC

◆ m_smearType