ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Pileup1DResidualCalibStep Class Reference

#include <Pileup1DResidualCalibStep.h>

Inheritance diagram for Pileup1DResidualCalibStep:
Collaboration diagram for Pileup1DResidualCalibStep:

Public Member Functions

 Pileup1DResidualCalibStep (const std::string &name="Pileup1DResidualCalibStep")
 
virtual StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
virtual StatusCode calibrate (xAOD::JetContainer &jetCont) const override
 Apply calibration to a jet container. More...
 
double getResidualOffset (double abseta, double mu, double NPV, int nJet, bool MuOnly, bool NOnly) const
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 
virtual StatusCode getNominalResolutionData (const xAOD::Jet &, const JetHelper::JetContext &, double &) const
 
virtual StatusCode getNominalResolutionMC (const xAOD::Jet &, const JetHelper::JetContext &, double &) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

double getResidualOffsetET (double abseta, double mu, double NPV, int nJet, bool MuOnly, bool NOnly, const std::vector< double > &OffsetMu, const std::vector< double > &OffsetNPV, const std::vector< double > &OffsetNjet, const TAxis *OffsetBins) const
 
double getNPVBeamspotCorrection (double NPV) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

Gaudi::Property< bool > m_isData {this, "IsData", false, ""}
 
Gaudi::Property< bool > m_doJetArea {this, "DoJetArea", false, "doc"}
 
SG::ReadDecorHandleKey< xAOD::EventInfom_muKey
 
SG::ReadHandleKey< xAOD::EventShapem_rhoKey {this, "RhoKey", "auto"}
 
SG::ReadHandleKey< xAOD::VertexContainerm_pvKey {this, "PrimaryVerticesContainerName", "PrimaryVertices"}
 
Gaudi::Property< bool > m_doMuOnly {this, "ApplyOnlyMuResidual", false, "doc"}
 
Gaudi::Property< bool > m_doNPVOnly {this, "ApplyOnlyNPVResidual", false, "doc"}
 
Gaudi::Property< bool > m_doNJetOnly {this, "ApplyOnlyNJetResidual", false, "doc"}
 
Gaudi::Property< float > m_NPV_ref {this , "DefaultNPVRef", -99., ""}
 
Gaudi::Property< float > m_mu_ref {this , "DefaultMuRef", -99., ""}
 
Gaudi::Property< float > m_nJet_ref {this , "DefaultNjetRef", -99., ""}
 
Gaudi::Property< float > m_muSF {this , "MuScaleFactor", 1., ""}
 
SG::ReadHandleKey< xAOD::JetContainerm_nJetContainerKey
 
Gaudi::Property< bool > m_useNjet {this , "UseNjet", false, ""}
 
Gaudi::Property< int > m_njetThreshold {this , "nJetThreshold", 20, ""}
 
Gaudi::Property< std::string > m_calibFile {this, "CalibFile", "none", "residual offset calib file"}
 
Gaudi::Property< std::string > m_corrName {this, "CorrectionName", "none", ""}
 
Gaudi::Property< std::string > m_corrDesc {this, "CorrectionDesc", "none", ""}
 
Gaudi::Property< std::vector< double > > m_offsetEtaBins {this, "AbsEtaBins", {} ,""}
 
Gaudi::Property< std::vector< double > > m_resOffsetMu {this, "MuTerm", {} ,""}
 
Gaudi::Property< std::vector< double > > m_resOffsetNjet {this, "nJetTerm", {} ,""}
 
Gaudi::Property< std::vector< double > > m_resOffsetNPV {this, "NPVTerm", {} ,""}
 
TAxis * m_resOffsetBins =nullptr
 
Gaudi::Property< bool > m_applyNPVBeamspotCorrection {this, "ApplyNPVBeamspotCorrection", false, "doc"}
 
NPVBeamspotCorrectionm_npvBeamspotCorr {}
 
Gaudi::Property< bool > m_doSequentialResidual {this, "DoSequentialResidual", false, "doc"}
 
