GlobalNNCalibration Class Reference

Tool to provide the global NN calibration for jets. More...

#include <GlobalNNCalibration.h>

Inheritance diagram for GlobalNNCalibration:

Collaboration diagram for GlobalNNCalibration:

Public Member Functions
	GlobalNNCalibration ()
	The constructor. More...
	GlobalNNCalibration (const std::string &name)
	The constructor. More...
	GlobalNNCalibration (const std::string &name, TEnv *config, TString jetAlgo, const TString &calibAreaTag, bool dev)
	The constructor, which is used by the JetCalibrationTool. More...
virtual	~GlobalNNCalibration ()=default
	The destructor. More...
virtual StatusCode	initialize () override
	Returns the charged fraction of a jet. More...
virtual void	setUnitsGeV (bool useGeV)
virtual StatusCode	getNominalResolutionData (const xAOD::Jet &, double &) const
virtual StatusCode	getNominalResolutionMC (const xAOD::Jet &, double &) const
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Protected Member Functions
virtual StatusCode	calibrate (xAOD::Jet &jet, JetEventInfo &) const override
virtual StatusCode	setStartP4 (xAOD::Jet &jet) const

Protected Attributes
double	m_GeV
std::string	m_jetStartScale
std::string	m_name

Private Member Functions
double	getJetChargedFraction (const xAOD::Jet &jet_reco) const
	Returns the charged fraction of a jet. More...
double	getJetDetEta (const xAOD::Jet &jet_reco) const
	Returns the detector eta of the jet. More...
int	getJetNtrk1000 (const xAOD::Jet &jet_reco) const
	Returns the number of tracks with pT > 1 GeV associated to the jet. More...
double	getJetWtrk1000 (const xAOD::Jet &jet_reco) const
	Returns the jet width. More...
double	getJESPt (const xAOD::Jet &jet_reco) const
	Returns the jet pT after the MCJES calibration. More...
std::map< std::string, double >	getJetFeatures (const xAOD::Jet &jet_reco, JetEventInfo &jetEventInfo) const
	Returns a map of possible inputs to the NN, and their corresponding values for this jet. More...
double	getSplineSlope (const int ieta, const double minPt) const
	Gets the slope of the spline histogram for a given eta bin, for extrapolation of the calibration. More...
void	loadSplineHists (const TString &fileName, const std::string &etajes_name="etaJes")
	Reads the spline histograms from the file given in the config, and stores them in m_ptCorrFactors. More...
double	getSplineCorr (const int etaBin, double E) const
	Returns the correction from spline histogram, which should be applied after the NN correction. More...
int	getEtaBin (const xAOD::Jet &jet_reco, const std::vector< double > &etaBins) const
	Returns the eta bin, as determined by a list of bin edges. More...
void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
std::vector< std::unique_ptr< lwt::LightweightGraph > >	m_lwnns
std::vector< std::unique_ptr< TH1 > >	m_ptCorrFactors
std::vector< double >	m_nnEtaBins
std::vector< double >	m_closureEtaBins
std::vector< TString >	m_NNInputs
TEnv *	m_config {}
TString	m_jetAlgo
std::string	m_calibAreaTag
bool	m_dev {}
bool	m_doSplineCorr {true}
bool	m_doLogPtScaling {}
double	m_minNNCorrection {}
double	m_maxNNCorrection {}
std::vector< double >	m_JPtS_MinPt_Slopes
std::vector< double >	m_JPtS_MinPt_Pt
std::vector< double >	m_JPtS_MinPt_R
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

Tool to provide the global NN calibration for jets.

Author

Jennifer Roloff

Date

August 2021

Definition at line 35 of file GlobalNNCalibration.h.

Constructor & Destructor Documentation

GlobalNNCalibration() [1/3]

GlobalNNCalibration::GlobalNNCalibration

(

)

The constructor.

Note that this doesn't have all the necessary information, so it will not configure things correctly.

