ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
CP::JetTileCorrectionTool Class Referenceabstract

#include <JetTileCorrectionTool.h>

Inheritance diagram for CP::JetTileCorrectionTool:
Collaboration diagram for CP::JetTileCorrectionTool:

Public Member Functions

 JetTileCorrectionTool (const std::string &name)
 Create a proper constructor for Athena. More...
 
virtual ~JetTileCorrectionTool ()
 Destructor: More...
 
virtual StatusCode initialize ()
 Function initialising the tool. More...
 
virtual CorrectionCode applyCorrection (xAOD::Jet &object)
 Apply the correction on a modifyable object. More...
 
virtual CorrectionCode correctedCopy (const xAOD::Jet &input, xAOD::Jet *&output)
 Create a corrected copy from a constant jet. More...
 
virtual bool isAffectedBySystematic (const SystematicVariation &systematic) const
 returns: whether this tool is affected by the given systematic More...
 
virtual SystematicSet affectingSystematics () const
 returns: the list of all systematics this tool can be affected by More...
 
virtual SystematicSet recommendedSystematics () const
 returns: the list of all systematics this tool recommends to use More...
 
const CP::SystematicSet & appliedSystematics () const
 returns: the currently applied systematics More...
 
virtual StatusCode applySystematicVariation (const SystematicSet &systConfig)
 effects: configure this tool for the given list of systematic variations. More...
 
StatusCode registerSystematics ()
 
JTC::TS getTileStatus (const xAOD::Jet &jet)
 
StatusCode addTileStatus (const xAOD::Jet &jet)
 
void setRJET (float r)
 
virtual void print () const =0
 Print the state of the tool. More...
 
virtual StatusCode sysInitialize ()
 Function initialising the tool in the correct way in Athena. More...
 
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 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
 

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

Protected Attributes

bool m_isData
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void loadDeadUser ()
 
void loadDeadDB ()
 
std::vector< float > getCorrections (const xAOD::Jet &j)
 
JTC::TS overlap (const xAOD::Jet &j, JTC::Hole region)
 
int getPtBin (float pt)
 
bool inIOV (JTC::Hole region, int run)
 
bool inHole (const xAOD::Jet &j, JTC::Hole rdead)
 
bool inHole (float eta, float phi, JTC::Hole rdead)
 
IPair getModulePosition (const xAOD::Jet &jet, JTC::Hole module)
 
void loadModulesFromMap (const xAOD::Jet &jet, JTC::TS &status, const std::map< std::string, JTC::Hole > &hmap, JTC::PART part=JTC::PART::LB, JTC::TYPE type=JTC::TYPE::DB)
 
StatusCode loadAllModules (const xAOD::Jet &jet, JTC::TS &status)
 
JTC::Hole partModToHole (int part, int mod)
 
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

bool m_constScale = false
 
bool m_isMC = false
 
int m_current_run = -1
 
int m_NbinsPt = -1
 
std::vector< std::string > m_v_user_dead
 
TFile * m_rootFile = 0
 
std::string m_rootFileName
 
std::string m_bd_dead_mapFile
 
std::vector< JTC::Region > m_position_masked
 
TH1F * m_core_sys_LB = 0
 //needs to be transient! More...
 
TH1F * m_core_sys_EB = 0
 
std::map< int, TH1F * > m_pars_LB
 
std::map< int, TH1F * > m_pars_EB
 
std::map< std::string, JTC::Hole > m_db_dead_LB
 
std::map< std::string, JTC::Hole > m_db_dead_EB
 
std::map< std::string, JTC::Hole > m_user_dead_LB
 
std::map< std::string, JTC::Hole > m_user_dead_EB
 
float m_RJET
 
std::unordered_map< CP::SystematicSet, CP::SystematicSet > m_systFilter
 Systematics filter map. More...
 
CP::SystematicSet * m_appliedSystematics = 0
 Currently applied systematics. More...
 
MetaStore_t m_inputMetaStore
 Object accessing the input metadata store. More...
 
MetaStore_t m_outputMetaStore
 Object accessing the output metadata store. More...
 
bool m_beginInputFileCalled
 Flag helping to discover when the tool misses the opening of the first input file. More...
 
bool m_useIncidents
 
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
 

Callback functions helping in metadata reading/writing

void setUseIncidents (const bool flag)
 
virtual void handle (const Incident &inc)
 Function receiving incidents from IncidentSvc/TEvent. More...
 
virtual StatusCode beginInputFile ()
 Function called when a new input file is opened. More...
 
virtual StatusCode endInputFile ()
 Function called when the currently open input file got completely processed. More...
 
virtual StatusCode beginEvent ()
 Function called when a new events is loaded. More...
 
virtual StatusCode metaDataStop ()
 Function called when the tool should write out its metadata. More...
 

Detailed Description

Definition at line 44 of file JetTileCorrectionTool.h.

Member Typedef Documentation

◆ MetaStore_t

typedef ServiceHandle< StoreGateSvc > asg::AsgMetadataTool::MetaStore_t
inherited

Type of the metadata store object in Athena.

Definition at line 66 of file AsgMetadataTool.h.

◆ MetaStorePtr_t

typedef const ServiceHandle< StoreGateSvc >& asg::AsgMetadataTool::MetaStorePtr_t
inherited

Type of the metadata store pointer in standalone mode.

Definition at line 68 of file AsgMetadataTool.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ JetTileCorrectionTool()

CP::JetTileCorrectionTool::JetTileCorrectionTool ( const std::string &  name)

Create a proper constructor for Athena.

Create a constructor for standalone usage

Definition at line 44 of file JetTileCorrectionTool.cxx.

45  : asg::AsgMetadataTool( name ),
46  m_appliedSystematics(nullptr)
47  {
48  declareProperty("CorrectionFileName", m_rootFileName="JetTileCorrection/JetTile_pFile_010216.root", "Parametrization file");
49  declareProperty("MaskedRegionsMap", m_bd_dead_mapFile="JetTileCorrection/Tile_maskedDB_Run2.conf", "Masked regions DB file");
50  declareProperty("UserMaskedRegions", m_v_user_dead, "List of (ad-hoc) TileCal dead modules"); //array of extra dead modules
51  }

◆ ~JetTileCorrectionTool()

CP::JetTileCorrectionTool::~JetTileCorrectionTool ( )
virtual

Destructor:

Definition at line 53 of file JetTileCorrectionTool.cxx.

54  {
55  if ( m_rootFile ){
56  delete m_rootFile;
57  m_rootFile = nullptr;
58  }
59  }

Member Function Documentation

◆ addTileStatus()

StatusCode CP::JetTileCorrectionTool::addTileStatus ( const xAOD::Jet &  jet)
virtual

Implements CP::IJetTileCorrectionTool.

Definition at line 487 of file JetTileCorrectionTool.cxx.

487  {
488  JTC::TS status = getTileStatus(jet);
489  dec_status(jet) = (unsigned int) status; //save status decoration
490  return StatusCode::SUCCESS;
491  }

◆ affectingSystematics()

SystematicSet CP::JetTileCorrectionTool::affectingSystematics ( ) const
virtual

returns: the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 226 of file JetTileCorrectionTool.cxx.