Gaudi::Property< bool > m_doOnlyResidual {this, "OnlyResidual", false, ""}
 
Gaudi::Property< std::string > m_originScale {this, "OriginScale", "", "scale from which correction is applied" }
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 35 of file Pileup1DResidualCalibStep.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ Pileup1DResidualCalibStep()

Pileup1DResidualCalibStep::Pileup1DResidualCalibStep ( const std::string &  name = "Pileup1DResidualCalibStep")

Definition at line 21 of file Pileup1DResidualCalibStep.cxx.

22  : asg::AsgTool( name ) { }

Member Function Documentation

◆ calibrate()

StatusCode Pileup1DResidualCalibStep::calibrate ( xAOD::JetContainer jets) const
overridevirtual

Apply calibration to a jet container.

Implements IJetCalibStep.

Definition at line 105 of file Pileup1DResidualCalibStep.cxx.

105  {
106 
108  CHECK_THEN_ERROR( ! eventInfoDecor.isPresent() , "EventInfo decoration not available! "<< m_muKey.key() );
109  double mu = eventInfoDecor(0) ;
110 
111 
113  CHECK_THEN_ERROR( ! PVCont.isValid() , "No Primary Vertices "<< m_pvKey.key() );
114  double NPV = JetCalibUtils::countNPV(*PVCont);
115 
117  CHECK_THEN_ERROR( ! eventShape.isValid() , "Could not retrieve xAOD::EventShape DataHandle : "<< m_rhoKey.key());
118  double rho=0;
119  CHECK_THEN_ERROR( ! eventShape->getDensity(xAOD::EventShape::Density, rho ),
120  "Could not retrieve xAOD::EventShape::Density from xAOD::EventShape "<< m_rhoKey.key() );
121 
122  int nJets=0;
123  if(m_useNjet){
125  CHECK_THEN_ERROR( !nJetCont.isValid() , "Jet container needed for nJet not found: "<< m_nJetContainerKey.key());
126  for(const xAOD::Jet*jet: *nJetCont){
127  if(jet->pt()/1000. > m_njetThreshold)
128  nJets += 1;
129  }
130  }
131 
132 
133  ATH_MSG_DEBUG(" Rho = " << 0.001*rho << " GeV");
134  static const double toGeV = 0.001;
136  const xAOD::JetAttributeAccessor::AccessorWrapper<xAOD::JetFourMom_t> puScaleMomAcc("JetPileupScaleMomentum");
137  const xAOD::JetAttributeAccessor::AccessorWrapper<xAOD::JetFourMom_t> cstScaleMomAcc("JetConstitScaleMomentum");
138  SG::AuxElement::Accessor<int> puCorrectedAcc("PileupCorrected");
139 
140  for( xAOD::Jet * jet : jetCont){
141 
142 
143  xAOD::JetFourMom_t jetStartP4 = cstScaleMomAcc.getAttribute(*jet);
144 
145  const double E_det = jetStartP4.e();
146  const double pT_det = jetStartP4.pt();
147  const double eta_det = jetStartP4.eta();
148  const double mass_det = jetStartP4.mass();
149 
150  if ( E_det < mass_det ) {
151  ATH_MSG_ERROR( "JetPileupCorrection::calibrateImpl : Current jet has mass=" << mass_det*toGeV << " GeV, which is greater than it's energy=" << E_det*toGeV << " GeV?? Aborting." );
152  return StatusCode::FAILURE;
153  }
154 
155  xAOD::JetFourMom_t jetareaP4 = areaAcc.getAttribute(*jet);
156  ATH_MSG_VERBOSE(" Area = " << jetareaP4);
157 
158  double offsetET = 0; // pT residual subtraction
159  double pT_offset = pT_det; // pT difference before/after pileup corrections
160  double pileup_SF = 1; // final calibration factor applied to the four vector
161 
162  xAOD::JetFourMom_t calibP4;
163  if(!m_doSequentialResidual){ // Default, both corrections are applied simultaneously
164 
165  offsetET = getResidualOffset(fabs(eta_det), mu, NPV, nJets, m_doMuOnly, m_doNPVOnly||m_doNJetOnly);
166 
167  // Calculate the pT after jet areas and residual offset
168  pT_offset = m_doJetArea ? pT_det - rho*jetareaP4.pt() - offsetET : pT_det - offsetET;
169 
170  // Set the jet pT to 10 MeV if the pT is negative after the jet area and residual offset corrections
171  pileup_SF = pT_offset >= 0 ? pT_offset / pT_det : 10./pT_det;
172 
173  calibP4 = jetStartP4*pileup_SF;
174 
175  }else{
176  // Calculate mu-based correction factor
177  offsetET = getResidualOffset(fabs(eta_det), mu, NPV, nJets, true, false);
178  pT_offset = m_doJetArea ? pT_det - rho*jetareaP4.pt() - offsetET : pT_det - offsetET;
179  double muSF = pT_offset >= 0 ? pT_offset / pT_det : 10./pT_det;
180 
181  calibP4 = jetStartP4*muSF;
182 
183  // Calculate and apply NPV/Njet-based calibration
184  offsetET = getResidualOffset(fabs(eta_det), mu, NPV, nJets, false, true);
185  double pT_afterMuCalib = calibP4.pt();
186  pT_offset = pT_afterMuCalib - offsetET;
187  double SF = pT_offset >= 0 ? pT_offset / pT_afterMuCalib : 10./pT_afterMuCalib;
188  calibP4 = calibP4*SF;
189 
190  }
191 
192  //Attribute to track if a jet has received the pileup subtraction (always true if this code was run)
193  puCorrectedAcc(*jet) = 1 ;
194  //Transfer calibrated jet properties to the Jet object
195  puScaleMomAcc.setAttribute(*jet, calibP4 );
196  jet->setJetP4( calibP4 );
197 
198  }
199 
200 
201  return StatusCode::SUCCESS;
202 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr) const
inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

