#include <InsituDataCorrection.h>

Inheritance diagram for InsituDataCorrection:

Collaboration diagram for InsituDataCorrection:

Public Member Functions
	InsituDataCorrection ()
	InsituDataCorrection (const std::string &name, TEnv *config, TString jetAlgo, TString calibAreaTag, bool dev, unsigned int firstRun=0, unsigned int lastRun=0)
virtual	~InsituDataCorrection ()
virtual StatusCode	initialize () override
virtual StatusCode	calibrate (xAOD::Jet &jet, JetEventInfo &jetEventInfo) const override
double	getRelHistoPtMax ()
double	getAbsHistoPtMax ()
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.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

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

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

Private Member Functions
double	getInsituCorr (double pt, double eta, const std::string &calibstep) const
double	getInsituCorr_JMS (double pt, double mass, double eta, const std::string &calibstep, bool isTAmass) const
std::unique_ptr< const TH2 >	combineCalibration (const TH2 h2d, const TH1 h)
std::unique_ptr< const TH2 >	invertHistogram (const TH2 *h2d)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
TEnv *	m_config {}
TString	m_jetAlgo
TString	m_calibAreaTag
bool	m_dev {}
std::unique_ptr< const TH2 >	m_insituCorr
std::unique_ptr< const TH2 >	m_insituCorr_JMS
std::unique_ptr< const TH2 >	m_insituCorr_JMS_TA
double	m_insituEtaMax {}
double	m_insituPtMin {}
double	m_insituPtMax {}
double	m_insituEtaMax_JMS {}
double	m_insituPtMin_JMS {}
double	m_insituPtMax_JMS {}
double	m_insituMassMin_JMS {}
double	m_insituMassMax_JMS {}
double	m_relhistoPtMax {}
double	m_abshistoPtMax {}
std::unique_ptr< const TH2 >	m_insituCorr_ResidualMCbased
double	m_insituEtaMax_ResidualMCbased {}
double	m_insituPtMin_ResidualMCbased {}
double	m_insituPtMax_ResidualMCbased {}
bool	m_applyRelativeandAbsoluteInsitu {}
bool	m_applyEtaRestrictionRelativeandAbsolute {}
bool	m_applyResidualMCbasedInsitu {}
bool	m_applyEtaRestrictionResidualMCbased {}
bool	m_applyInsituCaloTAjets {}
bool	m_applyInsituJMS {}
unsigned int	m_firstRun {}
unsigned int	m_lastRun {}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 24 of file InsituDataCorrection.h.

Constructor & Destructor Documentation

◆ InsituDataCorrection() [1/2]

InsituDataCorrection::InsituDataCorrection ( )

Definition at line 16 of file InsituDataCorrection.cxx.

  : JetCalibrationStep::JetCalibrationStep(),
    m_config(nullptr),
    m_jetAlgo(""),
    m_calibAreaTag(""),
    m_dev(false),
    m_insituCorr(nullptr),
    m_insituCorr_JMS(nullptr),
    m_insituCorr_ResidualMCbased(nullptr),
    m_firstRun(0),
    m_lastRun(0)
{ }

◆ InsituDataCorrection() [2/2]

InsituDataCorrection::InsituDataCorrection	(	const std::string &	name,
		TEnv *	config,
		TString	jetAlgo,
		TString	calibAreaTag,
		bool	dev,
		unsigned int	firstRun = 0,
		unsigned int	lastRun = 0 )

Definition at line 29 of file InsituDataCorrection.cxx.

  : JetCalibrationStep::JetCalibrationStep(name.c_str()),
    m_config(config),
    m_jetAlgo(std::move(jetAlgo)),
    m_calibAreaTag(std::move(calibAreaTag)),
    m_dev(dev),
    m_insituCorr(nullptr),
    m_insituCorr_JMS(nullptr),
    m_insituCorr_ResidualMCbased(nullptr),
    m_firstRun(firstRun),
    m_lastRun(lastRun)
{ }

◆ ~InsituDataCorrection()

InsituDataCorrection::~InsituDataCorrection ( )

virtualdefault

Member Function Documentation

◆ calibrate()

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

overridevirtual

Implements JetCalibrationStep.