227  {
228  SystematicSet result;
229 
230  result.insert(CP::SystematicVariation("JET_TILECORR_Uncertainty", 1));
231  result.insert(CP::SystematicVariation("JET_TILECORR_Uncertainty", -1));
232 
233  return result;
234  }

◆ appliedSystematics()

const CP::SystematicSet& CP::JetTileCorrectionTool::appliedSystematics ( ) const
inline

returns: the currently applied systematics

Definition at line 80 of file JetTileCorrectionTool.h.

80  {
81  return *m_appliedSystematics;
82  }

◆ applyCorrection()

CorrectionCode CP::JetTileCorrectionTool::applyCorrection ( xAOD::Jet &  object)
virtual

Apply the correction on a modifyable object.

Implements CP::IJetTileCorrectionTool.

Definition at line 147 of file JetTileCorrectionTool.cxx.

147  {
148 
149  //init decorations
150  dec_ptraw(jet) = jet.pt();
151  dec_status(jet) = (unsigned int) TS::UNKNOWN;
152 
153  //check validity range of the correction
154  if( std::abs(jet.eta()) > iov_aeta_max ) return CorrectionCode::OutOfValidityRange;
155  if( jet.pt() < iov_pt_min || jet.pt() > iov_pt_max ) return CorrectionCode::OutOfValidityRange;
156 
157  JTC::TS status = TS::GOOD;
158  if( loadAllModules(jet, status) != StatusCode::SUCCESS )
159  return CorrectionCode::Error;
160 
161  dec_status(jet) = (unsigned int) status; //save status decoration
162 
163  // Nothing to do, return gracefully:
164  if(status == TS::GOOD) return CorrectionCode::Ok;
165 
166  //get relative-pt factor to correct for
167  std::vector<float> cfactors = getCorrections(jet);
168 
169  //if not correction need it, just leave
170  if(cfactors.empty()) return CorrectionCode::Ok;
171 
172  // Redefine the jet 4vector by scaling both pt and mass
173  float newPt = jet.pt();
174  float newM = jet.m();
175 
176  for(auto cf : cfactors){
177 
178  newPt /= cf;
179  newM /= cf;
180  }
181 
182  // Set the new jet 4vector
183  xAOD::JetFourMom_t newp4;
184  newp4.SetCoordinates(newPt, jet.eta(), jet.phi(), newM);
185 
186  jet.setJetP4( newp4 );
187 
188  ATH_MSG_DEBUG("JetTileCorrection applied.");
189 
190  // Return gracefully:
191  return CorrectionCode::Ok;
192  }

◆ applySystematicVariation()

StatusCode CP::JetTileCorrectionTool::applySystematicVariation ( const SystematicSet &  systConfig)
virtual

effects: configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored (unless they cause other errors). failures: systematic unknown failures: requesting multiple variations on the same systematic (e.g. up & down) failures: requesting an unsupported variation on an otherwise supported systematic (e.g. a 2 sigma variation and the tool only supports 1 sigma variations) failures: unsupported combination of supported systematic failures: other tool specific errors

Implements CP::ISystematicsTool.

Definition at line 242 of file JetTileCorrectionTool.cxx.

242  {
243 
244  // First, check if we already know this systematic configuration
245  auto itr = m_systFilter.find(systConfig);
246 
247  // If it's a new input set, we need to filter it
248  if( itr == m_systFilter.end() ){
249 
250  // New systematic. We need to parse it.
251  static CP::SystematicSet affectingSys = affectingSystematics();
252  CP::SystematicSet filteredSys;
253  if (!CP::SystematicSet::filterForAffectingSystematics(systConfig, affectingSys, filteredSys)){
254  ATH_MSG_ERROR("Unsupported combination of systematics passed to the tool!");
255  return StatusCode::FAILURE;
256  }
257 
258  // Insert filtered set into the map
259  itr = m_systFilter.insert(std::make_pair(systConfig, filteredSys)).first;
260  }
261 
262  CP::SystematicSet& mySysConf = itr->second;
263  m_appliedSystematics = &mySysConf;
264  return StatusCode::SUCCESS;
265  }

◆ beginEvent()

StatusCode asg::AsgMetadataTool::beginEvent ( )
protectedvirtualinherited

Function called when a new events is loaded.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, TauAnalysisTools::TauSelectionTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, Trig::TrigDecisionTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, Trig::TrigConfBunchCrossingTool, xAODMaker::TriggerMenuMetaDataTool, and Trig::xAODBunchCrossingTool.

Definition at line 196 of file AsgMetadataTool.cxx.

196  {
197 
198  // Return gracefully:
199  return StatusCode::SUCCESS;
200  }

◆ beginInputFile()

StatusCode asg::AsgMetadataTool::beginInputFile ( )
protectedvirtualinherited

Function called when a new input file is opened.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, PMGTools::PMGTruthWeightTool, BookkeeperTool, HFORSelectionTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, Trig::TrigDecisionTool, xAODMaker::TriggerMenuMetaDataTool, xAODMaker::TruthMetaDataTool, Trig::xAODBunchCrossingTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, and TauAnalysisTools::TauSmearingTool.

Definition at line 180 of file AsgMetadataTool.cxx.

180  {
181 
182  // Return gracefully:
183  return StatusCode::SUCCESS;
184  }

◆ correctedCopy()

CorrectionCode CP::JetTileCorrectionTool::correctedCopy ( const xAOD::Jet &  input,
xAOD::Jet *&  output 
)
virtual

Create a corrected copy from a constant jet.

Implements CP::IJetTileCorrectionTool.

Definition at line 194 of file JetTileCorrectionTool.cxx.

194  {
195 
196  // A sanity check:
197  if( output ) {
198  ATH_MSG_WARNING( "Non-null pointer received. "
199  "There's a possible memory leak!" );
200  }
201 
202  ATH_MSG_DEBUG("making the copy");
203 
204  // Create the copy:
205  std::unique_ptr< xAOD::Jet > newobj( new xAOD::Jet( input ) );
206 
207  // Apply the correction to it:
208  const CorrectionCode result = this->applyCorrection( *newobj );
209  if( result == CorrectionCode::Error ) {
210  ATH_MSG_ERROR( "Failed to apply correction to jet" );
211  } else {
212  output = newobj.release();
213  }
214 
215  // Return the value from applyCorrection:
216  return result;
217  }

◆ 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;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, 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; }

◆ endInputFile()

StatusCode asg::AsgMetadataTool::endInputFile ( )
protectedvirtualinherited

Function called when the currently open input file got completely processed.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in BookkeeperTool, HFORSelectionTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 188 of file AsgMetadataTool.cxx.

188  {
189 
190  // Return gracefully:
191  return StatusCode::SUCCESS;
192  }

◆ 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

◆ getCorrections()

std::vector< float > CP::JetTileCorrectionTool::getCorrections ( const xAOD::Jet &  j)
private

Definition at line 535 of file JetTileCorrectionTool.cxx.