119  {
120 
121 #ifdef XAOD_STANDALONE
122  // In case we use @c xAOD::TEvent, we have a direct function call
123  // for this.
124  return evtStore()->event()->getKey( ptr );
125 #else
126  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127  return ( proxy == nullptr ? 0 : proxy->sgkey() );
128 #endif // XAOD_STANDALONE
129  }

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

106  {
107 
108 #ifdef XAOD_STANDALONE
109  // In case we use @c xAOD::TEvent, we have a direct function call
110  // for this.
111  return evtStore()->event()->getName( ptr );
112 #else
113  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114  static const std::string dummy = "";
115  return ( proxy == nullptr ? dummy : proxy->name() );
116 #endif // XAOD_STANDALONE
117  }

◆ getNominalResolutionData()

virtual StatusCode IJetCalibStep::getNominalResolutionData ( const xAOD::Jet ,
const JetHelper::JetContext ,
double &   
) const
inlinevirtualinherited

Reimplemented in SmearingCalibStep.

Definition at line 38 of file IJetCalibStep.h.

38 { return StatusCode::FAILURE; }

◆ getNominalResolutionMC()

virtual StatusCode IJetCalibStep::getNominalResolutionMC ( const xAOD::Jet ,
const JetHelper::JetContext ,
double &   
) const
inlinevirtualinherited

Reimplemented in SmearingCalibStep.

Definition at line 39 of file IJetCalibStep.h.

39 { return StatusCode::FAILURE; }

◆ getNPVBeamspotCorrection()

double Pileup1DResidualCalibStep::getNPVBeamspotCorrection ( double  NPV) const
private

Definition at line 267 of file Pileup1DResidualCalibStep.cxx.

267  {
268  if(!m_isData && m_applyNPVBeamspotCorrection) return std::as_const(m_npvBeamspotCorr)->GetNVertexBsCorrection(NPV);
269  return NPV;
270 }

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ getResidualOffset()

