ATLAS Offline Software
EMConvert.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /********************************************************************
6 
7 NAME: EMConvert.cxx
8 PACKAGE: offline/Reconstruction/egammaEvent
9 
10 AUTHORS: David Joffe
11 CREATED: Oct. 5, 2005
12 
13 PURPOSE: object containing information about conversions
14 UPDATED: Jul 30, 2010 (JM) Add ambiguity result
15 
16 ********************************************************************/
17 
18 // INCLUDE HEADER FILES:
19 
20 #include <cmath>
21 
22 #include "egammaEvent/EMConvert.h"
23 
24 #include "GaudiKernel/GaudiException.h"
25 #include "AthenaKernel/ClassName.h"
26 
27 #include "VxVertex/VxCandidate.h"
28 #include "VxVertex/ExtendedVxCandidate.h"
29 #include "VxVertex/VxTrackAtVertex.h"
30 #include "VxVertex/RecVertex.h"
31 #include "TrkParameters/TrackParameters.h"
32 #include "AthenaKernel/BaseInfo.h"
33 
34 
35 //using CLHEP::Hep3Vector;
36 
37 
38 // END OF HEADER FILES INCLUDE
39 
40 // ----------------------------
41 // Constructor
42 // ----------------------------
43 
44 // give default values
45 EMConvert::EMConvert()
46  : egDetail()
47 { }
48 
49 bool EMConvert::hasBoolParameter(egammaParameters::ParamDef key) const {
50  if (key == egammaParameters::convTrackMatch) return true;
51  if (key == egammaParameters::convAngleMatch) return true;
52  return false;
53 }
54 
55 bool EMConvert::hasIntParameter(egammaParameters::ParamDef key) const {
56  if (key == egammaParameters::refittedVertex_ndf) return true;
57  if (key == egammaParameters::refittedVertex_numTracks) return true;
58  if (key == egammaParameters::refittedVertex_track1_author) return true;
59  if (key == egammaParameters::refittedVertex_track2_author) return true;
60  if (key == egammaParameters::ambiguityResult) return true;
61  if (key == egammaParameters::linkIndex) return true;
62  return false;
63 }
64 
65 bool EMConvert::hasParameter(egammaParameters::ParamDef key) const {
66  if(hasBoolParameter(key)) return true;
67  if(hasIntParameter(key)) return true;
68  if (key == egammaParameters::refittedVertex_x) return true;
69  if (key == egammaParameters::refittedVertex_y) return true;
70  if (key == egammaParameters::refittedVertex_z) return true;
71  if (key == egammaParameters::refittedVertex_Covxx) return true;
72  if (key == egammaParameters::refittedVertex_Covxy) return true;
73  if (key == egammaParameters::refittedVertex_Covxz) return true;
74  if (key == egammaParameters::refittedVertex_Covyy) return true;
75  if (key == egammaParameters::refittedVertex_Covyz) return true;
76  if (key == egammaParameters::refittedVertex_Covzz) return true;
77  if (key == egammaParameters::refittedVertex_chi2) return true;
78  if (key == egammaParameters::refittedVertex_track1_phi) return true;
79  if (key == egammaParameters::refittedVertex_track1_theta) return true;
80  if (key == egammaParameters::refittedVertex_track1_qOverP) return true;
81  if (key == egammaParameters::refittedVertex_track1_chi2) return true;
82  if (key == egammaParameters::refittedVertex_track2_phi) return true;
83  if (key == egammaParameters::refittedVertex_track2_theta) return true;
84  if (key == egammaParameters::refittedVertex_track2_qOverP) return true;
85  if (key == egammaParameters::refittedVertex_track2_chi2) return true;
86  if (key == egammaParameters::refittedVertex_Covd01d01) return true;
87  if (key == egammaParameters::refittedVertex_Covd01z01) return true;
88  if (key == egammaParameters::refittedVertex_Covd01phi1) return true;
89  if (key == egammaParameters::refittedVertex_Covd01theta1) return true;
90  if (key == egammaParameters::refittedVertex_Covd01qOverP1) return true;
91  if (key == egammaParameters::refittedVertex_Covz01z01) return true;
92  if (key == egammaParameters::refittedVertex_Covz01phi1) return true;
93  if (key == egammaParameters::refittedVertex_Covz01theta1) return true;
94  if (key == egammaParameters::refittedVertex_Covz01qOverP1) return true;
95  if (key == egammaParameters::refittedVertex_Covphi1phi1) return true;
96  if (key == egammaParameters::refittedVertex_Covphi1theta1) return true;
97  if (key == egammaParameters::refittedVertex_Covphi1qOverP1) return true;
98  if (key == egammaParameters::refittedVertex_Covtheta1theta1) return true;
99  if (key == egammaParameters::refittedVertex_Covtheta1qOverP1) return true;
100  if (key == egammaParameters::refittedVertex_CovqOverP1qOverP1) return true;
101  if (key == egammaParameters::refittedVertex_Covphi1phi2) return true;
102  if (key == egammaParameters::refittedVertex_Covphi1theta2) return true;
103  if (key == egammaParameters::refittedVertex_Covphi1qOverP2) return true;
104  if (key == egammaParameters::refittedVertex_Covtheta1phi2) return true;
105  if (key == egammaParameters::refittedVertex_Covtheta1theta2) return true;
106  if (key == egammaParameters::refittedVertex_Covtheta1qOverP2) return true;
107  if (key == egammaParameters::refittedVertex_CovqOverP1phi2) return true;
108  if (key == egammaParameters::refittedVertex_CovqOverP1theta2) return true;
109  if (key == egammaParameters::refittedVertex_CovqOverP1qOverP2) return true;
110  if (key == egammaParameters::refittedVertex_Covphi1x) return true;
111  if (key == egammaParameters::refittedVertex_Covphi1y) return true;
112  if (key == egammaParameters::refittedVertex_Covphi1z) return true;
113  if (key == egammaParameters::refittedVertex_Covtheta1x) return true;
114  if (key == egammaParameters::refittedVertex_Covtheta1y) return true;
115  if (key == egammaParameters::refittedVertex_Covtheta1z) return true;
116  if (key == egammaParameters::refittedVertex_CovqOverP1x) return true;
117  if (key == egammaParameters::refittedVertex_CovqOverP1y) return true;
118  if (key == egammaParameters::refittedVertex_CovqOverP1z) return true;
119  if (key == egammaParameters::refittedVertex_Covd02d02) return true;
120  if (key == egammaParameters::refittedVertex_Covd02z02) return true;
121  if (key == egammaParameters::refittedVertex_Covd02phi2) return true;
122  if (key == egammaParameters::refittedVertex_Covd02theta2) return true;
123  if (key == egammaParameters::refittedVertex_Covd02qOverP2) return true;
124  if (key == egammaParameters::refittedVertex_Covz02z02) return true;
125  if (key == egammaParameters::refittedVertex_Covz02phi2) return true;
126  if (key == egammaParameters::refittedVertex_Covz02theta2) return true;
127  if (key == egammaParameters::refittedVertex_Covz02qOverP2) return true;
128  if (key == egammaParameters::refittedVertex_Covphi2phi2) return true;
129  if (key == egammaParameters::refittedVertex_Covphi2theta2) return true;
130  if (key == egammaParameters::refittedVertex_Covphi2qOverP2) return true;
131  if (key == egammaParameters::refittedVertex_Covtheta2theta2) return true;
132  if (key == egammaParameters::refittedVertex_Covtheta2qOverP2) return true;
133  if (key == egammaParameters::refittedVertex_CovqOverP2qOverP2) return true;
134  if (key == egammaParameters::refittedVertex_Covphi2x) return true;
135  if (key == egammaParameters::refittedVertex_Covphi2y) return true;
136  if (key == egammaParameters::refittedVertex_Covphi2z) return true;
137  if (key == egammaParameters::refittedVertex_Covtheta2x) return true;
138  if (key == egammaParameters::refittedVertex_Covtheta2y) return true;
139  if (key == egammaParameters::refittedVertex_Covtheta2z) return true;
140  if (key == egammaParameters::refittedVertex_CovqOverP2x) return true;
141  if (key == egammaParameters::refittedVertex_CovqOverP2y) return true;
142  if (key == egammaParameters::refittedVertex_CovqOverP2z) return true;
143  if (key == egammaParameters::convMatchDeltaEta1) return true;
144  if (key == egammaParameters::convMatchDeltaPhi1) return true;
145  if (key == egammaParameters::convMatchDeltaEta2) return true;
146  if (key == egammaParameters::convMatchDeltaPhi2) return true;
147  if (key == egammaParameters::convMatchDeltaEta1_refit) return true;
148  if (key == egammaParameters::convMatchDeltaPhi1_refit) return true;
149  if (key == egammaParameters::convMatchDeltaEta2_refit) return true;
150  if (key == egammaParameters::convMatchDeltaPhi2_refit) return true;
151  return false;
152 }
153 
154 //interfaces
155 const std::string& EMConvert::className() const
156 {
157  static const std::string s_name = ClassName<EMConvert>::name();
158  return s_name;
159 }
160 
161 double EMConvert::parameter(egammaParameters::ParamDef key) const {
162 
163  if ( !hasParameter(key) )
164  return egammaParameters::EgParamUndefined;
165 
166  if(hasBoolParameter(key)){
167  if ( boolParameter(key)) return 1.;
168  return 0;
169  }
170 
171  if ( hasIntParameter(key) ) {
172  return (double) intParameter(key);
173  }
174 
175  double result = egammaParameters::EgParamUndefined;
176  using elParams = std::pair<egammaParameters::ParamDef, double>;
177  std::vector<elParams>::const_iterator p = m_parameters.begin();
178 
179  for (;p !=m_parameters.end(); ++p) {
180  if ( (*p).first == key ) {
181  result = (*p).second;
182  break;
183  }
184  }
185  return result;
186 }
187 
188 bool EMConvert::boolParameter(egammaParameters::ParamDef key) const {
189 
190  using elParams = std::pair<egammaParameters::ParamDef, bool>;
191 
192  bool result = false;
193  std::vector<elParams>::const_iterator p = m_parametersBool.begin();
194 
195  for (;p !=m_parametersBool.end(); ++p) {
196  if ( (*p).first == key ) {
197  result = (*p).second;
198  break;
199  }
200  }
201  return result;
202 }
203 
204 int EMConvert::intParameter(egammaParameters::ParamDef key) const {
205 
206 
207  using elParams = std::pair<egammaParameters::ParamDef, int>;
208 
209  int result = (int)egammaParameters::EgParamUndefined;
210  std::vector<elParams>::const_iterator p = m_parametersInt.begin();
211 
212  for (;p !=m_parametersInt.end(); ++p) {
213  if ( (*p).first == key ){
214  result = (*p).second;
215  break;
216  }
217  }
218  return result;
219 }
220 
221 
222 void EMConvert::set_parameter(egammaParameters::ParamDef key, double value, bool overwrite) {
223 
224  if ( hasBoolParameter(key) ) {
225  if ( value != 0. )
226  set_parameterBool(key,true,overwrite);
227  else
228  set_parameterBool(key,false,overwrite);
229  }
230 
231  if ( hasIntParameter(key) ) {
232  set_parameterInt(key,(int)value,overwrite);
233  }
234 
235 
236  using elParams = std::pair<egammaParameters::ParamDef, double>;
237  std::vector<elParams>::iterator p = m_parameters.begin();
238 
239  for (;p !=m_parameters.end(); ++p) {
240  if ( (*p).first == key ) break;
241  }
242 
243  if ( p == m_parameters.end() ) {
244  m_parameters.emplace_back(key,value);
245  }
246  else {
247  if ( overwrite ) {
248  (*p).second = value;
249  }
250  else {
251  throw GaudiException("parameter not saved", "EMConvert::set_parameter(...)", StatusCode::FAILURE);
252  }
253  }
254 }
255 
256 
257 void EMConvert::set_parameterBool(egammaParameters::ParamDef key, bool value, bool overwrite) {
258 
259  using elParams = std::pair<egammaParameters::ParamDef, bool>;
260 
261  std::vector<elParams>::iterator p = m_parametersBool.begin();
262 
263  for (;p !=m_parametersBool.end(); ++p) {
264  if ( (*p).first == key ) break;
265  }
266 
267  if ( p == m_parametersBool.end() ) {
268  m_parametersBool.emplace_back(key,value );
269  }
270  else {
271  if ( overwrite ) {
272  (*p).second = value;
273  }
274  else {
275  throw GaudiException("parameter not saved", "EMConvert::set_parameter(...)", StatusCode::FAILURE);
276  }
277  }
278 }
279 
280 
281 void EMConvert::set_parameterInt(egammaParameters::ParamDef key, int value, bool overwrite) {
282 
283  using elParams = std::pair<egammaParameters::ParamDef, int>;
284 
285  std::vector<elParams>::iterator p = m_parametersInt.begin();
286 
287  for (;p !=m_parametersInt.end(); ++p) {
288  if ( (*p).first == key ) break;
289  }
290 
291  if ( p == m_parametersInt.end() ) {
292  m_parametersInt.emplace_back(key,value );
293  }
294  else {
295  if ( overwrite ) {
296  (*p).second = value;
297  }
298  else {
299  throw GaudiException("parameter not saved", "EMConvert::set_parameter(...)", StatusCode::FAILURE);
300  }
301  }
302 }
303 
304 
305 // print track match quantities
306 
307 void
308 EMConvert::print() const
309 {
310  std::cout << " EMConvert: convtrackmatch "<< boolParameter(egammaParameters::convTrackMatch) << std::endl;
311  std::cout << " EMConvert: convanglematch "<< boolParameter(egammaParameters::convAngleMatch) << std::endl;
312  std::cout << " EMConvert: convMatchDeltaEta1 "<< parameter(egammaParameters::convMatchDeltaEta1) << std::endl;
313  std::cout << " EMConvert: convMatchDeltaPhi1 "<< parameter(egammaParameters::convMatchDeltaPhi1) << std::endl;
314  std::cout << " EMConvert: convMatchDeltaEta2 "<< parameter(egammaParameters::convMatchDeltaEta2) << std::endl;
315  std::cout << " EMConvert: convMatchDeltaPhi2 "<< parameter(egammaParameters::convMatchDeltaPhi2) << std::endl;
316  std::cout << " EMConvert: convMatchDeltaEta1_refit "<< parameter(egammaParameters::convMatchDeltaEta1_refit) << std::endl;
317  std::cout << " EMConvert: convMatchDeltaPhi1_refit "<< parameter(egammaParameters::convMatchDeltaPhi1_refit) << std::endl;
318  std::cout << " EMConvert: convMatchDeltaEta2_refit "<< parameter(egammaParameters::convMatchDeltaEta2_refit) << std::endl;
319  std::cout << " EMConvert: convMatchDeltaPhi2_refit "<< parameter(egammaParameters::convMatchDeltaPhi2_refit) << std::endl;
320  std::cout << " EMConvert: vertex_x "<< parameter(egammaParameters::refittedVertex_x) << std::endl;
321  std::cout << " EMConvert: vertex_y "<< parameter(egammaParameters::refittedVertex_y) << std::endl;
322  std::cout << " EMConvert: vertex_z "<< parameter(egammaParameters::refittedVertex_z) << std::endl;
323  std::cout << " EMConvert: vertex_Covxx "<< parameter(egammaParameters::refittedVertex_Covxx) << std::endl;
324  std::cout << " EMConvert: vertex_Covxy "<< parameter(egammaParameters::refittedVertex_Covxy) << std::endl;
325  std::cout << " EMConvert: vertex_Covxz "<< parameter(egammaParameters::refittedVertex_Covxz) << std::endl;
326  std::cout << " EMConvert: vertex_Covyy "<< parameter(egammaParameters::refittedVertex_Covyy) << std::endl;
327  std::cout << " EMConvert: vertex_Covyz "<< parameter(egammaParameters::refittedVertex_Covyz) << std::endl;
328  std::cout << " EMConvert: vertex_Covzz "<< parameter(egammaParameters::refittedVertex_Covzz) << std::endl;
329  std::cout << " EMConvert: vertex_chi2 "<< parameter(egammaParameters::refittedVertex_chi2) << std::endl;
330  std::cout << " EMConvert: vertex_ndf "<< intParameter(egammaParameters::refittedVertex_ndf) << std::endl;
331  std::cout << " EMConvert: vertex_numTracks "<< intParameter(egammaParameters::refittedVertex_numTracks) << std::endl;
332  std::cout << " EMConvert: vertex_track1_phi "<< parameter(egammaParameters::refittedVertex_track1_phi) << std::endl;
333  std::cout << " EMConvert: vertex_track1_theta "<< parameter(egammaParameters::refittedVertex_track1_theta) << std::endl;
334  std::cout << " EMConvert: vertex_track1_qOverP "<< parameter(egammaParameters::refittedVertex_track1_qOverP) << std::endl;
335  std::cout << " EMConvert: vertex_track1_chi2 "<< parameter(egammaParameters::refittedVertex_track1_chi2) << std::endl;
336  std::cout << " EMConvert: vertex_track1_author "<< intParameter(egammaParameters::refittedVertex_track1_author) << std::endl;
337  std::cout << " EMConvert: vertex_track2_phi "<< parameter(egammaParameters::refittedVertex_track2_phi) << std::endl;
338  std::cout << " EMConvert: vertex_track2_theta "<< parameter(egammaParameters::refittedVertex_track2_theta) << std::endl;
339  std::cout << " EMConvert: vertex_track2_qOverP "<< parameter(egammaParameters::refittedVertex_track2_qOverP) << std::endl;
340  std::cout << " EMConvert: vertex_track2_chi2 "<< parameter(egammaParameters::refittedVertex_track2_chi2) << std::endl;
341  std::cout << " EMConvert: vertex_track2_author "<< intParameter(egammaParameters::refittedVertex_track2_author) << std::endl;
342  std::cout << " EMConvert: vertex_Covd01d01 "<< parameter(egammaParameters::refittedVertex_Covd01d01) << std::endl;
343  std::cout << " EMConvert: vertex_Covd01z01 "<< parameter(egammaParameters::refittedVertex_Covd01z01) << std::endl;
344  std::cout << " EMConvert: vertex_Covd01phi1 "<< parameter(egammaParameters::refittedVertex_Covd01phi1) << std::endl;
345  std::cout << " EMConvert: vertex_Covd01theta1 "<< parameter(egammaParameters::refittedVertex_Covd01theta1) << std::endl;
346  std::cout << " EMConvert: vertex_Covd01qOverP1 "<< parameter(egammaParameters::refittedVertex_Covd01qOverP1) << std::endl;
347  std::cout << " EMConvert: vertex_Covz01z01 "<< parameter(egammaParameters::refittedVertex_Covz01z01) << std::endl;
348  std::cout << " EMConvert: vertex_Covz01phi1 "<< parameter(egammaParameters::refittedVertex_Covz01phi1) << std::endl;
349  std::cout << " EMConvert: vertex_Covz01theta1 "<< parameter(egammaParameters::refittedVertex_Covz01theta1) << std::endl;
350  std::cout << " EMConvert: vertex_Covz01qOverP1 "<< parameter(egammaParameters::refittedVertex_Covz01qOverP1) << std::endl;
351  std::cout << " EMConvert: vertex_Covphi1phi1 "<< parameter(egammaParameters::refittedVertex_Covphi1phi1) << std::endl;
352  std::cout << " EMConvert: vertex_Covphi1theta1 "<< parameter(egammaParameters::refittedVertex_Covphi1theta1) << std::endl;
353  std::cout << " EMConvert: vertex_Covphi1qOverP1 "<< parameter(egammaParameters::refittedVertex_Covphi1qOverP1) << std::endl;
354  std::cout << " EMConvert: vertex_Covtheta1theta1 "<< parameter(egammaParameters::refittedVertex_Covtheta1theta1) << std::endl;
355  std::cout << " EMConvert: vertex_Covtheta1qOverP1 "<< parameter(egammaParameters::refittedVertex_Covtheta1qOverP1) << std::endl;
356  std::cout << " EMConvert: vertex_CovqOverP1qoverP1 "<< parameter(egammaParameters::refittedVertex_CovqOverP1qOverP1) << std::endl;
357  std::cout << " EMConvert: vertex_Covphi1phi2 "<< parameter(egammaParameters::refittedVertex_Covphi1phi2) << std::endl;
358  std::cout << " EMConvert: vertex_Covphi1heta2 "<< parameter(egammaParameters::refittedVertex_Covphi1theta2) << std::endl;
359  std::cout << " EMConvert: vertex_Covphi1qOverP2 "<< parameter(egammaParameters::refittedVertex_Covphi1qOverP2) << std::endl;
360  std::cout << " EMConvert: vertex_Covtheta1phi2 "<< parameter(egammaParameters::refittedVertex_Covtheta1phi2) << std::endl;
361  std::cout << " EMConvert: vertex_Covtheta1theta2 "<< parameter(egammaParameters::refittedVertex_Covtheta1theta2) << std::endl;
362  std::cout << " EMConvert: vertex_Covtheta1qOverP2 "<< parameter(egammaParameters::refittedVertex_Covtheta1qOverP2) << std::endl;
363  std::cout << " EMConvert: vertex_CovqOverP1phi2 "<< parameter(egammaParameters::refittedVertex_CovqOverP1phi2) << std::endl;
364  std::cout << " EMConvert: vertex_CovqOverP1theta2 "<< parameter(egammaParameters::refittedVertex_CovqOverP1theta2) << std::endl;
365  std::cout << " EMConvert: vertex_CovqOverP1qOverP2 "<< parameter(egammaParameters::refittedVertex_CovqOverP1qOverP2) << std::endl;
366  std::cout << " EMConvert: vertex_Covphi1x "<< parameter(egammaParameters::refittedVertex_Covphi1x) << std::endl;
367  std::cout << " EMConvert: vertex_Covphi1y "<< parameter(egammaParameters::refittedVertex_Covphi1y) << std::endl;
368  std::cout << " EMConvert: vertex_Covphi1z "<< parameter(egammaParameters::refittedVertex_Covphi1z) << std::endl;
369  std::cout << " EMConvert: vertex_Covtheta1x "<< parameter(egammaParameters::refittedVertex_Covtheta1x) << std::endl;
370  std::cout << " EMConvert: vertex_Covtheta1y "<< parameter(egammaParameters::refittedVertex_Covtheta1y) << std::endl;
371  std::cout << " EMConvert: vertex_Covtheta1z "<< parameter(egammaParameters::refittedVertex_Covtheta1z) << std::endl;
372  std::cout << " EMConvert: vertex_CovqOverP1x "<< parameter(egammaParameters::refittedVertex_CovqOverP1x) << std::endl;
373  std::cout << " EMConvert: vertex_CovqOverP1y "<< parameter(egammaParameters::refittedVertex_CovqOverP1y) << std::endl;
374  std::cout << " EMConvert: vertex_CovqOverP1z "<< parameter(egammaParameters::refittedVertex_CovqOverP1z) << std::endl;
375  std::cout << " EMConvert: vertex_Covd02d02 "<< parameter(egammaParameters::refittedVertex_Covd02d02) << std::endl;
376  std::cout << " EMConvert: vertex_Covd02z02 "<< parameter(egammaParameters::refittedVertex_Covd02z02) << std::endl;
377  std::cout << " EMConvert: vertex_Covd02phi2 "<< parameter(egammaParameters::refittedVertex_Covd02phi2) << std::endl;
378  std::cout << " EMConvert: vertex_Covd02theta2 "<< parameter(egammaParameters::refittedVertex_Covd02theta2) << std::endl;
379  std::cout << " EMConvert: vertex_Covd02qOverP2 "<< parameter(egammaParameters::refittedVertex_Covd02qOverP2) << std::endl;
380  std::cout << " EMConvert: vertex_Covz02z02 "<< parameter(egammaParameters::refittedVertex_Covz02z02) << std::endl;
381  std::cout << " EMConvert: vertex_Covz02phi2 "<< parameter(egammaParameters::refittedVertex_Covz02phi2) << std::endl;
382  std::cout << " EMConvert: vertex_Covz02theta2 "<< parameter(egammaParameters::refittedVertex_Covz02theta2) << std::endl;
383  std::cout << " EMConvert: vertex_Covz02qOverP2 "<< parameter(egammaParameters::refittedVertex_Covz02qOverP2) << std::endl;
384  std::cout << " EMConvert: vertex_Covphi2phi2 "<< parameter(egammaParameters::refittedVertex_Covphi2phi2) << std::endl;
385  std::cout << " EMConvert: vertex_Covphi2theta2 "<< parameter(egammaParameters::refittedVertex_Covphi2theta2) << std::endl;
386  std::cout << " EMConvert: vertex_Covphi2qOverP2 "<< parameter(egammaParameters::refittedVertex_Covphi2qOverP2) << std::endl;
387  std::cout << " EMConvert: vertex_Covtheta2theta2 "<< parameter(egammaParameters::refittedVertex_Covtheta2theta2) << std::endl;
388  std::cout << " EMConvert: vertex_Covtheta2qOverP2 "<< parameter(egammaParameters::refittedVertex_Covtheta2qOverP2) << std::endl;
389  std::cout << " EMConvert: vertex_CovqOverP2qOverP2 "<< parameter(egammaParameters::refittedVertex_CovqOverP2qOverP2) << std::endl;
390  std::cout << " EMConvert: vertex_Covphi2x "<< parameter(egammaParameters::refittedVertex_Covphi2x) << std::endl;
391  std::cout << " EMConvert: vertex_Covphi2y "<< parameter(egammaParameters::refittedVertex_Covphi2y) << std::endl;
392  std::cout << " EMConvert: vertex_Covphi2z "<< parameter(egammaParameters::refittedVertex_Covphi2z) << std::endl;
393  std::cout << " EMConvert: vertex_Covtheta2x "<< parameter(egammaParameters::refittedVertex_Covtheta2x) << std::endl;
394  std::cout << " EMConvert: vertex_Covtheta2y "<< parameter(egammaParameters::refittedVertex_Covtheta2y) << std::endl;
395  std::cout << " EMConvert: vertex_Covtheta2z "<< parameter(egammaParameters::refittedVertex_Covtheta2z) << std::endl;
396  std::cout << " EMConvert: vertex_CovqOverP2x "<< parameter(egammaParameters::refittedVertex_CovqOverP2x) << std::endl;
397  std::cout << " EMConvert: vertex_CovqOverP2y "<< parameter(egammaParameters::refittedVertex_CovqOverP2y) << std::endl;
398  std::cout << " EMConvert: vertex_CovqOverP2z "<< parameter(egammaParameters::refittedVertex_CovqOverP2z) << std::endl;
399  std::cout << " EMConvert: ambiguityResult "<< intParameter(egammaParameters::ambiguityResult) << std::endl;
400  std::cout << " EMConvert: linkIndex "<< intParameter(egammaParameters::linkIndex) << std::endl;
401 }
402 
403 
404 
405 // return values for the different variables in the EMConvert object
406 
407 bool EMConvert::convTrackMatch() const { return boolParameter(egammaParameters::convTrackMatch) ;}
408 bool EMConvert::convAngleMatch() const { return boolParameter(egammaParameters::convAngleMatch) ;}
409 double EMConvert::convMatchDeltaEta1() const { return parameter(egammaParameters::convMatchDeltaEta1) ;}
410 double EMConvert::convMatchDeltaPhi1() const { return parameter(egammaParameters::convMatchDeltaPhi1) ;}
411 double EMConvert::convMatchDeltaEta2() const { return parameter(egammaParameters::convMatchDeltaEta2) ;}
412 double EMConvert::convMatchDeltaPhi2() const { return parameter(egammaParameters::convMatchDeltaPhi2) ;}
413 double EMConvert::convMatchDeltaEta1_refit() const { return parameter(egammaParameters::convMatchDeltaEta1_refit) ;}
414 double EMConvert::convMatchDeltaPhi1_refit() const { return parameter(egammaParameters::convMatchDeltaPhi1_refit) ;}
415 double EMConvert::convMatchDeltaEta2_refit() const { return parameter(egammaParameters::convMatchDeltaEta2_refit) ;}
416 double EMConvert::convMatchDeltaPhi2_refit() const { return parameter(egammaParameters::convMatchDeltaPhi2_refit) ;}
417 double EMConvert::vertex_x() const { return parameter(egammaParameters::refittedVertex_x);}
418 double EMConvert::vertex_y() const { return parameter(egammaParameters::refittedVertex_y);}
419 double EMConvert::vertex_z() const { return parameter(egammaParameters::refittedVertex_z);}
420 double EMConvert::vertex_Covxx() const { return parameter(egammaParameters::refittedVertex_Covxx);}
421 double EMConvert::vertex_Covxy() const { return parameter(egammaParameters::refittedVertex_Covxy);}
422 double EMConvert::vertex_Covxz() const { return parameter(egammaParameters::refittedVertex_Covxz);}
423 double EMConvert::vertex_Covyy() const { return parameter(egammaParameters::refittedVertex_Covyy);}
424 double EMConvert::vertex_Covyz() const { return parameter(egammaParameters::refittedVertex_Covyz);}
425 double EMConvert::vertex_Covzz() const { return parameter(egammaParameters::refittedVertex_Covzz);}
426 double EMConvert::vertex_chi2() const { return parameter(egammaParameters::refittedVertex_chi2);}
427 int EMConvert::vertex_ndf() const { return intParameter(egammaParameters::refittedVertex_ndf);}
428 int EMConvert::vertex_numTracks() const { return intParameter(egammaParameters::refittedVertex_numTracks);}
429 double EMConvert::vertex_track1_phi() const { return parameter(egammaParameters::refittedVertex_track1_phi);}
430 double EMConvert::vertex_track1_theta() const { return parameter(egammaParameters::refittedVertex_track1_theta);}
431 double EMConvert::vertex_track1_qOverP() const { return parameter(egammaParameters::refittedVertex_track1_qOverP);}
432 double EMConvert::vertex_track1_chi2() const { return parameter(egammaParameters::refittedVertex_track1_chi2);}
433 int EMConvert::vertex_track1_author() const { return intParameter(egammaParameters::refittedVertex_track1_author);}
434 double EMConvert::vertex_track2_phi() const { return parameter(egammaParameters::refittedVertex_track2_phi);}
435 double EMConvert::vertex_track2_theta() const { return parameter(egammaParameters::refittedVertex_track2_theta);}
436 double EMConvert::vertex_track2_qOverP() const { return parameter(egammaParameters::refittedVertex_track2_qOverP);}
437 double EMConvert::vertex_track2_chi2() const { return parameter(egammaParameters::refittedVertex_track2_chi2);}
438 int EMConvert::vertex_track2_author() const { return intParameter(egammaParameters::refittedVertex_track2_author);}
439 double EMConvert::vertex_Covd01d01() const { return parameter(egammaParameters::refittedVertex_Covd01d01);}
440 double EMConvert::vertex_Covd01z01() const { return parameter(egammaParameters::refittedVertex_Covd01z01);}
441 double EMConvert::vertex_Covd01phi1() const { return parameter(egammaParameters::refittedVertex_Covd01phi1);}
442 double EMConvert::vertex_Covd01theta1() const { return parameter(egammaParameters::refittedVertex_Covd01theta1);}
443 double EMConvert::vertex_Covd01qOverP1() const { return parameter(egammaParameters::refittedVertex_Covd01qOverP1);}
444 double EMConvert::vertex_Covz01z01() const { return parameter(egammaParameters::refittedVertex_Covz01z01);}
445 double EMConvert::vertex_Covz01phi1() const { return parameter(egammaParameters::refittedVertex_Covz01phi1);}
446 double EMConvert::vertex_Covz01theta1() const { return parameter(egammaParameters::refittedVertex_Covz01theta1);}
447 double EMConvert::vertex_Covz01qOverP1() const { return parameter(egammaParameters::refittedVertex_Covz01qOverP1);}
448 double EMConvert::vertex_Covphi1phi1() const { return parameter(egammaParameters::refittedVertex_Covphi1phi1);}
449 double EMConvert::vertex_Covphi1theta1() const { return parameter(egammaParameters::refittedVertex_Covphi1theta1);}
450 double EMConvert::vertex_Covphi1qOverP1() const { return parameter(egammaParameters::refittedVertex_Covphi1qOverP1);}
451 double EMConvert::vertex_Covtheta1theta1() const { return parameter(egammaParameters::refittedVertex_Covtheta1theta1);}
452 double EMConvert::vertex_Covtheta1qOverP1() const { return parameter(egammaParameters::refittedVertex_Covtheta1qOverP1);}
453 double EMConvert::vertex_CovqOverP1qOverP1() const { return parameter(egammaParameters::refittedVertex_CovqOverP1qOverP1);}
454 double EMConvert::vertex_Covphi1phi2() const { return parameter(egammaParameters::refittedVertex_Covphi1phi2);}
455 double EMConvert::vertex_Covphi1theta2() const { return parameter(egammaParameters::refittedVertex_Covphi1theta2);}
456 double EMConvert::vertex_Covphi1qOverP2() const { return parameter(egammaParameters::refittedVertex_Covphi1qOverP2);}
457 double EMConvert::vertex_Covtheta1phi2() const { return parameter(egammaParameters::refittedVertex_Covtheta1phi2);}
458 double EMConvert::vertex_Covtheta1theta2() const { return parameter(egammaParameters::refittedVertex_Covtheta1theta2);}
459 double EMConvert::vertex_Covtheta1qOverP2() const { return parameter(egammaParameters::refittedVertex_Covtheta1qOverP2);}
460 double EMConvert::vertex_CovqOverP1phi2() const { return parameter(egammaParameters::refittedVertex_CovqOverP1phi2);}
461 double EMConvert::vertex_CovqOverP1theta2() const { return parameter(egammaParameters::refittedVertex_CovqOverP1theta2);}
462 double EMConvert::vertex_CovqOverP1qOverP2() const { return parameter(egammaParameters::refittedVertex_CovqOverP1qOverP2);}
463 double EMConvert::vertex_Covphi1x() const { return parameter(egammaParameters::refittedVertex_Covphi1x);}
464 double EMConvert::vertex_Covphi1y() const { return parameter(egammaParameters::refittedVertex_Covphi1y);}
465 double EMConvert::vertex_Covphi1z() const { return parameter(egammaParameters::refittedVertex_Covphi1z);}
466 double EMConvert::vertex_Covtheta1x() const { return parameter(egammaParameters::refittedVertex_Covtheta1x);}
467 double EMConvert::vertex_Covtheta1y() const { return parameter(egammaParameters::refittedVertex_Covtheta1y);}
468 double EMConvert::vertex_Covtheta1z() const { return parameter(egammaParameters::refittedVertex_Covtheta1z);}
469 double EMConvert::vertex_CovqOverP1x() const { return parameter(egammaParameters::refittedVertex_CovqOverP1x);}
470 double EMConvert::vertex_CovqOverP1y() const { return parameter(egammaParameters::refittedVertex_CovqOverP1y);}
471 double EMConvert::vertex_CovqOverP1z() const { return parameter(egammaParameters::refittedVertex_CovqOverP1z);}
472 double EMConvert::vertex_Covd02d02() const { return parameter(egammaParameters::refittedVertex_Covd02d02);}
473 double EMConvert::vertex_Covd02z02() const { return parameter(egammaParameters::refittedVertex_Covd02z02);}
474 double EMConvert::vertex_Covd02phi2() const { return parameter(egammaParameters::refittedVertex_Covd02phi2);}
475 double EMConvert::vertex_Covd02theta2() const { return parameter(egammaParameters::refittedVertex_Covd02theta2);}
476 double EMConvert::vertex_Covd02qOverP2() const { return parameter(egammaParameters::refittedVertex_Covd02qOverP2);}
477 double EMConvert::vertex_Covz02z02() const { return parameter(egammaParameters::refittedVertex_Covz02z02);}
478 double EMConvert::vertex_Covz02phi2() const { return parameter(egammaParameters::refittedVertex_Covz02phi2);}
479 double EMConvert::vertex_Covz02theta2() const { return parameter(egammaParameters::refittedVertex_Covz02theta2);}
480 double EMConvert::vertex_Covz02qOverP2() const { return parameter(egammaParameters::refittedVertex_Covz02qOverP2);}
481 double EMConvert::vertex_Covphi2phi2() const { return parameter(egammaParameters::refittedVertex_Covphi2phi2);}
482 double EMConvert::vertex_Covphi2theta2() const { return parameter(egammaParameters::refittedVertex_Covphi2theta2);}
483 double EMConvert::vertex_Covphi2qOverP2() const { return parameter(egammaParameters::refittedVertex_Covphi2qOverP2);}
484 double EMConvert::vertex_Covtheta2theta2() const { return parameter(egammaParameters::refittedVertex_Covtheta2theta2);}
485 double EMConvert::vertex_Covtheta2qOverP2() const { return parameter(egammaParameters::refittedVertex_Covtheta2qOverP2);}
486 double EMConvert::vertex_CovqOverP2qOverP2() const { return parameter(egammaParameters::refittedVertex_CovqOverP2qOverP2);}
487 double EMConvert::vertex_Covphi2x() const { return parameter(egammaParameters::refittedVertex_Covphi2x);}
488 double EMConvert::vertex_Covphi2y() const { return parameter(egammaParameters::refittedVertex_Covphi2y);}
489 double EMConvert::vertex_Covphi2z() const { return parameter(egammaParameters::refittedVertex_Covphi2z);}
490 double EMConvert::vertex_Covtheta2x() const { return parameter(egammaParameters::refittedVertex_Covtheta2x);}
491 double EMConvert::vertex_Covtheta2y() const { return parameter(egammaParameters::refittedVertex_Covtheta2y);}
492 double EMConvert::vertex_Covtheta2z() const { return parameter(egammaParameters::refittedVertex_Covtheta2z);}
493 double EMConvert::vertex_CovqOverP2x() const { return parameter(egammaParameters::refittedVertex_CovqOverP2x);}
494 double EMConvert::vertex_CovqOverP2y() const { return parameter(egammaParameters::refittedVertex_CovqOverP2y);}
495 double EMConvert::vertex_CovqOverP2z() const { return parameter(egammaParameters::refittedVertex_CovqOverP2z);}
496 int EMConvert::ambiguityResult() const { return intParameter(egammaParameters::ambiguityResult);}
497 int EMConvert::linkIndex() const { return intParameter(egammaParameters::linkIndex);}
498 
499 // set values for the different variables in the EMConvert object
500 
501 void EMConvert::set_convTrackMatch(bool x) { set_parameterBool(egammaParameters::convTrackMatch, x, true) ;}
502 void EMConvert::set_convAngleMatch(bool x) { set_parameterBool(egammaParameters::convAngleMatch, x, true) ;}
503 void EMConvert::set_convMatchDeltaEta1(double x) { set_parameter(egammaParameters::convMatchDeltaEta1, x, true) ;}
504 void EMConvert::set_convMatchDeltaPhi1(double x) { set_parameter(egammaParameters::convMatchDeltaPhi1, x, true) ;}
505 void EMConvert::set_convMatchDeltaEta2(double x) { set_parameter(egammaParameters::convMatchDeltaEta2, x, true) ;}
506 void EMConvert::set_convMatchDeltaPhi2(double x) { set_parameter(egammaParameters::convMatchDeltaPhi2, x, true) ;}
507 void EMConvert::set_convMatchDeltaEta1_refit(double x) { set_parameter(egammaParameters::convMatchDeltaEta1_refit, x, true) ;}
508 void EMConvert::set_convMatchDeltaPhi1_refit(double x) { set_parameter(egammaParameters::convMatchDeltaPhi1_refit, x, true) ;}
509 void EMConvert::set_convMatchDeltaEta2_refit(double x) { set_parameter(egammaParameters::convMatchDeltaEta2_refit, x, true) ;}
510 void EMConvert::set_convMatchDeltaPhi2_refit(double x) { set_parameter(egammaParameters::convMatchDeltaPhi2_refit, x, true) ;}
511 void EMConvert::set_vertex_x(double x) { set_parameter(egammaParameters::refittedVertex_x, x, true);}
512 void EMConvert::set_vertex_y(double x) { set_parameter(egammaParameters::refittedVertex_y, x, true);}
513 void EMConvert::set_vertex_z(double x) { set_parameter(egammaParameters::refittedVertex_z, x, true);}
514 void EMConvert::set_vertex_Covxx(double x) { set_parameter(egammaParameters::refittedVertex_Covxx, x, true);}
515 void EMConvert::set_vertex_Covxy(double x) { set_parameter(egammaParameters::refittedVertex_Covxy, x, true);}
516 void EMConvert::set_vertex_Covxz(double x) { set_parameter(egammaParameters::refittedVertex_Covxz, x, true);}
517 void EMConvert::set_vertex_Covyy(double x) { set_parameter(egammaParameters::refittedVertex_Covyy, x, true);}
518 void EMConvert::set_vertex_Covyz(double x) { set_parameter(egammaParameters::refittedVertex_Covyz, x, true);}
519 void EMConvert::set_vertex_Covzz(double x) { set_parameter(egammaParameters::refittedVertex_Covzz, x, true);}
520 void EMConvert::set_vertex_chi2(double x) { set_parameter(egammaParameters::refittedVertex_chi2, x, true);}
521 void EMConvert::set_vertex_ndf(int x) { set_parameterInt(egammaParameters::refittedVertex_ndf, x, true);}
522 void EMConvert::set_vertex_numTracks(int x) { set_parameterInt(egammaParameters::refittedVertex_numTracks, x, true);}
523 void EMConvert::set_vertex_track1_phi(double x) { set_parameter(egammaParameters::refittedVertex_track1_phi, x, true);}
524 void EMConvert::set_vertex_track1_theta(double x) { set_parameter(egammaParameters::refittedVertex_track1_theta, x, true);}
525 void EMConvert::set_vertex_track1_qOverP(double x) { set_parameter(egammaParameters::refittedVertex_track1_qOverP, x, true);}
526 void EMConvert::set_vertex_track1_chi2(double x) { set_parameter(egammaParameters::refittedVertex_track1_chi2, x, true);}
527 void EMConvert::set_vertex_track1_author(int x) { set_parameterInt(egammaParameters::refittedVertex_track1_author, x, true);}
528 void EMConvert::set_vertex_track2_phi(double x) { set_parameter(egammaParameters::refittedVertex_track2_phi, x, true);}
529 void EMConvert::set_vertex_track2_theta(double x) { set_parameter(egammaParameters::refittedVertex_track2_theta, x, true);}
530 void EMConvert::set_vertex_track2_qOverP(double x) { set_parameter(egammaParameters::refittedVertex_track2_qOverP, x, true);}
531 void EMConvert::set_vertex_track2_chi2(double x) { set_parameter(egammaParameters::refittedVertex_track2_chi2, x, true);}
532 void EMConvert::set_vertex_track2_author(int x) { set_parameterInt(egammaParameters::refittedVertex_track2_author, x, true);}
533 void EMConvert::set_vertex_Covd01d01(double x) { set_parameter(egammaParameters::refittedVertex_Covd01d01, x, true);}
534 void EMConvert::set_vertex_Covd01z01(double x) { set_parameter(egammaParameters::refittedVertex_Covd01z01, x, true);}
535 void EMConvert::set_vertex_Covd01phi1(double x) { set_parameter(egammaParameters::refittedVertex_Covd01phi1, x, true);}
536 void EMConvert::set_vertex_Covd01theta1(double x) { set_parameter(egammaParameters::refittedVertex_Covd01theta1, x, true);}
537 void EMConvert::set_vertex_Covd01qOverP1(double x) { set_parameter(egammaParameters::refittedVertex_Covd01qOverP1, x, true);}
538 void EMConvert::set_vertex_Covz01z01(double x) { set_parameter(egammaParameters::refittedVertex_Covz01z01, x, true);}
539 void EMConvert::set_vertex_Covz01phi1(double x) { set_parameter(egammaParameters::refittedVertex_Covz01phi1, x, true);}
540 void EMConvert::set_vertex_Covz01theta1(double x) { set_parameter(egammaParameters::refittedVertex_Covz01theta1, x, true);}
541 void EMConvert::set_vertex_Covz01qOverP1(double x) { set_parameter(egammaParameters::refittedVertex_Covz01qOverP1, x, true);}
542 void EMConvert::set_vertex_Covphi1phi1(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1phi1, x, true);}
543 void EMConvert::set_vertex_Covphi1theta1(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1theta1, x, true);}
544 void EMConvert::set_vertex_Covphi1qOverP1(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1qOverP1, x, true);}
545 void EMConvert::set_vertex_Covtheta1theta1(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1theta1, x, true);}
546 void EMConvert::set_vertex_Covtheta1qOverP1(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1qOverP1, x, true);}
547 void EMConvert::set_vertex_CovqOverP1qOverP1(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP1qOverP1, x, true);}
548 void EMConvert::set_vertex_Covphi1phi2(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1phi2, x, true);}
549 void EMConvert::set_vertex_Covphi1theta2(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1theta2, x, true);}
550 void EMConvert::set_vertex_Covphi1qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1qOverP2, x, true);}
551 void EMConvert::set_vertex_Covtheta1phi2(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1phi2, x, true);}
552 void EMConvert::set_vertex_Covtheta1theta2(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1theta2, x, true);}
553 void EMConvert::set_vertex_Covtheta1qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1qOverP2, x, true);}
554 void EMConvert::set_vertex_CovqOverP1phi2(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP1phi2, x, true);}
555 void EMConvert::set_vertex_CovqOverP1theta2(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP1theta2, x, true);}
556 void EMConvert::set_vertex_CovqOverP1qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP1qOverP2, x, true);}
557 void EMConvert::set_vertex_Covphi1x(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1x, x, true);}
558 void EMConvert::set_vertex_Covphi1y(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1y, x, true);}
559 void EMConvert::set_vertex_Covphi1z(double x) { set_parameter(egammaParameters::refittedVertex_Covphi1z, x, true);}
560 void EMConvert::set_vertex_Covtheta1x(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1x, x, true);}
561 void EMConvert::set_vertex_Covtheta1y(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1y, x, true);}
562 void EMConvert::set_vertex_Covtheta1z(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta1z, x, true);}
563 void EMConvert::set_vertex_CovqOverP1x(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP1x, x, true);}
564 void EMConvert::set_vertex_CovqOverP1y(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP1y, x, true);}
565 void EMConvert::set_vertex_CovqOverP1z(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP1z, x, true);}
566 void EMConvert::set_vertex_Covd02d02(double x) { set_parameter(egammaParameters::refittedVertex_Covd02d02, x, true);}
567 void EMConvert::set_vertex_Covd02z02(double x) { set_parameter(egammaParameters::refittedVertex_Covd02z02, x, true);}
568 void EMConvert::set_vertex_Covd02phi2(double x) { set_parameter(egammaParameters::refittedVertex_Covd02phi2, x, true);}
569 void EMConvert::set_vertex_Covd02theta2(double x) { set_parameter(egammaParameters::refittedVertex_Covd02theta2, x, true);}
570 void EMConvert::set_vertex_Covd02qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_Covd02qOverP2, x, true);}
571 void EMConvert::set_vertex_Covz02z02(double x) { set_parameter(egammaParameters::refittedVertex_Covz02z02, x, true);}
572 void EMConvert::set_vertex_Covz02phi2(double x) { set_parameter(egammaParameters::refittedVertex_Covz02phi2, x, true);}
573 void EMConvert::set_vertex_Covz02theta2(double x) { set_parameter(egammaParameters::refittedVertex_Covz02theta2, x, true);}
574 void EMConvert::set_vertex_Covz02qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_Covz02qOverP2, x, true);}
575 void EMConvert::set_vertex_Covphi2phi2(double x) { set_parameter(egammaParameters::refittedVertex_Covphi2phi2, x, true);}
576 void EMConvert::set_vertex_Covphi2theta2(double x) { set_parameter(egammaParameters::refittedVertex_Covphi2theta2, x, true);}
577 void EMConvert::set_vertex_Covphi2qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_Covphi2qOverP2, x, true);}
578 void EMConvert::set_vertex_Covtheta2theta2(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta2theta2, x, true);}
579 void EMConvert::set_vertex_Covtheta2qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta2qOverP2, x, true);}
580 void EMConvert::set_vertex_CovqOverP2qOverP2(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP2qOverP2, x, true);}
581 void EMConvert::set_vertex_Covphi2x(double x) { set_parameter(egammaParameters::refittedVertex_Covphi2x, x, true);}
582 void EMConvert::set_vertex_Covphi2y(double x) { set_parameter(egammaParameters::refittedVertex_Covphi2y, x, true);}
583 void EMConvert::set_vertex_Covphi2z(double x) { set_parameter(egammaParameters::refittedVertex_Covphi2z, x, true);}
584 void EMConvert::set_vertex_Covtheta2x(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta2x, x, true);}
585 void EMConvert::set_vertex_Covtheta2y(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta2y, x, true);}
586 void EMConvert::set_vertex_Covtheta2z(double x) { set_parameter(egammaParameters::refittedVertex_Covtheta2z, x, true);}
587 void EMConvert::set_vertex_CovqOverP2x(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP2x, x, true);}
588 void EMConvert::set_vertex_CovqOverP2y(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP2y, x, true);}
589 void EMConvert::set_vertex_CovqOverP2z(double x) { set_parameter(egammaParameters::refittedVertex_CovqOverP2z, x, true);}
590 void EMConvert::set_ambiguityResult(int x) { set_parameterInt(egammaParameters::ambiguityResult, x, true);}
591 void EMConvert::set_linkIndex(int x) { set_parameterInt(egammaParameters::linkIndex, x, true);}
592 
593 
594 void EMConvert::fillDummy()
595 {
596  set_vertex_x(-999.);
597  set_vertex_y(-999.);
598  set_vertex_z(-999.);
599  set_vertex_Covxx(-999.);
600  set_vertex_Covxy(-999.);
601  set_vertex_Covxz(-999.);
602  set_vertex_Covyy(-999.);
603  set_vertex_Covyz(-999.);
604  set_vertex_Covzz(-999.);
605  set_vertex_chi2(-999.);
606  set_vertex_ndf(-999);
607  set_vertex_numTracks(-999);
608  set_vertex_track1_phi(-999.);
609  set_vertex_track1_theta(-999.);
610  set_vertex_track1_qOverP(-999.);
611  set_vertex_track1_chi2(-999.);
612  set_vertex_track1_author(-999);
613  set_vertex_track2_phi(-999.);
614  set_vertex_track2_theta(-999.);
615  set_vertex_track2_qOverP(-999.);
616  set_vertex_track2_chi2(-999.);
617  set_vertex_track2_author(-999);
618  set_vertex_Covd01d01(-999.);
619  set_vertex_Covd01z01(-999.);
620  set_vertex_Covd01phi1(-999.);
621  set_vertex_Covd01theta1(-999.);
622  set_vertex_Covd01qOverP1(-999.);
623  set_vertex_Covz01z01(-999.);
624  set_vertex_Covz01phi1(-999.);
625  set_vertex_Covz01theta1(-999.);
626  set_vertex_Covz01qOverP1(-999.);
627  set_vertex_Covphi1phi1(-999.);
628  set_vertex_Covphi1theta1(-999.);
629  set_vertex_Covphi1qOverP1(-999.);
630  set_vertex_Covtheta1theta1(-999.);
631  set_vertex_Covtheta1qOverP1(-999.);
632  set_vertex_CovqOverP1qOverP1(-999.);
633  set_vertex_Covphi1phi2(-999.);
634  set_vertex_Covphi1theta2(-999.);
635  set_vertex_Covphi1qOverP2(-999.);
636  set_vertex_Covtheta1phi2(-999.);
637  set_vertex_Covtheta1theta2(-999.);
638  set_vertex_Covtheta1qOverP2(-999.);
639  set_vertex_CovqOverP1phi2(-999.);
640  set_vertex_CovqOverP1theta2(-999.);
641  set_vertex_CovqOverP1qOverP2(-999.);
642  set_vertex_Covphi1x(-999.);
643  set_vertex_Covphi1y(-999.);
644  set_vertex_Covphi1z(-999.);
645  set_vertex_Covtheta1x(-999.);
646  set_vertex_Covtheta1y(-999.);
647  set_vertex_Covtheta1z(-999.);
648  set_vertex_CovqOverP1x(-999.);
649  set_vertex_CovqOverP1y(-999.);
650  set_vertex_CovqOverP1z(-999.);
651  set_vertex_Covd02d02(-999.);
652  set_vertex_Covd02z02(-999.);
653  set_vertex_Covd02phi2(-999.);
654  set_vertex_Covd02theta2(-999.);
655  set_vertex_Covd02qOverP2(-999.);
656  set_vertex_Covz02z02(-999.);
657  set_vertex_Covz02phi2(-999.);
658  set_vertex_Covz02theta2(-999.);
659  set_vertex_Covz02qOverP2(-999.);
660  set_vertex_Covphi2phi2(-999.);
661  set_vertex_Covphi2theta2(-999.);
662  set_vertex_Covphi2qOverP2(-999.);
663  set_vertex_Covtheta2theta2(-999.);
664  set_vertex_Covtheta2qOverP2(-999.);
665  set_vertex_CovqOverP2qOverP2(-999.);
666  set_vertex_Covphi2x(-999.);
667  set_vertex_Covphi2y(-999.);
668  set_vertex_Covphi2z(-999.);
669  set_vertex_Covtheta2x(-999.);
670  set_vertex_Covtheta2y(-999.);
671  set_vertex_Covtheta2z(-999.);
672  set_vertex_CovqOverP2x(-999.);
673  set_vertex_CovqOverP2y(-999.);
674  set_vertex_CovqOverP2z(-999.);
675  set_ambiguityResult(-999);
676  set_linkIndex(-999);
677  set_convMatchDeltaEta1(-999.);
678  set_convMatchDeltaPhi1(-999.);
679  set_convMatchDeltaEta2(-999.);
680  set_convMatchDeltaPhi2(-999.);
681  set_convMatchDeltaEta1_refit(-999.);
682  set_convMatchDeltaPhi1_refit(-999.);
683  set_convMatchDeltaEta2_refit(-999.);
684  set_convMatchDeltaPhi2_refit(-999.);
685 }
686 
687 void EMConvert::fillVxDetails(const Trk::VxCandidate* vxCand, int trkAuthor)
688 {
689  if(vxCand){
690  fillVxTracks(vxCand, trkAuthor);
691  fillVertex(vxCand);
692  } else {
693  throw GaudiException("Parameters not saved, no VxCandidate", "EMConvert::fillDetails(...)", StatusCode::FAILURE);
694  }
695 }
696 
697 void EMConvert::fillVertex(const Trk::VxCandidate* vxCand)
698 {
699  set_vertex_x(vxCand->recVertex().position().x());
700  set_vertex_y(vxCand->recVertex().position().y());
701  set_vertex_z(vxCand->recVertex().position().z());
702  set_vertex_Covxx(vxCand->recVertex().covariancePosition()(Trk::x, Trk::x));
703  set_vertex_Covxy(vxCand->recVertex().covariancePosition()(Trk::x, Trk::y));
704  set_vertex_Covxz(vxCand->recVertex().covariancePosition()(Trk::x, Trk::z));
705  set_vertex_Covyy(vxCand->recVertex().covariancePosition()(Trk::y, Trk::y));
706  set_vertex_Covyz(vxCand->recVertex().covariancePosition()(Trk::y, Trk::z));
707  set_vertex_Covzz(vxCand->recVertex().covariancePosition()(Trk::z, Trk::z));
708  set_vertex_chi2(vxCand->recVertex().fitQuality().chiSquared());
709  set_vertex_ndf(vxCand->recVertex().fitQuality().numberDoF());
710  std::vector<Trk::VxTrackAtVertex*> trks(*(vxCand->vxTrackAtVertex()));
711  int numTracksAtVertex = trks.size();
712  set_vertex_numTracks(numTracksAtVertex);
713  const Trk::ExtendedVxCandidate* evxCand = dynamic_cast<const Trk::ExtendedVxCandidate*>(vxCand);
714  if(evxCand){
715  const Amg::MatrixX *errMat = evxCand->fullCovariance();
716  set_vertex_Covphi1phi1((*errMat)(3,3));
717  set_vertex_Covphi1theta1((*errMat)(3,4));
718  set_vertex_Covphi1qOverP1((*errMat)(3,5));
719  set_vertex_Covtheta1theta1((*errMat)(4,4));
720  set_vertex_Covtheta1qOverP1((*errMat)(4,5));
721  set_vertex_CovqOverP1qOverP1((*errMat)(5,5));
722  set_vertex_Covphi1x((*errMat)(3,0));
723  set_vertex_Covphi1y((*errMat)(3,1));
724  set_vertex_Covphi1z((*errMat)(3,2));
725  set_vertex_Covtheta1x((*errMat)(4,0));
726  set_vertex_Covtheta1y((*errMat)(4,1));
727  set_vertex_Covtheta1z((*errMat)(4,2));
728  set_vertex_CovqOverP1x((*errMat)(5,0));
729  set_vertex_CovqOverP1y((*errMat)(5,1));
730  set_vertex_CovqOverP1z((*errMat)(5,2));
731  if(numTracksAtVertex>1){
732  set_vertex_Covphi1phi2((*errMat)(6,6));
733  set_vertex_Covphi1theta2((*errMat)(6,7));
734  set_vertex_Covphi1qOverP2((*errMat)(6,8));
735  set_vertex_Covtheta1phi2((*errMat)(4,6));
736  set_vertex_Covtheta1theta2((*errMat)(4,7));
737  set_vertex_Covtheta1qOverP2((*errMat)(4,8));
738  set_vertex_CovqOverP1phi2((*errMat)(5,6));
739  set_vertex_CovqOverP1theta2((*errMat)(5,7));
740  set_vertex_CovqOverP1qOverP2((*errMat)(5,8));
741  set_vertex_Covphi2phi2((*errMat)(6,6));
742  set_vertex_Covphi2theta2((*errMat)(6,7));
743  set_vertex_Covphi2qOverP2((*errMat)(6,8));
744  set_vertex_Covtheta2theta2((*errMat)(7,7));
745  set_vertex_Covtheta2qOverP2((*errMat)(7,8));
746  set_vertex_CovqOverP2qOverP2((*errMat)(8,8));
747  set_vertex_Covphi2x((*errMat)(6,0));
748  set_vertex_Covphi2y((*errMat)(6,1));
749  set_vertex_Covphi2z((*errMat)(6,2));
750  set_vertex_Covtheta2x((*errMat)(7,0));
751  set_vertex_Covtheta2y((*errMat)(7,1));
752  set_vertex_Covtheta2z((*errMat)(7,2));
753  set_vertex_CovqOverP2x((*errMat)(8,0));
754  set_vertex_CovqOverP2y((*errMat)(8,1));
755  set_vertex_CovqOverP2z((*errMat)(8,2));
756  }
757  }
758 }
759 
760 void EMConvert::fillVxTracks(const Trk::VxCandidate* vxCand, int trkAuthor)
761 {
762  std::vector<Trk::VxTrackAtVertex*> trks(*(vxCand->vxTrackAtVertex()));
763  int numTracksAtVertex = trks.size();
764  for(int i=0; i<numTracksAtVertex; i++){
765  if(i==0){
766  Trk::VxTrackAtVertex* trk = trks[i];
767  const Trk::TrackParameters* trkParams = trk->perigeeAtVertex();
768  set_vertex_track1_chi2(trk->trackQuality().chiSquared());
769  set_vertex_track1_author(trkAuthor);
770  if(trkParams){
771  set_vertex_track1_phi(trkParams->parameters()[Trk::phi]);
772  set_vertex_track1_theta(trkParams->parameters()[Trk::theta]);
773  set_vertex_track1_qOverP(trkParams->parameters()[Trk::qOverP]);
774  const AmgSymMatrix(5)* errMat= trkParams->covariance();
775 
776  if(errMat){
777  set_vertex_Covd01d01((*errMat)(Trk::d0,Trk::d0));
778  set_vertex_Covd01z01((*errMat)(Trk::d0,Trk::z0));
779  set_vertex_Covd01phi1((*errMat)(Trk::d0,Trk::phi));
780  set_vertex_Covd01theta1((*errMat)(Trk::d0,Trk::theta));
781  set_vertex_Covd01qOverP1((*errMat)(Trk::d0,Trk::qOverP));
782  set_vertex_Covz01z01((*errMat)(Trk::z0,Trk::z0));
783  set_vertex_Covz01phi1((*errMat)(Trk::z0,Trk::phi));
784  set_vertex_Covz01theta1((*errMat)(Trk::z0,Trk::theta));
785  set_vertex_Covz01qOverP1((*errMat)(Trk::z0,Trk::qOverP));
786  if(numTracksAtVertex<2){
787  set_vertex_Covphi1phi1((*errMat)(Trk::phi,Trk::phi));
788  set_vertex_Covphi1theta1((*errMat)(Trk::phi,Trk::theta));
789  set_vertex_Covphi1qOverP1((*errMat)(Trk::phi,Trk::qOverP));
790  set_vertex_Covtheta1theta1((*errMat)(Trk::theta,Trk::theta));
791  set_vertex_Covtheta1qOverP1((*errMat)(Trk::theta,Trk::qOverP));
792  set_vertex_CovqOverP1qOverP1((*errMat)(Trk::qOverP,Trk::qOverP));
793  }
794  }
795  }
796  }else if(i==1){
797  Trk::VxTrackAtVertex* trk = trks[i];
798  const Trk::TrackParameters* trkParams = trk->perigeeAtVertex();
799  set_vertex_track2_chi2(trk->trackQuality().chiSquared());
800  set_vertex_track2_author(trkAuthor);
801  if(trkParams){
802  set_vertex_track2_phi(trkParams->parameters()[Trk::phi]);
803  set_vertex_track2_theta(trkParams->parameters()[Trk::theta]);
804  set_vertex_track2_qOverP(trkParams->parameters()[Trk::qOverP]);
805  const AmgSymMatrix(5)* errMat= trkParams->covariance();
806  if(errMat){
807  set_vertex_Covd02d02((*errMat)(Trk::d0,Trk::d0));
808  set_vertex_Covd02z02((*errMat)(Trk::d0,Trk::z0));
809  set_vertex_Covd02phi2((*errMat)(Trk::d0,Trk::phi));
810  set_vertex_Covd02theta2((*errMat)(Trk::d0,Trk::theta));
811  set_vertex_Covd02qOverP2((*errMat)(Trk::d0,Trk::qOverP));
812  set_vertex_Covz02z02((*errMat)(Trk::z0,Trk::z0));
813  set_vertex_Covz02phi2((*errMat)(Trk::z0,Trk::phi));
814  set_vertex_Covz02theta2((*errMat)(Trk::z0,Trk::theta));
815  set_vertex_Covz02qOverP2((*errMat)(Trk::z0,Trk::qOverP));
816  }
817  }
818  }
819  }
820 }
821 
822 AmgSymMatrix(3)* EMConvert::getVxPosErrorMatrix() const
823 {
824  // Make a 3x3 matrix that is filled with zero's alternatively we could fill it with the identity matrix;
825  // Chosen the identity matrix option
826  AmgSymMatrix(3)* hepSymMatrix = new AmgSymMatrix(3);
827  // Fill the matrix
828  hepSymMatrix->fillSymmetric(0,0, vertex_Covxx());
829  hepSymMatrix->fillSymmetric(0,1, vertex_Covxy());
830  hepSymMatrix->fillSymmetric(0,2, vertex_Covxz());
831  hepSymMatrix->fillSymmetric(1,1, vertex_Covyy());
832  hepSymMatrix->fillSymmetric(1,2, vertex_Covyz());
833  hepSymMatrix->fillSymmetric(2,2, vertex_Covzz());
834 
835  return hepSymMatrix;
836 
837 }
838 
839 AmgSymMatrix(5) EMConvert::getTrk2ErrorMatrix() const
840 {
841  AmgSymMatrix(5) hepSymMatrix;
842  // Fill the matrix
843  hepSymMatrix.fillSymmetric(0,0, vertex_Covd02d02());
844  hepSymMatrix.fillSymmetric(0,1, vertex_Covd02z02());
845  hepSymMatrix.fillSymmetric(0,2, vertex_Covd02phi2());
846  hepSymMatrix.fillSymmetric(0,3, vertex_Covd02theta2());
847  hepSymMatrix.fillSymmetric(0,4, vertex_Covd02qOverP2());
848  hepSymMatrix.fillSymmetric(1,1, vertex_Covz02z02());
849  hepSymMatrix.fillSymmetric(1,2, vertex_Covz02phi2());
850  hepSymMatrix.fillSymmetric(1,3, vertex_Covz02theta2());
851  hepSymMatrix.fillSymmetric(1,4, vertex_Covz02qOverP2());
852  hepSymMatrix.fillSymmetric(2,2, vertex_Covphi2phi2());
853  hepSymMatrix.fillSymmetric(2,3, vertex_Covphi2theta2());
854  hepSymMatrix.fillSymmetric(2,4, vertex_Covphi2qOverP2());
855  hepSymMatrix.fillSymmetric(3,3, vertex_Covtheta2theta2());
856  hepSymMatrix.fillSymmetric(3,4, vertex_Covtheta2qOverP2());
857  hepSymMatrix.fillSymmetric(4,4, vertex_CovqOverP2qOverP2());
858 
859  return hepSymMatrix;
860 }
861 
862 AmgSymMatrix(5) EMConvert::getTrk1ErrorMatrix() const
863 {
864  AmgSymMatrix(5) hepSymMatrix;
865  // Fill the matrix
866  hepSymMatrix.fillSymmetric(0,0, vertex_Covd01d01());
867  hepSymMatrix.fillSymmetric(0,1, vertex_Covd01z01());
868  hepSymMatrix.fillSymmetric(0,2, vertex_Covd01phi1());
869  hepSymMatrix.fillSymmetric(0,3, vertex_Covd01theta1());
870  hepSymMatrix.fillSymmetric(0,4, vertex_Covd01qOverP1());
871  hepSymMatrix.fillSymmetric(1,1, vertex_Covz01z01());
872  hepSymMatrix.fillSymmetric(1,2, vertex_Covz01phi1());
873  hepSymMatrix.fillSymmetric(1,3, vertex_Covz01theta1());
874  hepSymMatrix.fillSymmetric(1,4, vertex_Covz01qOverP1());
875  hepSymMatrix.fillSymmetric(2,2, vertex_Covphi1phi1());
876  hepSymMatrix.fillSymmetric(2,3, vertex_Covphi1theta1());
877  hepSymMatrix.fillSymmetric(2,4, vertex_Covphi1qOverP1());
878  hepSymMatrix.fillSymmetric(3,3, vertex_Covtheta1theta1());
879  hepSymMatrix.fillSymmetric(3,4, vertex_Covtheta1qOverP1());
880  hepSymMatrix.fillSymmetric(4,4, vertex_CovqOverP1qOverP1());
881 
882  return hepSymMatrix;
883 }
884 
885 
886 Amg::MatrixX* EMConvert::getVxErrorMatrix() const
887 {
888  if(vertex_numTracks()>0){
889 
890  Amg::MatrixX* hepSymMatrix = new Amg::MatrixX(9,9);
891 
892  // Fill the matrix
893  hepSymMatrix->fillSymmetric(0,0, vertex_Covxx());
894  hepSymMatrix->fillSymmetric(0,1, vertex_Covxy());
895  hepSymMatrix->fillSymmetric(0,2, vertex_Covxz());
896  hepSymMatrix->fillSymmetric(0,3, vertex_Covphi1x());
897  hepSymMatrix->fillSymmetric(0,4, vertex_Covtheta1x());
898  hepSymMatrix->fillSymmetric(0,5, vertex_CovqOverP1x());
899  hepSymMatrix->fillSymmetric(0,6, vertex_Covphi2x());
900  hepSymMatrix->fillSymmetric(0,7, vertex_Covtheta2x());
901  hepSymMatrix->fillSymmetric(0,8, vertex_CovqOverP2x());
902  hepSymMatrix->fillSymmetric(1,1, vertex_Covyy());
903  hepSymMatrix->fillSymmetric(1,2, vertex_Covyz());
904  hepSymMatrix->fillSymmetric(1,3, vertex_Covphi1y());
905  hepSymMatrix->fillSymmetric(1,4, vertex_Covtheta1y());
906  hepSymMatrix->fillSymmetric(1,5, vertex_CovqOverP1y());
907  hepSymMatrix->fillSymmetric(1,6, vertex_Covphi2y());
908  hepSymMatrix->fillSymmetric(1,7, vertex_Covtheta2y());
909  hepSymMatrix->fillSymmetric(1,8, vertex_CovqOverP2y());
910  hepSymMatrix->fillSymmetric(2,2, vertex_Covzz());
911  hepSymMatrix->fillSymmetric(2,3, vertex_Covphi1z());
912  hepSymMatrix->fillSymmetric(2,4, vertex_Covtheta1z());
913  hepSymMatrix->fillSymmetric(2,5, vertex_CovqOverP1z());
914  hepSymMatrix->fillSymmetric(2,6, vertex_Covphi2z());
915  hepSymMatrix->fillSymmetric(2,7, vertex_Covtheta2z());
916  hepSymMatrix->fillSymmetric(2,8, vertex_CovqOverP2z());
917  hepSymMatrix->fillSymmetric(3,3, vertex_Covphi1phi1());
918  hepSymMatrix->fillSymmetric(3,4, vertex_Covphi1theta1());
919  hepSymMatrix->fillSymmetric(3,5, vertex_Covphi1qOverP1());
920  hepSymMatrix->fillSymmetric(3,6, vertex_Covphi1phi2());
921  hepSymMatrix->fillSymmetric(3,7, vertex_Covphi1theta2());
922  hepSymMatrix->fillSymmetric(3,8, vertex_Covphi1qOverP2());
923  hepSymMatrix->fillSymmetric(4,4, vertex_Covtheta1theta1());
924  hepSymMatrix->fillSymmetric(4,5, vertex_Covtheta1qOverP1());
925  hepSymMatrix->fillSymmetric(4,6, vertex_Covtheta1phi2());
926  hepSymMatrix->fillSymmetric(4,7, vertex_Covtheta1theta2());
927  hepSymMatrix->fillSymmetric(4,8, vertex_Covtheta1qOverP2());
928  hepSymMatrix->fillSymmetric(5,5, vertex_CovqOverP1qOverP1());
929  hepSymMatrix->fillSymmetric(5,6, vertex_CovqOverP1phi2());
930  hepSymMatrix->fillSymmetric(5,7, vertex_CovqOverP1theta2());
931  hepSymMatrix->fillSymmetric(5,8, vertex_CovqOverP1qOverP2());
932  hepSymMatrix->fillSymmetric(6,6, vertex_Covphi2phi2());
933  hepSymMatrix->fillSymmetric(6,7, vertex_Covphi2theta2());
934  hepSymMatrix->fillSymmetric(6,8, vertex_Covphi2qOverP2());
935  hepSymMatrix->fillSymmetric(7,7, vertex_Covtheta2theta2());
936  hepSymMatrix->fillSymmetric(7,8, vertex_Covtheta2qOverP2());
937  hepSymMatrix->fillSymmetric(8,8, vertex_CovqOverP2qOverP2());
938 
939  return hepSymMatrix;
940 
941  }
942  //Convert the CovarianceMatrix into a ErrorMatrix and create a new new object to pass;
943  return nullptr;
944 }
945 
946 
947 Trk::VxCandidate* EMConvert::getVxCandidate() const
948 {
949 
950  Trk::ExtendedVxCandidate* evxCand = nullptr;
951  Trk::VxCandidate* vxCand = nullptr;
952  std::vector<Trk::VxTrackAtVertex*> vxTrkAtVx;
953 
954  AmgSymMatrix(3)* posmat = getVxPosErrorMatrix();
955  const Trk::RecVertex* vx = new Trk::RecVertex(Amg::Vector3D(vertex_x(),vertex_y(),vertex_z()),
956  *posmat, (double)vertex_ndf(), (double)vertex_chi2());
957  delete posmat;
958 
959  //perigee at vertex
960  Amg::Vector3D globPos(vertex_x(), vertex_y(), vertex_z());
961  AmgSymMatrix(5) trk1EM = getTrk1ErrorMatrix();
962 
963  const Trk::PerigeeSurface surface(globPos);
964  Trk::Perigee* trkParams= new Trk::Perigee(0,
965  0,
966  vertex_track1_phi(),
967  vertex_track1_theta(),
968  vertex_track1_qOverP(),
969  surface,
970  trk1EM);
971  Trk::VxTrackAtVertex* vxtrk1 = new Trk::VxTrackAtVertex(vertex_track1_chi2(), trkParams);
972  vxTrkAtVx.push_back(vxtrk1);
973 
974  if(vertex_numTracks()>1){
975  Trk::VxTrackAtVertex* vxtrk2 = nullptr;
976  AmgSymMatrix(5) trk2EM = getTrk2ErrorMatrix();
977  const Trk::PerigeeSurface surface2(globPos);
978  Trk::Perigee* trkParams2= new Trk::Perigee(0,
979  0,
980  vertex_track2_phi(),
981  vertex_track2_theta(),
982  vertex_track2_qOverP(),
983  surface,
984  trk2EM);
985 
986  vxtrk2 = new Trk::VxTrackAtVertex(vertex_track2_chi2(), trkParams2);
987  vxTrkAtVx.push_back(vxtrk2);
988  evxCand = new Trk::ExtendedVxCandidate(*vx, vxTrkAtVx, getVxErrorMatrix());
989  delete vx;
990  return evxCand;
991  }//single track conversion -> VxCandidate
992  vxCand = new Trk::VxCandidate(*vx, vxTrkAtVx);
993  delete vx;
994  return vxCand;
995 
996 }
997 
998 
999 SG_ADD_BASE (EMConvert, egDetail);
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
SG_ADD_BASE
#define SG_ADD_BASE(D, B)
Add a new base class B to class D.
Definition: Control/AthenaKernel/AthenaKernel/BaseInfo.h:325
egammaParameters::refittedVertex_Covzz
@ refittedVertex_Covzz
refitted vertex covariance item (z,z)
Definition: egammaParamDefs.h:367
EMConvert::convTrackMatch
bool convTrackMatch() const
conversion track matches egamma track
Definition: EMConvert.cxx:407
egammaParameters::refittedVertex_track2_phi
@ refittedVertex_track2_phi
refitted track global momentum after vertex fit
Definition: egammaParamDefs.h:383
egammaParameters::refittedVertex_Covphi1y
@ refittedVertex_Covphi1y
Definition: egammaParamDefs.h:410
EMConvert::set_vertex_Covd01d01
void set_vertex_Covd01d01(double)
Definition: EMConvert.cxx:533
RecVertex.h
EMConvert::vertex_Covd01phi1
double vertex_Covd01phi1() const
Definition: EMConvert.cxx:441
Trk::y
@ y
Definition: ParamDefs.h:62
egammaParameters::convAngleMatch
@ convAngleMatch
from EMConvert, true if a conversion is matched within an angle of 0,05 to the cluster
Definition: egammaParamDefs.h:268
egammaParameters::refittedVertex_chi2
@ refittedVertex_chi2
refitted vertex fit quality variables
Definition: egammaParamDefs.h:369
Trk::VxTrackAtVertex::trackQuality
FitQuality trackQuality(void) const
Returns a pointer to the original track if any.
EMConvert::set_vertex_Covphi1phi2
void set_vertex_Covphi1phi2(double)
Definition: EMConvert.cxx:548
egammaParameters::refittedVertex_Covphi1phi2
@ refittedVertex_Covphi1phi2
Definition: egammaParamDefs.h:399
EMConvert::set_vertex_Covtheta1qOverP2
void set_vertex_Covtheta1qOverP2(double)
Definition: EMConvert.cxx:553
EMConvert::set_vertex_CovqOverP2y
void set_vertex_CovqOverP2y(double)
Definition: EMConvert.cxx:588
EMConvert::set_vertex_CovqOverP2x
void set_vertex_CovqOverP2x(double)
Definition: EMConvert.cxx:587
EMConvert
Definition: EMConvert.h:35
EMConvert::vertex_Covtheta2theta2
double vertex_Covtheta2theta2() const
Definition: EMConvert.cxx:484
EMConvert::vertex_Covphi2x
double vertex_Covphi2x() const
Definition: EMConvert.cxx:487
egammaParameters::refittedVertex_track2_author
@ refittedVertex_track2_author
refitted track author
Definition: egammaParamDefs.h:389
EMConvert::vertex_track2_qOverP
double vertex_track2_qOverP() const
Definition: EMConvert.cxx:436
egammaParameters::refittedVertex_Covd01qOverP1
@ refittedVertex_Covd01qOverP1
Definition: egammaParamDefs.h:450
EMConvert::set_vertex_Covphi1y
void set_vertex_Covphi1y(double)
Definition: EMConvert.cxx:558
EMConvert::set_vertex_Covyz
void set_vertex_Covyz(double)
Definition: EMConvert.cxx:518
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:29
EMConvert::set_vertex_z
void set_vertex_z(double)
Definition: EMConvert.cxx:513
Trk::VxCandidate::recVertex
const Trk::RecVertex & recVertex(void) const
Returns a reference to reconstructed vertex.
Definition: VxCandidate.h:132
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
EMConvert::set_vertex_Covphi2theta2
void set_vertex_Covphi2theta2(double)
Definition: EMConvert.cxx:576
EMConvert::print
void print() const
Definition: EMConvert.cxx:308
egammaParameters::refittedVertex_Covtheta2z
@ refittedVertex_Covtheta2z
Definition: egammaParamDefs.h:431
egammaParameters::refittedVertex_ndf
@ refittedVertex_ndf
Definition: egammaParamDefs.h:370
TrackParameters.h
EMConvert::set_vertex_Covd02z02
void set_vertex_Covd02z02(double)
Definition: EMConvert.cxx:567
Trk::VxTrackAtVertex
The VxTrackAtVertex is a common class for all present TrkVertexFitters The VxTrackAtVertex is designe...
Definition: VxTrackAtVertex.h:77
Trk::z
@ z
global position (cartesian)
Definition: ParamDefs.h:63
EMConvert::vertex_CovqOverP2z
double vertex_CovqOverP2z() const
Definition: EMConvert.cxx:495
EMConvert::vertex_Covtheta2z
double vertex_Covtheta2z() const
Definition: EMConvert.cxx:492
EMConvert::vertex_Covphi1y
double vertex_Covphi1y() const
Definition: EMConvert.cxx:464
EMConvert::set_linkIndex
void set_linkIndex(int)
Definition: EMConvert.cxx:591
EMConvert::convMatchDeltaPhi2
double convMatchDeltaPhi2() const
Delta phi of match between 2nd track and cluster.
Definition: EMConvert.cxx:412
EMConvert::set_vertex_CovqOverP1x
void set_vertex_CovqOverP1x(double)
Definition: EMConvert.cxx:563
egammaParameters::refittedVertex_Covz01qOverP1
@ refittedVertex_Covz01qOverP1
Definition: egammaParamDefs.h:454
EMConvert::set_vertex_Covphi2qOverP2
void set_vertex_Covphi2qOverP2(double)
Definition: EMConvert.cxx:577
EMConvert::convMatchDeltaEta2
double convMatchDeltaEta2() const
Delta eta of match between 2nd track and cluster.
Definition: EMConvert.cxx:411
EMConvert::set_vertex_Covtheta2z
void set_vertex_Covtheta2z(double)
Definition: EMConvert.cxx:586
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
egammaParameters::refittedVertex_Covz01z01
@ refittedVertex_Covz01z01
Definition: egammaParamDefs.h:451
egammaParameters::refittedVertex_Covz02theta2
@ refittedVertex_Covz02theta2
Definition: egammaParamDefs.h:462
egammaParameters::refittedVertex_Covz02z02
@ refittedVertex_Covz02z02
Definition: egammaParamDefs.h:460
EMConvert::vertex_track1_phi
double vertex_track1_phi() const
track1 global momentum (cartesian coordinates)
Definition: EMConvert.cxx:429
EMConvert::convMatchDeltaEta1
double convMatchDeltaEta1() const
Delta eta of match between track or photon and cluster.
Definition: EMConvert.cxx:409
EMConvert::vertex_Covtheta2y
double vertex_Covtheta2y() const
Definition: EMConvert.cxx:491
egammaParameters::convTrackMatch
@ convTrackMatch
from EMConvert, true if a conversion is matched to the track associated to the cluster
Definition: egammaParamDefs.h:266
EMConvert::vertex_Covphi1theta1
double vertex_Covphi1theta1() const
Definition: EMConvert.cxx:449
EMConvert::vertex_Covz01qOverP1
double vertex_Covz01qOverP1() const
Definition: EMConvert.cxx:447
EMConvert::set_parameterInt
void set_parameterInt(egammaParameters::ParamDef, int, bool overwrite=false)
Definition: EMConvert.cxx:281
EMConvert::vertex_x
double vertex_x() const
vertex position (cartesian coordinates)
Definition: EMConvert.cxx:417
egammaParameters::refittedVertex_Covd02phi2
@ refittedVertex_Covd02phi2
Definition: egammaParamDefs.h:457
EMConvert::set_vertex_Covz01theta1
void set_vertex_Covz01theta1(double)
Definition: EMConvert.cxx:540
EMConvert::vertex_Covd02z02
double vertex_Covd02z02() const
Definition: EMConvert.cxx:473
egammaParameters::refittedVertex_Covtheta1y
@ refittedVertex_Covtheta1y
Definition: egammaParamDefs.h:413
EMConvert::vertex_Covtheta2qOverP2
double vertex_Covtheta2qOverP2() const
Definition: EMConvert.cxx:485
egammaParameters::refittedVertex_Covphi1qOverP2
@ refittedVertex_Covphi1qOverP2
Definition: egammaParamDefs.h:401
EMConvert::vertex_Covphi2qOverP2
double vertex_Covphi2qOverP2() const
Definition: EMConvert.cxx:483
CSV_InDetExporter.new
new
Definition: CSV_InDetExporter.py:145
egammaParameters::refittedVertex_Covyz
@ refittedVertex_Covyz
refitted vertex covariance item (y,z)
Definition: egammaParamDefs.h:365
EMConvert::set_convMatchDeltaEta2
void set_convMatchDeltaEta2(double)
Definition: EMConvert.cxx:505
EMConvert::vertex_Covphi1phi1
double vertex_Covphi1phi1() const
Definition: EMConvert.cxx:448
EMConvert::vertex_Covz02theta2
double vertex_Covz02theta2() const
Definition: EMConvert.cxx:479
EMConvert::linkIndex
int linkIndex() const
Definition: EMConvert.cxx:497
EMConvert::hasParameter
virtual bool hasParameter(egammaParameters::ParamDef) const
Definition: EMConvert.cxx:65
egammaParameters::refittedVertex_CovqOverP2x
@ refittedVertex_CovqOverP2x
Definition: egammaParamDefs.h:432
EMConvert::set_vertex_Covtheta2theta2
void set_vertex_Covtheta2theta2(double)
Definition: EMConvert.cxx:578
EMConvert::vertex_track2_theta
double vertex_track2_theta() const
Definition: EMConvert.cxx:435
egammaParameters::refittedVertex_Covphi1qOverP1
@ refittedVertex_Covphi1qOverP1
Definition: egammaParamDefs.h:394
egammaParameters::refittedVertex_CovqOverP1qOverP1
@ refittedVertex_CovqOverP1qOverP1
Definition: egammaParamDefs.h:397
egammaParameters::refittedVertex_CovqOverP2z
@ refittedVertex_CovqOverP2z
Definition: egammaParamDefs.h:434
EMConvert::set_vertex_Covd01qOverP1
void set_vertex_Covd01qOverP1(double)
Definition: EMConvert.cxx:537
EMConvert::vertex_track1_qOverP
double vertex_track1_qOverP() const
Definition: EMConvert.cxx:431
egammaParameters::refittedVertex_Covphi1z
@ refittedVertex_Covphi1z
Definition: egammaParamDefs.h:411
EMConvert::vertex_z
double vertex_z() const
Definition: EMConvert.cxx:419
Trk::z0
@ z0
Definition: ParamDefs.h:70
egammaParameters::ParamDef
ParamDef
Definition: egammaParamDefs.h:99
EMConvert::vertex_Covd01d01
double vertex_Covd01d01() const
refitted track covariance matrix and correlations with vertex position
Definition: EMConvert.cxx:439
egammaParameters::refittedVertex_Covz01phi1
@ refittedVertex_Covz01phi1
Definition: egammaParamDefs.h:452
EMConvert::set_vertex_Covz02theta2
void set_vertex_Covz02theta2(double)
Definition: EMConvert.cxx:573
EMConvert::set_vertex_CovqOverP1qOverP1
void set_vertex_CovqOverP1qOverP1(double)
Definition: EMConvert.cxx:547
EMConvert::vertex_track2_chi2
double vertex_track2_chi2() const
track2 chi2
Definition: EMConvert.cxx:437
athena.value
value
Definition: athena.py:122
egammaParameters::refittedVertex_Covphi1x
@ refittedVertex_Covphi1x
Definition: egammaParamDefs.h:409
EMConvert::intParameter
virtual int intParameter(egammaParameters::ParamDef) const
Definition: EMConvert.cxx:204
EMConvert::vertex_Covz01z01
double vertex_Covz01z01() const
Definition: EMConvert.cxx:444
EMConvert::parameter
virtual double parameter(egammaParameters::ParamDef) const
general parameter retrieval
Definition: EMConvert.cxx:161
EMConvert::vertex_Covphi1qOverP1
double vertex_Covphi1qOverP1() const
Definition: EMConvert.cxx:450
Trk::ExtendedVxCandidate::fullCovariance
const Amg::MatrixX * fullCovariance(void) const
Full covariance matrix access method.
Definition: ExtendedVxCandidate.h:87
EMConvert::vertex_CovqOverP2x
double vertex_CovqOverP2x() const
Definition: EMConvert.cxx:493
EMConvert::set_vertex_Covtheta1qOverP1
void set_vertex_Covtheta1qOverP1(double)
Definition: EMConvert.cxx:546
egammaParameters::convMatchDeltaPhi2_refit
@ convMatchDeltaPhi2_refit
Definition: egammaParamDefs.h:644
egammaParameters::refittedVertex_CovqOverP1y
@ refittedVertex_CovqOverP1y
Definition: egammaParamDefs.h:416
EMConvert::set_vertex_Covd02d02
void set_vertex_Covd02d02(double)
Definition: EMConvert.cxx:566
EMConvert::vertex_Covd01qOverP1
double vertex_Covd01qOverP1() const
Definition: EMConvert.cxx:443
egammaParameters::refittedVertex_Covd02theta2
@ refittedVertex_Covd02theta2
Definition: egammaParamDefs.h:458
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:562
EMConvert::set_vertex_track2_theta
void set_vertex_track2_theta(double)
Definition: EMConvert.cxx:529
egammaParameters::EgParamUndefined
const double EgParamUndefined
Definition: egammaParamDefs.h:78
EMConvert::vertex_track2_phi
double vertex_track2_phi() const
track2 global momentum (cartesian coordinates)
Definition: EMConvert.cxx:434
EMConvert::set_convMatchDeltaEta1
void set_convMatchDeltaEta1(double)
Definition: EMConvert.cxx:503
egammaParameters::refittedVertex_track2_theta
@ refittedVertex_track2_theta
Definition: egammaParamDefs.h:384
EMConvert::set_vertex_track2_chi2
void set_vertex_track2_chi2(double)
Definition: EMConvert.cxx:531
EMConvert::set_convAngleMatch
void set_convAngleMatch(bool)
Definition: EMConvert.cxx:502
EMConvert::set_vertex_Covd02qOverP2
void set_vertex_Covd02qOverP2(double)
Definition: EMConvert.cxx:570
egammaParameters::convMatchDeltaEta2_refit
@ convMatchDeltaEta2_refit
Definition: egammaParamDefs.h:643
x
#define x
EMConvert::set_vertex_Covtheta1theta2
void set_vertex_Covtheta1theta2(double)
Definition: EMConvert.cxx:552
EMConvert::EMConvert
EMConvert()
Default constructor.
Definition: EMConvert.cxx:45
EMConvert::vertex_CovqOverP2y
double vertex_CovqOverP2y() const
Definition: EMConvert.cxx:494
EMConvert::vertex_Covyz
double vertex_Covyz() const
Definition: EMConvert.cxx:424
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
EMConvert::vertex_Covphi1phi2
double vertex_Covphi1phi2() const
Definition: EMConvert.cxx:454
EMConvert::convMatchDeltaEta2_refit
double convMatchDeltaEta2_refit() const
Delta eta of match between 2nd track and cluster (after refit)
Definition: EMConvert.cxx:415
EMConvert::set_vertex_CovqOverP2z
void set_vertex_CovqOverP2z(double)
Definition: EMConvert.cxx:589
egammaParameters::refittedVertex_Covphi1theta2
@ refittedVertex_Covphi1theta2
Definition: egammaParamDefs.h:400
Trk::RecVertex
Trk::RecVertex inherits from Trk::Vertex.
Definition: RecVertex.h:44
EMConvert::vertex_Covz01theta1
double vertex_Covz01theta1() const
Definition: EMConvert.cxx:446
EMConvert::vertex_chi2
double vertex_chi2() const
vertex fit quality
Definition: EMConvert.cxx:426
EMConvert::set_vertex_Covxz
void set_vertex_Covxz(double)
Definition: EMConvert.cxx:516
egammaParameters::refittedVertex_Covz01theta1
@ refittedVertex_Covz01theta1
Definition: egammaParamDefs.h:453
egammaParameters::refittedVertex_track2_chi2
@ refittedVertex_track2_chi2
refitted track chi2 after vertex fit
Definition: egammaParamDefs.h:387
EMConvert::convMatchDeltaEta1_refit
double convMatchDeltaEta1_refit() const
Delta eta of match between track or photon and cluster (after refit)
Definition: EMConvert.cxx:413
EMConvert::vertex_Covz02z02
double vertex_Covz02z02() const
Definition: EMConvert.cxx:477
EMConvert::set_vertex_Covz02qOverP2
void set_vertex_Covz02qOverP2(double)
Definition: EMConvert.cxx:574
EMConvert::set_vertex_Covzz
void set_vertex_Covzz(double)
Definition: EMConvert.cxx:519
EMConvert::set_vertex_Covd01theta1
void set_vertex_Covd01theta1(double)
Definition: EMConvert.cxx:536
EMConvert::set_vertex_chi2
void set_vertex_chi2(double)
Definition: EMConvert.cxx:520
EMConvert::m_parametersInt
std::vector< std::pair< egammaParameters::ParamDef, int > > m_parametersInt
Definition: EMConvert.h:287
EMConvert::set_vertex_Covphi2y
void set_vertex_Covphi2y(double)
Definition: EMConvert.cxx:582
EMConvert::vertex_ndf
int vertex_ndf() const
Definition: EMConvert.cxx:427
EMConvert::set_vertex_track1_phi
void set_vertex_track1_phi(double)
Definition: EMConvert.cxx:523
EMConvert::set_vertex_Covtheta2qOverP2
void set_vertex_Covtheta2qOverP2(double)
Definition: EMConvert.cxx:579
EMConvert::vertex_CovqOverP1y
double vertex_CovqOverP1y() const
Definition: EMConvert.cxx:470
egammaParameters::refittedVertex_Covtheta2x
@ refittedVertex_Covtheta2x
Definition: egammaParamDefs.h:429
EMConvert::vertex_track1_author
int vertex_track1_author() const
track1 author
Definition: EMConvert.cxx:433
EMConvert::set_convMatchDeltaPhi1_refit
void set_convMatchDeltaPhi1_refit(double)
Definition: EMConvert.cxx:508
egammaParameters::refittedVertex_track1_theta
@ refittedVertex_track1_theta
Definition: egammaParamDefs.h:375
egammaParameters::refittedVertex_Covd02qOverP2
@ refittedVertex_Covd02qOverP2
Definition: egammaParamDefs.h:459
egammaParameters::refittedVertex_Covd01phi1
@ refittedVertex_Covd01phi1
Definition: egammaParamDefs.h:448
OfflineHitType::Perigee
@ Perigee
EMConvert::vertex_CovqOverP1z
double vertex_CovqOverP1z() const
Definition: EMConvert.cxx:471
EMConvert::vertex_Covtheta1qOverP1
double vertex_Covtheta1qOverP1() const
Definition: EMConvert.cxx:452
EMConvert::set_vertex_track2_phi
void set_vertex_track2_phi(double)
Definition: EMConvert.cxx:528
EMConvert::vertex_Covz02phi2
double vertex_Covz02phi2() const
Definition: EMConvert.cxx:478
EMConvert::set_vertex_Covxy
void set_vertex_Covxy(double)
Definition: EMConvert.cxx:515
EMConvert::vertex_Covtheta1qOverP2
double vertex_Covtheta1qOverP2() const
Definition: EMConvert.cxx:459
EMConvert::set_vertex_Covd01z01
void set_vertex_Covd01z01(double)
Definition: EMConvert.cxx:534
egammaParameters::refittedVertex_Covphi1phi1
@ refittedVertex_Covphi1phi1
refitted track covariance matrix and correlations with vertex position
Definition: egammaParamDefs.h:392
Trk::RecVertex::fitQuality
const Trk::FitQuality & fitQuality() const
Fit quality access method.
Definition: RecVertex.cxx:74
Trk::VxCandidate::vxTrackAtVertex
std::vector< Trk::VxTrackAtVertex * > * vxTrackAtVertex(void)
Unconst pointer to the vector of tracks Required by some of the vertex fitters.
Definition: VxCandidate.h:144
EMConvert::vertex_Covtheta1z
double vertex_Covtheta1z() const
Definition: EMConvert.cxx:468
EMConvert::set_vertex_Covxx
void set_vertex_Covxx(double)
Definition: EMConvert.cxx:514
EMConvert::set_vertex_Covz01z01
void set_vertex_Covz01z01(double)
Definition: EMConvert.cxx:538
EMConvert::vertex_Covyy
double vertex_Covyy() const
Definition: EMConvert.cxx:423
EMConvert::set_vertex_CovqOverP1z
void set_vertex_CovqOverP1z(double)
Definition: EMConvert.cxx:565
EMConvert::set_vertex_track1_chi2
void set_vertex_track1_chi2(double)
Definition: EMConvert.cxx:526
egammaParameters::refittedVertex_CovqOverP1z
@ refittedVertex_CovqOverP1z
Definition: egammaParamDefs.h:417
egammaParameters::refittedVertex_Covxy
@ refittedVertex_Covxy
refitted vertex covariance item (x,y)
Definition: egammaParamDefs.h:359
ClassName.h
An interface for getting the name of a class as a string.
egammaParameters::refittedVertex_Covphi2x
@ refittedVertex_Covphi2x
Definition: egammaParamDefs.h:426
EMConvert::fillVxTracks
void fillVxTracks(const Trk::VxCandidate *vxCand, int trkAuthor)
Definition: EMConvert.cxx:760
lumiFormat.i
int i
Definition: lumiFormat.py:92
egammaParameters::refittedVertex_y
@ refittedVertex_y
Definition: egammaParamDefs.h:353
BaseInfo.h
Provide an interface for finding inheritance information at run time.
egammaParameters::refittedVertex_z
@ refittedVertex_z
Definition: egammaParamDefs.h:354
EMConvert::set_vertex_Covtheta2x
void set_vertex_Covtheta2x(double)
Definition: EMConvert.cxx:584
EMConvert::set_vertex_ndf
void set_vertex_ndf(int)
Definition: EMConvert.cxx:521
egammaParameters::refittedVertex_Covtheta2theta2
@ refittedVertex_Covtheta2theta2
Definition: egammaParamDefs.h:422
Trk::theta
@ theta
Definition: ParamDefs.h:72
EMConvert::set_vertex_Covphi1phi1
void set_vertex_Covphi1phi1(double)
Definition: EMConvert.cxx:542
EMConvert::vertex_CovqOverP1qOverP2
double vertex_CovqOverP1qOverP2() const
Definition: EMConvert.cxx:462
egammaParameters::refittedVertex_CovqOverP1theta2
@ refittedVertex_CovqOverP1theta2
Definition: egammaParamDefs.h:406
egammaParameters::refittedVertex_Covz02phi2
@ refittedVertex_Covz02phi2
Definition: egammaParamDefs.h:461
EMConvert::set_convMatchDeltaPhi1
void set_convMatchDeltaPhi1(double)
Definition: EMConvert.cxx:504
egammaParameters::refittedVertex_CovqOverP1qOverP2
@ refittedVertex_CovqOverP1qOverP2
Definition: egammaParamDefs.h:407
EMConvert::set_vertex_Covtheta1y
void set_vertex_Covtheta1y(double)
Definition: EMConvert.cxx:561
EMConvert::vertex_y
double vertex_y() const
Definition: EMConvert.cxx:418
egammaParameters::refittedVertex_CovqOverP2y
@ refittedVertex_CovqOverP2y
Definition: egammaParamDefs.h:433
EMConvert::AmgSymMatrix
AmgSymMatrix(3) *getVxPosErrorMatrix() const
get the vertex position error matrix from the stored egammaParameters
ClassName::name
static std::string name()
Return the name of class T as a string.
EMConvert::convMatchDeltaPhi1_refit
double convMatchDeltaPhi1_refit() const
Delta phi of match between track or photon and cluster (after refit)
Definition: EMConvert.cxx:414
egammaParameters::refittedVertex_track1_qOverP
@ refittedVertex_track1_qOverP
Definition: egammaParamDefs.h:376
egammaParameters::refittedVertex_Covtheta1theta2
@ refittedVertex_Covtheta1theta2
Definition: egammaParamDefs.h:403
egammaParameters::refittedVertex_track1_phi
@ refittedVertex_track1_phi
refitted track global momentum after vertex fit
Definition: egammaParamDefs.h:374
EMConvert::vertex_CovqOverP1x
double vertex_CovqOverP1x() const
Definition: EMConvert.cxx:469
EMConvert::set_vertex_track2_author
void set_vertex_track2_author(int)
Definition: EMConvert.cxx:532
EMConvert::set_ambiguityResult
void set_ambiguityResult(int)
Definition: EMConvert.cxx:590
egammaParameters::refittedVertex_Covz02qOverP2
@ refittedVertex_Covz02qOverP2
Definition: egammaParamDefs.h:463
EMConvert::set_vertex_y
void set_vertex_y(double)
Definition: EMConvert.cxx:512
VxTrackAtVertex.h
EMConvert::vertex_Covphi1x
double vertex_Covphi1x() const
Definition: EMConvert.cxx:463
EMConvert::set_vertex_Covphi1x
void set_vertex_Covphi1x(double)
Definition: EMConvert.cxx:557
EMConvert::set_vertex_Covphi1theta2
void set_vertex_Covphi1theta2(double)
Definition: EMConvert.cxx:549
EMConvert::set_vertex_track1_author
void set_vertex_track1_author(int)
Definition: EMConvert.cxx:527
EMConvert::hasBoolParameter
virtual bool hasBoolParameter(egammaParameters::ParamDef) const
Definition: EMConvert.cxx:49
EMConvert::set_vertex_Covd02theta2
void set_vertex_Covd02theta2(double)
Definition: EMConvert.cxx:569
egammaParameters::refittedVertex_Covxz
@ refittedVertex_Covxz
refitted vertex covariance item (x,z)
Definition: egammaParamDefs.h:361
EMConvert::set_vertex_Covphi1z
void set_vertex_Covphi1z(double)
Definition: EMConvert.cxx:559
EMConvert::set_vertex_track1_theta
void set_vertex_track1_theta(double)
Definition: EMConvert.cxx:524
EMConvert::vertex_Covphi1qOverP2
double vertex_Covphi1qOverP2() const
Definition: EMConvert.cxx:456
egammaParameters::refittedVertex_Covphi2qOverP2
@ refittedVertex_Covphi2qOverP2
Definition: egammaParamDefs.h:421
Trk::ParametersBase
Definition: ParametersBase.h:55
Trk::Vertex::position
const Amg::Vector3D & position() const
return position of vertex
Definition: Vertex.cxx:72
EMConvert::set_vertex_track1_qOverP
void set_vertex_track1_qOverP(double)
Definition: EMConvert.cxx:525
EMConvert::set_vertex_Covz02phi2
void set_vertex_Covz02phi2(double)
Definition: EMConvert.cxx:572
egammaParameters::refittedVertex_Covphi2theta2
@ refittedVertex_Covphi2theta2
Definition: egammaParamDefs.h:420
EMConvert::ambiguityResult
int ambiguityResult() const
Definition: EMConvert.cxx:496
egammaParameters::refittedVertex_Covtheta1x
@ refittedVertex_Covtheta1x
Definition: egammaParamDefs.h:412
EMConvert::vertex_Covxy
double vertex_Covxy() const
Definition: EMConvert.cxx:421
EMConvert::set_vertex_Covphi1theta1
void set_vertex_Covphi1theta1(double)
Definition: EMConvert.cxx:543
egammaParameters::refittedVertex_Covtheta2y
@ refittedVertex_Covtheta2y
Definition: egammaParamDefs.h:430
egammaParameters::refittedVertex_Covyy
@ refittedVertex_Covyy
refitted vertex covariance item (y,y)
Definition: egammaParamDefs.h:363
egammaParameters::convMatchDeltaPhi2
@ convMatchDeltaPhi2
Definition: egammaParamDefs.h:640
EMConvert::vertex_CovqOverP1theta2
double vertex_CovqOverP1theta2() const
Definition: EMConvert.cxx:461
EMConvert::vertex_Covtheta1theta1
double vertex_Covtheta1theta1() const
Definition: EMConvert.cxx:451
EMConvert::set_vertex_Covphi2z
void set_vertex_Covphi2z(double)
Definition: EMConvert.cxx:583
EMConvert::vertex_CovqOverP2qOverP2
double vertex_CovqOverP2qOverP2() const
Definition: EMConvert.cxx:486
EMConvert::set_convMatchDeltaPhi2_refit
void set_convMatchDeltaPhi2_refit(double)
Definition: EMConvert.cxx:510
VxCandidate.h
EMConvert::set_vertex_Covtheta1phi2
void set_vertex_Covtheta1phi2(double)
Definition: EMConvert.cxx:551
EMConvert::set_vertex_CovqOverP2qOverP2
void set_vertex_CovqOverP2qOverP2(double)
Definition: EMConvert.cxx:580
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
EMConvert::set_vertex_Covz01qOverP1
void set_vertex_Covz01qOverP1(double)
Definition: EMConvert.cxx:541
EMConvert::set_convMatchDeltaEta2_refit
void set_convMatchDeltaEta2_refit(double)
Definition: EMConvert.cxx:509
EMConvert::vertex_Covphi2y
double vertex_Covphi2y() const
Definition: EMConvert.cxx:488
Amg
Definition of ATLAS Math & Geometry primitives (Amg)
Definition: AmgStringHelpers.h:19
egammaParameters::refittedVertex_CovqOverP1phi2
@ refittedVertex_CovqOverP1phi2
Definition: egammaParamDefs.h:405
Trk::VxTrackAtVertex::perigeeAtVertex
const TrackParameters * perigeeAtVertex(void) const
Perigee parameters with respect to fitted vertex d_0 and z_0 are equal to 0 in case the trajectory wa...
egammaParameters::refittedVertex_Covd01d01
@ refittedVertex_Covd01d01
Definition: egammaParamDefs.h:446
egammaParameters::convMatchDeltaEta1_refit
@ convMatchDeltaEta1_refit
Definition: egammaParamDefs.h:641
EMConvert::vertex_Covtheta1y
double vertex_Covtheta1y() const
Definition: EMConvert.cxx:467
Trk::d0
@ d0
Definition: ParamDefs.h:69
egammaParameters::convMatchDeltaEta1
@ convMatchDeltaEta1
Definition: egammaParamDefs.h:637
EMConvert::vertex_CovqOverP1qOverP1
double vertex_CovqOverP1qOverP1() const
Definition: EMConvert.cxx:453
EMConvert::boolParameter
virtual bool boolParameter(egammaParameters::ParamDef) const
Definition: EMConvert.cxx:188
egammaParameters::convMatchDeltaPhi1
@ convMatchDeltaPhi1
Definition: egammaParamDefs.h:638
EMConvert::set_vertex_Covphi2phi2
void set_vertex_Covphi2phi2(double)
Definition: EMConvert.cxx:575
egammaParameters::convMatchDeltaPhi1_refit
@ convMatchDeltaPhi1_refit
Definition: egammaParamDefs.h:642
EMConvert::fillVxDetails
void fillVxDetails(const Trk::VxCandidate *vxCand, int trkAuthor)
Definition: EMConvert.cxx:687
EMConvert::vertex_CovqOverP1phi2
double vertex_CovqOverP1phi2() const
Definition: EMConvert.cxx:460
EMConvert::vertex_Covtheta2x
double vertex_Covtheta2x() const
Definition: EMConvert.cxx:490
EMConvert::set_convMatchDeltaPhi2
void set_convMatchDeltaPhi2(double)
Definition: EMConvert.cxx:506
egammaParameters::ambiguityResult
@ ambiguityResult
ambiguity resolultion result, electron/photon
Definition: egammaParamDefs.h:708
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
egammaParameters::refittedVertex_Covphi2phi2
@ refittedVertex_Covphi2phi2
Definition: egammaParamDefs.h:419
EMConvert::set_convMatchDeltaEta1_refit
void set_convMatchDeltaEta1_refit(double)
Definition: EMConvert.cxx:507
egammaParameters::refittedVertex_track2_qOverP
@ refittedVertex_track2_qOverP
Definition: egammaParamDefs.h:385
egammaParameters::refittedVertex_Covd02z02
@ refittedVertex_Covd02z02
Definition: egammaParamDefs.h:456
EMConvert::vertex_Covphi2theta2
double vertex_Covphi2theta2() const
Definition: EMConvert.cxx:482
egammaParameters::refittedVertex_numTracks
@ refittedVertex_numTracks
Definition: egammaParamDefs.h:371
EMConvert::set_vertex_Covz01phi1
void set_vertex_Covz01phi1(double)
Definition: EMConvert.cxx:539
EMConvert::vertex_Covxx
double vertex_Covxx() const
vertex position covariance matrix (cartesian coordinates)
Definition: EMConvert.cxx:420
egammaParameters::refittedVertex_Covtheta1z
@ refittedVertex_Covtheta1z
Definition: egammaParamDefs.h:414
EMConvert::set_vertex_Covtheta1z
void set_vertex_Covtheta1z(double)
Definition: EMConvert.cxx:562
EMConvert::vertex_Covphi2z
double vertex_Covphi2z() const
Definition: EMConvert.cxx:489
EMConvert::vertex_Covd02theta2
double vertex_Covd02theta2() const
Definition: EMConvert.cxx:475
EMConvert::getVxCandidate
Trk::VxCandidate * getVxCandidate() const
get the VxCandidate from the stored egammaParameters
EMConvert::set_vertex_numTracks
void set_vertex_numTracks(int)
Definition: EMConvert.cxx:522
EMConvert::m_parametersBool
std::vector< std::pair< egammaParameters::ParamDef, bool > > m_parametersBool
Definition: EMConvert.h:286
calibdata.delete
list delete
Definition: calibdata.py:46
EMConvert::vertex_Covz01phi1
double vertex_Covz01phi1() const
Definition: EMConvert.cxx:445
EMConvert::set_vertex_Covtheta2y
void set_vertex_Covtheta2y(double)
Definition: EMConvert.cxx:585
egammaParameters::refittedVertex_Covd01theta1
@ refittedVertex_Covd01theta1
Definition: egammaParamDefs.h:449
EMConvert::set_vertex_Covtheta1x
void set_vertex_Covtheta1x(double)
Definition: EMConvert.cxx:560
egammaParameters::refittedVertex_Covxx
@ refittedVertex_Covxx
refitted vertex covariance matrix entries (cartesian coordinates)
Definition: egammaParamDefs.h:357
EMConvert::vertex_Covphi2phi2
double vertex_Covphi2phi2() const
Definition: EMConvert.cxx:481
EMConvert::vertex_Covd02d02
double vertex_Covd02d02() const
Definition: EMConvert.cxx:472
EMConvert::convMatchDeltaPhi1
double convMatchDeltaPhi1() const
Delta phi of match between track or photon and cluster.
Definition: EMConvert.cxx:410
EMConvert::set_parameterBool
void set_parameterBool(egammaParameters::ParamDef, bool, bool overwrite=false)
Definition: EMConvert.cxx:257
EMConvert::vertex_numTracks
int vertex_numTracks() const
Definition: EMConvert.cxx:428
EMConvert::vertex_Covd02phi2
double vertex_Covd02phi2() const
Definition: EMConvert.cxx:474
EMConvert::vertex_Covd02qOverP2
double vertex_Covd02qOverP2() const
Definition: EMConvert.cxx:476
Trk::VxCandidate
Definition: VxCandidate.h:27
EMConvert::set_vertex_Covyy
void set_vertex_Covyy(double)
Definition: EMConvert.cxx:517
EMConvert::vertex_Covd01z01
double vertex_Covd01z01() const
Definition: EMConvert.cxx:440
ExtendedVxCandidate.h
EMConvert::set_vertex_Covphi1qOverP2
void set_vertex_Covphi1qOverP2(double)
Definition: EMConvert.cxx:550
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
EMConvert::vertex_Covd01theta1
double vertex_Covd01theta1() const
Definition: EMConvert.cxx:442
egammaParameters::refittedVertex_Covtheta1qOverP2
@ refittedVertex_Covtheta1qOverP2
Definition: egammaParamDefs.h:404
EMConvert::vertex_Covphi1theta2
double vertex_Covphi1theta2() const
Definition: EMConvert.cxx:455
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:569
EMConvert::vertex_Covxz
double vertex_Covxz() const
Definition: EMConvert.cxx:422
EMConvert::set_vertex_CovqOverP1y
void set_vertex_CovqOverP1y(double)
Definition: EMConvert.cxx:564
EMConvert::set_vertex_CovqOverP1qOverP2
void set_vertex_CovqOverP1qOverP2(double)
Definition: EMConvert.cxx:556
EMConvert::set_vertex_Covphi2x
void set_vertex_Covphi2x(double)
Definition: EMConvert.cxx:581
egammaParameters::refittedVertex_Covd02d02
@ refittedVertex_Covd02d02
Definition: egammaParamDefs.h:455
EMConvert::set_vertex_x
void set_vertex_x(double)
Definition: EMConvert.cxx:511
EMConvert::fillDummy
void fillDummy()
fill the details with dummy values (so we can avoid uninitialized values when the conversion refit is...
Definition: EMConvert.cxx:594
EMConvert::convAngleMatch
bool convAngleMatch() const
conversion angle matches egamma angle
Definition: EMConvert.cxx:408
EMConvert::set_vertex_Covz02z02
void set_vertex_Covz02z02(double)
Definition: EMConvert.cxx:571
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
egammaParameters::refittedVertex_CovqOverP1x
@ refittedVertex_CovqOverP1x
Definition: egammaParamDefs.h:415
EMConvert::getVxErrorMatrix
Amg::MatrixX * getVxErrorMatrix() const
get the full vertex error matrix from the stored egammaParameters
EMConvert::set_vertex_CovqOverP1phi2
void set_vertex_CovqOverP1phi2(double)
Definition: EMConvert.cxx:554
EMConvert::fillVertex
void fillVertex(const Trk::VxCandidate *vxCand)
fill the vertex variables from a Trk::VxCandidate *\/
Definition: EMConvert.cxx:697
Trk::phi
@ phi
Definition: ParamDefs.h:81
EMConvert::vertex_Covtheta1x
double vertex_Covtheta1x() const
Definition: EMConvert.cxx:466
egammaParameters::refittedVertex_Covphi2y
@ refittedVertex_Covphi2y
Definition: egammaParamDefs.h:427
Trk::FitQuality::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
fillSymmetric
void fillSymmetric(size_t i, size_t j, Scalar value)
method to fill symmetrically elments
Definition: AmgMatrixBasePlugin.h:121
EMConvert::convMatchDeltaPhi2_refit
double convMatchDeltaPhi2_refit() const
Delta phi of match between 2nd track and cluster (after refit)
Definition: EMConvert.cxx:416
egammaParameters::refittedVertex_CovqOverP2qOverP2
@ refittedVertex_CovqOverP2qOverP2
Definition: egammaParamDefs.h:424
egammaParameters::linkIndex
@ linkIndex
link index for multiple track and vertex matches
Definition: egammaParamDefs.h:574
EMConvert::set_vertex_CovqOverP1theta2
void set_vertex_CovqOverP1theta2(double)
Definition: EMConvert.cxx:555
EMConvert::vertex_track2_author
int vertex_track2_author() const
track2 author
Definition: EMConvert.cxx:438
egammaParameters::refittedVertex_Covtheta2qOverP2
@ refittedVertex_Covtheta2qOverP2
Definition: egammaParamDefs.h:423
Trk::x
@ x
Definition: ParamDefs.h:61
egDetail
Definition: egDetail.h:29
EMConvert::className
virtual const std::string & className() const
Definition: EMConvert.cxx:155
egammaParameters::refittedVertex_Covtheta1phi2
@ refittedVertex_Covtheta1phi2
Definition: egammaParamDefs.h:402
egammaParameters::refittedVertex_Covd01z01
@ refittedVertex_Covd01z01
Definition: egammaParamDefs.h:447
EMConvert::vertex_Covz02qOverP2
double vertex_Covz02qOverP2() const
Definition: EMConvert.cxx:480
EMConvert::vertex_Covtheta1theta2
double vertex_Covtheta1theta2() const
Definition: EMConvert.cxx:458
egammaParameters::refittedVertex_Covtheta1theta1
@ refittedVertex_Covtheta1theta1
Definition: egammaParamDefs.h:395
EMConvert::hasIntParameter
virtual bool hasIntParameter(egammaParameters::ParamDef) const
Definition: EMConvert.cxx:55
EMConvert::vertex_track1_chi2
double vertex_track1_chi2() const
track1 chi2
Definition: EMConvert.cxx:432
EMConvert::set_vertex_Covtheta1theta1
void set_vertex_Covtheta1theta1(double)
Definition: EMConvert.cxx:545
EMConvert::set_convTrackMatch
void set_convTrackMatch(bool)
Definition: EMConvert.cxx:501
EMConvert::vertex_track1_theta
double vertex_track1_theta() const
Definition: EMConvert.cxx:430
egammaParameters::refittedVertex_Covphi2z
@ refittedVertex_Covphi2z
Definition: egammaParamDefs.h:428
EMConvert.h
EMConvert::set_vertex_Covd01phi1
void set_vertex_Covd01phi1(double)
Definition: EMConvert.cxx:535
EMConvert::vertex_Covphi1z
double vertex_Covphi1z() const
Definition: EMConvert.cxx:465
EMConvert::set_vertex_Covd02phi2
void set_vertex_Covd02phi2(double)
Definition: EMConvert.cxx:568
EMConvert::set_parameter
void set_parameter(egammaParameters::ParamDef, double, bool overwrite=false)
general parameter setting
Definition: EMConvert.cxx:222
egammaParameters::refittedVertex_x
@ refittedVertex_x
refitted vertex position (cartesian coordinates)
Definition: egammaParamDefs.h:352
egammaParameters::refittedVertex_Covphi1theta1
@ refittedVertex_Covphi1theta1
Definition: egammaParamDefs.h:393
EMConvert::m_parameters
std::vector< std::pair< egammaParameters::ParamDef, double > > m_parameters
Definition: EMConvert.h:288
egammaParameters::refittedVertex_Covtheta1qOverP1
@ refittedVertex_Covtheta1qOverP1
Definition: egammaParamDefs.h:396
EMConvert::set_vertex_Covphi1qOverP1
void set_vertex_Covphi1qOverP1(double)
Definition: EMConvert.cxx:544
EMConvert::vertex_Covtheta1phi2
double vertex_Covtheta1phi2() const
Definition: EMConvert.cxx:457
EMConvert::set_vertex_track2_qOverP
void set_vertex_track2_qOverP(double)
Definition: EMConvert.cxx:530
Trk::ExtendedVxCandidate
Definition: ExtendedVxCandidate.h:33
egammaParameters::refittedVertex_track1_author
@ refittedVertex_track1_author
refitted track author
Definition: egammaParamDefs.h:380
egammaParameters::refittedVertex_track1_chi2
@ refittedVertex_track1_chi2
refitted track chi2 after vertex fit
Definition: egammaParamDefs.h:378
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
EMConvert::vertex_Covzz
double vertex_Covzz() const
Definition: EMConvert.cxx:425
egammaParameters::convMatchDeltaEta2
@ convMatchDeltaEta2
Definition: egammaParamDefs.h:639
Generated on Tue Jul 2 2024 21:15:02 for ATLAS Offline Software by   doxygen 1.8.18