Definition at line 209 of file InsituDataCorrection.cxx.

                                                                                         {
 
  //If this is a time-dependent calibration and we're not on a relevant run, don't calibrate.
  unsigned int runNumber = static_cast<unsigned int>(jetEventInfo.runNumber()+0.5);
  if(m_lastRun > 0 && (runNumber < m_firstRun || runNumber > m_lastRun))
    return StatusCode::SUCCESS;
 
  float detectorEta = jet.getAttribute<float>("DetectorEta");
 
  // For small R jets or large-R jets without calo-TA combination
  if(!m_applyInsituCaloTAjets){
    xAOD::JetFourMom_t jetStartP4;
    ATH_CHECK( setStartP4(jet) );
    jetStartP4 = jet.jetP4();
 
    xAOD::JetFourMom_t calibP4=jetStartP4;
  
    if(m_applyResidualMCbasedInsitu) calibP4=calibP4*getInsituCorr( calibP4.pt(), fabs(detectorEta), "ResidualMCbased" );
    
    if(m_dev){
      float insituFactor = getInsituCorr( jetStartP4.pt(), detectorEta, "RelativeAbs" );
      jet.setAttribute<float>("JetRelativeAbsInsituCalibFactor",insituFactor);
    }
 
    if(m_applyRelativeandAbsoluteInsitu) calibP4=calibP4*getInsituCorr( jetStartP4.pt(), detectorEta, "RelativeAbs" );
 
    // Only for large R jets with insitu JMS but no combination
    if(m_applyInsituJMS){
      xAOD::JetFourMom_t calibP4_JMS;
      calibP4_JMS = calibP4;
 
      calibP4_JMS=calibP4*getInsituCorr_JMS( calibP4.pt(), calibP4.M(), detectorEta, "RelativeAbs", false );
 
      // pT doesn't change while applying in situ JMS
      TLorentzVector TLVjet;
      TLVjet.SetPtEtaPhiM( calibP4.pt(), calibP4.eta(), calibP4.phi(), calibP4_JMS.M() );
      calibP4.SetPxPyPzE( TLVjet.Px(), TLVjet.Py(), TLVjet.Pz(), TLVjet.E() );
    }
 
    //Transfer calibrated jet properties to the Jet object
    jet.setAttribute<xAOD::JetFourMom_t>("JetInsituScaleMomentum",calibP4);
    jet.setJetP4( calibP4 );
  }
 
  // For large-R jets: insitu needs to be applied to calo mass and TA mass (by default it's only applied to combined mass)
  if(m_applyInsituCaloTAjets){
 
    // calo mass calibrated jets
    xAOD::JetFourMom_t jetStartP4_calo;
    xAOD::JetFourMom_t calibP4_calo;
    if(jet.getAttribute<xAOD::JetFourMom_t>("JetJMSScaleMomentumCalo",jetStartP4_calo)){
      calibP4_calo=jetStartP4_calo;
    }else{
      ATH_MSG_FATAL( "Cannot retrieve JetJMSScaleMomentumCalo jets" );
      return StatusCode::FAILURE;
    }
 
    if(m_applyResidualMCbasedInsitu) calibP4_calo=calibP4_calo*getInsituCorr( calibP4_calo.pt(), fabs(detectorEta), "ResidualMCbased" );
 
    if(m_dev){
      float insituFactor_calo = getInsituCorr( jetStartP4_calo.pt(), detectorEta, "RelativeAbs" );
      jet.setAttribute<float>("JetRelativeAbsInsituCalibFactor_calo",insituFactor_calo);
    }
 
    if(m_applyRelativeandAbsoluteInsitu) calibP4_calo=calibP4_calo*getInsituCorr( jetStartP4_calo.pt(), detectorEta, "RelativeAbs" );
 
    if(m_applyInsituJMS){
      xAOD::JetFourMom_t calibP4_calo_JMS;
      calibP4_calo_JMS = calibP4_calo;
 
      calibP4_calo_JMS=calibP4_calo*getInsituCorr_JMS( calibP4_calo.pt(), calibP4_calo.M(), detectorEta, "RelativeAbs", false );
 
      // pT doesn't change while applying in situ JMS
      TLorentzVector TLVjet_calo;
      TLVjet_calo.SetPtEtaPhiM( calibP4_calo.pt(), calibP4_calo.eta(), calibP4_calo.phi(), calibP4_calo_JMS.M() );
      calibP4_calo.SetPxPyPzE( TLVjet_calo.Px(), TLVjet_calo.Py(), TLVjet_calo.Pz(), TLVjet_calo.E() );
    }
 
    //Transfer calibrated jet properties to the Jet object
    jet.setAttribute<xAOD::JetFourMom_t>("JetInsituScaleMomentumCalo",calibP4_calo);
    jet.setJetP4( calibP4_calo );
 
    // TA mass calibrated jets
    xAOD::JetFourMom_t jetStartP4_ta;
    xAOD::JetFourMom_t calibP4_ta;
    if(jet.getAttribute<xAOD::JetFourMom_t>("JetJMSScaleMomentumTA", jetStartP4_ta)){
      calibP4_ta=jetStartP4_ta;
    }else{
      ATH_MSG_FATAL( "Cannot retrieve JetJMSScaleMomentumTA jets" );
      return StatusCode::FAILURE;
    }
 
    if(m_applyResidualMCbasedInsitu) calibP4_ta=calibP4_ta*getInsituCorr( calibP4_ta.pt(), fabs(detectorEta), "ResidualMCbased" );
 
    if(m_dev){
      float insituFactor_ta = getInsituCorr( jetStartP4_ta.pt(), detectorEta, "RelativeAbs" );
      jet.setAttribute<float>("JetRelativeAbsInsituCalibFactor_ta",insituFactor_ta);
    }
 
    if(m_applyRelativeandAbsoluteInsitu) calibP4_ta=calibP4_ta*getInsituCorr( jetStartP4_ta.pt(), detectorEta, "RelativeAbs" );
 
    if(m_applyInsituJMS){
      xAOD::JetFourMom_t calibP4_ta_JMS;
      calibP4_ta_JMS = calibP4_ta;
 
      calibP4_ta_JMS=calibP4_ta*getInsituCorr_JMS( calibP4_ta.pt(), calibP4_ta.M(), detectorEta, "RelativeAbs", true );
 
      // pT doesn't change while applying in situ JMS
      TLorentzVector TLVjet_ta;
      TLVjet_ta.SetPtEtaPhiM( calibP4_ta.pt(), calibP4_ta.eta(), calibP4_ta.phi(), calibP4_ta_JMS.M() );
      calibP4_ta.SetPxPyPzE( TLVjet_ta.Px(), TLVjet_ta.Py(), TLVjet_ta.Pz(), TLVjet_ta.E() );
    }
 
    //Transfer calibrated jet properties to the Jet object
    jet.setAttribute<xAOD::JetFourMom_t>("JetInsituScaleMomentumTA",calibP4_ta);
    jet.setJetP4( calibP4_ta );
 
  }
 
  return StatusCode::SUCCESS;
}