Definition at line 30 of file GlobalNNCalibration.cxx.

    : JetCalibrationStep::JetCalibrationStep("GlobalNNCalibration/GlobalNNCalibration"),
m_config(nullptr), m_jetAlgo(""), m_calibAreaTag(""), m_dev(false), m_doSplineCorr(true)
{
}

GlobalNNCalibration() [2/3]

GlobalNNCalibration::GlobalNNCalibration

(

const std::string &

name

)

The constructor.

Note that this doesn't have all the necessary information, so it will not configure things correctly.

Parameters

name	The name of the tool being created

Definition at line 38 of file GlobalNNCalibration.cxx.

    : JetCalibrationStep::JetCalibrationStep(name.c_str()),
m_config(nullptr), m_jetAlgo(""), m_calibAreaTag(""), m_dev(false), m_doSplineCorr(true)
{
}

GlobalNNCalibration() [3/3]

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

The constructor, which is used by the JetCalibrationTool.

Parameters

name	The name of the tool being created
config	The name of the config file for the calibration
jetAlgo	The name of the jet collection
calibAreaTag	The tag for this calibration
dev	A flag for if the calibration is run in development mode

Definition at line 44 of file GlobalNNCalibration.cxx.

  : JetCalibrationStep::JetCalibrationStep( name.c_str() ),
    m_config(config), m_jetAlgo(std::move(jetAlgo)), m_calibAreaTag(calibAreaTag), m_dev(dev), m_doSplineCorr(true)
{
 
}

~GlobalNNCalibration()

virtual GlobalNNCalibration::~GlobalNNCalibration ( )

virtualdefault

The destructor.

Member Function Documentation

calibrate()

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

overrideprotectedvirtual

Implements JetCalibrationStep.

Definition at line 126 of file GlobalNNCalibration.cxx.

                                                                                        {
  xAOD::JetFourMom_t jetStartP4;
  jetStartP4 = jet.jetP4();
 
  // The NN learns the jet response, so the original jet pT is divided
  // by the NN output to get the calibrated pT
  int nnEtaBin = getEtaBin(jet, m_nnEtaBins);
  int closureEtaBin = getEtaBin(jet, m_closureEtaBins);
  std::map<std::string,double> NN_inputValues = getJetFeatures(jet, jetEventInfo);
  std::map<std::string,std::map<std::string,double>> inputs;
  inputs["node_0"] = NN_inputValues;
 
  std::map<std::string, double> outputs = m_lwnns[nnEtaBin]->compute(inputs);
  double nnCalibFactor =  outputs["out_0"];
  if(nnCalibFactor > m_maxNNCorrection) nnCalibFactor = m_maxNNCorrection;
  if(nnCalibFactor < m_minNNCorrection) nnCalibFactor = m_minNNCorrection;
 
  double response = nnCalibFactor;
  if(m_doSplineCorr){
    double jetPt = getJESPt(jet);
    response *= getSplineCorr(closureEtaBin, jetPt/nnCalibFactor);
    if(response == 0) response = nnCalibFactor;
  }
 
  xAOD::JetFourMom_t calibP4 = jetStartP4 / response;
 
  //Transfer calibrated jet properties to the Jet object
  jet.setAttribute<xAOD::JetFourMom_t>("JetGNNCScaleMomentum",calibP4);
  jet.setJetP4( calibP4 );
 
  return StatusCode::SUCCESS;
 
}

getEtaBin()

int GlobalNNCalibration::getEtaBin ( const xAOD::Jet &  jet_reco, const std::vector< double > &  etaBins  ) const

private

Returns the eta bin, as determined by a list of bin edges.

Parameters

jet_reco	The jet
etaBins	A list of bin edges

Definition at line 300 of file GlobalNNCalibration.cxx.

                                                                                                 {
  double detEta = jet_reco.getAttribute<float>("DetectorEta");
  for(unsigned int i=1; i<etaBins.size()-1; i++){
    if(std::abs(detEta) < etaBins[i]) return i-1;
  }
  // This should throw an error instead probably, since this is outside of the eta range we are calibrating
  return etaBins.size()-2;
}