double Pileup1DResidualCalibStep::getResidualOffset ( double  abseta,
double  mu,
double  NPV,
int  nJet,
bool  MuOnly,
bool  NOnly 
) const

Definition at line 205 of file Pileup1DResidualCalibStep.cxx.

206  {
207  return getResidualOffsetET(abseta, mu, NPV, nJet, MuOnly, NOnly,
209 }

◆ getResidualOffsetET()

double Pileup1DResidualCalibStep::getResidualOffsetET ( double  abseta,
double  mu,
double  NPV,
int  nJet,
bool  MuOnly,
bool  NOnly,
const std::vector< double > &  OffsetMu,
const std::vector< double > &  OffsetNPV,
const std::vector< double > &  OffsetNjet,
const TAxis *  OffsetBins 
) const
private

Definition at line 211 of file Pileup1DResidualCalibStep.cxx.

216  {
217 
218  static const double toMeV= 1000.;
219  //mu rescaling
220  const double muCorr = m_isData ? mu : mu*m_muSF;
221  if(m_useNjet) {
222  // further correction to nJet if desired
223  int nJetCorr = nJet;
224 
225  double alpha, beta, etaEdge;
226  if(!MuOnly){ beta = OffsetNjet[0];
227  } else { beta = 0; }
228  if(!NOnly){ alpha = OffsetMu[0];
229  } else { alpha = 0; }
230  etaEdge=0;
231  int bin=1;
232  for (;bin<=OffsetBins->GetNbins();++bin) {
233  etaEdge = OffsetBins->GetBinLowEdge(bin);
234  const double width=OffsetBins->GetBinWidth(bin);
235  if (abseta<etaEdge+width) break;
236  if(!NOnly) alpha += width*OffsetMu[bin];
237  if(!MuOnly) beta += width*OffsetNjet[bin];
238  }
239  if(!NOnly) alpha += OffsetMu[bin]*(abseta-etaEdge);
240  if(!MuOnly) beta += OffsetNjet[bin]*(abseta-etaEdge);
241  return (alpha*(muCorr-m_mu_ref) + beta*(nJetCorr-m_nJet_ref))*toMeV;
242  } else {
243  //NPV beamspot correction
244  const double NPVCorr = getNPVBeamspotCorrection(NPV);
245 
246  double alpha, beta, etaEdge;
247  if(!MuOnly){ beta = OffsetNPV[0];
248  } else { beta = 0; }
249  if(!NOnly){ alpha = OffsetMu[0];
250  } else { alpha = 0; }
251  etaEdge = 0;
252  int bin=1;
253  for (;bin<=OffsetBins->GetNbins();++bin) {
254  etaEdge = OffsetBins->GetBinLowEdge(bin);
255  const double width=OffsetBins->GetBinWidth(bin);
256  if (abseta<etaEdge+width) break;
257  if(!NOnly) alpha += width*OffsetMu[bin];
258  if(!MuOnly) beta += width*OffsetNPV[bin];
259  }
260  if(!NOnly) alpha += OffsetMu[bin]*(abseta-etaEdge);
261  if(!MuOnly) beta += OffsetNPV[bin]*(abseta-etaEdge);
262  return (alpha*(muCorr-m_mu_ref) + beta*(NPVCorr-m_NPV_ref))*toMeV;
263  }
264 
265 }

◆ initialize()

StatusCode Pileup1DResidualCalibStep::initialize ( )
overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 27 of file Pileup1DResidualCalibStep.cxx.

27  {
28 
30  ATH_MSG_FATAL("If you're trying to apply only the Residual pile up correction, it needs to be specify in the Calibration Sequence. ApplyOnlyResidual should be true in the configuration file and the PileupStartScale should be specified.");
31  return StatusCode::FAILURE;
32  }
33 
34  ATH_CHECK( m_muKey.initialize() );
35  ATH_CHECK( m_pvKey.initialize() );
36  ATH_CHECK( m_rhoKey.initialize() );
38 
39 
40 
41  if(m_doSequentialResidual) ATH_MSG_DEBUG("The pileup residual calibrations will be applied sequentially.");
42  else ATH_MSG_DEBUG("The pileup residual calibrations will be applied simultaneously (default).");
43  if(m_doMuOnly) ATH_MSG_INFO("Only the pileup mu-based calibration will be applied.");
44  if(m_doNPVOnly) ATH_MSG_INFO("Only the pileup NPV-based calibration will be applied.");
45  if(m_doNJetOnly) ATH_MSG_INFO("Only the pileup NJet-based calibration will be applied.");
46  if (m_useNjet) ATH_MSG_DEBUG("NJet will be used instead of NPV in the pileup corrections.");
47 
48  // Protections
50  "Sequential residual calibration can not be applied in doMuOnly or doNPVOnly or doNJetOnly cases.");
51 
53  "Conflicting configuation, UseNjet true but doMuOnly or doNPVOnly also true.");
54 
56  "It was requested to apply only the mu-based AND the NPV-based calibrations.");
57 
59  "It was requested to apply only the mu-based AND the NJet-based calibrations.");
60 
62  "It was requested to apply only the NJet-based calibration but not to use Njet instead of NPV.");
63 
65  "It was requested to apply NJet-based and NPV calibrations.");
66 
67  if(m_doJetArea) ATH_MSG_INFO("Jet area pile up correction will be applied.");
68 
69 
71  "OffsetCorrection.DefaultMuRef not specified.");
72 
74  "OffsetCorrection.DefaultNPVRef not specified.");
75 
77  "OffsetCorrection.DefaultNjetRef not specified.");
78 
79 
80  m_resOffsetBins = new TAxis(m_offsetEtaBins.size()-1,&m_offsetEtaBins[0]);
81 
82  if(!m_doNPVOnly && !m_doNJetOnly){
83  CHECK_THEN_ERROR( (int)m_resOffsetMu.size()!=(m_resOffsetBins->GetNbins()+1),
84  "Incorrect specification of MuTerm binning" );
85  }
86 
87  if(m_useNjet) {
88  CHECK_THEN_ERROR( (int)m_resOffsetNjet.size()!= (m_resOffsetBins->GetNbins()+1),
89  "Incorrect specification of nJetTerm binning." );
90  } else if(!m_doMuOnly){
91  CHECK_THEN_ERROR( (int)m_resOffsetNPV.size()!= (m_resOffsetBins->GetNbins()+1),
92  "Incorrect specification of NPVTerm binning." );
93 
96  ATH_MSG_INFO("\n NPV beamspot correction will be applied.");
97  }
98  }
99 
100  return StatusCode::SUCCESS;
101 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const
inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns
The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ print()