535  {
536 
537  float ptlast = jet.pt();
538  int ptbin = getPtBin(ptlast);
539 
540  //***
541  int ptbin_sys=m_core_sys_LB->FindBin(ptlast);
542  //***
543 
544  std::vector<float> corrections = {};
545 
546  if (ptbin < 0) return corrections; // no correction below 20GeV
547 
548  //***
549  if (ptlast < 40000) return corrections;
550  //***
551 
552  float clast = 1.;
553  float sigma = 0.;
554 
555  if(m_appliedSystematics!=nullptr){ //nomimal value
556  sigma = m_appliedSystematics->getParameterByBaseName("JET_TILECORR_Uncertainty");
557  }
558 
559  for(const auto& region : m_position_masked){
560 
561  ptlast *= clast;
562  ptbin = getPtBin( ptlast );
563 
564  if(region.part == PART::LB) {
565 
566  //***
567  if (region.status == TS::CORE) clast = m_pars_LB[region.ep.first + Pix_eta * region.ep.second]->GetBinContent(ptbin) + sigma * m_core_sys_LB->GetBinContent(ptbin_sys); //systematics are bigger if we are in the core
568  else clast = m_pars_LB[region.ep.first + Pix_eta * region.ep.second]->GetBinContent(ptbin) + sigma * m_pars_LB[region.ep.first + Pix_eta * region.ep.second]->GetBinError(ptbin);
569  //***
570 
571  }else{
572 
573  //***
574  if (region.status == TS::CORE) clast = m_pars_EB[region.ep.first + Pix_eta * region.ep.second]->GetBinContent(ptbin) + sigma * m_core_sys_EB->GetBinContent(ptbin_sys); //systematics are bigger if we are in the core
575  else clast = m_pars_EB[region.ep.first + Pix_eta * region.ep.second]->GetBinContent(ptbin) + sigma * m_pars_EB[region.ep.first + Pix_eta * region.ep.second]->GetBinError(ptbin);
576  //***
577 
578 
579  }
580  corrections.push_back(clast);
581  }
582 
583  return corrections;
584  }

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

◆ getModulePosition()

IPair CP::JetTileCorrectionTool::getModulePosition ( const xAOD::Jet &  jet,
JTC::Hole  module 
)
private

Definition at line 412 of file JetTileCorrectionTool.cxx.

412  {
413 
414  float eta = (mod.eta1+mod.eta2)/2.;
415  float phi = (mod.phi1+mod.phi2)/2.;
416 
417  float jet_eta = jet.jetP4(xAOD::JetConstitScaleMomentum).eta();
418  float jet_phi = jet.jetP4(xAOD::JetConstitScaleMomentum).phi();
419 
420  float eta_dist = jet_eta-eta;
421  float phi_dist = TVector2::Phi_mpi_pi((double)jet_phi - (double)phi);
422 
423  int inphi;
424 
425  if(std::abs(phi_dist)<0.05){ inphi=0; }
426  else if(std::abs(phi_dist)<0.1){ inphi=1; }
427  else if(std::abs(phi_dist)<0.2){ inphi=2; }
428  else if(std::abs(phi_dist)<0.3){ inphi=3; }
429  else if(std::abs(phi_dist)<0.4){ inphi=4; }
430  else { inphi=5;}
431 
432  float ieta = eta_dist/PIXWIDTH;
433  int ineta = (int)ieta;
434 
435 
436  //get parametrization from positive side always!
437  if(mod.eta1 < -0.1) ineta = -ineta;
438 
439  return std::make_pair(ineta+8, inphi);
440  }

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

◆ getProperty()

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

Get one of the tool's properties.

◆ getPtBin()

int CP::JetTileCorrectionTool::getPtBin ( float  pt)
private

Definition at line 587 of file JetTileCorrectionTool.cxx.

587  {
588 
589  if(pt < 20000.) return -1;
590 
591  int ptbin = m_pars_LB[0]->FindBin(pt*0.001); // no correction below 20GeV
592 
593  //adjust under/overflows
594  if (ptbin < 1) ptbin = 1;
595  if (ptbin > m_NbinsPt) ptbin = m_NbinsPt;
596 
597  return ptbin;
598  }

◆ getTileStatus()

JTC::TS CP::JetTileCorrectionTool::getTileStatus ( const xAOD::Jet &  jet)
virtual

Implements CP::IJetTileCorrectionTool.

Definition at line 477 of file JetTileCorrectionTool.cxx.

477  {
478  JTC::TS status = TS::GOOD;
479  if( loadAllModules(jet, status) != StatusCode::SUCCESS ){
480  ATH_MSG_ERROR( "Something went wrong while loading/checking the modules!");
481  return TS::UNKNOWN;
482  }
483  return status;
484  }

◆ handle()

void asg::AsgMetadataTool::handle ( const Incident &  inc)
protectedvirtualinherited

Function receiving incidents from IncidentSvc/TEvent.

Reimplemented in Trig::TrigDecisionTool.

Definition at line 130 of file AsgMetadataTool.cxx.

130  {
131 
132  // Tell the user what's happening:
133  ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
134 
135  // Call the appropriate member function:
136  if( inc.type() == IncidentType::BeginInputFile ) {
137  m_beginInputFileCalled = true;
138  if( beginInputFile().isFailure() ) {
139  ATH_MSG_FATAL( "Failed to call beginInputFile()" );
140  throw std::runtime_error( "Couldn't call beginInputFile()" );
141  }
142  } else if( inc.type() == IncidentType::EndInputFile ) {
143  if( endInputFile().isFailure() ) {
144  ATH_MSG_FATAL( "Failed to call endInputFile()" );
145  throw std::runtime_error( "Couldn't call endInputFile()" );
146  }
147  } else if( inc.type() == IncidentType::BeginEvent ) {
148  // If the tool didn't catch the begin input file incident for the
149  // first input file of the job, then call the appropriate function
150  // now.
151  if( ! m_beginInputFileCalled ) {
152  m_beginInputFileCalled = true;
153  if( beginInputFile().isFailure() ) {
154  ATH_MSG_FATAL( "Failed to call beginInputFile()" );
155  throw std::runtime_error( "Couldn't call beginInputFile()" );
156  }
157  }
158  if( beginEvent().isFailure() ) {
159  ATH_MSG_FATAL( "Failed to call beginEvent()" );
160  throw std::runtime_error( "Couldn't call beginEvent()" );
161  }
162 
163  #ifdef XAOD_STANDALONE
164  } else if( inc.type() == IncidentType::MetaDataStop ) {
165  if( metaDataStop().isFailure() ) {
166  ATH_MSG_FATAL( "Failed to call metaDataStop()" );
167  throw std::runtime_error( "Couldn't call metaDataStop()" );
168  }
169 
170  #endif // XAOD_STANDALONE
171  } else {
172  ATH_MSG_WARNING( "Unknown incident type received in AsgMetaDataTool: " << inc.type() );
173  }
174 
175  return;
176  }

◆ inHole() [1/2]

bool CP::JetTileCorrectionTool::inHole ( const xAOD::Jet &  j,
JTC::Hole  rdead 
)
private

Definition at line 606 of file JetTileCorrectionTool.cxx.

606  {
607  return inHole(jet.eta(), jet.phi(), rdead);
608  }

◆ inHole() [2/2]

bool CP::JetTileCorrectionTool::inHole ( float  eta,
float  phi,
JTC::Hole  rdead 
)
private

Definition at line 611 of file JetTileCorrectionTool.cxx.

