ATLAS Offline Software
MissingETAssociation_v1.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "xAODMissingET/versions/MissingETAssociation_v1.h"
6 #include "xAODMissingET/versions/MissingETCompositionBase.h"
7 #include "xAODJet/JetContainer.h"
8 #include "xAODTruth/TruthParticle.h"
9 #include "xAODPFlow/PFO.h"
10 #include "xAODPFlow/FlowElement.h"
11 #include "xAODPFlow/FEHelpers.h"
12 
13 #include <iterator>
14 #include <cstdio>
15 
16 using namespace MissingETBase::Types;
17 using std::vector;
18 
19 namespace xAOD {
20 
21  // Static accessors
22  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_calpx("calpx");
23  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_calpy("calpy");
24  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_calpz("calpz");
25  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_cale("cale");
26  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_calsumpt("calsumpt");
27 
28  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_trkpx("trkpx");
29  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_trkpy("trkpy");
30  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_trkpz("trkpz");
31  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_trke("trke");
32  const SG::AuxElement::Accessor<std::vector<float> > MissingETAssociation_v1::m_acc_trksumpt("trksumpt");
33 
34  const SG::AuxElement::Accessor<float> MissingETAssociation_v1::m_acc_jettrkpx("jettrkpx");
35  const SG::AuxElement::Accessor<float> MissingETAssociation_v1::m_acc_jettrkpy("jettrkpy");
36  const SG::AuxElement::Accessor<float> MissingETAssociation_v1::m_acc_jettrkpz("jettrkpz");
37  const SG::AuxElement::Accessor<float> MissingETAssociation_v1::m_acc_jettrke("jettrke");
38  const SG::AuxElement::Accessor<float> MissingETAssociation_v1::m_acc_jettrksumpt("jettrksumpt");
39 
40  MissingETBase::Types::bitmask_t getObjMask(size_t objIndex)
41  {
42  if(objIndex==MissingETBase::Numerical::invalidIndex()) return 0;
43  return 1<<objIndex;
44  }
45 
47  // MissingETAssociation_v1::ConstVec Implementations //
49 
50  MissingETAssociation_v1::ConstVec& MissingETAssociation_v1::ConstVec::operator+=(const ConstVec& cvec)
51  {
52  this->cpx() += cvec.cpx(); this->cpy() += cvec.cpy(); this->cpz() += cvec.cpz(); this->ce() += cvec.ce();
53  this->sumpt() += cvec.sumpt();
54  return *this;
55  }
56 
57  MissingETAssociation_v1::ConstVec& MissingETAssociation_v1::ConstVec::operator-=(const ConstVec& cvec)
58  {
59  this->cpx() -= cvec.cpx(); this->cpy() -= cvec.cpy(); this->cpz() -= cvec.cpz(); this->ce() -= cvec.ce();
60  this->sumpt() -= cvec.sumpt();
61  return *this;
62  }
63 
64  MissingETAssociation_v1::ConstVec& MissingETAssociation_v1::ConstVec::operator*=(float scale)
65  {
66  this->cpx() *= scale; this->cpy() *= scale; this->cpz() *= scale; this->ce() *= scale;
67  this->sumpt() *= scale;
68  return *this;
69  }
70 
71  MissingETAssociation_v1::ConstVec& MissingETAssociation_v1::ConstVec::operator/=(float scale)
72  {
73  if ( scale <1e-9 ) { this->cpx() = 0.; this->cpy() = 0.; this->cpz() = 0.; this->ce() = 0.; this->sumpt() = 0.; return *this; }
74  else { return this->operator*=(1./scale); }
75  }
76 
77  bool MissingETAssociation_v1::ConstVec::operator==(const ConstVec& cvec) const
78  {
79  return
80  MissingETBase::Numerical::isEqual(this->cpx(),cvec.cpx()) &&
81  MissingETBase::Numerical::isEqual(this->cpy(),cvec.cpy()) &&
82  MissingETBase::Numerical::isEqual(this->cpz(),cvec.cpz()) &&
83  MissingETBase::Numerical::isEqual(this->ce(),cvec.ce()) &&
84  MissingETBase::Numerical::isEqual(this->sumpt(),cvec.sumpt());
85  }
86 
87  float MissingETAssociation_v1::ConstVec::cpt() const
88  {
89  return sqrt(this->cpx()*this->cpx()+this->cpy()*this->cpy());
90  }
91 
93  // Constructors and destructors //
95 
96  MissingETAssociation_v1::MissingETAssociation_v1( bool createStore )
97  : SG::AuxElement()
98  {
99 
100  if( createStore ) createPrivateStore();
101  initCache();
102  }
103 
104  MissingETAssociation_v1::MissingETAssociation_v1( const Jet* pJet, bool isMisc )
105  : SG::AuxElement()
106  {
107 
108  createPrivateStore();
109  f_isMisc() = isMisc;
110  setRefJet( pJet );
111  initCache();
112  }
113 
114  MissingETAssociation_v1::MissingETAssociation_v1(const MissingETAssociation_v1& assocDescr)
115  : SG::AuxElement(assocDescr)
116  {
117  this->makePrivateStore(&assocDescr);
118  initCache();
119  }
120 
121  MissingETAssociation_v1& MissingETAssociation_v1::operator=(const MissingETAssociation_v1& assocDescr)
122  {
123  if((&assocDescr) != this) {
124  f_isMisc() = assocDescr.isMisc();
125  this->setJetLink(assocDescr.jetLink());
126  this->setObjectLinks(assocDescr.objectLinks());
127  this->setOverlaps(assocDescr.overlapIndices(),assocDescr.overlapTypes());
128  this->setCalPx(assocDescr.calpx());
129  this->setCalPy(assocDescr.calpy());
130  this->setCalPz(assocDescr.calpz());
131  this->setCalE(assocDescr.cale());
132  this->setCalSumpt(assocDescr.calsumpt());
133  this->setCalKey(assocDescr.calkey());
134  this->setTrkPx(assocDescr.trkpx());
135  this->setTrkPy(assocDescr.trkpy());
136  this->setTrkPz(assocDescr.trkpz());
137  this->setTrkE(assocDescr.trke());
138  this->setTrkSumpt(assocDescr.trksumpt());
139  this->setTrkKey(assocDescr.trkkey());
140  this->setJetTrkPx(assocDescr.jettrkpx());
141  this->setJetTrkPy(assocDescr.jettrkpy());
142  this->setJetTrkPz(assocDescr.jettrkpz());
143  this->setJetTrkE(assocDescr.jettrke());
144  }
145  return *this;
146  }
147 
148  MissingETAssociation_v1::~MissingETAssociation_v1() { }
149 
151  // Data store management //
153 
154  bool MissingETAssociation_v1::addObject(const IParticle* pPart,const std::vector<const IParticle*>& constlist)
155  {
156  // check if object is in store
157 
158  size_t idx(this->findIndex(pPart));
159  // found - add const vectors
160  if ( idx != MissingETBase::Numerical::invalidIndex() )
161  {
162  m_objConstLinks[idx].clear();
163  m_objConstLinks[idx].reserve(constlist.size());
164  for(const auto& signal : constlist) {
165  const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
166  MissingETBase::Types::objlink_t el(*pCont,signal->index());
167  m_objConstLinks[idx].push_back(el);
168  }
169  return false; }
170  // new object
171  else
172  {
173  MissingETBase::Types::objlink_t oLnk; f_setObject<IParticle,MissingETBase::Types::objlink_t>(pPart,oLnk);
174  // add to stores
175  this->f_objectLinks().push_back(oLnk);
176  vector<MissingETBase::Types::objlink_t > linklist;
177  linklist.reserve(constlist.size());
178  for(const auto& signal : constlist) {
179  const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
180  MissingETBase::Types::objlink_t el(*pCont,signal->index());
181  linklist.push_back(el);
182  }
183  m_objConstLinks.push_back(linklist);
184  this->f_overlapIndices().emplace_back(0);
185  this->f_overlapTypes().emplace_back(0);
186  bool linkset = f_setLink<MissingETBase::Types::objlink_t>(oLnk);
187  return linkset;
188  }
189  }
190 
191  // void MissingETAssociation_v1::updateLinks()
192  // {
193  // this->updateJetLink();
194  // static SG::AuxElement::Accessor<MissingETBase::Types::objlink_vector_t> acc("objectLinks");
195  // if(acc.isAvailableWritable(*this)) {
196  // for ( auto& link : this->f_objectLinks() ) {
197  // link.toPersistent();
198  // }
199  // }
200  // }
201 
202  // void MissingETAssociation_v1::updateJetLink() {
203  // if(!this->isMisc()) {
204  // static SG::AuxElement::Accessor<MissingETBase::Types::jetlink_t> acc("jetLink");
205  // if(acc.isAvailableWritable(*this)) {
206  // if(f_setLink<MissingETBase::Types::jetlink_t>(this->f_jetLink())) {
207  // this->f_jetLink().toPersistent();
208  // }
209  // }
210  // }
211  // }
212 
213  bool MissingETAssociation_v1::removeContrib()
214  {
215  if ( this->empty() ) { return false; }
216  else
217  { size_t nEnt(this->size()); for ( size_t objIdx(0); objIdx<nEnt; ++objIdx ) { this->f_removeContrib(objIdx); } return true; }
218  }
219 
220  bool MissingETAssociation_v1::f_removeContrib(size_t objIdx)
221  {
222  objlink_vector_t::iterator fCon(this->f_objectLinks().begin()); std::advance<objlink_vector_t::iterator>(fCon,objIdx);
223  this->f_objectLinks().erase(fCon);
224  vector<vector<size_t> >::iterator fOverlapIndices(this->f_overlapIndices().begin()); std::advance<vector<vector<size_t> >::iterator>(fOverlapIndices,objIdx);
225  this->f_overlapIndices().erase(fOverlapIndices);
226  vector<vector<unsigned char> >::iterator fOverlapTypes(this->f_overlapTypes().begin()); std::advance<vector<vector<unsigned char> >::iterator>(fOverlapTypes,objIdx);
227  this->f_overlapTypes().erase(fOverlapTypes);
228  this->f_calpx().clear();
229  this->f_calpy().clear();
230  this->f_calpz().clear();
231  this->f_cale().clear();
232  this->f_calsumpt().clear();
233  this->f_calkey().clear();
234  this->f_trkpx().clear();
235  this->f_trkpy().clear();
236  this->f_trkpz().clear();
237  this->f_trke().clear();
238  this->f_trksumpt().clear();
239  this->f_trkkey().clear();
240  return true;
241  }
242 
243  bool MissingETAssociation_v1::resetContrib(size_t /*objIdx*/)
244  {
245  this->resetContrib();
246  return true;
247  }
248 
249  bool MissingETAssociation_v1::resetContrib()
250  {
251  for (size_t idx = 0; idx < this->size(); idx++) this->f_overlapIndices()[idx].clear();
252  for (size_t idx = 0; idx < this->size(); idx++) this->f_overlapTypes()[idx].clear();
253  this->f_calpx().clear();
254  this->f_calpy().clear();
255  this->f_calpz().clear();
256  this->f_cale().clear();
257  this->f_calsumpt().clear();
258  this->f_calkey().clear();
259  this->f_trkpx().clear();
260  this->f_trkpy().clear();
261  this->f_trkpz().clear();
262  this->f_trke().clear();
263  this->f_trksumpt().clear();
264  this->f_trkkey().clear();
265  return true;
266  }
267 
268  size_t MissingETAssociation_v1::findIndex(const IParticle* pPart) const
269  {
270  objlink_vector_t::const_iterator fLnk(this->objectLinks().begin());
271  // FIXME: This is based on dereferencing the ElementLink, which is risky.
272  while ( fLnk != this->objectLinks().end() ) {
273  if((*fLnk).isValid()) {
274  if(*(*fLnk) == pPart) break;
275  }
276  ++fLnk;
277  }
278  if ( fLnk != this->objectLinks().end() )
279  return std::distance(this->objectLinks().begin(),fLnk);
280  return MissingETBase::Numerical::invalidIndex();
281  }
282 
283  size_t MissingETAssociation_v1::findCalIndex(MissingETBase::Types::bitmask_t mask) const
284  {
285  for (size_t ind = 0; ind < this->sizeCal(); ind++) if (mask==this->calkey()[ind]) return ind;
286  return MissingETBase::Numerical::invalidIndex();
287  }
288 
289  size_t MissingETAssociation_v1::findTrkIndex(MissingETBase::Types::bitmask_t mask) const
290  {
291  for (size_t ind = 0; ind < this->sizeTrk(); ind++) if (mask==this->trkkey()[ind]) return ind;
292  return MissingETBase::Numerical::invalidIndex();
293  }
294 
296  // Setters //
298 
299  bool MissingETAssociation_v1::setCalPx(const std::vector<float>& calpxvec)
300  { this->f_calpx().clear(); this->f_calpx().insert(this->f_calpx().end(),calpxvec.begin(),calpxvec.end()); return !this->f_calpx().empty(); }
301  bool MissingETAssociation_v1::setCalPy(const std::vector<float>& calpyvec)
302  { this->f_calpy().clear(); this->f_calpy().insert(this->f_calpy().end(),calpyvec.begin(),calpyvec.end()); return !this->f_calpy().empty(); }
303  bool MissingETAssociation_v1::setCalPz(const std::vector<float>& calpzvec)
304  { this->f_calpz().clear(); this->f_calpz().insert(this->f_calpz().end(),calpzvec.begin(),calpzvec.end()); return !this->f_calpz().empty(); }
305  bool MissingETAssociation_v1::setCalE(const std::vector<float>& calevec)
306  { this->f_cale().clear(); this->f_cale().insert(this->f_cale().end(),calevec.begin(),calevec.end()); return !this->f_cale().empty(); }
307  bool MissingETAssociation_v1::setCalSumpt(const std::vector<float>& calsumptvec)
308  { this->f_calsumpt().clear(); this->f_calsumpt().insert(this->f_calsumpt().end(),calsumptvec.begin(),calsumptvec.end()); return !this->f_calsumpt().empty(); }
309  bool MissingETAssociation_v1::setCalKey(const std::vector<MissingETBase::Types::bitmask_t>& calkeyvec)
310  { this->f_calkey().clear(); this->f_calkey().insert(this->f_calkey().end(),calkeyvec.begin(),calkeyvec.end()); return !this->f_calkey().empty(); }
311 
312  bool MissingETAssociation_v1::setTrkPx(const std::vector<float>& trkpxvec)
313  { this->f_trkpx().clear(); this->f_trkpx().insert(this->f_trkpx().end(),trkpxvec.begin(),trkpxvec.end()); return !this->f_trkpx().empty(); }
314  bool MissingETAssociation_v1::setTrkPy(const std::vector<float>& trkpyvec)
315  { this->f_trkpy().clear(); this->f_trkpy().insert(this->f_trkpy().end(),trkpyvec.begin(),trkpyvec.end()); return !this->f_trkpy().empty(); }
316  bool MissingETAssociation_v1::setTrkPz(const std::vector<float>& trkpzvec)
317  { this->f_trkpz().clear(); this->f_trkpz().insert(this->f_trkpz().end(),trkpzvec.begin(),trkpzvec.end()); return !this->f_trkpz().empty(); }
318  bool MissingETAssociation_v1::setTrkE(const std::vector<float>& trkevec)
319  { this->f_trke().clear(); this->f_trke().insert(this->f_trke().end(),trkevec.begin(),trkevec.end()); return !this->f_trke().empty(); }
320  bool MissingETAssociation_v1::setTrkSumpt(const std::vector<float>& trksumptvec)
321  { this->f_trksumpt().clear(); this->f_trksumpt().insert(this->f_trksumpt().end(),trksumptvec.begin(),trksumptvec.end()); return !this->f_trksumpt().empty(); }
322  bool MissingETAssociation_v1::setTrkKey(const std::vector<MissingETBase::Types::bitmask_t>& trkkeyvec)
323  { this->f_trkkey().clear(); this->f_trkkey().insert(this->f_trkkey().end(),trkkeyvec.begin(),trkkeyvec.end()); return !this->f_trkkey().empty(); }
324 
326  // FIXME: failsafe implementation checks on invalidKey and vector index - vector index may be sufficient?
327  bool MissingETAssociation_v1::setCalPx(size_t keyIdx,float calpx)
328  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calpx().size() ) { this->f_calpx()[keyIdx] = calpx; return true; } else { return false; } }
329  bool MissingETAssociation_v1::setCalPy(size_t keyIdx,float calpy)
330  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calpy().size() ) { this->f_calpy()[keyIdx] = calpy; return true; } else { return false; } }
331  bool MissingETAssociation_v1::setCalPz(size_t keyIdx,float calpz)
332  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calpz().size() ) { this->f_calpz()[keyIdx] = calpz; return true; } else { return false; } }
333  bool MissingETAssociation_v1::setCalE(size_t keyIdx,float cale)
334  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_cale().size() ) { this->f_cale()[keyIdx] = cale; return true; } else { return false; } }
335  bool MissingETAssociation_v1::setCalSumpt(size_t keyIdx,float calsumpt)
336  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calsumpt().size() ) { this->f_calsumpt()[keyIdx] = calsumpt; return true; } else { return false; } }
337  bool MissingETAssociation_v1::setCalKey(size_t keyIdx,MissingETBase::Types::bitmask_t calkey)
338  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calkey().size() ) { this->f_calkey()[keyIdx] = calkey; return true; } else { return false; } }
339  bool MissingETAssociation_v1::setCalVec(size_t keyIdx,float calpx,float calpy,float calpz,float cale,float sumpt)
340  {
341  if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_cale().size() ) {
342  this->f_calpx()[keyIdx] = calpx; this->f_calpy()[keyIdx] = calpy;
343  this->f_calpz()[keyIdx] = calpz; this->f_cale()[keyIdx] = cale;
344  this->f_calsumpt()[keyIdx] = sumpt; return true;
345  } else { return false; }
346  }
347  bool MissingETAssociation_v1::addCalVec(MissingETBase::Types::bitmask_t key,float calpx,float calpy,float calpz,float cale,float sumpt) {
348  for(MissingETBase::Types::bitmask_t testkey : this->f_calkey()) {
349  // quit if key already exists.
350  if(key==testkey) return false;
351  }
352  this->f_calkey().push_back(key);
353  this->f_calpx().push_back(calpx);
354  this->f_calpy().push_back(calpy);
355  this->f_calpz().push_back(calpz);
356  this->f_cale().push_back(cale);
357  this->f_calsumpt().push_back(sumpt);
358  return true;
359  }
360 
361  bool MissingETAssociation_v1::setTrkPx(size_t keyIdx,float trkpx)
362  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkpx().size() ) { this->f_trkpx()[keyIdx] = trkpx; return true; } else { return false; } }
363  bool MissingETAssociation_v1::setTrkPy(size_t keyIdx,float trkpy)
364  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkpy().size() ) { this->f_trkpy()[keyIdx] = trkpy; return true; } else { return false; } }
365  bool MissingETAssociation_v1::setTrkPz(size_t keyIdx,float trkpz)
366  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkpz().size() ) { this->f_trkpz()[keyIdx] = trkpz; return true; } else { return false; } }
367  bool MissingETAssociation_v1::setTrkE(size_t keyIdx,float trke)
368  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trke().size() ) { this->f_trke()[keyIdx] = trke; return true; } else { return false; } }
369  bool MissingETAssociation_v1::setTrkSumpt(size_t keyIdx,float trksumpt)
370  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trksumpt().size() ) { this->f_trksumpt()[keyIdx] = trksumpt; return true; } else { return false; } }
371  bool MissingETAssociation_v1::setTrkKey(size_t keyIdx,MissingETBase::Types::bitmask_t trkkey)
372  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkkey().size() ) { this->f_trkkey()[keyIdx] = trkkey; return true; } else { return false; } }
373  bool MissingETAssociation_v1::setTrkVec(size_t keyIdx,float trkpx,float trkpy,float trkpz,float trke,float sumpt)
374  {
375  if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trke().size() ) {
376  this->f_trkpx()[keyIdx] = trkpx; this->f_trkpy()[keyIdx] = trkpy;
377  this->f_trkpz()[keyIdx] = trkpz; this->f_trke()[keyIdx] = trke;
378  this->f_trksumpt()[keyIdx] = sumpt; return true;
379  } else { return false; }
380  }
381  bool MissingETAssociation_v1::addTrkVec(MissingETBase::Types::bitmask_t key,float trkpx,float trkpy,float trkpz,float trke,float sumpt) {
382  for(MissingETBase::Types::bitmask_t testkey : this->f_trkkey()) {
383  // quit if key already exists.
384  if(key==testkey) return false;
385  }
386  this->f_trkkey().push_back(key);
387  this->f_trkpx().push_back(trkpx);
388  this->f_trkpy().push_back(trkpy);
389  this->f_trkpz().push_back(trkpz);
390  this->f_trke().push_back(trke);
391  this->f_trksumpt().push_back(sumpt);
392  return true;
393  }
394 
395 
396  void MissingETAssociation_v1::setJetTrkPx(float px)
397  { this->f_jettrkpx() = px; }
398  void MissingETAssociation_v1::setJetTrkPy(float py)
399  { this->f_jettrkpy() = py; }
400  void MissingETAssociation_v1::setJetTrkPz(float pz)
401  { this->f_jettrkpz() = pz; }
402  void MissingETAssociation_v1::setJetTrkE(float e)
403  { this->f_jettrke() = e; }
404  void MissingETAssociation_v1::setJetTrkSumpt(float sumpt)
405  { this->f_jettrksumpt() = sumpt; }
406  void MissingETAssociation_v1::setJetTrkVec(float px,float py,float pz,float e,float sumpt)
407  {
408  this->f_jettrkpx() = px; this->f_jettrkpy() = py;
409  this->f_jettrkpz() = pz; this->f_jettrke() = e;
410  this->f_jettrksumpt() = sumpt;
411  }
412 
413  void MissingETAssociation_v1::clearOverlaps()
414  {
415  this->f_overlapIndices().clear();
416  this->f_overlapIndices().resize(this->f_overlapIndices().size(),vector<size_t>(0));
417  this->f_overlapTypes().clear();
418  this->f_overlapTypes().resize(this->f_overlapTypes().size(),vector<unsigned char>(0));
419  }
420  bool MissingETAssociation_v1::setOverlaps(const std::vector<std::vector<size_t> >& overlapIndexVector,const std::vector<std::vector<unsigned char> >& overlapTypeVector)
421  {
422  this->f_overlapIndices().clear(); this->f_overlapIndices().insert(this->f_overlapIndices().end(),overlapIndexVector.begin(),overlapIndexVector.end());
423  this->f_overlapTypes().clear(); this->f_overlapTypes().insert(this->f_overlapTypes().end(),overlapTypeVector.begin(),overlapTypeVector.end());
424  return !this->f_overlapIndices().empty();
425  }
426  bool MissingETAssociation_v1::setOverlaps(size_t objIdx,const std::vector<size_t>& overlapIndices,const std::vector<unsigned char>& overlapTypes)
427  {
428  if ( objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->f_overlapIndices().size() ) {
429  this->f_overlapIndices()[objIdx] = overlapIndices;
430  this->f_overlapTypes()[objIdx] = overlapTypes;
431  return true;
432  } else { return false; }
433  }
434 
435 
436  bool MissingETAssociation_v1::setRefJet(const Jet* pJet)
437  {
438  bool wasSet(this->f_jetLink().getStorableObjectPointer() != nullptr);
439  f_setObject<Jet,MissingETBase::Types::jetlink_t>(pJet,this->f_jetLink());
440  return wasSet;
441  }
442 
443  bool MissingETAssociation_v1::setRefJet(const JetContainer* pJetCont, size_t pJetIdx)
444  {
445  bool wasSet(this->f_jetLink().getStorableObjectPointer() != nullptr);
446  this->f_jetLink().toIndexedElement(*pJetCont,pJetIdx);
447  return wasSet;
448  }
449 
450  bool MissingETAssociation_v1::setJetLink(const MissingETBase::Types::jetlink_t& jetLnk)
451  {
452  bool wasSet(this->f_jetLink().getStorableObjectPointer() != nullptr);
453  this->f_jetLink() = jetLnk;
454  return wasSet;
455  }
456 
457  bool MissingETAssociation_v1::setObjectLinks(const MissingETBase::Types::objlink_vector_t& objLnks)
458  {
459  bool wasSet(!this->f_objectLinks().empty());
460  if ( wasSet ) { this->f_objectLinks().clear(); this->f_objectLinks().insert(this->f_objectLinks().end(),objLnks.begin(),objLnks.end()); }
461  return wasSet;
462  }
463 
464 
466  // Getters //
468 
469  float MissingETAssociation_v1::calpx(size_t keyIdx) const
470  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calpx()[keyIdx] : MissingETBase::Numerical::cpxError(); }
471  float MissingETAssociation_v1::calpy(size_t keyIdx) const
472  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calpy()[keyIdx] : MissingETBase::Numerical::cpyError(); }
473  float MissingETAssociation_v1::calpz(size_t keyIdx) const
474  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calpz()[keyIdx] : MissingETBase::Numerical::cpzError(); }
475  float MissingETAssociation_v1::cale(size_t keyIdx) const
476  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->cale()[keyIdx] : MissingETBase::Numerical::ceError(); }
477  float MissingETAssociation_v1::calsumpt(size_t keyIdx) const
478  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calsumpt()[keyIdx] : MissingETBase::Numerical::sumptError(); }
479  MissingETBase::Types::bitmask_t MissingETAssociation_v1::calkey(size_t keyIdx) const
480  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calkey()[keyIdx] : MissingETBase::Numerical::invalidIndex(); }
481 
482  float MissingETAssociation_v1::trkpx(size_t keyIdx) const
483  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkpx()[keyIdx] : MissingETBase::Numerical::cpxError(); }
484  float MissingETAssociation_v1::trkpy(size_t keyIdx) const
485  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkpy()[keyIdx] : MissingETBase::Numerical::cpyError(); }
486  float MissingETAssociation_v1::trkpz(size_t keyIdx) const
487  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkpz()[keyIdx] : MissingETBase::Numerical::cpzError(); }
488  float MissingETAssociation_v1::trke(size_t keyIdx) const
489  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trke()[keyIdx] : MissingETBase::Numerical::ceError(); }
490  float MissingETAssociation_v1::trksumpt(size_t keyIdx) const
491  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trksumpt()[keyIdx] : MissingETBase::Numerical::sumptError(); }
492  MissingETBase::Types::bitmask_t MissingETAssociation_v1::trkkey(size_t keyIdx) const
493  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkkey()[keyIdx] : MissingETBase::Numerical::invalidIndex(); }
494 
495  std::vector<size_t> MissingETAssociation_v1::overlapIndices(size_t objIdx) const
496  {
497  return (objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->size()) ? this->overlapIndices()[objIdx] : vector<size_t>(0);
498  }
499 
500  std::vector<unsigned char> MissingETAssociation_v1::overlapTypes(size_t objIdx) const
501  {
502  return (objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->size()) ? this->overlapTypes()[objIdx] : vector<unsigned char>(0);
503  }
504 
505  std::vector<const IParticle*> MissingETAssociation_v1::objects() const
506  {
507  vector<const IParticle*> pVec;
508  for ( objlink_vector_t::const_iterator fLnk(this->objectLinks().begin()); fLnk != this->objectLinks().end(); ++fLnk) {pVec.push_back((*fLnk).isValid()?*(*fLnk):nullptr); }
509  return pVec;
510  }
511 
512  std::vector<const IParticle*> MissingETAssociation_v1::objects(std::vector<constvec_t>& calVecs,std::vector<constvec_t>& trkVecs) const
513  {
514  size_t nEnt(this->objectLinks().size());
515  vector<const IParticle*> pVec(nEnt,(const IParticle*)nullptr);
516  calVecs.clear(); calVecs.resize(this->sizeCal(),constvec_t());
517  trkVecs.clear(); trkVecs.resize(this->sizeTrk(),constvec_t());
518  for ( size_t idx(0); idx < nEnt; ++idx ) pVec[idx] = *(this->objectLinks().at(idx));
519  for ( size_t idx(0); idx < this->sizeCal(); idx++) calVecs[idx] = constvec_t(this->calpx(idx),this->calpy(idx),this->calpz(idx),this->cale(idx),this->calsumpt(idx));
520  for ( size_t idx(0); idx < this->sizeTrk(); idx++) trkVecs[idx] = constvec_t(this->trkpx(idx),this->trkpy(idx),this->trkpz(idx),this->trke(idx),this->trksumpt(idx));
521  return pVec;
522  }
523 
524  std::vector<const IParticle*> MissingETAssociation_v1::objects(const std::vector<float>*& calpxPtr,const std::vector<float>*& calpyPtr,
525  const std::vector<float>*& calpzPtr,const std::vector<float>*& calePtr,
526  const std::vector<float>*& calsumptPtr,
527  const std::vector<float>*& trkpxPtr,const std::vector<float>*& trkpyPtr,
528  const std::vector<float>*& trkpzPtr,const std::vector<float>*& trkePtr,
529  const std::vector<float>*& trksumptPtr) const
530  {
531  calpxPtr = &(this->calpx()); calpyPtr = &(this->calpy()); calpzPtr = &(this->calpz()); calePtr = &(this->cale()); calsumptPtr = &(this->calsumpt());
532  trkpxPtr = &(this->trkpx()); trkpyPtr = &(this->trkpy()); trkpzPtr = &(this->trkpz()); trkePtr = &(this->trke()); trksumptPtr = &(this->trksumpt());
533  return this->objects();
534  }
535 
537  // constvec_t object generators //
539 
540  MissingETAssociation_v1::ConstVec MissingETAssociation_v1::calVec(const IParticle* pPart) const
541  {
542  MissingETBase::Types::constvec_t totalvec;
543  for (size_t iKey = 0; iKey < this->sizeCal(); iKey++) {
544  if (this->calkey(iKey) & getObjMask(this->findIndex(pPart)))
545  totalvec+=this->calVec(iKey);
546  }
547  return totalvec;
548  }
549 
550  MissingETAssociation_v1::ConstVec MissingETAssociation_v1::trkVec(const IParticle* pPart) const
551  {
552  MissingETBase::Types::constvec_t totalvec;
553  for (size_t iKey = 0; iKey < this->sizeTrk(); iKey++) {
554  if (this->trkkey(iKey) & getObjMask(this->findIndex(pPart)))
555  totalvec+=this->trkVec(iKey);
556  }
557  return totalvec;
558  }
559 
560  constvec_t MissingETAssociation_v1::calVec(size_t keyIdx) const
561  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal()
562  ? constvec_t(this->calpx(keyIdx),this->calpy(keyIdx),this->calpz(keyIdx),this->cale(keyIdx),this->calsumpt(keyIdx))
563  : constvec_t(MissingETBase::Numerical::cpxError(),MissingETBase::Numerical::cpyError(),MissingETBase::Numerical::cpzError(),MissingETBase::Numerical::ceError(),MissingETBase::Numerical::sumptError()); }
564 
565  constvec_t MissingETAssociation_v1::trkVec(size_t keyIdx) const
566  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk()
567  ? constvec_t(this->trkpx(keyIdx),this->trkpy(keyIdx),this->trkpz(keyIdx),this->trke(keyIdx),this->trksumpt(keyIdx))
568  : constvec_t(MissingETBase::Numerical::cpxError(),MissingETBase::Numerical::cpyError(),MissingETBase::Numerical::cpzError(),MissingETBase::Numerical::ceError(),MissingETBase::Numerical::sumptError()); }
569 
570  constvec_t MissingETAssociation_v1::jetTrkVec() const
571  { return constvec_t(this->jettrkpx(),this->jettrkpy(),this->jettrkpz(),this->jettrke(),this->jettrksumpt()); }
572 
574  // Comparators //
576 
577  bool MissingETAssociation_v1::operator==(const MissingETAssociation_v1& assocDescr) const
578  {
579  // FIXME compare only jet link and number of contributing particles
580  return
581  this->jetLink() == assocDescr.jetLink() &&
582  this->size() == assocDescr.size();
583  }
584 
585 
587  // Overlap functions //
589 
590 
591  bool MissingETAssociation_v1::addOverlap(size_t objIdx,size_t overlapIndex,unsigned char overlapType)
592  {
593  if ( objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->f_overlapIndices().size() ) {
594  this->f_overlapIndices()[objIdx].push_back(overlapIndex);
595  this->f_overlapTypes()[objIdx].push_back(overlapType);
596  return true;
597  } else { return false; }
598  }
599 
600  bool MissingETAssociation_v1::identifyOverlaps()
601  {
602  using bitmask_t = MissingETBase::Types::bitmask_t;
603  this->resetContrib();
604  std::map<MissingETBase::Types::bitmask_t,MissingETBase::Types::constvec_t> trkOverlaps;
605  std::map<MissingETBase::Types::bitmask_t,MissingETBase::Types::constvec_t> calOverlaps;
606  std::map<ElementLink<IParticleContainer>,bitmask_t> objects;
607  for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
608  const vector<ElementLink<IParticleContainer> >& myConst = m_objConstLinks[iObj];
609  for (size_t iConst=0; iConst<myConst.size(); ++iConst) {
610  objects[myConst[iConst]] |= static_cast<bitmask_t>(1) << iObj;
611  }
612  }
613  for (const auto& objpair : objects) {
614  const IParticle* obj = *objpair.first;
615  MissingETBase::Types::bitmask_t bm = objpair.second;
616  if (obj->type()==xAOD::Type::TrackParticle) trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
617  else if (obj->type()==xAOD::Type::FlowElement) {
618  const xAOD::FlowElement* fe = static_cast<const xAOD::FlowElement*>(obj);
619  // Assume this FlowElement represents a PFO
620  if(fe->isCharged()) {
621  // apply cPFO weight if present, only for the inclusive PFO sum
622  if (m_override.find(obj)!=m_override.end()) {
623  calOverlaps[bm] += m_override[obj];
624  } else {
625  calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
626  }
627  trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
628  } else {
629  if (m_override.find(obj)!=m_override.end()) {
630  calOverlaps[bm] += m_override[obj];
631  } else {
632  calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
633  } // gets ignored otherwise?
634  }
635  }
636  else if (obj->type()==xAOD::Type::ParticleFlow) {
637  const PFO* pfo = static_cast<const PFO*>(obj);
638  if(pfo->isCharged()) {
639  // apply cPFO weight if present, only for the inclusive PFO sum
640  if (m_override.find(obj)!=m_override.end()) {
641  calOverlaps[bm] += m_override[obj];
642  } else {
643  calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
644  }
645  trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
646  } else {
647  if (m_override.find(obj)!=m_override.end()) {
648  calOverlaps[bm] += m_override[obj];
649  } else {
650  calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
651  } // gets ignored otherwise?
652  }
653  } else if(obj->type()==xAOD::Type::TruthParticle) {
654  const TruthParticle* tp = static_cast<const TruthParticle*>(obj);
655  if(fabs(tp->charge())>0.)
656  trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
657  if(!tp->isMuon())
658  calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
659  }
660  else calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
661  }
662  for (const auto& calpair : calOverlaps) {
663  MissingETBase::Types::bitmask_t bm = calpair.first;
664  MissingETBase::Types::constvec_t cv = calpair.second;
665  this->addCalVec(bm,cv.cpx(),cv.cpy(),cv.cpz(),cv.ce(),cv.sumpt());
666  }
667  for (const auto& trkpair : trkOverlaps) {
668  MissingETBase::Types::bitmask_t bm = trkpair.first;
669  MissingETBase::Types::constvec_t cv = trkpair.second;
670  this->addTrkVec(bm,cv.cpx(),cv.cpy(),cv.cpz(),cv.ce(),cv.sumpt());
671  }
672 
673  bool foundOverlaps(false);
674  for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
675  foundOverlaps |= identifyOverlaps(iObj);
676  }
677  return foundOverlaps;
678  }
679 
680  bool MissingETAssociation_v1::identifyOverlaps(size_t objIdx)
681  {
682  if ( objIdx == MissingETBase::Numerical::invalidIndex() ) return false;
683  // extract constituent list
684  const vector<MissingETBase::Types::objlink_t >& myConst = m_objConstLinks[objIdx];
685  // loop over subsequent objects in this association
686  // (assume earlier ones have been tested)
687  vector<size_t>& myOverlaps = f_overlapIndices()[objIdx];
688  for(size_t iTargetObj=objIdx+1; iTargetObj<this->objectLinks().size(); ++iTargetObj) {
689  const vector<MissingETBase::Types::objlink_t >& checkConst = m_objConstLinks[iTargetObj];
690  bool overlapFound(false);
691  unsigned char overlapTypes(0);
692  // if we somehow already recorded an overlap for this one, skip
693  for(vector<size_t>::const_iterator iOverlap=myOverlaps.begin();
694  iOverlap!=myOverlaps.end() && !overlapFound; ++iOverlap) {
695  overlapFound = (*iOverlap) == iTargetObj;
696  }
697  if(overlapFound) continue;
698  // otherwise, compare constituents to check if any match
699  for(const auto& mine : myConst) {
700  for(const auto& target : checkConst) {
701  overlapFound |= ( mine == target );
702  if(mine == target) {
703  if((*mine)->type()==xAOD::Type::TruthParticle) overlapTypes |= 1;
704  else if((*mine)->type()==xAOD::Type::Other) overlapTypes |= 1 << xAOD::Type::NeutralParticle;
705  else if((*mine)->type()==xAOD::Type::FlowElement) overlapTypes |= 1 << FEHelpers::signalToXAODType(static_cast<const xAOD::FlowElement&>(**mine));
706  else overlapTypes |= 1 << (*mine)->type();
707  }
708  }
709  }
710  // record the overlap
711  if(overlapFound) {
712  this->addOverlap(objIdx,iTargetObj,overlapTypes);
713  this->addOverlap(iTargetObj,objIdx,overlapTypes);
714  }
715  }
716  return !overlapIndices(objIdx).empty();
717  }
718 
719  bool MissingETAssociation_v1::hasOverlaps(const MissingETAssociationHelper& helper, size_t objIdx,MissingETBase::UsageHandler::Policy p) const
720  {
721  if ( objIdx == MissingETBase::Numerical::invalidIndex() ) return false;
722  vector<size_t> indices = this->overlapIndices(objIdx);
723  vector<unsigned char> types = this->overlapTypes(objIdx);
724  for(size_t iOL=0; iOL<indices.size(); ++iOL) {
725  if(helper.objSelected(this, indices[iOL])) {
726  // printf("Test object %lu for overlaps: OL type %i\n",indices[iOL],(int)types[iOL]);
727  switch(p) {
728  case MissingETBase::UsageHandler::TrackCluster:
729  if((types[iOL] & 1<<xAOD::Type::CaloCluster) || (types[iOL] & 1<<xAOD::Type::TrackParticle)) {break;}
730  else {continue;}
731  case MissingETBase::UsageHandler::OnlyCluster:
732  if(types[iOL] & 1<<xAOD::Type::CaloCluster) {break;}
733  else {continue;}
734  case MissingETBase::UsageHandler::OnlyTrack:
735  if(types[iOL] & 1<<xAOD::Type::TrackParticle) {break;}
736  else {continue;}
737  case MissingETBase::UsageHandler::ParticleFlow:
738  if(types[iOL] & 1<<xAOD::Type::ParticleFlow) {break;}
739  else {continue;}
740  case MissingETBase::UsageHandler::TruthParticle:
741  if(types[iOL] & 1) {break;}
742  else {continue;}
743  case MissingETBase::UsageHandler::AllCalo:
744  if(types[iOL] & ~(1<<xAOD::Type::TrackParticle)) {break;}
745  else {continue;}
746  default: continue;
747  }
748  return true;
749  }
750  }
751  return false;
752  }
753 
754  bool MissingETAssociation_v1::hasAlternateConstVec() const
755  {
756  return (!this->isMisc() && this->containsPhysics(this->refJet()));
757  }
758 
759  xAOD::JetFourMom_t MissingETAssociation_v1::getAlternateConstVec() const
760  {
761  xAOD::JetFourMom_t newvec;
762  constvec_t newpt;
763  size_t newptIndex = this->findIndex(this->refJet());
764  if (newptIndex == MissingETBase::Numerical::invalidIndex()) return newvec;
765  MissingETBase::Types::bitmask_t mask = (MissingETBase::Types::bitmask_t)1 << newptIndex;
766 
767  for (size_t iKey = 0; iKey < this->sizeCal(); iKey++) if (mask & this->calkey()[iKey]) newpt += this->calVec(iKey);
768  newvec.SetPxPyPzE(newpt.cpx(),newpt.cpy(),newpt.cpz(),newpt.ce());
769  return newvec;
770  }
771 
772  constvec_t MissingETAssociation_v1::overlapCalVec(const MissingETAssociationHelper& helper) const
773  {
774  constvec_t calvec;
775  for (size_t iKey = 0; iKey < this->sizeCal(); iKey++) {
776  bool selector = (helper.getObjSelectionFlags(this) & this->calkey()[iKey]) ? !this->isMisc() : this->isMisc();
777  if (selector) calvec+=this->calVec(iKey);
778  }
779  return calvec;
780  }
781 
782  constvec_t MissingETAssociation_v1::overlapTrkVec(const MissingETAssociationHelper& helper) const
783  {
784  constvec_t trkvec;
785  for (size_t iKey = 0; iKey < this->sizeTrk(); iKey++) {
786  bool selector = (helper.getObjSelectionFlags(this) & this->trkkey()[iKey]) ? !this->isMisc() : this->isMisc();
787  if (selector) trkvec+=ConstVec(this->trkpx()[iKey],this->trkpy()[iKey],this->trkpz()[iKey],this->trke()[iKey],this->trksumpt()[iKey]);
788  }
789  return trkvec;
790  }
791 
792  bool MissingETAssociation_v1::containsPhysics(const IParticle* pPhys) const
793  {
794  for(const auto& link : this->objectLinks()) {
795  if(link.isValid()) {
796  if(pPhys == *link) {
797  return true;
798  }
799  }
800  }
801  return false;
802  }
803 
804  bool MissingETAssociation_v1::containsSignal(const IParticle* pSig) const
805  {
806  for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
807  for(const auto& link : m_objConstLinks[iObj]) {
808  if(link.isValid()) {
809  if(pSig == *link) {
810  return true;
811  }
812  }
813  }
814  }
815  return false;
816  }
817 
818  bool MissingETAssociation_v1::checkUsage(const MissingETAssociationHelper& helper, const IParticle* pSig, MissingETBase::UsageHandler::Policy p) const
819  {
820  if(MissingETAssociation_v1::testPolicy(*pSig,p)) {
821  const IParticleContainer* pCont = static_cast<const IParticleContainer*>(pSig->container());
822  MissingETBase::Types::objlink_t el(*pCont,pSig->index());
823  for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
824  if(helper.objSelected(this,iObj)) {
825  for(const auto& link : m_objConstLinks[iObj]) {
826  if(el == link) return true;
827  }
828  }
829  }
830  }
831  return false;
832  }
833 
835  // Other function(s) //
837 
838  void MissingETAssociation_v1::createPrivateStore()
839  {
840 
841  makePrivateStore();
842  f_jetLink() = jetlink_t();
843  f_objectLinks().clear();
844  f_overlapIndices().clear();
845  f_overlapTypes().clear();
846  f_isMisc() = false;
847  f_calpx().clear();
848  f_calpy().clear();
849  f_calpz().clear();
850  f_cale().clear();
851  f_calsumpt().clear();
852  f_calkey().clear();
853  f_trkpx().clear();
854  f_trkpy().clear();
855  f_trkpz().clear();
856  f_trke().clear();
857  f_trksumpt().clear();
858  f_trkkey().clear();
859  f_jettrkpx() = 0;
860  f_jettrkpy() = 0;
861  f_jettrkpz() = 0;
862  f_jettrke() = 0;
863  f_jettrksumpt() = 0;
864 
865  return;
866  }
867 
868  void MissingETAssociation_v1::initCache()
869  {
870 
871  m_objConstLinks.clear();
872  m_objConstLinks.reserve(50);
873  }
874 
875  bool MissingETAssociation_v1::testPolicy(const xAOD::IParticle& part, MissingETBase::UsageHandler::Policy p) {
876  xAOD::Type::ObjectType objType = part.type();
877  if(objType == xAOD::Type::FlowElement) objType = FEHelpers::signalToXAODType(static_cast<const xAOD::FlowElement&>(part));
878  return testPolicy(objType, p);
879  }
880 
881  bool MissingETAssociation_v1::testPolicy(xAOD::Type::ObjectType type, MissingETBase::UsageHandler::Policy p) {
882  switch(p) {
883  case MissingETBase::UsageHandler::TrackCluster:
884  return type==xAOD::Type::CaloCluster
885  || type==xAOD::Type::TrackParticle;
886  case MissingETBase::UsageHandler::OnlyCluster:
887  return type==xAOD::Type::CaloCluster;
888  case MissingETBase::UsageHandler::OnlyTrack:
889  return type==xAOD::Type::TrackParticle;
890  case MissingETBase::UsageHandler::ParticleFlow:
891  return type==xAOD::Type::ParticleFlow;
892  case MissingETBase::UsageHandler::AllCalo:
893  return type!=xAOD::Type::TrackParticle;
894  default: break;
895  }
896  return false;
897  }
898 
899 }
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
xAOD::MissingETAssociation_v1::initCache
void initCache()
initialise cache for overlap removal decisions
Definition: MissingETAssociation_v1.cxx:868
xAOD::MissingETAssociation_v1::clearOverlaps
void clearOverlaps()
Clear the vectors of overlap indices
Definition: MissingETAssociation_v1.cxx:413
xAOD::MissingETAssociation_v1::setCalPx
bool setCalPx(const std::vector< float > &calpxvec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:299
xAOD::MissingETAssociation_v1::f_calpy
std::vector< float > & f_calpy()
xAOD::MissingETAssociation_v1::objectLinks
const MissingETBase::Types::objlink_vector_t & objectLinks() const
Get the vector of links to the contributing physics or signal objects.
operator==
bool operator==(const DataVector< T > &a, const DataVector< T > &b)
Vector equality comparison.
test_pyathena.px
px
Definition: test_pyathena.py:18
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
xAOD::MissingETAssociation_v1::setJetTrkPy
void setJetTrkPy(float py)
Set track constituent vector for the reference jet.
Definition: MissingETAssociation_v1.cxx:398
SG
Forward declaration.
Definition: CaloCellPacker_400_500.h:32
xAOD::MissingETAssociation_v1::jettrkpx
float jettrkpx() const
Get the vector for a given object referenced by index.
MissingETBase::UsageHandler::TruthParticle
@ TruthParticle
Truth particle based.
Definition: MissingETCompositionBase.h:189
xAOD::MissingETAssociation_v1::overlapCalVec
ConstVec overlapCalVec(const MissingETAssociationHelper &helper) const
Retrieve total cluster-based vector to be subtracted from the jet.
Definition: MissingETAssociation_v1.cxx:772
xAOD::MissingETAssociation_v1::f_overlapTypes
std::vector< std::vector< unsigned char > > & f_overlapTypes()
record overlapTypes between constributing objects
xAOD::MissingETAssociation_v1::setJetTrkSumpt
void setJetTrkSumpt(float sumpt)
Set track constituent vector for the reference jet.
Definition: MissingETAssociation_v1.cxx:404
ObjectType
ObjectType
Definition: BaseObject.h:11
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
xAOD::MissingETAssociation_v1
MET association descriptor contains object links and corresponding parameters.
Definition: MissingETAssociation_v1.h:29
Cut::signal
@ signal
Definition: SUSYToolsAlg.cxx:64
xAOD::MissingETAssociation_v1::setTrkPy
bool setTrkPy(const std::vector< float > &trkpyvec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:314
xAOD::MissingETAssociation_v1::operator=
MissingETAssociation_v1 & operator=(const MissingETAssociation_v1 &assocDescr)
Definition: MissingETAssociation_v1.cxx:121
xAOD::MissingETAssociation_v1::hasAlternateConstVec
bool hasAlternateConstVec() const
Definition: MissingETAssociation_v1.cxx:754
xAOD::MissingETAssociation_v1::removeContrib
bool removeContrib()
Remove all contributions.
Definition: MissingETAssociation_v1.cxx:213
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
xAOD::MissingETAssociation_v1::setJetTrkE
void setJetTrkE(float e)
Set track constituent vector for the reference jet.
Definition: MissingETAssociation_v1.cxx:402
MissingETBase::Numerical::ceError
static double ceError()
Access error return value for constituent vector .
Definition: MissingETBase.h:101
xAOD::MissingETAssociation_v1::cale
const std::vector< float > & cale() const
Get the vector of
TruthParticle
HepMC::GenParticle TruthParticle
Definition: Simulation/G4Sim/MCTruth/MCTruth/TruthEvent.h:13
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
xAOD::MissingETAssociation_v1::setTrkSumpt
bool setTrkSumpt(const std::vector< float > &trksumptvec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:320
xAOD::MissingETAssociation_v1::identifyOverlaps
bool identifyOverlaps()
Loop over contributing objects to identify those that share constituents.
Definition: MissingETAssociation_v1.cxx:600
xAOD::MissingETAssociation_v1::f_trksumpt
std::vector< float > & f_trksumpt()
MissingETCompositionBase.h
ParticleTest.tp
tp
Definition: ParticleTest.py:25
MissingETBase::Numerical::cpxError
static double cpxError()
Access error return value for constituent vector .
Definition: MissingETBase.h:98
xAOD
ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.
Definition: ICaloAffectedTool.h:24
xAOD::MissingETAssociation_v1::containsSignal
bool containsSignal(const IParticle *pSig) const
Check if this signal object matches the constituents of any contributing objects.
Definition: MissingETAssociation_v1.cxx:804
xAOD::MissingETAssociation_v1::f_trkpz
std::vector< float > & f_trkpz()
xAOD::MissingETAssociation_v1::overlapTypes
const std::vector< std::vector< unsigned char > > & overlapTypes() const
Get the list of object overlapTypes.
xAOD::MissingETAssociation_v1::jettrksumpt
float jettrksumpt() const
Get the sumpt for a given object referenced by index.
atn_test_sgProducerConsumerDataPool_jobOptions.end
end
Definition: atn_test_sgProducerConsumerDataPool_jobOptions.py:25
MissingETBase::Numerical::invalidIndex
static size_t invalidIndex()
Access invalid index indicator.
Definition: MissingETBase.h:103
MissingETBase::Numerical::sumptError
static double sumptError()
Access error return value for constituent vector sumpt.
Definition: MissingETBase.h:102
xAOD::MissingETAssociation_v1::addObject
bool addObject(const IParticle *pPart, const std::vector< const IParticle * > &constlist)
Add object (particle) from pointer reference with individual constituent vectors.
Definition: MissingETAssociation_v1.cxx:154
MissingETAssociation_v1.h
MissingETBase::Types::bitmask_t
uint64_t bitmask_t
Type for status word bit mask.
Definition: MissingETBase.h:39
MissingETBase::UsageHandler::OnlyCluster
@ OnlyCluster
CaloCluster based only.
Definition: MissingETCompositionBase.h:184
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:40
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
xAOD::MissingETAssociation_v1::jettrkpz
float jettrkpz() const
Get the vector for a given object referenced by pointer.
xAOD::MissingETAssociation_v1::setJetTrkPz
void setJetTrkPz(float pz)
Set track constituent vector for the reference jet.
Definition: MissingETAssociation_v1.cxx:400
xAOD::py
py
Definition: CompositeParticle_v1.cxx:160
xAOD::MissingETAssociation_v1::setTrkE
bool setTrkE(const std::vector< float > &trkevec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:318
xAOD::MissingETAssociation_v1::overlapIndices
const std::vector< std::vector< size_t > > & overlapIndices() const
Get the list of object overlapIndices.
xAOD::MissingETAssociation_v1::trksumpt
const std::vector< float > & trksumpt() const
Get the vector of
xAOD::MissingETAssociation_v1::hasOverlaps
bool hasOverlaps(const MissingETAssociationHelper &helper, size_t objIdx, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const
Check if any selected particles overlap this one.
Definition: MissingETAssociation_v1.cxx:719
xAOD::MissingETAssociation_v1::ConstVec
Vector sum of constituents for subtractive overlap removal.
Definition: MissingETAssociation_v1.h:36
xAOD::MissingETAssociation_v1::containsPhysics
bool containsPhysics(const IParticle *pPhys) const
Check if this physics object matches any contributing objects.
Definition: MissingETAssociation_v1.cxx:792
xAOD::MissingETAssociation_v1::testPolicy
static bool testPolicy(const xAOD::IParticle &part, MissingETBase::UsageHandler::Policy p)
Definition: MissingETAssociation_v1.cxx:875
xAOD::CaloCluster
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.
Definition: Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloCluster.h:19
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
xAOD::getObjMask
MissingETBase::Types::bitmask_t getObjMask(size_t objIndex)
Definition: MissingETAssociation_v1.cxx:40
xAOD::MissingETAssociation_v1::resetContrib
bool resetContrib()
Reset all contribution parameters.
Definition: MissingETAssociation_v1.cxx:249
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition: Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
MissingETBase::Types::jetlink_t
ElementLink< xAOD::JetContainer > jetlink_t
Link to Jet object.
Definition: MissingETCompositionBase.h:42
xAOD::MissingETAssociation_v1::findIndex
size_t findIndex(const IParticle *pPart) const
Find index of given object in contributing object store.
Definition: MissingETAssociation_v1.cxx:268
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
xAOD::FlowElement_v1::isCharged
bool isCharged() const
Definition: FlowElement_v1.cxx:56
xAOD::MissingETAssociation_v1::calpx
const std::vector< float > & calpx() const
Get the vector of
PFO.h
xAOD::MissingETAssociation_v1::f_removeContrib
bool f_removeContrib(size_t objIdx)
Copy the contribution data from a source.
Definition: MissingETAssociation_v1.cxx:220
xAOD::MissingETAssociation_v1::setJetLink
bool setJetLink(const MissingETBase::Types::jetlink_t &jetLnk)
Set the link to the reference jet.
Definition: MissingETAssociation_v1.cxx:450
MissingETBase::Numerical::cpzError
static double cpzError()
Access error return value for constituent vector .
Definition: MissingETBase.h:100
MissingETBase::Types::objlink_vector_t
std::vector< objlink_t > objlink_vector_t
Vector of object links type.
Definition: MissingETCompositionBase.h:58
FlowElement.h
xAOD::MissingETAssociation_v1::setCalSumpt
bool setCalSumpt(const std::vector< float > &calsumptvec)
Set the vector of sumpt
Definition: MissingETAssociation_v1.cxx:307
xAOD::MissingETAssociation_v1::setJetTrkVec
void setJetTrkVec(const ConstVec &cvec=ConstVec())
Set the track constituent vector for the reference jet.
xAOD::MissingETAssociation_v1::calsumpt
const std::vector< float > & calsumpt() const
Get the vector of sumpt
xAOD::e
setPy e
Definition: CompositeParticle_v1.cxx:166
xAOD::FlowElement
FlowElement_v1 FlowElement
Definition of the current "pfo version".
Definition: FlowElement.h:16
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:41
xAOD::MissingETAssociation_v1::ConstVec::cpy
float cpy() const
Returns .
xAOD::MissingETAssociation_v1::ConstVec::sumpt
float sumpt() const
Returns sum of component pt.
MissingETBase::Types::constvec_t
xAOD::MissingETAssociation_v1::ConstVec constvec_t
Type for constituent vector.
Definition: MissingETAssociation_v1.h:457
xAOD::MissingETAssociation_v1::f_trkpy
std::vector< float > & f_trkpy()
xAOD::MissingETAssociation_v1::jettrkpy
float jettrkpy() const
Get the vector for a given object referenced by pointer.
xAOD::MissingETAssociation_v1::trkkey
const std::vector< MissingETBase::Types::bitmask_t > & trkkey() const
Get the vector of trk keys.
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
xAOD::MissingETAssociation_v1::~MissingETAssociation_v1
virtual ~MissingETAssociation_v1()
Assignment operator.
Definition: MissingETAssociation_v1.cxx:148
xAOD::MissingETAssociation_v1::setCalPy
bool setCalPy(const std::vector< float > &calpyvec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:301
xAOD::MissingETAssociation_v1::setJetTrkPx
void setJetTrkPx(float px)
Set track constituent vector for the reference jet.
Definition: MissingETAssociation_v1.cxx:396
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
xAOD::MissingETAssociation_v1::setTrkPx
bool setTrkPx(const std::vector< float > &trkpxvec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:312
xAODType::ParticleFlow
@ ParticleFlow
The object is a particle-flow object.
Definition: ObjectType.h:41
xAOD::MissingETAssociation_v1::f_jettrksumpt
float & f_jettrksumpt()
xAOD::MissingETAssociation_v1::addOverlap
bool addOverlap(const IParticle *pPart, size_t index, unsigned char type)
Add overlap index for a given contributing object referenced by pointer.
xAOD::NeutralParticle
NeutralParticle_v1 NeutralParticle
Reference the current persistent version:
Definition: NeutralParticle.h:13
xAOD::MissingETAssociation_v1::setTrkVec
bool setTrkVec(size_t keyIdx, const ConstVec &cvec=ConstVec())
Set the track constituent vector of an object contribution referenced by index.
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
FEHelpers::signalToXAODType
xAOD::Type::ObjectType signalToXAODType(const xAOD::FlowElement &fe)
Definition: FEHelpers.cxx:178
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
xAOD::MissingETAssociation_v1::m_objConstLinks
std::vector< std::vector< ElementLink< IParticleContainer > > > m_objConstLinks
Cache object constituents for overlap-finding.
Definition: MissingETAssociation_v1.h:427
xAOD::MissingETAssociation_v1::jetLink
const MissingETBase::Types::jetlink_t & jetLink() const
Get the link to the reference jet.
MissingETBase::UsageHandler::TrackCluster
@ TrackCluster
Both cluster and track based.
Definition: MissingETCompositionBase.h:186
xAOD::MissingETAssociation_v1::ConstVec::cpz
float cpz() const
Returns .
xAOD::MissingETAssociation_v1::f_jettrkpz
float & f_jettrkpz()
xAOD::MissingETAssociation_v1::calVec
ConstVec calVec(const IParticle *pPart) const
Get calo constituent vector for a given object.
Definition: MissingETAssociation_v1.cxx:540
xAOD::PFO_v1::isCharged
bool isCharged() const
is a charged PFO
Definition: PFO_v1.cxx:251
xAOD::MissingETAssociation_v1::jetTrkVec
ConstVec jetTrkVec() const
Get track constituent vector for the reference jet.
Definition: MissingETAssociation_v1.cxx:570
xAOD::MissingETAssociation_v1::addCalVec
bool addCalVec(MissingETBase::Types::bitmask_t key, float calpx, float calpy, float calpz, float cale, float sumpt)
Add a key/vector pair for calo contributions.
Definition: MissingETAssociation_v1.cxx:347
PFO
Definition: ClusterMomentPlots.h:13
xAOD::MissingETAssociation_v1::setTrkKey
bool setTrkKey(const std::vector< MissingETBase::Types::bitmask_t > &trkkeyvec)
Set the vector of keys
Definition: MissingETAssociation_v1.cxx:322
MissingETBase::UsageHandler::Policy
Policy
Policies on usage checks.
Definition: MissingETCompositionBase.h:182
xAOD::JetFourMom_t
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > > JetFourMom_t
Base 4 Momentum type for Jet.
Definition: JetTypes.h:17
xAOD::MissingETAssociation_v1::f_jetLink
MissingETBase::Types::jetlink_t & f_jetLink()
Non-const link reference
xAOD::MissingETAssociation_v1::trke
const std::vector< float > & trke() const
Get the vector of
xAOD::MissingETAssociation_v1::createPrivateStore
void createPrivateStore()
Function initialising the object to work in standalone mode.
Definition: MissingETAssociation_v1.cxx:838
xAOD::MissingETAssociation_v1::setCalVec
bool setCalVec(size_t keyIdx, const ConstVec &cvec=ConstVec())
Set the calo constituent vector of an object contribution referenced by index.
xAOD::MissingETAssociation_v1::f_isMisc
char & f_isMisc()
MissingETBase::UsageHandler::AllCalo
@ AllCalo
Inclusive except tracks.
Definition: MissingETCompositionBase.h:183
FEHelpers.h
MissingETBase::Numerical::isEqual
static bool isEqual(double x, double y)
Test of equality.
Definition: MissingETBase.h:119
xAOD::MissingETAssociation_v1::f_overlapIndices
std::vector< std::vector< size_t > > & f_overlapIndices()
record overlapIndices between constributing objects
MissingETBase::Numerical::cpyError
static double cpyError()
Access error return value for constituent vector .
Definition: MissingETBase.h:99
MissingETBase::UsageHandler::OnlyTrack
@ OnlyTrack
Track based only.
Definition: MissingETCompositionBase.h:185
xAOD::MissingETAssociation_v1::m_override
std::map< const IParticle *, ConstVec > m_override
Definition: MissingETAssociation_v1.h:430
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:172
xAOD::MissingETAssociationHelper
Definition: MissingETAssociationHelper.h:26
xAOD::MissingETAssociation_v1::overlapTrkVec
ConstVec overlapTrkVec(const MissingETAssociationHelper &helper) const
Retrieve total track-based vector to be subtracted from the jet.
Definition: MissingETAssociation_v1.cxx:782
xAOD::MissingETAssociation_v1::jettrke
float jettrke() const
Get the vector for a given object referenced by index.
MissingETBase::UsageHandler::ParticleFlow
@ ParticleFlow
Particle Flow Object based.
Definition: MissingETCompositionBase.h:188
xAOD::MissingETAssociation_v1::f_trke
std::vector< float > & f_trke()
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
xAOD::MissingETAssociation_v1::f_jettrke
float & f_jettrke()
xAOD::MissingETAssociation_v1::f_objectLinks
MissingETBase::Types::objlink_vector_t & f_objectLinks()
Non-const link reference.
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
xAOD::MissingETAssociation_v1::calkey
const std::vector< MissingETBase::Types::bitmask_t > & calkey() const
Get the vector of cal keys.
JetContainer.h
xAOD::MissingETAssociation_v1::addTrkVec
bool addTrkVec(MissingETBase::Types::bitmask_t key, float trkpx, float trkpy, float trkpz, float ce, float sumpt)
Add a key/vector pair for calo contributions.
Definition: MissingETAssociation_v1.cxx:381
xAOD::MissingETAssociation_v1::calpz
const std::vector< float > & calpz() const
Get the vector of
xAOD::MissingETAssociation_v1::isMisc
bool isMisc() const
Check if this association is a miscellaneous association.
xAOD::MissingETAssociation_v1::f_calkey
std::vector< MissingETBase::Types::bitmask_t > & f_calkey()
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
xAOD::MissingETAssociation_v1::empty
bool empty() const
Update all internally used ElementLink instances.
xAOD::MissingETAssociation_v1::trkpy
const std::vector< float > & trkpy() const
Get the vector of
xAOD::MissingETAssociation_v1::checkUsage
bool checkUsage(const MissingETAssociationHelper &helper, const IParticle *pSig, MissingETBase::UsageHandler::Policy p) const
Check if this signal object matches the constituents of any flagged contributing objects.
Definition: MissingETAssociation_v1.cxx:818
xAOD::MissingETAssociation_v1::setCalE
bool setCalE(const std::vector< float > &calevec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:305
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
xAOD::MissingETAssociation_v1::f_calpz
std::vector< float > & f_calpz()
xAOD::MissingETAssociation_v1::setOverlaps
bool setOverlaps(const std::vector< std::vector< size_t > > &overlapIndices, const std::vector< std::vector< unsigned char > > &overlapTypes)
Set the vector of overlap indices and types.
Definition: MissingETAssociation_v1.cxx:420
xAOD::MissingETAssociation_v1::findTrkIndex
size_t findTrkIndex(MissingETBase::Types::bitmask_t mask) const
Definition: MissingETAssociation_v1.cxx:289
xAOD::MissingETAssociation_v1::f_calsumpt
std::vector< float > & f_calsumpt()
xAOD::MissingETAssociation_v1::f_trkpx
std::vector< float > & f_trkpx()
xAOD::MissingETAssociation_v1::trkVec
ConstVec trkVec(const IParticle *pPart) const
Get track constituent vector for a given object.
Definition: MissingETAssociation_v1.cxx:550
xAOD::MissingETAssociation_v1::f_jettrkpx
float & f_jettrkpx()
xAOD::JetConstituentVector::iterator
Definition: JetConstituentVector.h:121
xAOD::MissingETAssociation_v1::setCalPz
bool setCalPz(const std::vector< float > &calpzvec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:303
xAOD::MissingETAssociation_v1::f_calpx
std::vector< float > & f_calpx()
xAOD::MissingETAssociation_v1::f_cale
std::vector< float > & f_cale()
xAOD::MissingETAssociation_v1::setCalKey
bool setCalKey(const std::vector< MissingETBase::Types::bitmask_t > &calkeyvec)
Set the vector of keys
Definition: MissingETAssociation_v1.cxx:309
COOLRates.target
target
Definition: COOLRates.py:1106
SG::AuxElement::container
const SG::AuxVectorData * container() const
Return the container holding this element.
xAOD::MissingETAssociation_v1::trkpx
const std::vector< float > & trkpx() const
Get the vector of
xAOD::MissingETAssociation_v1::ConstVec::cpx
float cpx() const
Returns .
xAOD::MissingETAssociation_v1::trkpz
const std::vector< float > & trkpz() const
Get the vector of
xAOD::MissingETAssociation_v1::findCalIndex
size_t findCalIndex(MissingETBase::Types::bitmask_t mask) const
Definition: MissingETAssociation_v1.cxx:283
TruthParticle.h
xAOD::MissingETAssociation_v1::setObjectLinks
bool setObjectLinks(const MissingETBase::Types::objlink_vector_t &objLnks)
Set the vector of links to the contributing physics or signal objects.
Definition: MissingETAssociation_v1.cxx:457
python.PyAthena.obj
obj
Definition: PyAthena.py:135
xAOD::MissingETAssociation_v1::f_jettrkpy
float & f_jettrkpy()
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
xAOD::MissingETAssociation_v1::refJet
const Jet * refJet() const
Access reference jet.
xAOD::MissingETAssociation_v1::f_trkkey
std::vector< MissingETBase::Types::bitmask_t > & f_trkkey()
xAOD::MissingETAssociation_v1::operator==
bool operator==(const MissingETAssociation_v1 &contrib) const
Definition: MissingETAssociation_v1.cxx:577
xAOD::MissingETAssociation_v1::ConstVec::ce
float ce() const
Returns .
xAOD::MissingETAssociation_v1::objects
std::vector< const IParticle * > objects() const
Access contributing objects.
Definition: MissingETAssociation_v1.cxx:505
xAOD::MissingETAssociation_v1::setTrkPz
bool setTrkPz(const std::vector< float > &trkpzvec)
Set the vector of
Definition: MissingETAssociation_v1.cxx:316
MissingETBase::Types
Namespace for generally used type definitions.
Definition: MissingETAssociation_v1.h:456
xAOD::MissingETAssociation_v1::getAlternateConstVec
xAOD::JetFourMom_t getAlternateConstVec() const
Definition: MissingETAssociation_v1.cxx:759
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
xAOD::MissingETAssociation_v1::setRefJet
bool setRefJet(const Jet *pJet)
Set reference jet by object pointer reference.
Definition: MissingETAssociation_v1.cxx:436
xAOD::MissingETAssociation_v1::calpy
const std::vector< float > & calpy() const
Get the vector of
xAOD::FlowElement_v1
A detector object made of other lower level object(s)
Definition: FlowElement_v1.h:25
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
xAOD::MissingETAssociation_v1::MissingETAssociation_v1
MissingETAssociation_v1(bool createStore=false)
Default constructor.
Definition: MissingETAssociation_v1.cxx:96
Generated on Sun May 19 2024 21:21:38 for ATLAS Offline Software by   doxygen 1.8.18