void asg::AsgTool::print ( ) const
virtualinherited

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_applyNPVBeamspotCorrection

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_applyNPVBeamspotCorrection {this, "ApplyNPVBeamspotCorrection", false, "doc"}
private

Definition at line 106 of file Pileup1DResidualCalibStep.h.

◆ m_calibFile

Gaudi::Property<std::string> Pileup1DResidualCalibStep::m_calibFile {this, "CalibFile", "none", "residual offset calib file"}
private

Definition at line 94 of file Pileup1DResidualCalibStep.h.

◆ m_corrDesc

Gaudi::Property<std::string> Pileup1DResidualCalibStep::m_corrDesc {this, "CorrectionDesc", "none", ""}
private

Definition at line 97 of file Pileup1DResidualCalibStep.h.

◆ m_corrName

Gaudi::Property<std::string> Pileup1DResidualCalibStep::m_corrName {this, "CorrectionName", "none", ""}
private

Definition at line 96 of file Pileup1DResidualCalibStep.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doJetArea

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_doJetArea {this, "DoJetArea", false, "doc"}
private

Definition at line 68 of file Pileup1DResidualCalibStep.h.

◆ m_doMuOnly

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_doMuOnly {this, "ApplyOnlyMuResidual", false, "doc"}
private

Definition at line 78 of file Pileup1DResidualCalibStep.h.