◆ combineCalibration()

std::unique_ptr< const TH2 > InsituDataCorrection::combineCalibration	(	const TH2 *	h2d,
		const TH1 *	h )

private

Definition at line 407 of file InsituDataCorrection.cxx.

                                                                                              {
  std::unique_ptr<TH2> prod(static_cast<TH2*>(h2d->Clone()));
  for (int xi=1;xi<=prod->GetNbinsX();xi++) {
    double pt=prod->GetXaxis()->GetBinCenter(xi);
    const double R_abs=h->Interpolate(pt); // Rdata/RMC for the absolute scale
    const double inv_R_abs = 1. / R_abs;
    //printf("pT = %7.1f GeV, abs calib: %.4f\n",pt,abs);
    for (int yi=1;yi<=prod->GetNbinsY();yi++) {
      double c_rel = h2d->GetBinContent(xi,yi); // 1/Rrel = RMC/Rdata
      prod->SetBinContent(xi,yi,c_rel*inv_R_abs);
    }
  }
  return prod;
}

◆ getAbsHistoPtMax()

double InsituDataCorrection::getAbsHistoPtMax ( )

inline

Definition at line 39 of file InsituDataCorrection.h.

39{return m_abshistoPtMax;}

InsituDataCorrection::m_abshistoPtMax

double m_abshistoPtMax

Definition InsituDataCorrection.h:56

◆ getInsituCorr()

double InsituDataCorrection::getInsituCorr	(	double	pt,
		double	eta,
		const std::string &	calibstep ) const

private

