ATLAS Offline Software
ElectronMuonTopoInfo.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 /**************************************************************************
6  **
7  ** File: Trigger/TrigEvent/TrigTopoEvent/ElectronMuonTopoInfo.cxx
8  **
9  ** Description: -Class for description of combined electron-muon object for
10  ** algorithms in TrigEgammaMuonCombHypo package
11  **
12  ** Author: Pavel Jez <pavel.jez@cern.ch>
13  **
14  ** Created: Apr 9, 2011
15  **
16  **
17  **************************************************************************/
18 
19 #include "TrigTopoEvent/ElectronMuonTopoInfo.h"
20 #include <sstream>
21 #include <iostream>
22 #ifdef __APPLE__
23 #include "CxxUtils/sincos.h"
24 #endif
25 #include "EventPrimitives/EventPrimitivesHelpers.h"
26 // constructors
27 
28 ElectronMuonTopoInfo::ElectronMuonTopoInfo(): m_roiWord(-1),
29  m_DeltaPhi(-1),
30  m_DeltaR(-1),
31  m_InvMass(-1),
32  m_electronValid(false),
33  m_oppositeCharge(false),
34  m_vertexState(0)
35 
36 {}
37 
38 ElectronMuonTopoInfo::ElectronMuonTopoInfo(int roiWord, float deltaPhi, float deltaR, float invMass, bool el_valid,
39  bool oppositeCharge, unsigned short vertexState): m_roiWord(roiWord),
40  m_DeltaPhi(deltaPhi),
41  m_DeltaR(deltaR),
42  m_InvMass(invMass),
43  m_electronValid(el_valid),
44  m_oppositeCharge(oppositeCharge),
45  m_vertexState(vertexState)
46 
47 {}
48 
49 // destructor
50  ElectronMuonTopoInfo::~ElectronMuonTopoInfo() {}
51 
52 
53 // set methods
54  void ElectronMuonTopoInfo::SetRoiWord(int RoiWord){m_roiWord = RoiWord;}
55  void ElectronMuonTopoInfo::SetDeltaPhi(float DeltaPhi){m_DeltaPhi= DeltaPhi;}
56  void ElectronMuonTopoInfo::SetDeltaR(float DeltaR){m_DeltaR= DeltaR;}
57  void ElectronMuonTopoInfo::SetInvMass(float InvMass){m_InvMass = InvMass;}
58  void ElectronMuonTopoInfo::SetElecValid(bool ElecValid){m_electronValid = ElecValid;}
59  void ElectronMuonTopoInfo::SetOppositeCharge(bool OppositeCharge){m_oppositeCharge = OppositeCharge;}
60  void ElectronMuonTopoInfo::SetVertexState(unsigned short vertexState){m_vertexState = vertexState;}
61 
62 // text output
63  std::string str( const ElectronMuonTopoInfo& d )
64  {
65  std::stringstream ss;
66  ss << "ElectronMuonTopoInfo at address: " << &d
67  << " RoIWord: " << d.RoiWord()
68  << " Delta Phi: " << d.DeltaPhi()
69  << " Delta R: " << d.DeltaR()
70  << " Invariant mass: " << d.InvMass()
71  << " electron valid: " << d.ElecValid()
72  << " opposite charge: " << d.OppositeCharge()
73  << " vertex state: " << d.VertexState();
74  return ss.str();
75  }
76 
77  MsgStream& operator<< ( MsgStream& m, const ElectronMuonTopoInfo& d )
78  {
79  return( m << str ( d ) );
80  }
81 
82  bool operator==( const ElectronMuonTopoInfo& d1, const ElectronMuonTopoInfo& d2 )
83  {
84  return(d1.DeltaPhi()==d2.DeltaPhi() && d1.DeltaR()==d2.DeltaR() && d1.InvMass()==d2.InvMass()
85  && d1.OppositeCharge()==d2.OppositeCharge() && d1.VertexState() == d2.VertexState() );
86  }
87  // helper functions, overloaded separately for L2 and EF interface
88 
89  // Vextex matching @ L2
90  ElectronMuonTopoInfo::Vertex ElectronMuonTopoInfo::commonVertex(const TrigElectron* electron1,
91  const CombinedMuonFeature* muon1) {
92 
93 
94  double trk_e1_z0error = electron1->err_Zvtx();
95  double trk_e2_z0error = muon1->IDTrack()->param()->ez0();
96 
97 
98  if ( trk_e1_z0error > 0 && trk_e2_z0error > 0 ) {
99  double z0_distance = fabs(electron1->Zvtx()
100  - muon1->IDTrack()->param()->z0());
101 
102  double z0_error = sqrt(trk_e1_z0error * trk_e1_z0error
103  + trk_e2_z0error * trk_e2_z0error);
104 
105 
106  // reject combination if distance squared between perigee of
107  // tracks is greater than sqrt(6)*error = 2.45*error: this
108  // should accept 99% of good combinations (common vertex)
109  // Note: I changed 2.45 to 3 to be conservative => efficiency is
110  // now 99.7%
111  if (z0_distance > 3*z0_error) {
112  return NotCommon;
113 
114  } else {
115 
116  return Common;
117  }
118  }
119 
120  return Unapplicable;
121 }
122 
123 // Vertex matching @ EF
124 
125 ElectronMuonTopoInfo::Vertex ElectronMuonTopoInfo::commonVertex(const Trk::Perigee* perigeeEL,
126  const Trk::Perigee* perigeeMU,
127  double& pull, bool debug) {
128 
129  if(debug) std::cout << "Now checking electron perigee at " << perigeeEL << " and muon perigee at " << perigeeMU << "." << std::endl;
130 
131 
132  double electron_z0=0.;
133  double electron_z0_error=0.;
134 
135  double muon_z0=0.;
136  double muon_z0_error=0.;
137 
138  if(perigeeEL!=0)
139  {
140  electron_z0 = perigeeEL->parameters()[Trk::z0];
141  electron_z0_error= Amg::error( *perigeeEL->covariance(), Trk::z0 );
142  //electron_z0_error= perigeeEL->localErrorMatrix().error(Trk::z0);
143  delete perigeeEL;
144  }
145 
146  if(perigeeMU!=0)
147  {
148 
149 
150 
151  muon_z0 = perigeeMU->parameters()[Trk::z0];
152  muon_z0_error= Amg::error( *perigeeMU->covariance(), Trk::z0 );
153 
154  //muon_z0_error= perigeeMU->localErrorMatrix().error(Trk::z0);
155  delete perigeeMU;
156  }
157 
158  if(debug) std::cout << "Electron z0 = " << electron_z0 << "+-" << electron_z0_error << "; muon_z0 = " << muon_z0 << "+-" << muon_z0_error << std::endl;
159 
160  pull = -999.;
161 
162  if ( electron_z0_error > 0 && muon_z0_error > 0 ) {
163  double z0_distance = fabs(electron_z0
164  - muon_z0);
165 
166  double z0_error = sqrt(electron_z0_error * electron_z0_error
167  + muon_z0_error * muon_z0_error);
168 
169  pull = z0_distance/z0_error;
170 
171  if(debug) std::cout << "z-distance is " << z0_distance << "+-" << z0_error << ". And the pull is " << pull << "." << std::endl;
172 
173  // reject combination if distance squared between perigee of
174  // tracks is greater than sqrt(6)*error = 2.45*error: this
175  // should accept 99% of good combinations (common vertex)
176  // Note: I changed 2.45 to 3 to be conservative => efficiency is
177  // now 99.7%
178  if (z0_distance > 3*z0_error) {
179  return ElectronMuonTopoInfo::NotCommon;
180 
181  } else {
182 
183  return ElectronMuonTopoInfo::Common;
184  }
185  }
186 
187  return ElectronMuonTopoInfo::Unapplicable;
188 }
189 
190 
191 //L2
192 bool ElectronMuonTopoInfo::opositeCharge(const TrigElectron* electron1,
193  const CombinedMuonFeature* muon1) {
194  if ( electron1->charge() * muon1->ptq() > 0 )
195  return false;
196  return true;
197 }
198 
199 //EF
200 bool ElectronMuonTopoInfo::opositeCharge(const egamma* electron1, const Trk::Perigee* muon1){
201  if( (electron1->charge() * muon1->charge()) > 0 )
202  return false;
203  return true;
204 }
205 
206 //L2
207 double ElectronMuonTopoInfo::deltaPhi(const TrigElectron* electron1,
208  const CombinedMuonFeature* muon1) {
209  double dPhi = electron1->phi()-muon1->IDTrack()->param()->phi0();
210  if (dPhi < -M_PI) dPhi += 2*M_PI;
211  if (dPhi > M_PI) dPhi -= 2*M_PI;
212  double distEmu = fabs(dPhi);
213 
214  return distEmu;
215 }
216 
217 //L2 tau tau
218 double ElectronMuonTopoInfo::deltaPhi(const TrigTau* tau1,
219  const TrigTau* tau2) {
220  double dPhi = tau1->phi()-tau2->phi();
221  if (dPhi < -M_PI) dPhi += 2*M_PI;
222  if (dPhi > M_PI) dPhi -= 2*M_PI;
223  double distEmu = fabs(dPhi);
224 
225  return distEmu;
226 }
227 
228 //L2 tau e
229 double ElectronMuonTopoInfo::deltaPhi(const TrigTau* tau1,
230  const TrigElectron* electron1) {
231  double dPhi = tau1->phi()-electron1->phi();
232  if (dPhi < -M_PI) dPhi += 2*M_PI;
233  if (dPhi > M_PI) dPhi -= 2*M_PI;
234  double distEmu = fabs(dPhi);
235 
236  return distEmu;
237 }
238 
239 //L2 tau mu
240 double ElectronMuonTopoInfo::deltaPhi(const TrigTau* tau1,
241  const CombinedMuonFeature* muon1) {
242  double dPhi = tau1->phi()-muon1->IDTrack()->param()->phi0();
243  if (dPhi < -M_PI) dPhi += 2*M_PI;
244  if (dPhi > M_PI) dPhi -= 2*M_PI;
245  double distEmu = fabs(dPhi);
246 
247  return distEmu;
248 }
249 
250 
251 
252 
253 //L2
254 double ElectronMuonTopoInfo::deltaR(const TrigElectron* electron1,
255  const CombinedMuonFeature* muon1) {
256  double dPhi = electron1->phi()-muon1->IDTrack()->param()->phi0();
257  if (dPhi < -M_PI) dPhi += 2*M_PI;
258  if (dPhi > M_PI) dPhi -= 2*M_PI;
259  double dEta = electron1->eta() - muon1->IDTrack()->param()->eta();
260  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
261 
262  return distEmu;
263 }
264 
265 //L2 tautau
266 double ElectronMuonTopoInfo::deltaR( const TrigTau* tau1,
267  const TrigTau* tau2) {
268  double dPhi = tau1->phi()-tau2->phi();
269  if (dPhi < -M_PI) dPhi += 2*M_PI;
270  if (dPhi > M_PI) dPhi -= 2*M_PI;
271  double dEta = tau1->eta() - tau2->eta();
272  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
273 
274  return distEmu;
275 }
276 
277 //L2 tau e
278 double ElectronMuonTopoInfo::deltaR( const TrigTau* tau1,
279  const TrigElectron* electron1) {
280  double dPhi = tau1->phi()-electron1->phi();
281  if (dPhi < -M_PI) dPhi += 2*M_PI;
282  if (dPhi > M_PI) dPhi -= 2*M_PI;
283  double dEta = tau1->eta() - electron1->eta();
284  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
285 
286  return distEmu;
287 }
288 
289 //L2 tau mu
290 double ElectronMuonTopoInfo::deltaR( const TrigTau* tau1,
291  const CombinedMuonFeature* muon1) {
292  double dPhi = tau1->phi()-muon1->IDTrack()->param()->phi0();
293  if (dPhi < -M_PI) dPhi += 2*M_PI;
294  if (dPhi > M_PI) dPhi -= 2*M_PI;
295  double dEta = tau1->eta() - muon1->IDTrack()->param()->eta();
296  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
297 
298  return distEmu;
299 }
300 
301 //EF
302 double ElectronMuonTopoInfo::deltaPhi(const egamma* electron1,
303  const Trk::Perigee* muon1) {
304  float mu_phi = muon1->parameters()[Trk::phi];
305 
306  double dPhi = electron1->trackParticle()->phi()-mu_phi;
307  if (dPhi < -M_PI) dPhi += 2*M_PI;
308  if (dPhi > M_PI) dPhi -= 2*M_PI;
309  double distEmu = fabs(dPhi);
310 
311  return distEmu;
312 }
313 //EF tau tau
314 double ElectronMuonTopoInfo::deltaPhi(const Analysis::TauJet* tau1,
315  const Analysis::TauJet* tau2) {
316  double dPhi = tau1->phi()-tau2->phi();
317  if (dPhi < -M_PI) dPhi += 2*M_PI;
318  if (dPhi > M_PI) dPhi -= 2*M_PI;
319  double distEmu = fabs(dPhi);
320 
321  return distEmu;
322 }
323 
324 //EF tau e
325 double ElectronMuonTopoInfo::deltaPhi(const Analysis::TauJet* tau1,
326  const egamma* electron1) {
327  double dPhi = tau1->phi()-electron1->trackParticle()->phi();
328  if (dPhi < -M_PI) dPhi += 2*M_PI;
329  if (dPhi > M_PI) dPhi -= 2*M_PI;
330  double distEmu = fabs(dPhi);
331 
332  return distEmu;
333 }
334 
335 //EF tau mu
336 double ElectronMuonTopoInfo::deltaPhi(const Analysis::TauJet* tau1,
337  const Trk::Perigee* muon1) {
338  float mu_phi = muon1->parameters()[Trk::phi];
339 
340  double dPhi = tau1->phi()-mu_phi;
341  if (dPhi < -M_PI) dPhi += 2*M_PI;
342  if (dPhi > M_PI) dPhi -= 2*M_PI;
343  double distEmu = fabs(dPhi);
344 
345  return distEmu;
346 }
347 
348 
349 //EF
350 double ElectronMuonTopoInfo::deltaR(const egamma* electron1,
351  const Trk::Perigee* muon1) {
352  float mu_phi =muon1->parameters()[Trk::phi];
353 
354  double dPhi = electron1->trackParticle()->phi()-mu_phi;
355  if (dPhi < -M_PI) dPhi += 2*M_PI;
356  if (dPhi > M_PI) dPhi -= 2*M_PI;
357  double dEta = electron1->trackParticle()->eta() - muon1->eta();
358  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
359 
360  return distEmu;
361 }
362 
363 //EF tautau
364 double ElectronMuonTopoInfo::deltaR( const Analysis::TauJet* tau1,
365  const Analysis::TauJet* tau2) {
366  double dPhi = tau1->phi()-tau2->phi();
367  if (dPhi < -M_PI) dPhi += 2*M_PI;
368  if (dPhi > M_PI) dPhi -= 2*M_PI;
369  double dEta = tau1->eta() - tau2->eta();
370  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
371 
372  return distEmu;
373 }
374 
375 //EF tau e
376 double ElectronMuonTopoInfo::deltaR( const Analysis::TauJet* tau1,
377  const egamma* electron1) {
378  double dPhi = tau1->phi()-electron1->trackParticle()->phi();
379  if (dPhi < -M_PI) dPhi += 2*M_PI;
380  if (dPhi > M_PI) dPhi -= 2*M_PI;
381  double dEta = tau1->eta() - electron1->trackParticle()->eta();
382  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
383 
384  return distEmu;
385 }
386 
387 //EF tau mu
388 double ElectronMuonTopoInfo::deltaR( const Analysis::TauJet* tau1,
389  const Trk::Perigee* muon1) {
390  float mu_phi =muon1->parameters()[Trk::phi];
391 
392  double dPhi = tau1->phi()-mu_phi;
393  if (dPhi < -M_PI) dPhi += 2*M_PI;
394  if (dPhi > M_PI) dPhi -= 2*M_PI;
395  double dEta = tau1->eta() - muon1->eta();
396  double distEmu = sqrt(dPhi*dPhi+dEta*dEta);
397 
398  return distEmu;
399 }
400 
401 
402 // L2
403 double ElectronMuonTopoInfo::invariantMass(const TrigElectron* electron1,
404  const CombinedMuonFeature* muon1) {
405  // get parameters: not electron pT no longer signed
406  double eta1 = electron1->eta();
407  double eta2 = muon1->IDTrack()->param()->eta();
408 
409 
410  double Pt1 = electron1->pt() ; // IMPORTANT: pt() is the 4-momentum base class method and
411  double Pt2 = muon1->pt(); // it returns the cluster pT; the track pT is given by Pt()
412 
413  double phi1 = electron1->phi();
414  double phi2 = muon1->IDTrack()->param()->phi0();
415 
416  return invariantMass(Pt1, eta1, phi1, 0.511, Pt2, eta2, phi2, 105.6);
417 }
418 
419 // L2 tautau
420 double ElectronMuonTopoInfo::invariantMass( const TrigTau* tau1,
421  const TrigTau* tau2) {
422  // get parameters: not electron pT no longer signed
423  double eta1 = tau1->eta();
424  double eta2 = tau2->eta();
425 
426 
427  double Pt1 = tau1->pt() ; // IMPORTANT: pt() is the 4-momentum base class method and
428  double Pt2 = tau2->pt(); // it returns the cluster pT; the track pT is given by Pt()
429 
430  double phi1 = tau1->phi();
431  double phi2 = tau2->phi();
432 
433  return invariantMass(Pt1, eta1, phi1, 1777., Pt2, eta2, phi2, 1777.);//tau mass used
434 }
435 
436 // L2 tau e
437 double ElectronMuonTopoInfo::invariantMass( const TrigTau* tau1,
438  const TrigElectron* electron1) {
439  // get parameters: not electron pT no longer signed
440  double eta1 = tau1->eta();
441  double eta2 = electron1->eta();
442 
443 
444  double Pt1 = tau1->pt() ; // IMPORTANT: pt() is the 4-momentum base class method and
445  double Pt2 = electron1->pt(); // it returns the cluster pT; the track pT is given by Pt()
446 
447  double phi1 = tau1->phi();
448  double phi2 = electron1->phi();
449 
450  return invariantMass(Pt1, eta1, phi1, 1777., Pt2, eta2, phi2, 0.511);//tau mass used
451 }
452 
453 // L2 tau mu
454 double ElectronMuonTopoInfo::invariantMass( const TrigTau* tau1,
455  const CombinedMuonFeature* muon1) {
456  // get parameters: not electron pT no longer signed
457  double eta1 = tau1->eta();
458  double eta2 = muon1->IDTrack()->param()->eta();
459 
460 
461  double Pt1 = tau1->pt() ; // IMPORTANT: pt() is the 4-momentum base class method and
462  double Pt2 = muon1->pt(); // it returns the cluster pT; the track pT is given by Pt()
463 
464  double phi1 = tau1->phi();
465  double phi2 = muon1->IDTrack()->param()->phi0();
466 
467  return invariantMass(Pt1, eta1, phi1, 1777., Pt2, eta2, phi2, 105.6);//tau mass used
468 }
469 
470 // EF tautau
471 double ElectronMuonTopoInfo::invariantMass( const Analysis::TauJet* tau1,
472  const Analysis::TauJet* tau2) {
473  // get parameters: not electron pT no longer signed
474  double eta1 = tau1->eta();
475  double eta2 = tau2->eta();
476 
477 
478  double Pt1 = tau1->pt() ; // IMPORTANT: pt() is the 4-momentum base class method and
479  double Pt2 = tau2->pt(); // it returns the cluster pT; the track pT is given by Pt()
480 
481  double phi1 = tau1->phi();
482  double phi2 = tau2->phi();
483 
484  return invariantMass(Pt1, eta1, phi1, 1777., Pt2, eta2, phi2, 1777.);//tau mass used
485 }
486 
487 
488 // EF tautau
489 double ElectronMuonTopoInfo::invariantMass( const Analysis::TauJet* tau1,
490  const egamma* electron1) {
491  // get parameters: not electron pT no longer signed
492  double eta1 = tau1->eta();
493  double eta2 = electron1->trackParticle()->eta();
494 
495 
496  double Pt1 = tau1->pt() ; // IMPORTANT: pt() is the 4-momentum base class method and
497  double Pt2 = electron1->cluster()->e()/cosh(electron1->trackParticle()->eta()) ; //
498 
499  double phi1 = tau1->phi();
500  double phi2 = electron1->trackParticle()->phi();
501 
502  return invariantMass(Pt1, eta1, phi1, 1777., Pt2, eta2, phi2, 0.511);//tau mass used
503 }
504 // EF tautau
505 double ElectronMuonTopoInfo::invariantMass( const Analysis::TauJet* tau1,
506  const Trk::Perigee* muon1) {
507  // get parameters: not electron pT no longer signed
508  double eta1 = tau1->eta();
509  double eta2 = muon1->eta();
510 
511 
512  double Pt1 = tau1->pt() ; // IMPORTANT: pt() is the 4-momentum base class method and
513  double Pt2 = muon1->pT() ; //
514 
515  double phi1 = tau1->phi();
516  double phi2 = muon1->parameters()[Trk::phi];
517 
518  return invariantMass(Pt1, eta1, phi1, 1777., Pt2, eta2, phi2, 105.6);//tau mass used
519 }
520 
521 double ElectronMuonTopoInfo::invariantMass(double Pt1, double eta1, double phi1, double m1,
522  double Pt2, double eta2, double phi2,double m2 ) const {
523  // protection in case upstream algorithm suplies negative pt
524 
525  Pt1 = fabs(Pt1);
526  Pt2 = fabs(Pt2);
527 
528  double theta1 = 2*atan2((double)exp(-eta1),1.);
529  double theta2 = 2*atan2((double)exp(-eta2),1.);
530  double P1 = Pt1/sin(theta1);
531  double P2 = Pt2/sin(theta2);
532  double p1[3],p2[3];
533 
534  // Replace the following by sincos which calculates the sin and cos
535  // of the same angle 40% faster (fwinkl)
536  // p1[0] = Pt1*cos(phi1);
537  // p1[1] = Pt1*sin(phi1);
538 #ifndef __APPLE__
539  sincos(phi1,&p1[1],&p1[0]);
540  p1[0] *= Pt1;
541  p1[1] *= Pt1;
542 #else
543  CxxUtils::sincos scphi1(phi1);
544  p1[0] = Pt1*scphi1.cs;
545  p1[1] = Pt1*scphi1.sn;
546 #endif
547 
548  // dito
549  // p2[0] = Pt2*cos(phi2);
550  // p2[1] = Pt2*sin(phi2);
551 #ifndef __APPLE__
552  sincos(phi2,&p2[1],&p2[0]);
553  p2[0] *= Pt2;
554  p2[1] *= Pt2;
555 #else
556  CxxUtils::sincos scphi2(phi2);
557  p2[0] = Pt2*scphi2.cs;
558  p2[1] = Pt2*scphi2.sn;
559 #endif
560 
561  p1[2] = P1*cos(theta1);
562  p2[2] = P2*cos(theta2);
563 
564  // evaluate mass
565  double Ptot1 = sqrt(std::pow(p1[0],2)+std::pow(p1[1],2)+std::pow(p1[2],2));
566  double Ptot2 = sqrt(std::pow(p2[0],2)+std::pow(p2[1],2)+std::pow(p2[2],2));
567  double e1 = sqrt(Ptot1*Ptot1 + m1*m1);
568  double e2 = sqrt(Ptot2*Ptot2 + m2*m2);
569  double mass = sqrt(m1*m1+m2*m2+ 2*e1*e2 - 2*p1[0]*p2[0] - 2*p1[1]*p2[1] - 2*p1[2]*p2[2]);
570 
571  return mass;
572 }
573 // EF
574 double ElectronMuonTopoInfo::invariantMass(const egamma* electron1,
575  const Trk::Perigee* muon1) {
576 
577  // get parameters: not electron pT no longer signed
578  double eta1 = electron1->trackParticle()->eta();
579  double eta2 = muon1->eta();
580 
581 
582  double Pt1 = electron1->cluster()->e()/cosh(electron1->trackParticle()->eta()) ; // IMPORTANT: pt() is the 4-momentum base class method and
583  double Pt2 = muon1->pT(); // it returns the cluster pT; the track pT is given by Pt()
584 
585  double phi1 = electron1->trackParticle()->phi();
586  double phi2 = muon1->parameters()[Trk::phi];
587 
588  return invariantMass(Pt1, eta1, phi1, 0.511, Pt2, eta2, phi2, 105.6);
589 }
590 
591 
ElectronMuonTopoInfo::SetOppositeCharge
void SetOppositeCharge(bool OppositeCharge)
Definition: ElectronMuonTopoInfo.cxx:59
egamma::trackParticle
const Rec::TrackParticle * trackParticle(unsigned int index=0) const
pointer to TrackParticle
Definition: egamma.cxx:391
ElectronMuonTopoInfo::~ElectronMuonTopoInfo
~ElectronMuonTopoInfo()
Definition: ElectronMuonTopoInfo.cxx:50
TrigInDetTrack::param
void param(const TrigInDetTrackFitPar *param)
Definition: TrigInDetTrack.h:126
python.SystemOfUnits.m2
int m2
Definition: SystemOfUnits.py:92
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
ParticleImpl::pt
virtual double pt() const
transverse momentum
Definition: ParticleImpl.h:554
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
P4Helpers::invMass
double invMass(const I4Momentum &pA, const I4Momentum &pB)
invariant mass from two I4momentum references
Definition: P4Helpers.h:239
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
hist_file_dump.d
d
Definition: hist_file_dump.py:137
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
met::DeltaR
@ DeltaR
Definition: METRecoCommon.h:11
EventPrimitivesHelpers.h
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
ElectronMuonTopoInfo::InvMass
float InvMass() const
Definition: ElectronMuonTopoInfo.h:65
M_PI
#define M_PI
Definition: ActiveFraction.h:11
sincos.h
Helper to simultaneously calculate sin and cos of the same angle.
Trk::z0
@ z0
Definition: ParamDefs.h:70
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
CombinedMuonFeature::pt
double pt(void) const
transverse momentum
Definition: CombinedMuonFeature.h:56
xAOD::eta1
setEt setPhi setE277 setWeta2 eta1
Definition: TrigEMCluster_v1.cxx:41
operator<<
MsgStream & operator<<(MsgStream &m, const ElectronMuonTopoInfo &d)
Definition: ElectronMuonTopoInfo.cxx:77
ElectronMuonTopoInfo
ElectronMuonTopoInfo is a class for storing information about combuned electron-muon object....
Definition: ElectronMuonTopoInfo.h:51
ElectronMuonTopoInfo.h
ElectronMuonTopoInfo::SetVertexState
void SetVertexState(unsigned short vextexState)
Definition: ElectronMuonTopoInfo.cxx:60
TrigElectron
File: TrigElectron.h.
Definition: Trigger/TrigEvent/TrigParticle/TrigParticle/TrigElectron.h:63
ElectronMuonTopoInfo::SetInvMass
void SetInvMass(float InvMass)
Definition: ElectronMuonTopoInfo.cxx:57
ElectronMuonTopoInfo::deltaR
double deltaR(const TrigElectron *electron1, const CombinedMuonFeature *muon1)
Delta R @ L2.
Definition: ElectronMuonTopoInfo.cxx:254
ElectronMuonTopoInfo::SetDeltaPhi
void SetDeltaPhi(float DeltaPhi)
Definition: ElectronMuonTopoInfo.cxx:55
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ElectronMuonTopoInfo::invariantMass
double invariantMass(const TrigElectron *electron1, const CombinedMuonFeature *muon1)
Invariant mass calculation @ L2.
Definition: ElectronMuonTopoInfo.cxx:403
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
ElectronMuonTopoInfo::m_DeltaR
float m_DeltaR
Delta R between electron and muon.
Definition: ElectronMuonTopoInfo.h:137
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
ElectronMuonTopoInfo::deltaPhi
double deltaPhi(const TrigElectron *electron1, const CombinedMuonFeature *muon1)
Delta phi @ L2.
Definition: ElectronMuonTopoInfo.cxx:207
egamma
Definition: egamma.h:58
ElectronMuonTopoInfo::ElectronMuonTopoInfo
ElectronMuonTopoInfo()
Definition: ElectronMuonTopoInfo.cxx:28
xAOD::roiWord
roiWord
Definition: TrigMissingET_v1.cxx:36
ElectronMuonTopoInfo::opositeCharge
bool opositeCharge(const TrigElectron *electron1, const CombinedMuonFeature *muon1)
Opposite charge @ L2.
Definition: ElectronMuonTopoInfo.cxx:192
CombinedMuonFeature::ptq
double ptq(void) const
Definition: CombinedMuonFeature.h:58
ElectronMuonTopoInfo::m_InvMass
float m_InvMass
Invariant mass of electron and muon.
Definition: ElectronMuonTopoInfo.h:139
P4PtEtaPhiM::phi
virtual double phi() const
get phi data member
Definition: P4PtEtaPhiM.h:109
operator==
bool operator==(const ElectronMuonTopoInfo &d1, const ElectronMuonTopoInfo &d2)
Definition: ElectronMuonTopoInfo.cxx:82
python.changerun.m1
m1
Definition: changerun.py:32
ParticleImpl::charge
virtual ChargeType charge() const
returns charge as a typedef ChargeType currently Charge Type is a double for jets this may be changed...
Definition: ParticleImpl.h:718
CxxUtils::sincos::cs
double cs
Definition: sincos.h:95
ElectronMuonTopoInfo::Vertex
Vertex
other methods
Definition: ElectronMuonTopoInfo.h:84
TrigElectron::err_Zvtx
float err_Zvtx() const
Definition: Trigger/TrigEvent/TrigParticle/TrigParticle/TrigElectron.h:143
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:530
ElectronMuonTopoInfo::m_electronValid
bool m_electronValid
boolean flag showing the validity of electron
Definition: ElectronMuonTopoInfo.h:141
ElectronMuonTopoInfo::Common
@ Common
Definition: ElectronMuonTopoInfo.h:84
Analysis::TauJet
Object for taus common for ESD and AOD.
Definition: Reconstruction/tauEvent/tauEvent/TauJet.h:61
ElectronMuonTopoInfo::Unapplicable
@ Unapplicable
Definition: ElectronMuonTopoInfo.h:84
egamma::cluster
const CaloCluster * cluster() const
pointer to CaloCluster
Definition: egamma.cxx:360
ElectronMuonTopoInfo::OppositeCharge
bool OppositeCharge() const
Definition: ElectronMuonTopoInfo.h:67
ElectronMuonTopoInfo::ElecValid
bool ElecValid() const
Definition: ElectronMuonTopoInfo.h:66
I4Momentum::eta
virtual double eta() const =0
pseudo rapidity
ParticleImpl::phi
virtual double phi() const
phi in [-pi,pi[
Definition: ParticleImpl.h:524
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:264
ElectronMuonTopoInfo::m_vertexState
unsigned short m_vertexState
3 bit description of vertex: 0=common, 1=not common, 3= not applicable
Definition: ElectronMuonTopoInfo.h:145
ParticleImpl::eta
virtual double eta() const
pseudo rapidity
Definition: ParticleImpl.h:514
ElectronMuonTopoInfo::SetElecValid
void SetElecValid(bool ElecValid)
Definition: ElectronMuonTopoInfo.cxx:58
P4PtEtaPhiM::pt
virtual double pt() const
get pt data member
Definition: P4PtEtaPhiM.h:103
TrigElectron::Zvtx
float Zvtx() const
Definition: Trigger/TrigEvent/TrigParticle/TrigParticle/TrigElectron.h:122
I4Momentum::phi
virtual double phi() const =0
phi in [-pi,pi[
plotIsoValidation.mu_phi
mu_phi
Definition: plotIsoValidation.py:152
CombinedMuonFeature
Definition: CombinedMuonFeature.h:30
ElectronMuonTopoInfo::m_oppositeCharge
bool m_oppositeCharge
True if electron and muon have opposite charged.
Definition: ElectronMuonTopoInfo.h:143
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
P4PtEtaPhiM::eta
virtual double eta() const
get eta data member
Definition: P4PtEtaPhiM.h:106
ElectronMuonTopoInfo::m_roiWord
int m_roiWord
Identifier of the RoI.
Definition: ElectronMuonTopoInfo.h:133
CombinedMuonFeature::IDTrack
const TrigInDetTrack * IDTrack(void) const
Definition: CombinedMuonFeature.h:66
CxxUtils::sincos::sn
double sn
Definition: sincos.h:92
ElectronMuonTopoInfo::SetDeltaR
void SetDeltaR(float DeltaR)
Definition: ElectronMuonTopoInfo.cxx:56
ElectronMuonTopoInfo::RoiWord
int RoiWord() const
accessor methods
Definition: ElectronMuonTopoInfo.h:62
ElectronMuonTopoInfo::commonVertex
Vertex commonVertex(const TrigElectron *electron1, const CombinedMuonFeature *muon1)
checking Vertex compatibility @ L2
Definition: ElectronMuonTopoInfo.cxx:90
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
ElectronMuonTopoInfo::DeltaR
float DeltaR() const
Definition: ElectronMuonTopoInfo.h:64
dq_defect_virtual_defect_validation.d2
d2
Definition: dq_defect_virtual_defect_validation.py:81
str
std::string str(const ElectronMuonTopoInfo &d)
Helper function for printing the object.
Definition: ElectronMuonTopoInfo.cxx:63
CaloCluster::e
virtual double e() const
Retrieve energy independent of signal state.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloCluster.h:753
TrigTau
File: TrigTau.h.
Definition: TrigTau.h:37
CxxUtils::sincos
Helper to simultaneously calculate sin and cos of the same angle.
Definition: sincos.h:76
TrigElectron::charge
int charge() const
accessor to return the track charge (sign of TrigInDetTrack pT)
Definition: Trigger/TrigEvent/TrigParticle/TrigParticle/TrigElectron.h:136
Trk::phi
@ phi
Definition: ParamDefs.h:81
str
Definition: BTagTrackIpAccessor.cxx:11
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
ElectronMuonTopoInfo::NotCommon
@ NotCommon
Definition: ElectronMuonTopoInfo.h:84
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:525
ElectronMuonTopoInfo::SetRoiWord
void SetRoiWord(int RoiWord)
set methods
Definition: ElectronMuonTopoInfo.cxx:54
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
ElectronMuonTopoInfo::m_DeltaPhi
float m_DeltaPhi
Delta Phi between electron and muon.
Definition: ElectronMuonTopoInfo.h:135
ElectronMuonTopoInfo::DeltaPhi
float DeltaPhi() const
Definition: ElectronMuonTopoInfo.h:63
Generated on Tue Jul 2 2024 21:14:45 for ATLAS Offline Software by   doxygen 1.8.18