◆ m_doNJetOnly

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_doNJetOnly {this, "ApplyOnlyNJetResidual", false, "doc"}
private

Definition at line 80 of file Pileup1DResidualCalibStep.h.

◆ m_doNPVOnly

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_doNPVOnly {this, "ApplyOnlyNPVResidual", false, "doc"}
private

Definition at line 79 of file Pileup1DResidualCalibStep.h.

◆ m_doOnlyResidual

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_doOnlyResidual {this, "OnlyResidual", false, ""}
private

Definition at line 111 of file Pileup1DResidualCalibStep.h.

◆ m_doSequentialResidual

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_doSequentialResidual {this, "DoSequentialResidual", false, "doc"}
private

Definition at line 109 of file Pileup1DResidualCalibStep.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_isData

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_isData {this, "IsData", false, ""}
private

Definition at line 67 of file Pileup1DResidualCalibStep.h.

◆ m_mu_ref

Gaudi::Property<float> Pileup1DResidualCalibStep::m_mu_ref {this , "DefaultMuRef", -99., ""}
private

Definition at line 83 of file Pileup1DResidualCalibStep.h.

◆ m_muKey

SG::ReadDecorHandleKey<xAOD::EventInfo> Pileup1DResidualCalibStep::m_muKey
private
Initial value:
{this, "averageInteractionsPerCrossingKey",
"EventInfo.averageInteractionsPerCrossing","Decoration for Average Interaction Per Crossing"}

Definition at line 70 of file Pileup1DResidualCalibStep.h.

◆ m_muSF

Gaudi::Property<float> Pileup1DResidualCalibStep::m_muSF {this , "MuScaleFactor", 1., ""}
private

Definition at line 85 of file Pileup1DResidualCalibStep.h.

◆ m_nJet_ref

Gaudi::Property<float> Pileup1DResidualCalibStep::m_nJet_ref {this , "DefaultNjetRef", -99., ""}
private

Definition at line 84 of file Pileup1DResidualCalibStep.h.

◆ m_nJetContainerKey

SG::ReadHandleKey<xAOD::JetContainer> Pileup1DResidualCalibStep::m_nJetContainerKey
private
Initial value:
{this, "nJetContainerName",
"","a jet container such as HLT_xAOD__JetContainer_a4tcemsubjesISFS"}

Definition at line 87 of file Pileup1DResidualCalibStep.h.

◆ m_njetThreshold

Gaudi::Property<int> Pileup1DResidualCalibStep::m_njetThreshold {this , "nJetThreshold", 20, ""}
private

Definition at line 91 of file Pileup1DResidualCalibStep.h.

◆ m_NPV_ref

Gaudi::Property<float> Pileup1DResidualCalibStep::m_NPV_ref {this , "DefaultNPVRef", -99., ""}
private

Definition at line 82 of file Pileup1DResidualCalibStep.h.

◆ m_npvBeamspotCorr

NPVBeamspotCorrection* Pileup1DResidualCalibStep::m_npvBeamspotCorr {}
private

Definition at line 107 of file Pileup1DResidualCalibStep.h.

◆ m_offsetEtaBins

Gaudi::Property<std::vector<double> > Pileup1DResidualCalibStep::m_offsetEtaBins {this, "AbsEtaBins", {} ,""}
private

Definition at line 99 of file Pileup1DResidualCalibStep.h.

◆ m_originScale

Gaudi::Property<std::string> Pileup1DResidualCalibStep::m_originScale {this, "OriginScale", "", "scale from which correction is applied" }
private

Definition at line 113 of file Pileup1DResidualCalibStep.h.

◆ m_pvKey

SG::ReadHandleKey<xAOD::VertexContainer> Pileup1DResidualCalibStep::m_pvKey {this, "PrimaryVerticesContainerName", "PrimaryVertices"}
private

Definition at line 75 of file Pileup1DResidualCalibStep.h.

◆ m_resOffsetBins