Definition at line 331 of file InsituDataCorrection.cxx.

                                                                                                  {
  if (m_insituCorr==nullptr && m_insituCorr_ResidualMCbased==nullptr) return 1.0;
  double myEta = eta, myPt = pt/m_GeV;
 
  //eta and pt ranges depends on the insitu calibration
  double etaMax = m_insituEtaMax;
  double ptMin  = m_insituPtMin;
  double ptMax  = m_insituPtMax;
  if (calibstep == "ResidualMCbased"){
    etaMax = m_insituEtaMax_ResidualMCbased;
    ptMin  = m_insituPtMin_ResidualMCbased;
    ptMax  = m_insituPtMax_ResidualMCbased;
  }
 
  //protection against values outside the histogram range, snap back to the lowest/highest bin edge
  if ( myPt <= ptMin ) myPt = ptMin + 1e-6;
  else if ( myPt >= ptMax ) myPt = ptMax - 1e-6;
  if (calibstep == "ResidualMCbased" && m_applyEtaRestrictionResidualMCbased) {
    if(myEta>=etaMax) return 1.0;
    return m_insituCorr_ResidualMCbased? (m_insituCorr_ResidualMCbased->Interpolate(myPt,myEta)) : 1.0;
  }
  if (calibstep == "RelativeAbs" && m_applyEtaRestrictionRelativeandAbsolute) {
    if(myEta>=etaMax) return 1.0;
    else if(myEta<=-etaMax) return 1.0;
  }
  if (myEta <= -etaMax) myEta = 1e-6 - etaMax;
  else if (myEta >= etaMax) myEta = etaMax - 1e-6;
  if (calibstep == "ResidualMCbased" && !m_applyEtaRestrictionResidualMCbased){
    return m_insituCorr_ResidualMCbased? (m_insituCorr_ResidualMCbased->Interpolate(myPt,myEta)) : 1.0;
  }
  return m_insituCorr? (m_insituCorr->Interpolate(myPt,myEta)):1.0;
}

◆ getInsituCorr_JMS()

double InsituDataCorrection::getInsituCorr_JMS	(	double	pt,
		double	mass,
		double	eta,
		const std::string &	calibstep,
		bool	isTAmass ) const

private

Definition at line 364 of file InsituDataCorrection.cxx.

                                                                                                                                  {
 
  if(!isTAmass){
    if (!m_insituCorr_JMS) return 1.0;
  }
  else{
    if (!m_insituCorr_JMS_TA) return 1.0;
  }
 
  double myEta = eta, myPt = pt/m_GeV, myMass = mass/m_GeV;
 
  //eta and pt ranges depends on the insitu calibration
  double etaMax  = m_insituEtaMax_JMS;
  double ptMin   = m_insituPtMin_JMS;
  double ptMax   = m_insituPtMax_JMS;
  double massMin = m_insituMassMin_JMS;
  double massMax = m_insituMassMax_JMS;
 
  //protection against values outside the histogram range, snap back to the lowest/highest bin edge
  if ( myPt <= ptMin ) myPt = ptMin + 1e-6;
  else if ( myPt >= ptMax ) myPt = ptMax - 1e-6;
  if (calibstep == "RelativeAbs" && m_applyEtaRestrictionRelativeandAbsolute) {
    if(myEta>=etaMax) return 1.0;
    else if(myEta<=-etaMax) return 1.0;
  }
  if (myEta <= -etaMax) myEta = 1e-6 - etaMax;
  else if (myEta >= etaMax) myEta = etaMax - 1e-6;
  if (myMass <= massMin ) myMass = massMin + 1e-6;
  else if (myMass >= massMax ) myMass = massMax - 1e-6;
 
  double calibFactor = 1.0;
  if(!isTAmass){
    calibFactor = m_insituCorr_JMS->Interpolate(myPt,myMass);
  }
  else{
    calibFactor = m_insituCorr_JMS_TA->Interpolate(myPt,myMass);
  }
 
  return calibFactor;
}

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

◆ getRelHistoPtMax()

double InsituDataCorrection::getRelHistoPtMax ( )

inline

Definition at line 38 of file InsituDataCorrection.h.

38{return m_relhistoPtMax;}

InsituDataCorrection::m_relhistoPtMax

double m_relhistoPtMax

Definition InsituDataCorrection.h:56

◆ initialize()

StatusCode InsituDataCorrection::initialize ( )

overridevirtual

Implements JetCalibrationStep.