611  {
612 
613  if(rdead.eta1==rdead.eta2 || rdead.phi1==rdead.phi2) return false;
614  if((eta > rdead.eta1) && (eta < rdead.eta2) && (phi > rdead.phi1) && (phi < rdead.phi2)) return true;
615 
616  return false;
617  }

◆ inIOV()

bool CP::JetTileCorrectionTool::inIOV ( JTC::Hole  region,
int  run 
)
private

Definition at line 600 of file JetTileCorrectionTool.cxx.

600  {
601  if( region.iov.first>=0 && (run < region.iov.first) ) return false;
602  if( region.iov.second>=0 && (run > region.iov.second) ) return false;
603  return true;
604  }

◆ initialize()

StatusCode CP::JetTileCorrectionTool::initialize ( )
virtual

Function initialising the tool.

Reimplemented from asg::AsgTool.

Definition at line 61 of file JetTileCorrectionTool.cxx.

61  {
62 
63  // Greet the user:
64  ATH_MSG_INFO( "Initialising..." );
65 
66 #ifdef XAOD_STANDALONE
67  // Retrieve the event information (check if MC or data)
68  const xAOD::EventInfo* ei(nullptr);
69  ATH_CHECK( evtStore()->retrieve( ei, "EventInfo" ) );
70 
71  m_isMC = ei->eventType( xAOD::EventInfo::IS_SIMULATION );
72 #else
73  // Retrieve the metadata (check if MC or data)
74  std::string projectName = "";
75  ATH_CHECK( AthAnalysisHelper::retrieveMetadata("/TagInfo", "project_name", projectName, inputMetaStore() ) );
76  if ( projectName == "IS_SIMULATION" ) m_isMC = true;
77  else if (projectName.compare(0, 4, "data") == 0 ) m_isMC = false;
78  ATH_MSG_INFO("Set up JetTileCorrectionTool -- this is MC? " << m_isMC);
79 #endif
80 
81 
82  //set RJET
83  setRJET( (float) RJET );
84 
85  //Load user dead regions map
86  loadDeadUser();
87 
88  //Load dead regions in DB map
89  loadDeadDB();
90 
91  // Load the ROOT file
92  std::string fname = PathResolverFindCalibFile(m_rootFileName);
93  m_rootFile = TFile::Open( fname.c_str(), "READ" );
94 
95  if ( !m_rootFile ) {
96  ATH_MSG_ERROR("Parametrization file " << m_rootFileName << "not found!");
97  return StatusCode::FAILURE;
98  }
99 
100  //Load parametrizations
101  TString sub="";
102 
103  m_pars_LB={};
104  m_pars_EB={};
105 
106 
107  for(unsigned int ieta=0; ieta < Pix_eta ; ieta++){
108  for(unsigned int iphi=0; iphi < Pix_phi ; iphi++){
109  sub = Form("_%d_%d",ieta,iphi);
110 
111  //flatten 2D-etaphi-to-1D
112  m_pars_LB[ieta+iphi*Pix_eta]=(TH1F*)m_rootFile->Get("param_LB_fit"+sub);
113  m_pars_EB[ieta+iphi*Pix_eta]=(TH1F*)m_rootFile->Get("param_EB_fit"+sub);
114  m_pars_LB[ieta+iphi*Pix_eta]->SetDirectory(nullptr);
115  m_pars_EB[ieta+iphi*Pix_eta]->SetDirectory(nullptr);
116  }
117  }
118 
119  //***
120  m_core_sys_LB=(TH1F*)m_rootFile->Get("sys_LB");
121  m_core_sys_EB=(TH1F*)m_rootFile->Get("sys_EB");
122  //***
123 
124  //book number of pt bins in parametrization for later
125  m_NbinsPt = m_pars_LB[0]->GetNbinsX();
126 
127 
128  // set up for default running without systematics
129  if (!applySystematicVariation (SystematicSet ())) {
130  ATH_MSG_ERROR("Loading the central value systematic set failed.");
131  return StatusCode::FAILURE;
132  }
133  // Add the affecting systematics to the global registry
134  SystematicRegistry& registry = SystematicRegistry::getInstance();
135  if (registry.registerSystematics(*this) != StatusCode::SUCCESS){
136  ATH_MSG_ERROR("Unable to register the systematics");
137  return StatusCode::FAILURE;
138  }
139 
140  ATH_MSG_DEBUG("Successfully initialized! ");
141 
142  // Return gracefully:
143  return StatusCode::SUCCESS;
144  }

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

◆ inputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::inputMetaStore ( ) const
inherited

Accessor for the input metadata store.

Definition at line 88 of file AsgMetadataTool.cxx.

88  {
89 
90 #ifdef XAOD_STANDALONE
91  return &m_inputMetaStore;
92 #else // XAOD_STANDALONE
93  return m_inputMetaStore;
94 #endif // XAOD_STANDALONE
95  }

◆ isAffectedBySystematic()

bool CP::JetTileCorrectionTool::isAffectedBySystematic ( const SystematicVariation &  systematic) const
virtual

returns: whether this tool is affected by the given systematic

Implements CP::ISystematicsTool.

Definition at line 219 of file JetTileCorrectionTool.cxx.

220  {
221  SystematicSet sys = affectingSystematics();
222  return sys.find (systematic) != sys.end ();
223  }

◆ loadAllModules()

StatusCode CP::JetTileCorrectionTool::loadAllModules ( const xAOD::Jet &  jet,
JTC::TS &  status 
)
private

Definition at line 498 of file JetTileCorrectionTool.cxx.

498  {
499 
500  m_position_masked.clear();
501 
502  //Read dead regions DB if we change run/LB
503  if(!m_isMC){
504 
505  const xAOD::EventInfo* ei = nullptr;
506  if( evtStore()->retrieve( ei, "EventInfo" ).isFailure() ) {
507  ATH_MSG_WARNING( "No EventInfo object could be retrieved" );
508  }
509 
510  if (!ei) {
511  ATH_MSG_ERROR( "Cannot retrieve the EventInfo" );
512  return StatusCode::FAILURE;
513  }
514 
515  m_current_run = ei->runNumber();
516 
517  }
518 
519  //load DB-defined modules in LB
520  loadModulesFromMap(jet, status, m_db_dead_LB, PART::LB, TYPE::DB);
521  //load DB-defined modules in EB
522  loadModulesFromMap(jet, status, m_db_dead_EB, PART::EB, TYPE::DB);
523 
524  //load user-defined modules in LB
525  loadModulesFromMap(jet, status, m_user_dead_LB, PART::LB, TYPE::User);
526  //load user-defined modules in EB
527  loadModulesFromMap(jet, status, m_user_dead_EB, PART::EB, TYPE::User);
528 
529  //sort modules by correction size (in decreasing order)
530  std::sort(m_position_masked.begin(), m_position_masked.end(), std::greater<Region>());
531 
532  return StatusCode::SUCCESS;
533  }

◆ loadDeadDB()

void CP::JetTileCorrectionTool::loadDeadDB ( )
private

Definition at line 338 of file JetTileCorrectionTool.cxx.