TAxis* Pileup1DResidualCalibStep::m_resOffsetBins =nullptr
private

Definition at line 103 of file Pileup1DResidualCalibStep.h.

◆ m_resOffsetMu

Gaudi::Property<std::vector<double> > Pileup1DResidualCalibStep::m_resOffsetMu {this, "MuTerm", {} ,""}
private

Definition at line 100 of file Pileup1DResidualCalibStep.h.

◆ m_resOffsetNjet

Gaudi::Property<std::vector<double> > Pileup1DResidualCalibStep::m_resOffsetNjet {this, "nJetTerm", {} ,""}
private

Definition at line 101 of file Pileup1DResidualCalibStep.h.

◆ m_resOffsetNPV

Gaudi::Property<std::vector<double> > Pileup1DResidualCalibStep::m_resOffsetNPV {this, "NPVTerm", {} ,""}
private

Definition at line 102 of file Pileup1DResidualCalibStep.h.

◆ m_rhoKey

SG::ReadHandleKey<xAOD::EventShape> Pileup1DResidualCalibStep::m_rhoKey {this, "RhoKey", "auto"}
private

Definition at line 74 of file Pileup1DResidualCalibStep.h.

◆ m_useNjet

Gaudi::Property<bool> Pileup1DResidualCalibStep::m_useNjet {this , "UseNjet", false, ""}
private