getJESPt()

double GlobalNNCalibration::getJESPt ( const xAOD::Jet &  jet_reco ) const

private

Returns the jet pT after the MCJES calibration.

Parameters

jet_reco

The jet

Definition at line 341 of file GlobalNNCalibration.cxx.

                                                                  {
  return jet_reco.jetP4("JetEtaJESScaleMomentum").pt() / 1.e3;
}

getJetChargedFraction()

double GlobalNNCalibration::getJetChargedFraction ( const xAOD::Jet &  jet_reco ) const

private

Returns the charged fraction of a jet.

Parameters

jet_reco

The jet

Definition at line 310 of file GlobalNNCalibration.cxx.

                                                                              {
  static const SG::ConstAccessor<std::vector<float> > SumPtChargedPFOPt500Acc ("SumPtChargedPFOPt500");
  if( SumPtChargedPFOPt500Acc.isAvailable(jet_reco) ) {
    float thisChargedFraction =  SumPtChargedPFOPt500Acc(jet_reco).at(0);
    thisChargedFraction /= jet_reco.jetP4(xAOD::JetConstitScaleMomentum).Pt();
    return double(thisChargedFraction);
  }
 
  return -999.;
}

getJetDetEta()

double GlobalNNCalibration::getJetDetEta ( const xAOD::Jet &  jet_reco ) const

private

Returns the detector eta of the jet.

Parameters

jet_reco

The jet

Definition at line 321 of file GlobalNNCalibration.cxx.

                                                                      {
  static const SG::ConstAccessor<float> DetectorEtaAcc ("DetectorEta");
  return DetectorEtaAcc.withDefault (jet_reco, -999);
}

getJetFeatures()

std::map< std::string, double > GlobalNNCalibration::getJetFeatures ( const xAOD::Jet &  jet_reco, JetEventInfo &  jetEventInfo  ) const

private

Returns a map of possible inputs to the NN, and their corresponding values for this jet.

Parameters

jet_reco	The jet
jetEventInfo	A set of information about the event and jet