338  {
339 
340  m_db_dead_LB = {};
341  m_db_dead_EB = {};
342 
343  std::vector<Hole> dbholes={};
344 
345  //Simulation
346  if(m_isMC){
347 
348  //-- MC15c : no dead modules
349  //COOLOFL_TILE/OFLP200 /TILE/OFL02/STATUS/ADC TileOfl02StatusAdc-IOVDEP-05
350  //COOLOFL_TILE/OFLP200 /TILE/OFL02/NOISE/CELL TileOfl02NoiseCell-OF2-07
351  //
352 
353  //TODO: add RunNumber check and add these below if running on MC15b //M.T.
354 
355  //-- MC15b : two dead modules
356  //COOLOFL_TILE/OFLP200 /TILE/OFL02/STATUS/ADC TileOfl02StatusAdc-IOVDEP-05
357  //COOLOFL_TILE/OFLP200 /TILE/OFL02/NOISE/CELL TileOfl02NoiseCell-OF2-07
358  //
359  // //LBA10
360  // Hole rdead = partModToHole(0, 9);
361  // rdead.iov = make_pair(0,1000000); //no range
362  // dbholes.push_back( rdead );
363 
364  // //EBC21
365  // rdead = partModToHole(3, 20);
366  // rdead.iov = make_pair(0,1000000); //no range
367  // dbholes.push_back( rdead );
368 
369  }
370  else{ //DATA
371 
372  //read map file
373  std::string mapFilename = PathResolverFindCalibFile(m_bd_dead_mapFile);
374  std::ifstream mapFile;
375  mapFile.open(mapFilename);
376 
377  std::string line;
378  while (std::getline(mapFile, line)){
379 
380  if(line[0]=='#') continue;
381 
382  std::istringstream iss(line);
383  int part,mod, irun, erun;
384  std::string modname;
385 
386  if (!(iss >> part >> mod >> irun >> erun >> modname)) { break; } // error
387 
388  Hole rdead = partModToHole(part, mod);
389  rdead.iov = std::make_pair(irun,erun);
390  dbholes.push_back( rdead );
391 
392  }
393  }
394 
395  int dbh=1;
396  for(const auto& h : dbholes){
397  if(std::abs(h.eta1)>1 || std::abs(h.eta2)>1){
398  m_db_dead_EB[Form("DB%d",dbh)] = h;
399  }
400  else{
401  m_db_dead_LB[Form("DB%d",dbh)] = h;
402  }
403 
404  dbh++;
405 
406  // ATH_MSG_INFO("Adding DB dead module at (eta1,phi1)=(" << h.eta1 << "," << h.phi1 << ")");
407  ATH_MSG_DEBUG("Adding DB dead module at (eta1,phi1)=(" << h.eta1 << "," << h.phi1 << ")");
408  }
409  }

◆ loadDeadUser()

void CP::JetTileCorrectionTool::loadDeadUser ( )
private

Definition at line 287 of file JetTileCorrectionTool.cxx.

287  {
288 
289  m_user_dead_LB = {};
290  m_user_dead_EB = {};
291 
292  //Format accepted for module input: "LBA 10" == "0 9"
293  for(auto& r : m_v_user_dead){
294 
295  std::stringstream ss(r);
296  std::string s;
297 
298  std::vector<std::string> tokens;
299  while (getline(ss, s, ' ')) {
300  tokens.push_back(s);
301  }
302 
303  if(tokens.size() < 2){
304  ATH_MSG_ERROR("Part-Module pair " << r << " not known! Please use \"PART MOD\" format ");
305  continue;
306  }
307 
308  int i_part = 0;
309  int i_mod = std::atoi((tokens.at(1)).c_str());
310  if (tokens.at(0).find('B') != std::string::npos)
311  i_mod -= 1; // substract 1 from second coor if given in format "LBA 4"
312 
313  if(tokens.at(0)=="LBA" || tokens.at(0)== "0"){
314  i_part = 0;
315  }else if (tokens.at(0)=="LBC" || tokens.at(0)== "1"){
316  i_part = 1;
317  }else if (tokens.at(0)=="EBA" || tokens.at(0)== "2"){
318  i_part = 2;
319  }else if (tokens.at(0)=="EBC" || tokens.at(0)== "3"){
320  i_part = 3;
321  }else{
322  ATH_MSG_ERROR("Part-Module pair " << r << " not known! Please use \"PART MOD\" format ");
323  continue;
324  }
325 
326  //Classify into long and extended barrel modules
327  Hole rdead = partModToHole(i_part, i_mod);
328 
329  if( i_part < 2 )
330  m_user_dead_LB[r] = rdead; //LBA, LBC
331  else
332  m_user_dead_EB[r] = rdead; //EBA, EBC
333 
334  }
335  }

◆ loadModulesFromMap()

void CP::JetTileCorrectionTool::loadModulesFromMap ( const xAOD::Jet &  jet,
JTC::TS &  status,
const std::map< std::string, JTC::Hole > &  hmap,
JTC::PART  part = JTC::PART::LB,
JTC::TYPE  type = JTC::TYPE::DB 
)
private

Definition at line 442 of file JetTileCorrectionTool.cxx.

442  {
443 
444  float cfactor(0.);
445  IPair mpos;
446  JTC::TS cstatus = TS::GOOD;
447 
448  for (const auto& mod : hmap){
449 
450  //check IOV for DB defined modules
451  if(!m_isMC && type == TYPE::DB && !inIOV(mod.second, m_current_run)) continue;
452 
453  cstatus = overlap(jet,mod.second);
454  if(cstatus != TS::GOOD){
455 
456  //get eta-phi position (relative to jet axis)
457  mpos = getModulePosition(jet,mod.second);
458 
459  //get correction (1D-array)
460  if(part == PART::LB)
461  cfactor = m_pars_LB[mpos.first + Pix_eta * mpos.second]->GetBinContent(getPtBin(jet.pt()));
462  else
463  cfactor = m_pars_EB[mpos.first + Pix_eta * mpos.second]->GetBinContent(getPtBin(jet.pt()));
464 
465  //overwrite global status with worst case
466  if(cstatus > status) status = cstatus;
467 
468  //create new d-region and add it to the list
469  m_position_masked.emplace_back( mod.second,mpos,part,cfactor,cstatus,type );
470 
471  }
472  }
473 
474  }

◆ metaDataStop()

StatusCode asg::AsgMetadataTool::metaDataStop ( )
protectedvirtualinherited

Function called when the tool should write out its metadata.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in xAODMaker::FileMetaDataTool, BookkeeperTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 204 of file AsgMetadataTool.cxx.

204  {
205 
206  // Return gracefully:
207  return StatusCode::SUCCESS;
208  }

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

◆ outputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::outputMetaStore ( ) const
inherited

Accessor for the output metadata store.

Definition at line 97 of file AsgMetadataTool.cxx.

97  {
98 
99 #ifdef XAOD_STANDALONE
100  return &m_outputMetaStore;
101 #else // XAOD_STANDALONE
102  return m_outputMetaStore;
103 #endif // XAOD_STANDALONE
104  }

◆ overlap()

JTC::TS CP::JetTileCorrectionTool::overlap ( const xAOD::Jet &  j,
JTC::Hole  region 
)
private

Definition at line 268 of file JetTileCorrectionTool.cxx.

