#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. 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 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. More...

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

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

◆ 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();
   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.

◆ m_applyEtaRestrictionRelativeandAbsolute

bool InsituDataCorrection::m_applyEtaRestrictionRelativeandAbsolute {}

private

Definition at line 61 of file InsituDataCorrection.h.

◆ m_applyEtaRestrictionResidualMCbased

bool InsituDataCorrection::m_applyEtaRestrictionResidualMCbased {}

private

Definition at line 64 of file InsituDataCorrection.h.

◆ m_applyInsituCaloTAjets

bool InsituDataCorrection::m_applyInsituCaloTAjets {}

private

Definition at line 66 of file InsituDataCorrection.h.

◆ m_applyInsituJMS

bool InsituDataCorrection::m_applyInsituJMS {}

private

Definition at line 67 of file InsituDataCorrection.h.

◆ m_applyRelativeandAbsoluteInsitu

bool InsituDataCorrection::m_applyRelativeandAbsoluteInsitu {}

private

Definition at line 60 of file InsituDataCorrection.h.

◆ m_applyResidualMCbasedInsitu

bool InsituDataCorrection::m_applyResidualMCbasedInsitu {}

private

Definition at line 63 of file InsituDataCorrection.h.

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

◆ m_dev

bool InsituDataCorrection::m_dev {}

private

Definition at line 50 of file InsituDataCorrection.h.

◆ m_firstRun

unsigned int InsituDataCorrection::m_firstRun {}

private

Definition at line 69 of file InsituDataCorrection.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_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.

◆ m_insituEtaMax_JMS

double InsituDataCorrection::m_insituEtaMax_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

◆ m_insituEtaMax_ResidualMCbased

double InsituDataCorrection::m_insituEtaMax_ResidualMCbased {}

private

Definition at line 58 of file InsituDataCorrection.h.

◆ m_insituMassMax_JMS

double InsituDataCorrection::m_insituMassMax_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

◆ m_insituMassMin_JMS

double InsituDataCorrection::m_insituMassMin_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

◆ m_insituPtMax

double InsituDataCorrection::m_insituPtMax {}

private

Definition at line 55 of file InsituDataCorrection.h.

◆ m_insituPtMax_JMS

double InsituDataCorrection::m_insituPtMax_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

◆ m_insituPtMax_ResidualMCbased

double InsituDataCorrection::m_insituPtMax_ResidualMCbased {}

private

Definition at line 58 of file InsituDataCorrection.h.

◆ m_insituPtMin

double InsituDataCorrection::m_insituPtMin {}

private

Definition at line 55 of file InsituDataCorrection.h.

◆ m_insituPtMin_JMS

double InsituDataCorrection::m_insituPtMin_JMS {}

private

Definition at line 55 of file InsituDataCorrection.h.

◆ m_insituPtMin_ResidualMCbased

double InsituDataCorrection::m_insituPtMin_ResidualMCbased {}

private

Definition at line 58 of file InsituDataCorrection.h.

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

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

double InsituDataCorrection::m_relhistoPtMax {}

private

Definition at line 56 of file InsituDataCorrection.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ 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