ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
METNetSig.cxx File Reference
#include <math.h>
#include "AsgDataHandles/ReadHandle.h"
#include "METUtilities/METNetSig.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"
Include dependency graph for METNetSig.cxx:

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

31 {
32
33 static const SG::ConstAccessor<std::string> acc_name("name");
34 static const SG::ConstAccessor<MissingETBase::Types::bitmask_t> acc_source("source");
35
36 typedef ElementLink<xAOD::IParticleContainer> iplink_t;
37 static const SG::ConstAccessor< std::vector<iplink_t > > acc_constitObjLinks("ConstitObjectLinks");
38 static const SG::Decorator< std::vector<iplink_t> > dec_constitObjLinks("ConstitObjectLinks");
39
40 // Decorator for passing the vector of inputs to the met object
41 static const SG::ConstAccessor< std::vector<float> > acc_inputvalues("input_values");
42 static const SG::ConstAccessor< std::vector<std::string> > acc_inputnames("input_names");
43 static const SG::Decorator< std::vector<float> > dec_inputvalues("input_values");
44 static const SG::Decorator< std::vector<std::string> > dec_inputnames("input_names");
45
47
48 METNetSig::METNetSig(const std::string& name):
49 AsgTool(name){}
50
52
53 METNetSig::~METNetSig() { }
54
56
57 StatusCode METNetSig::initialize() {
58 ATH_MSG_INFO( "Initializing " << name() << "..." );
59
60 if (m_netSigLocation.value().find("dummy") != std::string::npos ) {
61 ATH_MSG_WARNING( "You are loading a dummy/untrained METNetSig network! This should only be done when testing the code!\n"
62 " -- If you wish to load a trained network please specify a path to an onnx file using the 'NetworkLocation' argument.\n"
63 " -- A list of supported networks can be found at atlas-groupdata.web.cern.ch/atlas-groupdata/METUtilities/run2_13TeV/METNet/" );
64 }
65
66 ATH_CHECK(m_eventInfoKey.initialize());
67 ATH_CHECK(m_pvContainerKey.initialize());
68 ATH_CHECK(m_jetContainerKey.initialize());
69
70 // Tool initialisations
71 ATH_MSG_INFO("Initialising the METNet ONNX environment using the file " + m_netSigLocation);
72 m_metnetsighandler = std::make_unique<METNetSigHandler>( m_netSigLocation );
73 if( m_metnetsighandler->initialize() != 0){
74 ATH_MSG_ERROR("METNetSig model file not found!");
75 return StatusCode::FAILURE;
76 }
77
78 if(m_metmaker_loose.empty()){
79 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_loose");
80 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
81 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
82 ATH_CHECK( toolConfig.setProperty("JetSelection", "Loose") );
83 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_loose) );
84 }
85 ATH_CHECK( m_metmaker_loose.retrieve() );
86
87 if(m_metmaker_tight.empty()){
88 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_tight");
89 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
90 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
91 ATH_CHECK( toolConfig.setProperty("JetSelection", "Tight") );
92 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_tight) );
93 }
94 ATH_CHECK( m_metmaker_tight.retrieve() );
95
96 if(m_metmaker_tghtr.empty()){
97 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_tghtr");
98 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
99 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
100 ATH_CHECK( toolConfig.setProperty("JetSelection", "Tighter") );
101 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_tghtr) );
102 }
103 ATH_CHECK( m_metmaker_tghtr.retrieve() );
104
105 if(m_metmaker_tenac.empty()){
106 asg::AsgToolConfig toolConfig("met::METMaker/metmaker_tenac");
107 ATH_CHECK( toolConfig.setProperty("JetContainer", m_jetContainerKey.key()) );
108 ATH_CHECK( toolConfig.setProperty("DoPFlow", true) );
109 ATH_CHECK( toolConfig.setProperty("JetSelection", "Tenacious") );
110 ATH_CHECK( toolConfig.makePrivateTool(m_metmaker_tenac) );
111 }
112 ATH_CHECK( m_metmaker_tenac.retrieve() );
113
114 return StatusCode::SUCCESS;
115 }
116
118
119 StatusCode METNetSig::rebuildMET( const std::string& metKey,
120 xAOD::Type::ObjectType metType,
121 xAOD::MissingETContainer* metCont,
122 const xAOD::IParticleContainer* collection,
123 xAOD::MissingETAssociationHelper& helper,
124 MissingETBase::UsageHandler::Policy objScale ) const
125 {
126 // If the MET term already exists in the container, skip rebuilding to avoid duplicates
127 if ( (*metCont)[metKey] != nullptr ) {
128 ATH_MSG_DEBUG("MET term '" << metKey << "' already exists in the container — skipping rebuild in METNetSig.");
129 return StatusCode::SUCCESS;
130 }
131
132 return m_metmaker_tight->rebuildMET( metKey, metType, metCont, collection, helper, objScale );
133 }
134
135 StatusCode METNetSig::rebuildJetMET( const std::string&,
136 const std::string& softClusKey,
137 const std::string& softTrkKey,
138 xAOD::MissingETContainer* metCont,
139 const xAOD::JetContainer* jets,
140 const xAOD::MissingETContainer* metCoreCont,
141 xAOD::MissingETAssociationHelper& helper,
142 bool ) const {
143
144 // Retrieving the event information (Needed for METSig, so we do it early)
145 SG::ReadHandle<xAOD::EventInfo> ei(m_eventInfoKey);
146
147 float avgmu = ei->averageInteractionsPerCrossing();
148 float actmu = ei->actualInteractionsPerCrossing();
149
151
152 // Creating the new containers for all the WPs
153 auto metCont_loose = std::make_unique<xAOD::MissingETContainer>();
154 auto metCont_looseAux = std::make_unique<xAOD::MissingETAuxContainer>();
155 metCont_loose->setStore( metCont_looseAux.get() );
156
157 auto metCont_tight = std::make_unique<xAOD::MissingETContainer>();
158 auto metCont_tightAux = std::make_unique<xAOD::MissingETAuxContainer>();
159 metCont_tight->setStore( metCont_tightAux.get() );
160
161 auto metCont_tghtr = std::make_unique<xAOD::MissingETContainer>();
162 auto metCont_tghtrAux = std::make_unique<xAOD::MissingETAuxContainer>();
163 metCont_tghtr->setStore( metCont_tghtrAux.get() );
164
165 auto metCont_tenac = std::make_unique<xAOD::MissingETContainer>();
166 auto metCont_tenacAux = std::make_unique<xAOD::MissingETAuxContainer>();
167 metCont_tenac->setStore( metCont_tenacAux.get() );
168
169 // Copying the contents of the original container into each WP container
170 // Avoids redundant calculation of identical terms.
171 ATH_MSG_VERBOSE( "Making copies of base MET container" );
172 ATH_CHECK( copyMETContainer( metCont_loose.get(), metCont ) );
173 ATH_CHECK( copyMETContainer( metCont_tight.get(), metCont ) );
174 ATH_CHECK( copyMETContainer( metCont_tghtr.get(), metCont ) );
175 ATH_CHECK( copyMETContainer( metCont_tenac.get(), metCont ) );
176
177 // Selected objects may differ between WPs due to jets, muon-in-jet treatment, etc. Need unique helpers, so copy current state.
178 xAOD::MissingETAssociationHelper helper_loose(helper);
179 xAOD::MissingETAssociationHelper helper_tight(helper);
180 xAOD::MissingETAssociationHelper helper_tghtr(helper);
181 xAOD::MissingETAssociationHelper helper_tenac(helper);
182
183 // Building the jet and soft terms for each WP
184 ATH_MSG_VERBOSE( "Building jet and soft terms for each MET WP" );
185 ATH_CHECK( m_metmaker_loose->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_loose.get(), jets, metCoreCont, helper_loose, true ) );
186 ATH_CHECK( m_metmaker_tight->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_tight.get(), jets, metCoreCont, helper_tight, true ) );
187 ATH_CHECK( m_metmaker_tghtr->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_tghtr.get(), jets, metCoreCont, helper_tghtr, true ) );
188 ATH_CHECK( m_metmaker_tenac->rebuildJetMET( "RefJet", softClusKey, softTrkKey, metCont_tenac.get(), jets, metCoreCont, helper_tenac, true ) );
189
190 // Building and adding the "Final" MET object to each WP container
191 ATH_MSG_VERBOSE( "Building the Final MET object for each MET WP" );
192 ATH_CHECK( buildMETSum( "FinalTrk", metCont_loose.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
193 ATH_CHECK( buildMETSum( "FinalTrk", metCont_tight.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
194 ATH_CHECK( buildMETSum( "FinalTrk", metCont_tghtr.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
195 ATH_CHECK( buildMETSum( "FinalTrk", metCont_tenac.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track)) );
196 // CST uses the LCTopo source bitmask even if the clusters are actually at EM scale
197 ATH_CHECK( buildMETSum( "FinalClus", metCont_loose.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
198 ATH_CHECK( buildMETSum( "FinalClus", metCont_tight.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
199 ATH_CHECK( buildMETSum( "FinalClus", metCont_tghtr.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
200 ATH_CHECK( buildMETSum( "FinalClus", metCont_tenac.get(), static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::LCTopo)) );
201
203
204 // Initialise two vectors: One for holding the network input values and another for the input names
205 std::vector<std::string> input_names;
206 std::vector<float> input_values;
207
208 ATH_CHECK( addMETFinal( "Loose", metCont_loose.get(), input_names, input_values ) );
209
210 // Tight gets all its hard terms included as well (same as all th others, only needed once)
211 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::electron())), input_names, input_values ) );
212 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::photon())), input_names, input_values ) );
213 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::tau())), input_names, input_values ) );
214 ATH_CHECK( addMETTerm( "Tight", *(metCont_tight->find(MissingETBase::Source::muon())), input_names, input_values ) );
215 ATH_CHECK( addMETFinal( "Tight", metCont_tight.get(), input_names, input_values ) );
216
217 ATH_CHECK( addMETFinal( "Tighter", metCont_tghtr.get(), input_names, input_values ) );
218 ATH_CHECK( addMETFinal( "Tenacious", metCont_tenac.get(), input_names, input_values ) );
219
220 // Pileup information and tracking information (using the user provided primary vertex container name)
221 SG::ReadHandle<xAOD::VertexContainer> pvtxs(m_pvContainerKey);
222 if(!pvtxs.isValid()){
223 ATH_MSG_ERROR("Could not retrieve primary vertex container!");
224 return StatusCode::FAILURE;
225 }
226 int NVx_2Tracks = 0;
227 int NVx_4Tracks = 0;
228 int PV_NTracks = 0;
229 int n_tracks = 0;
230 for ( const xAOD::Vertex* vx : *pvtxs ) {
231 n_tracks = vx->nTrackParticles();
232 if ( n_tracks>=2 ) NVx_2Tracks++;
233 if ( n_tracks>=4 ) NVx_4Tracks++;
234 if ( vx->vertexType() == xAOD::VxType::PriVtx ) PV_NTracks = n_tracks;
235 }
236 ATH_CHECK( addInputValue( "ActualMu", actmu, input_names, input_values ) );
237 ATH_CHECK( addInputValue( "AverageMu", avgmu, input_names, input_values ) );
238 ATH_CHECK( addInputValue( "NPV_2Tracks", NVx_2Tracks, input_names, input_values ) );
239 ATH_CHECK( addInputValue( "NPV_4Tracks", NVx_4Tracks, input_names, input_values ) );
240 ATH_CHECK( addInputValue( "PV_NTracks", PV_NTracks, input_names, input_values ) );
241
242 // Creating a dummy MET object on the output container to carry the NN features and decorate it with the two vectors
243 ATH_MSG_VERBOSE( "Saving network inputs to base MET container" );
244 xAOD::MissingET* net_inpts = nullptr;
245 if ( (*metCont)["NetInputDummy"] != NULL ) {
246 // If NetInputDummy already exists, erase it from the container so we recreate a clean object.
247 ATH_MSG_DEBUG("NetInputDummy already present in container — erasing and recreating.");
248 auto it = metCont->find("NetInputDummy");
249 if ( it != metCont->end() ) metCont->erase(it);
250 }
251 ATH_CHECK( fillMET( net_inpts, metCont, "NetInputDummy", static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Type::UnknownType) ) );
252 dec_inputnames( *(*metCont)["NetInputDummy"] ) = std::move(input_names);
253 dec_inputvalues( *(*metCont)["NetInputDummy"] ) = std::move(input_values);
254 return StatusCode::SUCCESS;
255 }
256
257 StatusCode METNetSig::evaluateNNMETSig( xAOD::MissingETContainer* metCont,
258 float& met_x, float& met_y, float& sigma_x, float& sigma_y) const
259 {
260
261 // First we check that the container has the correct decorations
262 ATH_MSG_VERBOSE( "Checking MET container for network inputs" );
263 if ( (*metCont)["NetInputDummy"] == NULL ) {
264 ATH_MSG_ERROR( "Could not find the NetInputDummy MET object in the container. Did you run rebuildJetMET?" );
265 return StatusCode::FAILURE;
266 }
267
268
269 // Pull out the vector from the met containter
270 std::vector<float> tmp_inputs = acc_inputvalues(*(*metCont)["NetInputDummy"]);
271 ATH_MSG_VERBOSE( "Loaded " << tmp_inputs.size() << " network inputs" );
272
273 // Check that the list of inputs matches the network size
274 if ( (int)tmp_inputs.size() != m_metnetsighandler->getReqSize() ) {
275 ATH_MSG_ERROR( "The MET container provided " << tmp_inputs.size()
276 << " elements, but the ONNX network needs exactly " << m_metnetsighandler->getReqSize() << "!" );
277 return StatusCode::FAILURE;
278 }
279
280 // Passing the inputs through the network
281 std::vector<float> net_met = m_metnetsighandler->predict( std::move(tmp_inputs) );
282
283 // // Adding the network output to the Final Met container
284 // xAOD::MissingET* metFinal = nullptr;
285 // ATH_CHECK( fillMET( metFinal, metCont, totalName, MissingETBase::Source::total() ) );
286
287 met_x = net_met[0];
288 met_y = net_met[1];
289 sigma_x = net_met[2];
290 sigma_y = net_met[3];
291
292 ATH_MSG_DEBUG( "Writing the Final Network MET: (" << met_x << ", " << met_y << ", " << sigma_x << ", " << sigma_y << ")" );
293
294 return StatusCode::SUCCESS;
295 }
296
298
299 StatusCode METNetSig::addMETFinal( const std::string& WP_name,
300 xAOD::MissingETContainer* met_container,
301 std::vector<std::string>& name_vec,
302 std::vector<float>& val_vec ) const
303 {
304 // Add the jet, soft, and final terms to the vector
305 ATH_CHECK( addMETTerm( WP_name, (*met_container)["RefJet"], name_vec, val_vec ) );
306 ATH_CHECK( addMETTerm( WP_name, (*met_container)["PVSoftTrk"], name_vec, val_vec ) );
307 ATH_CHECK( addMETTerm( WP_name, (*met_container)["FinalTrk"], name_vec, val_vec ) );
308 ATH_CHECK( addMETTerm( WP_name, (*met_container)["SoftClus"], name_vec, val_vec ) );
309 ATH_CHECK( addMETTerm( WP_name, (*met_container)["FinalClus"], name_vec, val_vec ) );
310 return StatusCode::SUCCESS;
311 }
312
313 StatusCode METNetSig::addMETTerm( const std::string &WP_name,
314 xAOD::MissingET* met,
315 std::vector<std::string>& name_vec,
316 std::vector<float>& val_vec ) const
317 {
318 // Build the name of the term from the WP and the Object type from the container
319 std::string tname = WP_name + "_" + acc_name(*met);
320
321 // Add the MET components and SumET
322 ATH_CHECK( addInputValue( tname+"_mpx", met->mpx()/1000., name_vec, val_vec ) );
323 ATH_CHECK( addInputValue( tname+"_mpy", met->mpy()/1000., name_vec, val_vec ) );
324 ATH_CHECK( addInputValue( tname+"_sumet", met->sumet()/1000., name_vec, val_vec ) );
325
326 return StatusCode::SUCCESS;
327 }
328
329 StatusCode METNetSig::addInputValue( const std::string& var_name,
330 float value,
331 std::vector<std::string>& name_vec,
332 std::vector<float>& val_vec ) const
333 {
334 // This is the only place we push_back to either vector
335 // Ensuring that they are always consistant with each other!!
336 ATH_MSG_VERBOSE( "Adding variable: " << var_name << " = " << value << " to the network input vector" );
337 name_vec.push_back( var_name );
338 val_vec.push_back( value );
339 return StatusCode::SUCCESS;
340 }
341
342 StatusCode METNetSig::copyMETContainer( xAOD::MissingETContainer* new_container,
343 const xAOD::MissingETContainer* old_container) const
344 {
345
346 // Initiase variables used in the loop
347 std::string name;
348 xAOD::MissingET* blank_met;
349 MissingETBase::Types::bitmask_t source;
350
351 for ( const xAOD::MissingET* old_met : *old_container ) {
352 blank_met = nullptr; // Resetting the null pointer
353 name = acc_name(*old_met); // Getting the name from the original container
354 source = acc_source(*old_met); // Getting the particle type from the original container
355 ATH_CHECK( fillMET( blank_met, new_container, name, source ) ); // Initialising the blank met with the new name in the new container
356 *(*new_container)[name] = *(*old_container)[name]; // Copying over the contents from one container to another
357
358 // Also need to copy the original object links
359 dec_constitObjLinks(*(*new_container)[name]) = acc_constitObjLinks(*(*old_container)[name]);
360 }
361
362 return StatusCode::SUCCESS;
363 }
364
366
367 StatusCode METNetSig::rebuildMET( xAOD::MissingET*,
368 const xAOD::IParticleContainer*,
369 xAOD::MissingETAssociationHelper&,
370 MissingETBase::UsageHandler::Policy ) const
371 {
372 ATH_MSG_ERROR( "METNetSig has not overloaded this version of rebuildMET from IMETMaker!\n"
373 "Please only use this method:\n"
374 "StatusCode METMaker::rebuildMET("
375 "const std::string& metKey,\n"
376 "xAOD::Type::ObjectType metType,\n"
377 "xAOD::MissingETContainer* metCont,\n"
378 "const xAOD::IParticleContainer* collection,\n"
379 "xAOD::MissingETAssociationHelper& helper,\n"
380 "MissingETBase::UsageHandler::Policy objScale\n"
381 ")" );
382 return StatusCode::FAILURE;
383 }
384
385 StatusCode METNetSig::rebuildMET( xAOD::MissingET*,
386 const xAOD::IParticleContainer*,
387 xAOD::MissingETAssociationHelper&,
388 MissingETBase::UsageHandler::Policy,
389 bool,
390 MissingETBase::UsageHandler::Policy ) const
391
392 {
393 ATH_MSG_ERROR( "METNetSig has not overloaded this version of rebuildMET from IMETMaker!\n"
394 "Please only use this method:\n"
395 "StatusCode METMaker::rebuildMET("
396 "const std::string& metKey,\n"
397 "xAOD::Type::ObjectType metType,\n"
398 "xAOD::MissingETContainer* metCont,\n"
399 "const xAOD::IParticleContainer* collection,\n"
400 "xAOD::MissingETAssociationHelper& helper,\n"
401 "MissingETBase::UsageHandler::Policy objScale\n"
402 ")" );
403 return StatusCode::FAILURE;
404 }
405
406 StatusCode METNetSig::rebuildJetMET(const std::string& metJetKey,
407 const std::string& /*metSoftKey*/,
408 xAOD::MissingETContainer* metCont,
409 const xAOD::JetContainer* jets,
410 const xAOD::MissingETContainer* metCoreCont,
411 xAOD::MissingETAssociationHelper& helper,
412 bool doJetJVT) const
413 {
414 return rebuildJetMET(metJetKey, "SoftClus", "PVSoftTrk", metCont, jets, metCoreCont, helper, doJetJVT);
415 }
416
417 StatusCode METNetSig::rebuildJetMET( xAOD::MissingET*,
418 const xAOD::JetContainer*,
419 xAOD::MissingETAssociationHelper&,
420 xAOD::MissingET*,
421 const xAOD::MissingET*,
422 xAOD::MissingET*,
423 const xAOD::MissingET*,
424 bool,
425 bool,
426 std::vector<const xAOD::IParticle*>* ) const
427 {
428 ATH_MSG_ERROR( "METNetSig has not overloaded this version of rebuildJetMET from IMETMaker!\n"
429 "Please use the method with the following arguments:\n"
430 "StatusCode METNetSig::rebuildJetMET(\n"
431 "const std::string& metJetKey,\n"
432 "const std::string& softClusKey,\n"
433 "const std::string& softTrkKey,\n"
434 "xAOD::MissingETContainer* metCont,\n"
435 "const xAOD::JetContainer* jets,\n"
436 "const xAOD::MissingETContainer* metCoreCont,\n"
437 "xAOD::MissingETAssociationHelper& helper,\n"
438 "bool doJetJVT\n"
439 ")" );
440 return StatusCode::FAILURE;
441 }
442
443 StatusCode METNetSig::rebuildTrackMET( const std::string&,
444 const std::string&,
445 xAOD::MissingETContainer*,
446 const xAOD::JetContainer*,
447 const xAOD::MissingETContainer*,
448 xAOD::MissingETAssociationHelper&,
449 bool ) const
450 {
451 ATH_MSG_ERROR( "Please dont use the method METNetSig::rebuildTrackMET!\n"
452 "It has no use in METNetSig and is a holdover from it's inheritance from IMETMaker." );
453 return StatusCode::FAILURE;
454 }
455
456 StatusCode METNetSig::rebuildTrackMET( xAOD::MissingET*,
457 const xAOD::JetContainer*,
458 xAOD::MissingETAssociationHelper&,
459 xAOD::MissingET*,
460 const xAOD::MissingET*,
461 bool ) const
462 {
463 ATH_MSG_ERROR( "METNetSig does not support Track MET!" );
464 return StatusCode::FAILURE;
465 }
466
467 StatusCode METNetSig::markInvisible( const xAOD::IParticleContainer*,
468 xAOD::MissingETAssociationHelper&,
469 xAOD::MissingETContainer* ) const
470 {
471 ATH_MSG_ERROR( "METNetSig does not support markInvisible!");
472 return StatusCode::FAILURE;
473 }
474
475}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x,...)
Definition AthMsgStreamMacros.h:47
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x,...)
Definition AthMsgStreamMacros.h:46
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x,...)
Definition AthMsgStreamMacros.h:42
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
iplink_t
ElementLink< xAOD::IParticleContainer > iplink_t
Definition SystObjectLinkerAlg.cxx:13
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::erase
iterator erase(iterator position)
Remove element at a given position.
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::MissingETContainer_v1::find
const_iterator find(const std::string &name) const
Find non-modifiable MET object by name.
Definition MissingETContainer_v1.cxx:52
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::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