268  {
269 
270  double phisize = region.phi2-region.phi1;
271  double phicenter = (region.phi1+region.phi2)/2.;
272  float jet_eta = j.jetP4(xAOD::JetConstitScaleMomentum).eta();
273  float jet_phi = j.jetP4(xAOD::JetConstitScaleMomentum).phi();
274 
275  // GOOD?
276  if( region.eta2 < (jet_eta-m_RJET) ) return TS::GOOD;
277  if( region.eta1 > (jet_eta+m_RJET) ) return TS::GOOD;
278  if( std::abs(TVector2::Phi_mpi_pi(jet_phi-phicenter)) > m_RJET+phisize/2.) return TS::GOOD;
279 
280  // CORE-BAD?
281  if( inHole(jet_eta, jet_phi, region) ) return TS::CORE;
282 
283  // CORE-EDGE? (elsewhere)
284  return TS::EDGE;
285  }

◆ partModToHole()

Hole CP::JetTileCorrectionTool::partModToHole ( int  part,
int  mod 
)
private

Definition at line 619 of file JetTileCorrectionTool.cxx.

619  {
620 
621  Hole region;
622  region.iov = std::make_pair(0,1000000); //a dummy full IOV is set by default
623 
624  switch(part){
625  case 0: //LBA
626  region.eta1=0;
627  region.eta2=0.9;
628  break;
629  case 1: //LBC
630  region.eta1=-0.9;
631  region.eta2=0;
632  break;
633  case 2: //EBA
634  region.eta1=0.8;
635  region.eta2=1.7;
636  break;
637  case 3: //EBC
638  region.eta1=-1.7;
639  region.eta2=-0.8;
640  break;
641  default:
642  std::cout<<"Bad partition value passed!\n";
643  region.eta1=-999;
644  region.eta2=-999;
645  region.phi1=-999;
646  region.phi2=-999;
647  return region;
648  }
649  if(mod<32){
650  region.phi1=((double)mod)*width;
651  region.phi2=region.phi1+width;
652  }
653  else if(mod<64){
654  region.phi1=((double)mod)*width-2.*M_PI;
655  region.phi2=region.phi1+width;
656  }
657  else{
658  std::cout<<"Bad module value passed!\n";
659  region.eta1=-999;
660  region.eta2=-999;
661  region.phi1=-999;
662  region.phi2=-999;
663  return region;
664  }
665  return region;
666  }

◆ print() [1/2]

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

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, top::TopObjectSelection, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

Print the state of the tool.

Implemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, top::TopObjectSelection, asg::AsgTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

◆ recommendedSystematics()

SystematicSet CP::JetTileCorrectionTool::recommendedSystematics ( ) const
virtual

returns: the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 236 of file JetTileCorrectionTool.cxx.

237  {
238  return affectingSystematics();
239  }

◆ registerSystematics()

StatusCode CP::JetTileCorrectionTool::registerSystematics ( )

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

◆ setRJET()

void CP::JetTileCorrectionTool::setRJET ( float  r)
virtual

Implements CP::IJetTileCorrectionTool.

Definition at line 493 of file JetTileCorrectionTool.cxx.

493  {
494  m_RJET = r;
495  }

◆ setUseIncidents()

void asg::AsgMetadataTool::setUseIncidents ( const bool  flag)
inlineprotectedinherited

Definition at line 132 of file AsgMetadataTool.h.

133  {
134  m_useIncidents = flag;
135  }

◆ sysInitialize()

StatusCode asg::AsgMetadataTool::sysInitialize ( )
virtualinherited

Function initialising the tool in the correct way in Athena.

This function is used to set up the callbacks from IncidentSvc in Athena at the right time during initialisation, without the user having to do anything special in his/her code.

Reimplemented from AthCommonDataStore< AthCommonMsg< AlgTool > >.

Definition at line 110 of file AsgMetadataTool.cxx.

110  {
111 
112 #ifndef XAOD_STANDALONE
113  if (m_useIncidents) {
114  // Connect to the IncidentSvc:
115  ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
116  ATH_CHECK( incSvc.retrieve() );
117 
118  // Set up the right callbacks: don't rethrow exceptions, any failure and we should end
119  incSvc->addListener( this, IncidentType::BeginEvent, 0, false );
120  }
121  // Let the base class do its thing:
122  ATH_CHECK( AlgTool::sysInitialize() );
123 
124 #endif // not XAOD_STANDALONE
125 
126  // Return gracefully:
127  return StatusCode::SUCCESS;
128  }

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

CP::SystematicSet* CP::JetTileCorrectionTool::m_appliedSystematics = 0
private

Currently applied systematics.

Definition at line 160 of file JetTileCorrectionTool.h.

◆ m_bd_dead_mapFile

std::string CP::JetTileCorrectionTool::m_bd_dead_mapFile
private

Definition at line 138 of file JetTileCorrectionTool.h.

◆ m_beginInputFileCalled

bool asg::AsgMetadataTool::m_beginInputFileCalled
privateinherited

Flag helping to discover when the tool misses the opening of the first input file.

Definition at line 126 of file AsgMetadataTool.h.

◆ m_constScale

bool CP::JetTileCorrectionTool::m_constScale = false
private

Definition at line 125 of file JetTileCorrectionTool.h.

◆ m_core_sys_EB

TH1F* CP::JetTileCorrectionTool::m_core_sys_EB = 0
private

Definition at line 144 of file JetTileCorrectionTool.h.

◆ m_core_sys_LB

TH1F* CP::JetTileCorrectionTool::m_core_sys_LB = 0
private

//needs to be transient!

Definition at line 143 of file JetTileCorrectionTool.h.

◆ m_current_run

int CP::JetTileCorrectionTool::m_current_run = -1
private

Definition at line 128 of file JetTileCorrectionTool.h.

◆ m_db_dead_EB

std::map<std::string,JTC::Hole> CP::JetTileCorrectionTool::m_db_dead_EB
private

Definition at line 150 of file JetTileCorrectionTool.h.

◆ m_db_dead_LB

std::map<std::string,JTC::Hole> CP::JetTileCorrectionTool::m_db_dead_LB
private

Definition at line 149 of file JetTileCorrectionTool.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_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_inputMetaStore

MetaStore_t asg::AsgMetadataTool::m_inputMetaStore
privateinherited

Object accessing the input metadata store.

Definition at line 119 of file AsgMetadataTool.h.

◆ m_isData

bool CP::JetTileCorrectionTool::m_isData
protected

Definition at line 99 of file JetTileCorrectionTool.h.

◆ m_isMC

bool CP::JetTileCorrectionTool::m_isMC = false
private

Definition at line 126 of file JetTileCorrectionTool.h.

◆ m_NbinsPt

int CP::JetTileCorrectionTool::m_NbinsPt = -1
private

Definition at line 131 of file JetTileCorrectionTool.h.

◆ m_outputMetaStore

MetaStore_t asg::AsgMetadataTool::m_outputMetaStore
privateinherited

Object accessing the output metadata store.

Definition at line 121 of file AsgMetadataTool.h.

◆ m_pars_EB

std::map<int,TH1F*> CP::JetTileCorrectionTool::m_pars_EB
private

Definition at line 148 of file JetTileCorrectionTool.h.

◆ m_pars_LB