Definition at line 223 of file GlobalNNCalibration.cxx.

                                                                                                                      {
  std::vector<float> samplingFrac = jet_reco.getAttribute<std::vector<float> >("EnergyPerSampling");
  xAOD::JetFourMom_t jetconstitP4 = jet_reco.getAttribute<xAOD::JetFourMom_t>("JetConstitScaleMomentum");
 
  xAOD::JetFourMom_t jetStartP4;
  jetStartP4 = jet_reco.jetP4();
 
  float jetE_constitscale = jetconstitP4.e();
 
  //EM3 and Tile0 fraction calculations
  //EM3 = (EMB3+EME3)/energy, Tile0 = (TileBar0+TileExt0)/energy
  //Check the map above to make sure the correct entries of samplingFrac are being used
  float EM0 = (samplingFrac[0]+samplingFrac[4])/jetE_constitscale;
  float EM1 = (samplingFrac[1]+samplingFrac[5])/jetE_constitscale;
  float EM2 = (samplingFrac[2]+samplingFrac[6])/jetE_constitscale;
  float EM3 = (samplingFrac[3]+samplingFrac[7])/jetE_constitscale;
  float Tile0 = (samplingFrac[12]+samplingFrac[18])/jetE_constitscale;
  float Tile1 = (samplingFrac[13]+samplingFrac[19])/jetE_constitscale;
  float Tile2 = (samplingFrac[14]+samplingFrac[20])/jetE_constitscale;
  float HEC0 = (samplingFrac[8])/jetE_constitscale;
  float HEC1 = (samplingFrac[9])/jetE_constitscale;
  float HEC2 = (samplingFrac[10])/jetE_constitscale;
  float HEC3 = (samplingFrac[11])/jetE_constitscale;
 
  float FCAL0 = (samplingFrac[21])/jetE_constitscale;
  float FCAL1 = (samplingFrac[22])/jetE_constitscale;
  float FCAL2 = (samplingFrac[23])/jetE_constitscale;
 
 
  // A map of possible NN inputs with their values for this jet.
  // These may not all be included in the NN.
  std::map<std::string,double> inputValues;
 
  // This is a list of variables that could be included in the NN.
  // This makes it simple to change the variables in the NN without complicated changes
  // to the code.
  if(m_doLogPtScaling) {
      inputValues["jet_pt"] = log10(getJESPt(jet_reco));
  }
  else{
    inputValues["jet_pt"] = getJESPt(jet_reco);
  }
  inputValues["EM0"] = EM0;
  inputValues["EM1"] = EM1;
  inputValues["EM2"] = EM2;
  inputValues["EM3"] = EM3;
  inputValues["TILE0"] = Tile0;
  inputValues["TILE1"] = Tile1;
  inputValues["TILE2"] = Tile2;
  inputValues["HEC0"] = HEC0;
  inputValues["HEC1"] = HEC1;
  inputValues["HEC2"] = HEC2;
  inputValues["HEC3"] = HEC3;
  inputValues["FCAL0"] = FCAL0;
  inputValues["FCAL1"] = FCAL1;
  inputValues["FCAL2"] = FCAL2;
  inputValues["jet_Ntrk1000"] = getJetNtrk1000(jet_reco);
  inputValues["jet_ChargedFraction"] = getJetChargedFraction(jet_reco);
  inputValues["jet_Wtrk1000"] = getJetWtrk1000(jet_reco);
  inputValues["jet_DetEta"] = getJetDetEta(jet_reco);
  inputValues["jet_n90Constituents"] = jet_reco.getAttribute<float>("N90Constituents");
  inputValues["jet_nMuSeg"] = jet_reco.getAttribute<int>("GhostMuonSegmentCount");
  inputValues["NPV"] = jetEventInfo.NPV();
  inputValues["averageInteractionsPerCrossing"] = jetEventInfo.mu();
 
  // The actual NN inputs and values
  std::map<std::string,double> NNInputValues;
  for(const TString& input : m_NNInputs){
    NNInputValues[input.Data()] = inputValues[input.Data()];
  }
 
    return NNInputValues;
}

getJetNtrk1000()

int GlobalNNCalibration::getJetNtrk1000 ( const xAOD::Jet &  jet_reco ) const

private

Returns the number of tracks with pT > 1 GeV associated to the jet.

Parameters

jet_reco

The jet

Definition at line 326 of file GlobalNNCalibration.cxx.

                                                                     {
  static const SG::ConstAccessor<std::vector<int> > NumTrkPt1000Acc ("NumTrkPt1000");
  if(NumTrkPt1000Acc.isAvailable(jet_reco))
    return NumTrkPt1000Acc(jet_reco).at(0);
  return -999;
}

getJetWtrk1000()

double GlobalNNCalibration::getJetWtrk1000 ( const xAOD::Jet &  jet_reco ) const

private

Returns the jet width.

Parameters

jet_reco

The jet

Definition at line 333 of file GlobalNNCalibration.cxx.

                                                                        {
  static const SG::ConstAccessor<std::vector<float> > TrackWidthPt1000Acc ("TrackWidthPt1000");
  if(TrackWidthPt1000Acc.isAvailable(jet_reco))
    return double(TrackWidthPt1000Acc(jet_reco).at(0));
  return -999.;
}

getNominalResolutionData()

StatusCode JetCalibrationStep::getNominalResolutionData ( const xAOD::Jet &  , double &    ) const

virtualinherited

Reimplemented in JetSmearingCorrection.

Definition at line 33 of file JetCalibrationStep.cxx.

                                                                                    {
  ATH_MSG_ERROR("Nominal data resolution requested from a jet calibration step that doesn't define it.");
  return StatusCode::FAILURE;
}