Definition at line 90 of file Pileup1DResidualCalibStep.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Pileup1DResidualCalibStep::m_applyNPVBeamspotCorrection
Gaudi::Property< bool > m_applyNPVBeamspotCorrection
Definition: Pileup1DResidualCalibStep.h:106
Pileup1DResidualCalibStep::m_doOnlyResidual
Gaudi::Property< bool > m_doOnlyResidual
Definition: Pileup1DResidualCalibStep.h:111
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
Pileup1DResidualCalibStep::getNPVBeamspotCorrection
double getNPVBeamspotCorrection(double NPV) const
Definition: Pileup1DResidualCalibStep.cxx:267
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TRT_PAI_gasdata::SF
const float SF[NF]
Cross sections for Fluor.
Definition: TRT_PAI_gasdata.h:285
bin
Definition: BinsDiffFromStripMedian.h:43
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Pileup1DResidualCalibStep::m_doMuOnly
Gaudi::Property< bool > m_doMuOnly
Definition: Pileup1DResidualCalibStep.h:78
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
Pileup1DResidualCalibStep::m_isData
Gaudi::Property< bool > m_isData
Definition: Pileup1DResidualCalibStep.h:67
Pileup1DResidualCalibStep::m_npvBeamspotCorr
NPVBeamspotCorrection * m_npvBeamspotCorr
Definition: Pileup1DResidualCalibStep.h:107
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
xAOD::EventShape_v1::Density
@ Density
Definition: EventShape_v1.h:47
Pileup1DResidualCalibStep::m_resOffsetBins
TAxis * m_resOffsetBins
Definition: Pileup1DResidualCalibStep.h:103
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
Pileup1DResidualCalibStep::m_offsetEtaBins
Gaudi::Property< std::vector< double > > m_offsetEtaBins
Definition: Pileup1DResidualCalibStep.h:99
Pileup1DResidualCalibStep::m_nJetContainerKey
SG::ReadHandleKey< xAOD::JetContainer > m_nJetContainerKey
Definition: Pileup1DResidualCalibStep.h:87
Pileup1DResidualCalibStep::m_resOffsetNjet
Gaudi::Property< std::vector< double > > m_resOffsetNjet
Definition: Pileup1DResidualCalibStep.h:101
CHECK_THEN_ERROR
#define CHECK_THEN_ERROR(checkcode, message)
Definition: JetCalibUtils.h:20
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Pileup1DResidualCalibStep::m_muKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_muKey
Definition: Pileup1DResidualCalibStep.h:70
Pileup1DResidualCalibStep::m_nJet_ref
Gaudi::Property< float > m_nJet_ref
Definition: Pileup1DResidualCalibStep.h:84
toGeV
#define toGeV
Definition: HIEfficiencyResponseHistos.cxx:16
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
Pileup1DResidualCalibStep::m_useNjet
Gaudi::Property< bool > m_useNjet
Definition: Pileup1DResidualCalibStep.h:90
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
jet::PileupComp::OffsetNPV
@ OffsetNPV
Definition: UncertaintyEnum.h:165
Pileup1DResidualCalibStep::m_mu_ref
Gaudi::Property< float > m_mu_ref
Definition: Pileup1DResidualCalibStep.h:83
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::JetFourMom_t
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > > JetFourMom_t
Base 4 Momentum type for Jet.
Definition: JetTypes.h:17
Pileup1DResidualCalibStep::m_doSequentialResidual
Gaudi::Property< bool > m_doSequentialResidual
Definition: Pileup1DResidualCalibStep.h:109
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
Pileup1DResidualCalibStep::getResidualOffset
double getResidualOffset(double abseta, double mu, double NPV, int nJet, bool MuOnly, bool NOnly) const
Definition: Pileup1DResidualCalibStep.cxx:205
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
jet::PileupComp::OffsetMu
@ OffsetMu
Definition: UncertaintyEnum.h:166
Pileup1DResidualCalibStep::m_NPV_ref
Gaudi::Property< float > m_NPV_ref
Definition: Pileup1DResidualCalibStep.h:82
a
TList * a
Definition: liststreamerinfos.cxx:10
Pileup1DResidualCalibStep::m_doNJetOnly
Gaudi::Property< bool > m_doNJetOnly
Definition: Pileup1DResidualCalibStep.h:80
h
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
Pileup1DResidualCalibStep::m_doNPVOnly
Gaudi::Property< bool > m_doNPVOnly
Definition: Pileup1DResidualCalibStep.h:79
xAOD::JetAttributeAccessor::AccessorWrapper< xAOD::JetFourMom_t >
Pileup1DResidualCalibStep::m_njetThreshold
Gaudi::Property< int > m_njetThreshold
Definition: Pileup1DResidualCalibStep.h:91
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Pileup1DResidualCalibStep::m_resOffsetNPV
Gaudi::Property< std::vector< double > > m_resOffsetNPV
Definition: Pileup1DResidualCalibStep.h:102
Pileup1DResidualCalibStep::m_rhoKey
SG::ReadHandleKey< xAOD::EventShape > m_rhoKey
Definition: Pileup1DResidualCalibStep.h:74
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
Pileup1DResidualCalibStep::m_pvKey
SG::ReadHandleKey< xAOD::VertexContainer > m_pvKey
Definition: Pileup1DResidualCalibStep.h:75
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
JetCalibUtils::countNPV
int countNPV(const VXCONT &vxCont)
Definition: JetCalibUtils.h:39
Pileup1DResidualCalibStep::m_muSF
Gaudi::Property< float > m_muSF
Definition: Pileup1DResidualCalibStep.h:85
Pileup1DResidualCalibStep::m_doJetArea
Gaudi::Property< bool > m_doJetArea
Definition: Pileup1DResidualCalibStep.h:68
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
SG::DataProxy
Definition: DataProxy.h:44
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
Pileup1DResidualCalibStep::m_resOffsetMu
Gaudi::Property< std::vector< double > > m_resOffsetMu
Definition: Pileup1DResidualCalibStep.h:100
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Pileup1DResidualCalibStep::getResidualOffsetET
double getResidualOffsetET(double abseta, double mu, double NPV, int nJet, bool MuOnly, bool NOnly, const std::vector< double > &OffsetMu, const std::vector< double > &OffsetNPV, const std::vector< double > &OffsetNjet, const TAxis *OffsetBins) const
Definition: Pileup1DResidualCalibStep.cxx:211
fitman.rho
rho
Definition: fitman.py:532
NPVBeamspotCorrection
Definition: NPVBeamspotCorrection.h:21
fitman.k
k
Definition: fitman.py:528