std::map<int,TH1F*> CP::JetTileCorrectionTool::m_pars_LB
private

Definition at line 147 of file JetTileCorrectionTool.h.

◆ m_position_masked

std::vector<JTC::Region> CP::JetTileCorrectionTool::m_position_masked
private

Definition at line 140 of file JetTileCorrectionTool.h.

◆ m_RJET

float CP::JetTileCorrectionTool::m_RJET
private

Definition at line 154 of file JetTileCorrectionTool.h.

◆ m_rootFile

TFile* CP::JetTileCorrectionTool::m_rootFile = 0
private

Definition at line 135 of file JetTileCorrectionTool.h.

◆ m_rootFileName

std::string CP::JetTileCorrectionTool::m_rootFileName
private

Definition at line 136 of file JetTileCorrectionTool.h.

◆ m_systFilter

std::unordered_map<CP::SystematicSet, CP::SystematicSet> CP::JetTileCorrectionTool::m_systFilter
private

Systematics filter map.

Definition at line 157 of file JetTileCorrectionTool.h.

◆ m_useIncidents

bool asg::AsgMetadataTool::m_useIncidents
privateinherited

Definition at line 128 of file AsgMetadataTool.h.

◆ m_user_dead_EB

std::map<std::string,JTC::Hole> CP::JetTileCorrectionTool::m_user_dead_EB
private

Definition at line 152 of file JetTileCorrectionTool.h.

◆ m_user_dead_LB

std::map<std::string,JTC::Hole> CP::JetTileCorrectionTool::m_user_dead_LB
private

Definition at line 151 of file JetTileCorrectionTool.h.

◆ m_v_user_dead

std::vector<std::string> CP::JetTileCorrectionTool::m_v_user_dead
private