getNominalResolutionMC()

StatusCode JetCalibrationStep::getNominalResolutionMC ( const xAOD::Jet &  , double &    ) const

virtualinherited

Reimplemented in JetSmearingCorrection.

Definition at line 38 of file JetCalibrationStep.cxx.

                                                                                  {
  ATH_MSG_ERROR("Nominal MC resolution requested from a jet calibration step that doesn't define it.");
  return StatusCode::FAILURE;
}

getSplineCorr()

double GlobalNNCalibration::getSplineCorr ( const int  etaBin, double  E  ) const

private

Returns the correction from spline histogram, which should be applied after the NN correction.

Parameters

etaBin
E

Definition at line 190 of file GlobalNNCalibration.cxx.

                                                                           {
  if(pT >=  m_ptCorrFactors[ etaBin ]->GetBinLowEdge( m_ptCorrFactors[ etaBin ]->GetNbinsX()+1)){
     pT =  m_ptCorrFactors[ etaBin ]->GetBinLowEdge( m_ptCorrFactors[ etaBin ]->GetNbinsX());
  }
  if(pT < m_JPtS_MinPt_Pt[etaBin]){
    double ptCutoff = m_JPtS_MinPt_Pt[etaBin];
    double Rcutoff = m_JPtS_MinPt_R[etaBin];
    double slope = m_JPtS_MinPt_Slopes[etaBin];
    double R = slope*(pT-ptCutoff)+Rcutoff;
    return R;
  }
 
 
  double R = m_ptCorrFactors[ etaBin ]->Interpolate(pT);
  return R;
}

getSplineSlope()

double GlobalNNCalibration::getSplineSlope ( const int  ieta, const double  minPt  ) const

private

Gets the slope of the spline histogram for a given eta bin, for extrapolation of the calibration.

Parameters

ieta	The eta bin for the spline histogram
minPt	The pT at which the extrapolation starts, and where the slope should be calculated

Definition at line 208 of file GlobalNNCalibration.cxx.

                                                                                   {
  // Don't want to use interpolation here, so instead just use the values at the bin centers near the cutoff
  int minBin = m_ptCorrFactors[ieta]->FindBin(minPt);
 
  double rFirst = m_ptCorrFactors[ ieta ]->GetBinContent(minBin);
  double rSecond = m_ptCorrFactors[ ieta ]->GetBinContent(minBin+1);
  double binWidth = m_ptCorrFactors[ ieta ]->GetBinCenter(minBin+1) - m_ptCorrFactors[ ieta ]->GetBinCenter(minBin);
  double slope = (rSecond - rFirst) / binWidth;
 
  return slope;
}

initialize()

StatusCode GlobalNNCalibration::initialize ( )

overridevirtual

Returns the charged fraction of a jet.

Parameters

name	The name of the tool being created

Implements JetCalibrationStep.

