ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
METNet.cxx File Reference
#include <math.h>
#include "AsgDataHandles/ReadHandle.h"
#include "AsgTools/AsgToolConfig.h"
#include "PathResolver/PathResolver.h"
#include "METUtilities/METNet.h"
#include "METUtilities/METHelpers.h"
#include "xAODBase/IParticleHelpers.h"
#include "xAODMissingET/MissingETContainer.h"
#include "xAODMissingET/MissingETComposition.h"
#include "xAODMissingET/MissingETAuxContainer.h"
#include "xAODJet/JetContainer.h"

Go to the source code of this file.

Functions

namespace ADD_CMODE (met)

Function Documentation

◆ ADD_CMODE()

namespace ADD_CMODE ( met )

Definition at line 1 of file METNet.cxx.

31 {
32
33 typedef ElementLink<xAOD::IParticleContainer> iplink_t;
34 static const SG::ConstAccessor< std::vector<iplink_t > > acc_constitObjLinks("ConstitObjectLinks");
35 static const SG::Decorator< std::vector<iplink_t> > dec_constitObjLinks("ConstitObjectLinks");
36
37 static const SG::ConstAccessor< std::vector<float> > acc_inputvalues("input_values");
38 static const SG::ConstAccessor< std::vector<std::string> > acc_inputnames("input_names");
39 static const SG::Decorator< std::vector<float> > dec_inputvalues("input_values");
40 static const SG::Decorator< std::vector<std::string> > dec_inputnames("input_names");
41
42 METNet::METNet(const std::string& name):
43 AsgTool(name){}
44
45 StatusCode METNet::initialize() {
46 ATH_MSG_INFO( "Initializing " << name() << "..." );
47
48 ATH_CHECK(m_eventInfoKey.initialize());
49 ATH_CHECK(m_pvContainerKey.initialize());
50 ATH_CHECK(m_jetContainerKey.initialize());
51
52 if( m_netLocation.empty()){
53 ATH_MSG_ERROR("NetworkFile property was not specified!");
54 return StatusCode::FAILURE;
55 }
56 std::string netFilePath = PathResolverFindCalibFile(m_netLocation);
57 std::unique_ptr<METNetHandler> metNetHandler = std::make_unique<METNetHandler>( netFilePath );
58 if( metNetHandler->initialize() != 0){
59 ATH_MSG_ERROR("METNet model file not found!");
60 return StatusCode::FAILURE;
61 }
62 ATH_MSG_INFO("Resolved METNet ONNX file at " + netFilePath);
63 m_metNetHandler = std::move(metNetHandler);
64
65 if(m_metmaker_loose.empty()){
66 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_loose");
67 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
68 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
69 ATH_CHECK( toolConfig.setProperty("JetSelection", "Loose") );
70 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_loose) );
71 }
72 ATH_CHECK( m_metmaker_loose.retrieve() );
73
74 if(m_metmaker_tight.empty()){
75 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_tight");
76 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
77 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
78 ATH_CHECK( toolConfig.setProperty("JetSelection", "Tight") );
79 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_tight) );
80 }
81 ATH_CHECK( m_metmaker_tight.retrieve() );
82
83 if(m_metmaker_tghtr.empty()){
84 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_tghtr");
85 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
86 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
87 ATH_CHECK( toolConfig.setProperty("JetSelection", "Tighter") );
88 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_tghtr) );
89 }
90 ATH_CHECK( m_metmaker_tghtr.retrieve() );
91
92 if(m_metmaker_tenac.empty()){
93 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_tenac");
94 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
95 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
96 ATH_CHECK( toolConfig.setProperty("JetSelection", "Tenacious") );
97 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_tenac) );
98 }
99 ATH_CHECK( m_metmaker_tenac.retrieve() );
100
101 return StatusCode::SUCCESS;
102 }
103
104 StatusCode METNet::rebuildMET( const std::string& metKey,
105 xAOD::Type::ObjectType metType,
106 xAOD::MissingETContainer* metCont,
107 const xAOD::IParticleContainer* collection,
108 xAOD::MissingETAssociationHelper& helper,
109 MissingETBase::UsageHandler::Policy objScale ) const {
110 return m_metmaker_tight->rebuildMET( metKey, metType, metCont, collection, helper, objScale );
111 }
112
113 StatusCode METNet::rebuildJetMET( const std::string&,
114 const std::string& softClusKey,
115 const std::string& softTrkKey,
116 xAOD::MissingETContainer* metCont,
117 const xAOD::JetContainer* jets,
118 const xAOD::MissingETContainer* metCoreCont,
119 xAOD::MissingETAssociationHelper& helper,
120 bool ) const {
121
122 // Retrieving the event information (Needed for METSig, so we do it early)
123 SG::ReadHandle<xAOD::EventInfo> ei(m_eventInfoKey);
124
125 float avgmu = ei->averageInteractionsPerCrossing();
126 float actmu = ei->actualInteractionsPerCrossing();
127
128 // Creating the new containers for all the WPs
129 auto metCont_loose = std::make_shared<xAOD::MissingETContainer>();
130 auto metCont_looseAux = std::make_shared<xAOD::MissingETAuxContainer>();
131 metCont_loose->setStore( metCont_looseAux.get() );
132
133 auto metCont_tight = std::make_shared<xAOD::MissingETContainer>();
134 auto metCont_tightAux = std::make_shared<xAOD::MissingETAuxContainer>();
135 metCont_tight->setStore( metCont_tightAux.get() );
136
137 auto metCont_tghtr = std::make_shared<xAOD::MissingETContainer>();
138 auto metCont_tghtrAux = std::make_shared<xAOD::MissingETAuxContainer>();
139 metCont_tghtr->setStore( metCont_tghtrAux.get() );
140
141 auto metCont_tenac = std::make_shared<xAOD::MissingETContainer>();
142 auto metCont_tenacAux = std::make_shared<xAOD::MissingETAuxContainer>();
143 metCont_tenac->setStore( metCont_tenacAux.get() );
144
145 // Copying the contents of the original container into each WP container
146 // Avoids redundant calculation of identical terms.
147 ATH_MSG_VERBOSE( "Making copies of base MET container" );
148 ATH_CHECK( copyMETContainer( metCont_loose.get(), metCont ) );
149 ATH_CHECK( copyMETContainer( metCont_tight.get(), metCont ) );
150 ATH_CHECK( copyMETContainer( metCont_tghtr.get(), metCont ) );
151 ATH_CHECK( copyMETContainer( metCont_tenac.get(), metCont ) );
152
153 // Selected objects may differ between WPs due to jets, muon-in-jet treatment, etc. Need unique helpers, so copy current state.
154 xAOD::MissingETAssociationHelper helper_loose(helper);
155 xAOD::MissingETAssociationHelper helper_tight(helper);
156 xAOD::MissingETAssociationHelper helper_tghtr(helper);
157 xAOD::MissingETAssociationHelper helper_tenac(helper);
158
159 // Building the jet and soft terms for each WP
160 ATH_MSG_VERBOSE( "Building jet and soft terms for each MET WP" );
161 ATH_CHECK( m_metmaker_loose->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_loose.get(), jets, metCoreCont, helper_loose, true ) );
162 ATH_CHECK( m_metmaker_tight->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_tight.get(), jets, metCoreCont, helper_tight, true ) );
163 ATH_CHECK( m_metmaker_tghtr->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_tghtr.get(), jets, metCoreCont, helper_tghtr, true ) );
164 ATH_CHECK( m_metmaker_tenac->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_tenac.get(), jets, metCoreCont, helper_tenac, true ) );
165
166 // Building and adding the "Final" MET object to each WP container
167 ATH_MSG_VERBOSE( "Building the Final MET object for each MET WP" );
168 ATH_CHECK( buildMETSum( "FinalTrk", metCont_loose.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
169 ATH_CHECK( buildMETSum( "FinalTrk", metCont_tight.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
170 ATH_CHECK( buildMETSum( "FinalTrk", metCont_tghtr.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
171 ATH_CHECK( buildMETSum( "FinalTrk", metCont_tenac.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
172 // CST uses the LCTopo source bitmask even if the clusters are actually at EM scale
173 ATH_CHECK( buildMETSum( "FinalClus", metCont_loose.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
174 ATH_CHECK( buildMETSum( "FinalClus", metCont_tight.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
175 ATH_CHECK( buildMETSum( "FinalClus", metCont_tghtr.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
176 ATH_CHECK( buildMETSum( "FinalClus", metCont_tenac.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
177
179
180 // Initialise two vectors: One for holding the network input values and another for the input names
181 std::vector<std::string> input_names;
182 std::vector<float> input_values;
183
184 ATH_CHECK( addMETFinal( "Loose", metCont_loose.get(), input_names, input_values ) );
185
186 // Tight gets all its hard terms included as well (same as all th others, only needed once)
187 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::electron())), input_names, input_values ) );
188 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::photon())), input_names, input_values ) );
189 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::tau())), input_names, input_values ) );
190 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::muon())), input_names, input_values ) );
191 ATH_CHECK( addMETFinal( "Tight", metCont_tight.get(), input_names, input_values ) );
192
193 ATH_CHECK( addMETFinal( "Tighter", metCont_tghtr.get(), input_names, input_values ) );
194 ATH_CHECK( addMETFinal( "Tenacious", metCont_tenac.get(), input_names, input_values ) );
195
196 // Pileup information and tracking information (using the user provided primary vertex container name)
197 SG::ReadHandle<xAOD::VertexContainer> pvtxs(m_pvContainerKey);
198 if(!pvtxs.isValid()){
199 ATH_MSG_ERROR("Could not retrieve primary vertex container!");
200 return StatusCode::FAILURE;
201 }
202 int NVx_2Tracks = 0;
203 int NVx_4Tracks = 0;
204 int PV_NTracks = 0;
205 int n_tracks = 0;
206 for ( const xAOD::Vertex* vx : *pvtxs ) {
207 n_tracks = vx->nTrackParticles();
208 if ( n_tracks>=2 ) NVx_2Tracks++;
209 if ( n_tracks>=4 ) NVx_4Tracks++;
210 if ( vx->vertexType() == xAOD::VxType::PriVtx ) PV_NTracks = n_tracks;
211 }
212 ATH_CHECK( addInputValue( "ActualMu", actmu, input_names, input_values ) );
213 ATH_CHECK( addInputValue( "AverageMu", avgmu, input_names, input_values ) );
214 ATH_CHECK( addInputValue( "NPV_2Tracks", NVx_2Tracks, input_names, input_values ) );
215 ATH_CHECK( addInputValue( "NPV_4Tracks", NVx_4Tracks, input_names, input_values ) );
216 ATH_CHECK( addInputValue( "PV_NTracks", PV_NTracks, input_names, input_values ) );
217
218 // Creating a dummy MET object on the output container to carry the NN features and decorate it with the two vectors
219 ATH_MSG_VERBOSE( "Saving network inputs to base MET container" );
220 xAOD::MissingET* net_inpts = nullptr;
221 ATH_CHECK( fillMET( net_inpts, metCont, "NetInputDummy", static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Type::UnknownType) ) );
222 dec_inputnames( *(*metCont)["NetInputDummy"] ) = std::move(input_names);
223 dec_inputvalues( *(*metCont)["NetInputDummy"] ) = std::move(input_values);
224
225 return StatusCode::SUCCESS;
226 }
227
228 StatusCode METNet::evaluateNNMET( const std::string& totalName,
229 xAOD::MissingETContainer* metCont) const {
230
231 // First we check that the container has the correct decorations
232 ATH_MSG_VERBOSE( "Checking MET container for network inputs" );
233 if ( (*metCont)["NetInputDummy"] == NULL ) {
234 ATH_MSG_ERROR( "Could not find the NetInputDummy MET object in the container. Did you run rebuildJetMET?" );
235 return StatusCode::FAILURE;
236 }
237
238 // Pull out the vector from the met containter
239 std::vector<float> tmp_inputs = acc_inputvalues(*(*metCont)["NetInputDummy"]);
240 ATH_MSG_VERBOSE( "Loaded " << tmp_inputs.size() << " network inputs" );
241
242 // Check that the list of inputs matches the network size
243 if ( tmp_inputs.size() != m_metNetHandler->getReqSize() ) {
244 ATH_MSG_ERROR( "The MET container provided " << tmp_inputs.size()
245 << " elements, but the ONNX network needs exactly " << m_metNetHandler->getReqSize() << "!" );
246 return StatusCode::FAILURE;
247 }
248
249 // Passing the inputs through the network
250 std::vector<float> net_met;
251 m_metNetHandler->predict(net_met, tmp_inputs);
252
253 // Adding the network output to the Final Met container
254 xAOD::MissingET* metFinal = nullptr;
255 ATH_CHECK( fillMET( metFinal, metCont, totalName, MissingETBase::Source::total() ) );
256 metFinal->setMpx( net_met[0] );
257 metFinal->setMpy( net_met[1] );
258
259 ATH_MSG_VERBOSE( "Writing the Final Network MET: (" << net_met[0] << ", " << net_met[1] << ")" );
260
261 return StatusCode::SUCCESS;
262 }
263
264 StatusCode METNet::addMETFinal( const std::string& WP_name,
265 xAOD::MissingETContainer* met_container,
266 std::vector<std::string>& name_vec,
267 std::vector<float>& val_vec ) const {
268 // Add the jet, soft, and final terms to the vector
269 ATH_CHECK( addMETTerm( WP_name, (*met_container)["RefJet"], name_vec, val_vec ) );
270 ATH_CHECK( addMETTerm( WP_name, (*met_container)["PVSoftTrk"], name_vec, val_vec ) );
271 ATH_CHECK( addMETTerm( WP_name, (*met_container)["FinalTrk"], name_vec, val_vec ) );
272 ATH_CHECK( addMETTerm( WP_name, (*met_container)["SoftClus"], name_vec, val_vec ) );
273 ATH_CHECK( addMETTerm( WP_name, (*met_container)["FinalClus"], name_vec, val_vec ) );
274 return StatusCode::SUCCESS;
275 }
276
277 StatusCode METNet::addMETTerm( const std::string &WP_name,
278 xAOD::MissingET* met,
279 std::vector<std::string>& name_vec,
280 std::vector<float>& val_vec ) const {
281
282 if(!met){
283 ATH_MSG_ERROR("addMETTerm was called with a null pointer for the input MET value!");
284 return StatusCode::FAILURE;
285 }
286
287 // Build the name of the term from the WP and the Object type from the container
288 std::string tname = WP_name + "_" + met->name();
289
290 // Add the MET components and SumET
291 ATH_CHECK( addInputValue( tname+"_mpx", met->mpx(), name_vec, val_vec ) );
292 ATH_CHECK( addInputValue( tname+"_mpy", met->mpy(), name_vec, val_vec ) );
293 ATH_CHECK( addInputValue( tname+"_sumet", met->sumet(), name_vec, val_vec ) );
294
295 return StatusCode::SUCCESS;
296 }
297
298 StatusCode METNet::addInputValue( const std::string& var_name,
299 float value,
300 std::vector<std::string>& name_vec,
301 std::vector<float>& val_vec ) const {
302 // This is the only place we push_back to either vector
303 // Ensuring that they are always consistant with each other!!
304 ATH_MSG_VERBOSE( "Adding variable: " << var_name << " = " << value << " to the network input vector" );
305 name_vec.push_back( var_name );
306 val_vec.push_back( value );
307 return StatusCode::SUCCESS;
308 }
309
310 StatusCode METNet::copyMETContainer( xAOD::MissingETContainer* new_container,
311 const xAOD::MissingETContainer* old_container) const {
312 xAOD::MissingET* blank_met;
313
314 for ( const xAOD::MissingET* old_met : *old_container ) {
315 blank_met = nullptr;
316 const std::string& name = old_met->name();
317
318 ATH_CHECK( fillMET( blank_met, new_container, name, old_met->source() ) ); // Initialize the blank met with the new name in the new container
319 *(*new_container)[name] = *(*old_container)[name]; // Copy over the contents of this "term" from old container to new
320
321 // Also need to copy the original object links
322 dec_constitObjLinks(*(*new_container)[name]) = acc_constitObjLinks(*(*old_container)[name]);
323 }
324
325 return StatusCode::SUCCESS;
326 }
327
328 StatusCode METNet::rebuildMET( xAOD::MissingET*,
329 const xAOD::IParticleContainer*,
330 xAOD::MissingETAssociationHelper&,
331 MissingETBase::UsageHandler::Policy ) const {
332 ATH_MSG_ERROR( "METNet has not overloaded this version of rebuildMET from IMETMaker!\n"
333 "Please only use this method:\n"
334 "StatusCode METMaker::rebuildMET("
335 "const std::string& metKey,\n"
336 "xAOD::Type::ObjectType metType,\n"
337 "xAOD::MissingETContainer* metCont,\n"
338 "const xAOD::IParticleContainer* collection,\n"
339 "xAOD::MissingETAssociationHelper& helper,\n"
340 "MissingETBase::UsageHandler::Policy objScale\n"
341 ")" );
342 return StatusCode::FAILURE;
343 }
344
345 StatusCode METNet::rebuildMET( xAOD::MissingET*,
346 const xAOD::IParticleContainer*,
347 xAOD::MissingETAssociationHelper&,
348 MissingETBase::UsageHandler::Policy,
349 bool,
350 MissingETBase::UsageHandler::Policy ) const {
351 ATH_MSG_ERROR( "METNet has not overloaded this version of rebuildMET from IMETMaker!\n"
352 "Please only use this method:\n"
353 "StatusCode METMaker::rebuildMET("
354 "const std::string& metKey,\n"
355 "xAOD::Type::ObjectType metType,\n"
356 "xAOD::MissingETContainer* metCont,\n"
357 "const xAOD::IParticleContainer* collection,\n"
358 "xAOD::MissingETAssociationHelper& helper,\n"
359 "MissingETBase::UsageHandler::Policy objScale\n"
360 ")" );
361 return StatusCode::FAILURE;
362 }
363
364 StatusCode METNet::rebuildJetMET(const std::string& metJetKey,
365 const std::string& /*metSoftKey*/,
366 xAOD::MissingETContainer* metCont,
367 const xAOD::JetContainer* jets,
368 const xAOD::MissingETContainer* metCoreCont,
369 xAOD::MissingETAssociationHelper& helper,
370 bool doJetJVT) const {
371 return rebuildJetMET(metJetKey, "SoftClus", "PVSoftTrk", metCont, jets, metCoreCont, helper, doJetJVT);
372 }
373
374 StatusCode METNet::rebuildJetMET( xAOD::MissingET*,
375 const xAOD::JetContainer*,
376 xAOD::MissingETAssociationHelper&,
377 xAOD::MissingET*,
378 const xAOD::MissingET*,
379 xAOD::MissingET*,
380 const xAOD::MissingET*,
381 bool,
382 bool,
383 std::vector<const xAOD::IParticle*>* ) const {
384 ATH_MSG_ERROR( "METNet has not overloaded this version of rebuildJetMET from IMETMaker!\n"
385 "Please use the method with the following arguments:\n"
386 "StatusCode METNet::rebuildJetMET(\n"
387 "const std::string& metJetKey,\n"
388 "const std::string& softClusKey,\n"
389 "const std::string& softTrkKey,\n"
390 "xAOD::MissingETContainer* metCont,\n"
391 "const xAOD::JetContainer* jets,\n"
392 "const xAOD::MissingETContainer* metCoreCont,\n"
393 "xAOD::MissingETAssociationHelper& helper,\n"
394 "bool doJetJVT\n"
395 ")" );
396 return StatusCode::FAILURE;
397 }
398
399 StatusCode METNet::rebuildTrackMET( const std::string&,
400 const std::string&,
401 xAOD::MissingETContainer*,
402 const xAOD::JetContainer*,
403 const xAOD::MissingETContainer*,
404 xAOD::MissingETAssociationHelper&,
405 bool ) const {
406 ATH_MSG_ERROR( "Please don't use the method METNet::rebuildTrackMET!\n"
407 "It has no use in METNet and is a holdover from its inheritance from IMETMaker." );
408 return StatusCode::FAILURE;
409 }
410
411 StatusCode METNet::rebuildTrackMET( xAOD::MissingET*,
412 const xAOD::JetContainer*,
413 xAOD::MissingETAssociationHelper&,
414 xAOD::MissingET*,
415 const xAOD::MissingET*,
416 bool ) const {
417 ATH_MSG_ERROR( "METNet does not support Track MET!" );
418 return StatusCode::FAILURE;
419 }
420
421 StatusCode METNet::markInvisible( const xAOD::IParticleContainer*,
422 xAOD::MissingETAssociationHelper&,
423 xAOD::MissingETContainer* ) const {
424 ATH_MSG_ERROR( "METNet does not support markInvisible!");
425 return StatusCode::FAILURE;
426 }
427
428}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x,...)
Definition AthMsgStreamMacros.h:47
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x,...)
Definition AthMsgStreamMacros.h:42
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition PathResolver.cxx:325
iplink_t
ElementLink< xAOD::IParticleContainer > iplink_t
Definition SystObjectLinkerAlg.cxx:13
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition ConstAccessor.h:55
asg::AsgToolConfig
an object that can create a AsgTool
Definition AsgToolConfig.h:22
xAOD::MissingET_v1::setMpy
void setMpy(float value)
Set the component.
xAOD::MissingET_v1::setMpx
void setMpx(float value)
Set the component.
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
MissingETBase::Types::bitmask_t
uint64_t bitmask_t
Type for status word bit mask.
Definition MissingETBase.h:39
SG::Decorator
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576
xAODType::ObjectType
ObjectType
Type of objects that have a representation in the xAOD EDM.
Definition ObjectType.h:32
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition TrackingPrimitives.h:597
xAOD::MissingET
MissingET_v1 MissingET
Version control by type defintion.
Definition MissingET.h:15
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
xAOD::MissingETContainer
MissingETContainer_v1 MissingETContainer
Definition MissingETContainer.h:16
xAOD::JetContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
Definition JetContainer.h:17
xAOD::IParticleContainer
DataVector< IParticle > IParticleContainer
Simple convenience declaration of IParticleContainer.
Definition xAOD/xAODBase/xAODBase/IParticleContainer.h:32
MissingETBase::Source::total
static Types::bitmask_t total(Region reg=Region::FullAcceptance)
Standard full reconstructed MET.
Definition MissingETBase.h:271
MissingETBase::Source::muon
static Types::bitmask_t muon(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed muons.
Definition MissingETBase.h:250
MissingETBase::Source::tau
static Types::bitmask_t tau(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed tau leptons.
Definition MissingETBase.h:243
MissingETBase::Source::electron
static Types::bitmask_t electron(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed electrons.
Definition MissingETBase.h:229
MissingETBase::Source::photon
static Types::bitmask_t photon(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed photons.
Definition MissingETBase.h:236
MissingETBase::Source::Signal::LCTopo
@ LCTopo
Indicator for MET contribution from TopoClusters with LCW calibration applied.
Definition MissingETBase.h:214
MissingETBase::Source::Signal::Track
@ Track
Indicator for MET contribution from reconstructed charged particle tracks.
Definition MissingETBase.h:216
Generated on for ATLAS Offline Software by doxygen 1.17.0