Definition at line 133 of file JetTileCorrectionTool.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:
CP::JetTileCorrectionTool::getPtBin
int getPtBin(float pt)
Definition: JetTileCorrectionTool.cxx:587
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
python.Dso.registry
registry
Definition: Control/AthenaServices/python/Dso.py:159
JTC::TS
TS
Definition: IJetTileCorrectionTool.h:27
JTC::Hole::iov
std::pair< int, int > iov
Definition: IJetTileCorrectionTool.h:36
CP::JetTileCorrectionTool::m_pars_LB
std::map< int, TH1F * > m_pars_LB
Definition: JetTileCorrectionTool.h:147
beamspotman.r
def r
Definition: beamspotman.py:676
iov_pt_max
const float iov_pt_max
Definition: JetTileCorrectionTool.cxx:33
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
checkFileSG.line
line
Definition: checkFileSG.py:75
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
asg::AsgMetadataTool::beginEvent
virtual StatusCode beginEvent()
Function called when a new events is loaded.
Definition: AsgMetadataTool.cxx:196
get_generator_info.result
result
Definition: get_generator_info.py:21
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CP::JetTileCorrectionTool::inIOV
bool inIOV(JTC::Hole region, int run)
Definition: JetTileCorrectionTool.cxx:600
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
CP::JetTileCorrectionTool::m_RJET
float m_RJET
Definition: JetTileCorrectionTool.h:154
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
RJET
#define RJET
Definition: JetTileCorrectionTool.h:33
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CP::JetTileCorrectionTool::m_user_dead_EB
std::map< std::string, JTC::Hole > m_user_dead_EB
Definition: JetTileCorrectionTool.h:152
JTC::TS::UNKNOWN
@ UNKNOWN
JTC::Hole::phi1
double phi1
Definition: IJetTileCorrectionTool.h:34
JTC::TYPE::User
@ User
iov_aeta_max
const float iov_aeta_max
Definition: JetTileCorrectionTool.cxx:34
width
const double width
Definition: JetTileCorrectionTool.cxx:29
test_pyathena.pt
pt
Definition: test_pyathena.py:11
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
M_PI
#define M_PI
Definition: ActiveFraction.h:11
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
asg::AsgMetadataTool::inputMetaStore
MetaStorePtr_t inputMetaStore() const
Accessor for the input metadata store.
Definition: AsgMetadataTool.cxx:88
CP::JetTileCorrectionTool::m_v_user_dead
std::vector< std::string > m_v_user_dead
Definition: JetTileCorrectionTool.h:133
xAOD::Jet_v1::jetP4
JetFourMom_t jetP4() const
The full 4-momentum of the particle : internal jet type.
Definition: Jet_v1.cxx:76
CP::JetTileCorrectionTool::m_db_dead_EB
std::map< std::string, JTC::Hole > m_db_dead_EB
Definition: JetTileCorrectionTool.h:150
asg::AsgMetadataTool::m_beginInputFileCalled
bool m_beginInputFileCalled
Flag helping to discover when the tool misses the opening of the first input file.
Definition: AsgMetadataTool.h:126
asg::AsgMetadataTool::endInputFile
virtual StatusCode endInputFile()
Function called when the currently open input file got completely processed.
Definition: AsgMetadataTool.cxx:188
asg::AsgMetadataTool::m_outputMetaStore
MetaStore_t m_outputMetaStore
Object accessing the output metadata store.
Definition: AsgMetadataTool.h:121
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
CP::JetTileCorrectionTool::loadAllModules
StatusCode loadAllModules(const xAOD::Jet &jet, JTC::TS &status)
Definition: JetTileCorrectionTool.cxx:498
beamspotman.tokens
tokens
Definition: beamspotman.py:1284
CP::SystematicVariation
Definition: SystematicVariation.h:47
IPair
std::pair< int, int > IPair
Definition: IJetTileCorrectionTool.h:21
CP::JetTileCorrectionTool::m_appliedSystematics
CP::SystematicSet * m_appliedSystematics
Currently applied systematics.
Definition: JetTileCorrectionTool.h:160
Phi_mpi_pi
__HOSTDEV__ double Phi_mpi_pi(double)
Definition: GeoRegion.cxx:7
xAOD::EventInfo_v1::IS_SIMULATION
@ IS_SIMULATION
true: simulation, false: data
Definition: EventInfo_v1.h:151
CP::JetTileCorrectionTool::partModToHole
JTC::Hole partModToHole(int part, int mod)
Definition: JetTileCorrectionTool.cxx:619
CP::JetTileCorrectionTool::getCorrections
std::vector< float > getCorrections(const xAOD::Jet &j)
Definition: JetTileCorrectionTool.cxx:535
CP::SystematicSet::getParameterByBaseName
float getParameterByBaseName(const std::string &basename) const
returns: the parameter value for the given basename
Definition: SystematicSet.cxx:193
python.PyAthena.modname
modname
print (" ==> moduletype")
Definition: PyAthena.py:133
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
CP::JetTileCorrectionTool::m_pars_EB
std::map< int, TH1F * > m_pars_EB
Definition: JetTileCorrectionTool.h:148
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
xAOD::JetConstitScaleMomentum
@ JetConstitScaleMomentum
Definition: JetTypes.h:29
CommonSkeletonJobOptions.projectName
projectName
Definition: CommonSkeletonJobOptions.py:49
JTC::Hole::phi2
double phi2
Definition: IJetTileCorrectionTool.h:35
CP::JetTileCorrectionTool::m_bd_dead_mapFile
std::string m_bd_dead_mapFile
Definition: JetTileCorrectionTool.h:138
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
CP::JetTileCorrectionTool::m_db_dead_LB
std::map< std::string, JTC::Hole > m_db_dead_LB
Definition: JetTileCorrectionTool.h:149
CP::CorrectionCode::OutOfValidityRange
@ OutOfValidityRange
Input object is out of validity range.
Definition: CorrectionCode.h:37
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition: CorrectionCode.h:36
EDGE
#define EDGE
Definition: BooleanProcessor.h:96
Pix_eta
#define Pix_eta
Definition: JetTileCorrectionTool.h:36
CP::JetTileCorrectionTool::getModulePosition
IPair getModulePosition(const xAOD::Jet &jet, JTC::Hole module)
Definition: JetTileCorrectionTool.cxx:412
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
h
extractSporadic.h
list h
Definition: extractSporadic.py:97
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
asg::AsgMetadataTool::beginInputFile
virtual StatusCode beginInputFile()
Function called when a new input file is opened.
Definition: AsgMetadataTool.cxx:180
master.flag
bool flag
Definition: master.py:29
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
CP::JetTileCorrectionTool::m_rootFileName
std::string m_rootFileName
Definition: JetTileCorrectionTool.h:136
asg::AsgMetadataTool::metaDataStop
virtual StatusCode metaDataStop()
Function called when the tool should write out its metadata.
Definition: AsgMetadataTool.cxx:204
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
run
Definition: run.py:1
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
CP::JetTileCorrectionTool::inHole
bool inHole(const xAOD::Jet &j, JTC::Hole rdead)
Definition: JetTileCorrectionTool.cxx:606
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
JTC::TYPE::DB
@ DB
CP::JetTileCorrectionTool::getTileStatus
JTC::TS getTileStatus(const xAOD::Jet &jet)
Definition: JetTileCorrectionTool.cxx:477
CP::JetTileCorrectionTool::m_current_run
int m_current_run
Definition: JetTileCorrectionTool.h:128
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
merge.output
output
Definition: merge.py:17
PIXWIDTH
#define PIXWIDTH
Definition: JetTileCorrectionTool.h:31
xAOD::JetFourMom_t
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > > JetFourMom_t
Base 4 Momentum type for Jet.
Definition: JetTypes.h:17
CP::JetTileCorrectionTool::applyCorrection
virtual CorrectionCode applyCorrection(xAOD::Jet &object)
Apply the correction on a modifyable object.
Definition: JetTileCorrectionTool.cxx:147
CP::JetTileCorrectionTool::m_systFilter
std::unordered_map< CP::SystematicSet, CP::SystematicSet > m_systFilter
Systematics filter map.
Definition: JetTileCorrectionTool.h:157
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
asg::AsgMetadataTool::m_inputMetaStore
MetaStore_t m_inputMetaStore
Object accessing the input metadata store.
Definition: AsgMetadataTool.h:119
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
iov_pt_min
const float iov_pt_min
Definition: JetTileCorrectionTool.cxx:32
CP::JetTileCorrectionTool::m_NbinsPt
int m_NbinsPt
Definition: JetTileCorrectionTool.h:131
CP::JetTileCorrectionTool::m_rootFile
TFile * m_rootFile
Definition: JetTileCorrectionTool.h:135
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
JTC::Hole
Definition: IJetTileCorrectionTool.h:31
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
CP::JetTileCorrectionTool::loadDeadDB
void loadDeadDB()
Definition: JetTileCorrectionTool.cxx:338
JTC::Hole::eta1
double eta1
Definition: IJetTileCorrectionTool.h:32
a
TList * a
Definition: liststreamerinfos.cxx:10
h
CP::JetTileCorrectionTool::m_user_dead_LB
std::map< std::string, JTC::Hole > m_user_dead_LB
Definition: JetTileCorrectionTool.h:151
asg::AsgMetadataTool
Base class for dual-use tools that provide file metadata access.
Definition: AsgMetadataTool.h:48
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
Pix_phi
#define Pix_phi
Definition: JetTileCorrectionTool.h:37
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::JetTileCorrectionTool::m_position_masked
std::vector< JTC::Region > m_position_masked
Definition: JetTileCorrectionTool.h:140
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
CP::JetTileCorrectionTool::m_core_sys_LB
TH1F * m_core_sys_LB
//needs to be transient!
Definition: JetTileCorrectionTool.h:143
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
JTC::TS::GOOD
@ GOOD
JTC::Hole::eta2
double eta2
Definition: IJetTileCorrectionTool.h:33
CP::JetTileCorrectionTool::loadDeadUser
void loadDeadUser()
Definition: JetTileCorrectionTool.cxx:287
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
merge.status
status
Definition: merge.py:17
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
CP::JetTileCorrectionTool::overlap
JTC::TS overlap(const xAOD::Jet &j, JTC::Hole region)
Definition: JetTileCorrectionTool.cxx:268
SG::DataProxy
Definition: DataProxy.h:44
CP::JetTileCorrectionTool::m_core_sys_EB
TH1F * m_core_sys_EB
Definition: JetTileCorrectionTool.h:144
CP::JetTileCorrectionTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const SystematicSet &systConfig)
effects: configure this tool for the given list of systematic variations.
Definition: JetTileCorrectionTool.cxx:242
CP::JetTileCorrectionTool::affectingSystematics
virtual SystematicSet affectingSystematics() const
returns: the list of all systematics this tool can be affected by
Definition: JetTileCorrectionTool.cxx:226
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
JTC::PART::LB
@ LB
CP::JetTileCorrectionTool::m_isMC
bool m_isMC
Definition: JetTileCorrectionTool.h:126
CP::SystematicSet::filterForAffectingSystematics
static StatusCode filterForAffectingSystematics(const SystematicSet &systConfig, const SystematicSet &affectingSystematics, SystematicSet &filteredSystematics)
description: filter the systematics for the affected systematics returns: success guarantee: strong f...
Definition: SystematicSet.cxx:213
fitman.k
k
Definition: fitman.py:528
CP::JetTileCorrectionTool::setRJET
void setRJET(float r)
Definition: JetTileCorrectionTool.cxx:493
CP::SystematicRegistry::getInstance
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
Definition: SystematicRegistry.cxx:25
AthAnalysisHelper::retrieveMetadata
static std::string retrieveMetadata(const std::string &folder, const std::string &key, const ServiceHandle< StoreGateSvc > &inputMetaStore)
method that always returns as a string you can use from, e.g, pyROOT with evt = ROOT....
Definition: AthAnalysisHelper.h:254
CP::JetTileCorrectionTool::loadModulesFromMap
void loadModulesFromMap(const xAOD::Jet &jet, JTC::TS &status, const std::map< std::string, JTC::Hole > &hmap, JTC::PART part=JTC::PART::LB, JTC::TYPE type=JTC::TYPE::DB)
Definition: JetTileCorrectionTool.cxx:442
ServiceHandle< IIncidentSvc >
asg::AsgMetadataTool::m_useIncidents
bool m_useIncidents
Definition: AsgMetadataTool.h:128
Generated on Fri Jun 28 2024 22:13:58 for ATLAS Offline Software by   doxygen 1.8.18