Definition at line 52 of file GlobalNNCalibration.cxx.

                                          {
 
  ATH_MSG_INFO("Initializing tool");
  m_nnEtaBins = JetCalibUtils::VectorizeD( m_config->GetValue("GNNC.EtaBinsForNN","") );
  m_closureEtaBins = JetCalibUtils::VectorizeD( m_config->GetValue("GNNC.EtaBinsForClosure","") );
  m_NNInputs = JetCalibUtils::Vectorize( m_config->GetValue("GNNC.Inputs","") );
  m_doSplineCorr = m_config->GetValue("GNNC.UseSplineCorr", true);
  m_doLogPtScaling = m_config->GetValue("GNNC.UseLogPtScaling", false);
  m_maxNNCorrection = m_config->GetValue("GNNC.MaxNNCorrection", 2.0);
  m_minNNCorrection = m_config->GetValue("GNNC.MinNNCorrection", 0.5);
 
  // This code is copied from the GlobalSequentialCorrection code,
  // so while it is hard-coded, it is consistent with how these filenames are parsed.
  if ( m_jetAlgo.EqualTo("") ) { ATH_MSG_FATAL("No jet algorithm specified. Aborting."); return StatusCode::FAILURE; }
 
  //find the ROOT file containing response histograms, path comes from the config file.
  TString MLGSCFile = m_config->GetValue("GNNC.MLFactorsFile","empty");
  if ( MLGSCFile.EqualTo("empty") ) {
    ATH_MSG_FATAL("NO MLFactorsFile specified. Aborting.");
    return StatusCode::FAILURE;
  }
  if(m_dev){
    MLGSCFile.Remove(0,33);
    MLGSCFile.Insert(0,"JetCalibTools/");
  }
  else{MLGSCFile.Insert(14,m_calibAreaTag);}
 
 
  // Get all of the different NN json files for each eta bin
  for(unsigned int i=0; i<m_nnEtaBins.size()-1; i++){
    TString fileName = PathResolverFindCalibFile(Form("%s_etabin_%d.json", MLGSCFile.Data(), i));
    std::ifstream input(fileName);
    std::unique_ptr<lwt::LightweightGraph> lwnn = std::make_unique<lwt::LightweightGraph> ( lwt::parse_json_graph(input) );
    m_lwnns.push_back(std::move(lwnn));
  }
 
 
 
  // An additional correction on top of the neural network to smooth out fluctuations in the pt response
  if(m_doSplineCorr){
    TString ptCalibHists = m_config->GetValue("GNNC.JPtS_CalibHists","");
    if(m_dev){
      ptCalibHists.Remove(0,33);
      ptCalibHists.Insert(0,"JetCalibTools/");
    }
    else{
      ptCalibHists.Insert(14,m_calibAreaTag);
    }
    TString calibHistFile = PathResolverFindCalibFile(ptCalibHists.Data());
    loadSplineHists(calibHistFile, "etaJes");
    m_JPtS_MinPt_Pt = JetCalibUtils::VectorizeD( m_config->GetValue("GNNC.ptCutoff","") );
    if(m_JPtS_MinPt_Pt.size() != m_closureEtaBins.size()-1){
      ATH_MSG_FATAL("Pt cutoff vector has wrong length. There should be one value per eta bin."); return StatusCode::FAILURE;
      return StatusCode::FAILURE;
    }
 
    for (uint ieta=0;ieta<m_closureEtaBins.size()-1;++ieta) {
      //Calculate the slope of the response curve at the minPt for each eta bin
      //Used in the GetLowPtJPtS method when Pt < minPt
      const double Rcutoff = getSplineCorr(ieta, m_JPtS_MinPt_Pt[ieta]);
      const double Slope = getSplineSlope(ieta, m_JPtS_MinPt_Pt[ieta]);
      if(Slope > Rcutoff/m_JPtS_MinPt_Pt[ieta]) ATH_MSG_WARNING("Slope of calibration curve at minimum ET is too steep for the JPtS factors of etabin " << ieta << ", eta = " << m_closureEtaBins[ieta] );
 
      m_JPtS_MinPt_R.push_back(Rcutoff);
      m_JPtS_MinPt_Slopes.push_back(Slope);
    }
  }
 
 
  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;
}

loadSplineHists()

void GlobalNNCalibration::loadSplineHists ( const TString &  fileName, const std::string &  etajes_name = "etaJes"  )

private

Reads the spline histograms from the file given in the config, and stores them in m_ptCorrFactors.

Loads the calib constants from histograms in TFile named fileName.

Parameters

fileName
etajes_name