Definition at line 44 of file InsituDataCorrection.cxx.

                                            {
 
  ATH_MSG_INFO("Initializing In Situ correction.");
 
  if(!m_config){
    ATH_MSG_ERROR("In Situ data correction tool received a null config pointer.");
    return StatusCode::FAILURE;
  }
 
  m_jetStartScale = m_config->GetValue("InsituStartingScale","JetGSCScaleMomentum");
 
  //Retrieve the name of root file containing the in-situ calibration histograms from the config
  TString insitu_filename = m_config->GetValue("InsituCalibrationFile","None");
  //Should be the Relative and Abosolute Insitu correction applied?
  m_applyRelativeandAbsoluteInsitu = m_config->GetValue("ApplyRelativeandAbsoluteInsitu", true);
  //Should be a Eta restriction in the Relative and Absolute Insitu correction?
  m_applyEtaRestrictionRelativeandAbsolute = m_config->GetValue("ApplyEtaRestrictionRelativeandAbsolute", false);
  //Should be applied the Residual MC based Insitu correction?
  m_applyResidualMCbasedInsitu = m_config->GetValue("ApplyResidualMCbasedInsitu", false);
  //Should be a Eta restriction in the Residual MC based Insitu correction?
  m_applyEtaRestrictionResidualMCbased = m_config->GetValue("ApplyEtaRestrictionResidualMCbased", false);
  //Retrieve the name of the histogram for the relative in-situ calibration
  TString rel_histoname = m_config->GetValue("RelativeInsituCalibrationHistogram","");
  //Retrieve the name of the histogram for the absolute in-situ calibration 
  TString abs_histoname = m_config->GetValue("AbsoluteInsituCalibrationHistogram","");
  //Retrieve the name of the histogram for the absolute in-situ calibration 
  TString residualmcbased_histoname = m_config->GetValue("ResidualMCbasedInsituCalibrationHistogram","");
  //Retrieve the description/name of the in-situ calibration
  TString insitu_desc = m_config->GetValue("InsituCalibrationDescription","");
  //Retrieve the Eta restriction on the Residual MC based insitu calibration
  double insitu_etarestriction_residualmcbased = m_config->GetValue("InsituEtaRestrictionResidualMCbased",0.8);
  //Retrieve the Eta restriction on the Relative and Absolute insitu calibration
  double insitu_etarestriction_relativeandabsolute = m_config->GetValue("InsituEtaRestrictionRelativeandAbsolute",0.8);
  // Apply Insitu only to calo and TA mass calibrated jets (only for large jets)
  m_applyInsituCaloTAjets = m_config->GetValue("ApplyInsituCaloTAJets", false);
  // Apply in situ JMS:
  m_applyInsituJMS = m_config->GetValue("ApplyInsituJMS", false);
 
  //Find the absolute path to the insitu root file
  if ( !insitu_filename.EqualTo("None") ){
    if(m_dev){
      insitu_filename.Remove(0,32);
      insitu_filename.Insert(0,"JetCalibTools/");
    }
    else{insitu_filename.Insert(14,m_calibAreaTag);}
    insitu_filename=PathResolverFindCalibFile(insitu_filename.Data());
  }
 
  std::unique_ptr<TFile> insitu_file(TFile::Open(insitu_filename));
  if ( !insitu_file ) { ATH_MSG_FATAL( "Cannot open InsituCalibrationFile: " << insitu_filename ); return StatusCode::FAILURE; }
 
  ATH_MSG_INFO("Reading In-situ correction factors from: " << insitu_filename);
 
  rel_histoname.ReplaceAll("JETALGO",m_jetAlgo); abs_histoname.ReplaceAll("JETALGO",m_jetAlgo);
  if(m_applyRelativeandAbsoluteInsitu){
    std::unique_ptr<const TH2> rel_histo(JetCalibUtils::GetHisto2(*insitu_file,rel_histoname));
    std::unique_ptr<const TH1> abs_histo(JetCalibUtils::GetHisto(*insitu_file,abs_histoname));
    if ( !rel_histo || !abs_histo ) {
      ATH_MSG_FATAL( "\n  Tool configured for data, but no residual in-situ histograms could be retrieved. Aborting..." );
      return StatusCode::FAILURE;
    }
    gROOT->cd();
    // save pTmax of the relative and absolute in situ calibrations
    m_relhistoPtMax = rel_histo->GetXaxis()->GetBinLowEdge(rel_histo->GetNbinsX()+1);
    m_abshistoPtMax = abs_histo->GetBinLowEdge(abs_histo->GetNbinsX()+1);
    // combine in situ calibrations
    m_insituCorr = combineCalibration(rel_histo.get(),abs_histo.get());
    m_insituEtaMax = m_insituCorr->GetYaxis()->GetBinLowEdge(m_insituCorr->GetNbinsY()+1);
    m_insituPtMin = m_insituCorr->GetXaxis()->GetBinLowEdge(1);
    m_insituPtMax = m_insituCorr->GetXaxis()->GetBinLowEdge(m_insituCorr->GetNbinsX()+1);
    if(m_applyEtaRestrictionRelativeandAbsolute) m_insituEtaMax = insitu_etarestriction_relativeandabsolute;
  }
  if(m_applyResidualMCbasedInsitu){
    m_insituCorr_ResidualMCbased = JetCalibUtils::GetHisto2(*insitu_file,residualmcbased_histoname);
    if ( !m_insituCorr_ResidualMCbased ) {
      ATH_MSG_FATAL( "\n  Tool configured for the Residual MC based correction, but no residualmcbased in-situ histograms could be retrieved. Aborting..." );
      return StatusCode::FAILURE;
    }
    else{
      gROOT->cd();
      m_insituEtaMax_ResidualMCbased = m_insituCorr_ResidualMCbased->GetYaxis()->GetBinLowEdge(m_insituCorr_ResidualMCbased->GetNbinsY()+1);
      m_insituPtMin_ResidualMCbased = m_insituCorr_ResidualMCbased->GetXaxis()->GetBinLowEdge(1);
      m_insituPtMax_ResidualMCbased = m_insituCorr_ResidualMCbased->GetXaxis()->GetBinLowEdge(m_insituCorr_ResidualMCbased->GetNbinsX()+1);
    }
    if(m_applyEtaRestrictionResidualMCbased) m_insituEtaMax_ResidualMCbased = insitu_etarestriction_residualmcbased;
  }
  if(!m_applyRelativeandAbsoluteInsitu && !m_applyResidualMCbasedInsitu){
    ATH_MSG_FATAL( "\n  Tool configured for Insitu correction, but no in-situ histograms could be retrieved. Aborting..." );
    return StatusCode::FAILURE;
  }
 
  //Large-R in situ JMS calibration  
  if(m_applyInsituJMS){
    //Retrieve the name of root files containing the in-situ calibration histograms from the config
    TString insituJMS_filename = m_config->GetValue("InsituCalibrationFile_JMS","None");
    //Retrieve the name of the histogram for the absolute in-situ calibration
    TString abs_histoname_JMS = m_config->GetValue("AbsoluteInsituCalibrationHistogram_JMS","");
    TString abs_histoname_JMS_TA = m_config->GetValue("AbsoluteInsituCalibrationHistogram_JMS_TA","");
    //Retrieve the eta range for the in-situ JMS calibration
    double insitu_etarestriction_JMS = m_config->GetValue("InsituEtaRestriction_JMS",2.0);
 
    //Find the absolute path to the insitu root file Low and High Mass
    if ( !insituJMS_filename.EqualTo("None")){
      if(m_dev){
        insituJMS_filename.Remove(0,32);
        insituJMS_filename.Insert(0,"JetCalibTools/");
      }
      else{
        insituJMS_filename.Insert(14,m_calibAreaTag);
      }
      insituJMS_filename=PathResolverFindCalibFile(insituJMS_filename.Data());
    }
 
    std::unique_ptr<TFile> insituJMS_file(TFile::Open(insituJMS_filename));
    if ( !insituJMS_file ) { ATH_MSG_FATAL( "Cannot open InsituJMSCalibrationFile: " << insituJMS_filename ); return StatusCode::FAILURE; }
 
    ATH_MSG_INFO("Reading In-situ JMS correction factors from: " << insituJMS_filename);
 
    abs_histoname_JMS.ReplaceAll("JETALGO",m_jetAlgo);
    if(m_applyInsituCaloTAjets){
      abs_histoname_JMS_TA.ReplaceAll("JETALGO",m_jetAlgo);
    }
 
    if(m_applyRelativeandAbsoluteInsitu){
      std::unique_ptr<const TH2> abs_histo_JMS(JetCalibUtils::GetHisto2(*insituJMS_file,abs_histoname_JMS));
      if ( !abs_histo_JMS ) {
        ATH_MSG_FATAL( "\n  Tool configured for data, but no in-situ JMS histogram could be retrieved. Aborting..." );
        return StatusCode::FAILURE;
      }
      else {
        gROOT->cd();
        // combine in situ calibrations
        m_insituCorr_JMS    = invertHistogram(abs_histo_JMS.get());
        m_insituEtaMax_JMS  = insitu_etarestriction_JMS;
        m_insituPtMin_JMS   = m_insituCorr_JMS->GetXaxis()->GetBinLowEdge(1);
        m_insituPtMax_JMS   = m_insituCorr_JMS->GetXaxis()->GetBinLowEdge(m_insituCorr_JMS->GetNbinsX()+1);
        m_insituMassMin_JMS = m_insituCorr_JMS->GetYaxis()->GetBinLowEdge(1);
        m_insituMassMax_JMS = m_insituCorr_JMS->GetYaxis()->GetBinLowEdge((m_insituCorr_JMS->GetNbinsY()+1));
 
        if(m_applyInsituCaloTAjets){
 
          std::unique_ptr<const TH2> abs_histo_JMS_TA(JetCalibUtils::GetHisto2(*insituJMS_file,abs_histoname_JMS_TA));
 
          if ( !abs_histo_JMS_TA ){
            ATH_MSG_FATAL( "\n  Tool configured for data, but no in-situ JMS histogram for TA mass could be retrieved. Aborting..." );
            return StatusCode::FAILURE;
          }
 
          gROOT->cd();
          m_insituCorr_JMS_TA = invertHistogram(abs_histo_JMS_TA.get());
        }
      }
    }
    if(!m_applyRelativeandAbsoluteInsitu){
      ATH_MSG_FATAL( "\n  Tool configured for Insitu correction, but no in-situ histograms could be retrieved. Aborting..." );
      return StatusCode::FAILURE;
    }
  }
 
  ATH_MSG_INFO("Tool configured to calibrate data");
  ATH_MSG_INFO("In-situ correction to be applied: " << insitu_desc);
  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();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ invertHistogram()

std::unique_ptr< const TH2 > InsituDataCorrection::invertHistogram ( const TH2 * h2d )

private

Definition at line 422 of file InsituDataCorrection.cxx.

                                                                            {
  std::unique_ptr<TH2> inv(static_cast<TH2*>(h2d->Clone()));
  for (int xi=1;xi<=inv->GetNbinsX();xi++) {
    for (int yi=1;yi<=inv->GetNbinsY();yi++) {
      inv->SetBinContent(xi,yi,1./h2d->GetBinContent(xi,yi));
 
    }
  }
  return inv;
}

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

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_abshistoPtMax

double InsituDataCorrection::m_abshistoPtMax {}

private

Definition at line 56 of file InsituDataCorrection.h.

56{}, m_abshistoPtMax{};

◆ m_applyEtaRestrictionRelativeandAbsolute

bool InsituDataCorrection::m_applyEtaRestrictionRelativeandAbsolute {}

private

Definition at line 61 of file InsituDataCorrection.h.

61{};

◆ m_applyEtaRestrictionResidualMCbased

bool InsituDataCorrection::m_applyEtaRestrictionResidualMCbased {}

private

Definition at line 64 of file InsituDataCorrection.h.

64{};

◆ m_applyInsituCaloTAjets

bool InsituDataCorrection::m_applyInsituCaloTAjets {}

private

Definition at line 66 of file InsituDataCorrection.h.

66{};

◆ m_applyInsituJMS

bool InsituDataCorrection::m_applyInsituJMS {}

private

Definition at line 67 of file InsituDataCorrection.h.

67{};

◆ m_applyRelativeandAbsoluteInsitu

bool InsituDataCorrection::m_applyRelativeandAbsoluteInsitu {}

private

Definition at line 60 of file InsituDataCorrection.h.

60{};

◆ m_applyResidualMCbasedInsitu

bool InsituDataCorrection::m_applyResidualMCbasedInsitu {}

private

Definition at line 63 of file InsituDataCorrection.h.

63{};

◆ m_calibAreaTag

TString InsituDataCorrection::m_calibAreaTag

private

Definition at line 49 of file InsituDataCorrection.h.

◆ m_config

TEnv* InsituDataCorrection::m_config {}

private

Definition at line 48 of file InsituDataCorrection.h.

48{};

◆ m_dev

bool InsituDataCorrection::m_dev {}

private

Definition at line 50 of file InsituDataCorrection.h.

50{};

◆ m_firstRun

unsigned int InsituDataCorrection::m_firstRun {}

private

Definition at line 69 of file InsituDataCorrection.h.

69{};

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

135{ nullptr };

◆ m_insituCorr

std::unique_ptr<const TH2> InsituDataCorrection::m_insituCorr

private

Definition at line 52 of file InsituDataCorrection.h.

◆ m_insituCorr_JMS

std::unique_ptr<const TH2> InsituDataCorrection::m_insituCorr_JMS

private

Definition at line 53 of file InsituDataCorrection.h.

◆ m_insituCorr_JMS_TA

std::unique_ptr<const TH2> InsituDataCorrection::m_insituCorr_JMS_TA

private

Definition at line 54 of file InsituDataCorrection.h.

◆ m_insituCorr_ResidualMCbased

std::unique_ptr<const TH2> InsituDataCorrection::m_insituCorr_ResidualMCbased

private

Definition at line 57 of file InsituDataCorrection.h.

◆ m_insituEtaMax

double InsituDataCorrection::m_insituEtaMax {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituEtaMax_JMS

double InsituDataCorrection::m_insituEtaMax_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituEtaMax_ResidualMCbased

double InsituDataCorrection::m_insituEtaMax_ResidualMCbased {}

private

Definition at line 58 of file InsituDataCorrection.h.

58{}, m_insituPtMin_ResidualMCbased{}, m_insituPtMax_ResidualMCbased{};

◆ m_insituMassMax_JMS

double InsituDataCorrection::m_insituMassMax_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituMassMin_JMS

double InsituDataCorrection::m_insituMassMin_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituPtMax

double InsituDataCorrection::m_insituPtMax {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituPtMax_JMS

double InsituDataCorrection::m_insituPtMax_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituPtMax_ResidualMCbased

double InsituDataCorrection::m_insituPtMax_ResidualMCbased {}

private

Definition at line 58 of file InsituDataCorrection.h.

58{}, m_insituPtMin_ResidualMCbased{}, m_insituPtMax_ResidualMCbased{};

◆ m_insituPtMin

double InsituDataCorrection::m_insituPtMin {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituPtMin_JMS

double InsituDataCorrection::m_insituPtMin_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

55{}, m_insituPtMin{}, m_insituPtMax{}, m_insituEtaMax_JMS{}, m_insituPtMin_JMS{}, m_insituPtMax_JMS{}, m_insituMassMin_JMS{}, m_insituMassMax_JMS{};

◆ m_insituPtMin_ResidualMCbased

double InsituDataCorrection::m_insituPtMin_ResidualMCbased {}

private

Definition at line 58 of file InsituDataCorrection.h.

58{}, m_insituPtMin_ResidualMCbased{}, m_insituPtMax_ResidualMCbased{};

◆ m_jetAlgo

TString InsituDataCorrection::m_jetAlgo

private

Definition at line 49 of file InsituDataCorrection.h.

◆ m_jetStartScale

std::string JetCalibrationStep::m_jetStartScale

protectedinherited

Definition at line 41 of file JetCalibrationStep.h.

◆ m_lastRun

unsigned int InsituDataCorrection::m_lastRun {}

private

Definition at line 70 of file InsituDataCorrection.h.

70{};

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

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

double InsituDataCorrection::m_relhistoPtMax {}

private

Definition at line 56 of file InsituDataCorrection.h.

56{}, m_abshistoPtMax{};

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

◆ InsituDataCorrection() [1/2]

◆ InsituDataCorrection() [2/2]

◆ ~InsituDataCorrection()

Member Function Documentation

◆ calibrate()

◆ combineCalibration()

◆ getAbsHistoPtMax()

◆ getInsituCorr()

◆ getInsituCorr_JMS()

◆ getNominalResolutionData()

◆ getNominalResolutionMC()

◆ getRelHistoPtMax()

◆ initialize()

◆ initMessaging()

◆ invertHistogram()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setLevel()

◆ setStartP4()

◆ setUnitsGeV()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_abshistoPtMax

◆ m_applyEtaRestrictionRelativeandAbsolute

◆ m_applyEtaRestrictionResidualMCbased

◆ m_applyInsituCaloTAjets

◆ m_applyInsituJMS

◆ m_applyRelativeandAbsoluteInsitu

◆ m_applyResidualMCbasedInsitu

◆ m_calibAreaTag

◆ m_config

◆ m_dev

◆ m_firstRun

◆ m_GeV

◆ m_imsg

◆ m_insituCorr

◆ m_insituCorr_JMS

◆ m_insituCorr_JMS_TA

◆ m_insituCorr_ResidualMCbased

◆ m_insituEtaMax

◆ m_insituEtaMax_JMS

◆ m_insituEtaMax_ResidualMCbased

◆ m_insituMassMax_JMS

◆ m_insituMassMin_JMS

◆ m_insituPtMax

◆ m_insituPtMax_JMS

◆ m_insituPtMax_ResidualMCbased

◆ m_insituPtMin

◆ m_insituPtMin_JMS

◆ m_insituPtMin_ResidualMCbased

◆ m_jetAlgo

◆ m_jetStartScale

◆ m_lastRun

◆ m_lvl

◆ m_msg_tls

◆ m_name

◆ m_nm

◆ m_relhistoPtMax