Definition at line 164 of file GlobalNNCalibration.cxx.

                                                                                                {
  std::unique_ptr<TFile> tmpF(TFile::Open( fileName ));
  TList *ptCorr_l = dynamic_cast<TList*>( tmpF->Get(ptCorr_name.c_str()));
  if (not ptCorr_l){
    ATH_MSG_ERROR("TList pointer is null in GlobalNNCalibration::loadSplineHists");
    tmpF->Close();
    return;
  }
  m_ptCorrFactors.resize( ptCorr_l->GetSize() );
  int nBinsCorr = ptCorr_l->GetSize();
  int nEtaBins = m_closureEtaBins.size()-1;
  if(nBinsCorr != nEtaBins){
    ATH_MSG_WARNING("Do not have the correct number of eta bins for " << fileName << "\t" << ptCorr_name << "\t" << ptCorr_l->GetSize() );
  }
 
  for(unsigned int i=0 ; i<m_closureEtaBins.size()-1; i++){
    auto *pTH1 = dynamic_cast<TH1*>(ptCorr_l->At(i));
    if (not pTH1) continue;
    m_ptCorrFactors[i].reset(pTH1);
    m_ptCorrFactors[i]->SetDirectory(nullptr);
  }
  tmpF->Close();
}

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
   }

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.

{ 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_calibAreaTag

std::string GlobalNNCalibration::m_calibAreaTag

private

Definition at line 156 of file GlobalNNCalibration.h.

m_closureEtaBins

std::vector<double> GlobalNNCalibration::m_closureEtaBins

private

Definition at line 150 of file GlobalNNCalibration.h.

m_config

TEnv* GlobalNNCalibration::m_config {}

private

Definition at line 154 of file GlobalNNCalibration.h.

m_dev

bool GlobalNNCalibration::m_dev {}

private

Definition at line 157 of file GlobalNNCalibration.h.

m_doLogPtScaling

bool GlobalNNCalibration::m_doLogPtScaling {}

private

Definition at line 159 of file GlobalNNCalibration.h.

m_doSplineCorr

bool GlobalNNCalibration::m_doSplineCorr {true}

private

Definition at line 158 of file GlobalNNCalibration.h.

m_GeV

double JetCalibrationStep::m_GeV

protectedinherited

Definition at line 40 of file JetCalibrationStep.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_jetAlgo

TString GlobalNNCalibration::m_jetAlgo

private

Definition at line 155 of file GlobalNNCalibration.h.

m_jetStartScale

std::string JetCalibrationStep::m_jetStartScale

protectedinherited

Definition at line 41 of file JetCalibrationStep.h.

m_JPtS_MinPt_Pt

std::vector<double> GlobalNNCalibration::m_JPtS_MinPt_Pt

private

Definition at line 164 of file GlobalNNCalibration.h.

m_JPtS_MinPt_R

std::vector<double> GlobalNNCalibration::m_JPtS_MinPt_R

private

Definition at line 165 of file GlobalNNCalibration.h.

m_JPtS_MinPt_Slopes

std::vector<double> GlobalNNCalibration::m_JPtS_MinPt_Slopes

private

Definition at line 163 of file GlobalNNCalibration.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_lwnns

std::vector<std::unique_ptr<lwt::LightweightGraph> > GlobalNNCalibration::m_lwnns

private

Definition at line 147 of file GlobalNNCalibration.h.

m_maxNNCorrection

double GlobalNNCalibration::m_maxNNCorrection {}

private

Definition at line 161 of file GlobalNNCalibration.h.

m_minNNCorrection

double GlobalNNCalibration::m_minNNCorrection {}

private

Definition at line 160 of file GlobalNNCalibration.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_nnEtaBins

std::vector<double> GlobalNNCalibration::m_nnEtaBins

private

Definition at line 149 of file GlobalNNCalibration.h.

m_NNInputs

std::vector<TString> GlobalNNCalibration::m_NNInputs

private

Definition at line 151 of file GlobalNNCalibration.h.

m_ptCorrFactors

std::vector<std::unique_ptr<TH1> > GlobalNNCalibration::m_ptCorrFactors

private

Definition at line 148 of file GlobalNNCalibration.h.

---

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

• GlobalNNCalibration.h
• GlobalNNCalibration.cxx