Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
JetFitterInitializationHelper.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /***************************************************************************
6  JetFitterInitializationHelper.h - Description
7  -------------------
8 
9  begin : Februar 2007
10  authors: Giacinto Piacquadio (University of Freiburg),
11  Christian Weiser (University of Freiburg)
12  email : nicola.giacinto.piacquadio@cern.ch,
13  christian.weiser@cern.ch
14 
15  changes: * January 2008: added method for initializing on vector<ITrackLink>
16 
17  2007 (c) Atlas Detector Software
18 
19  Look at the header file for more information.
20 
21  ***************************************************************************/
22 
23 #include "TrkJetVxFitter/JetFitterInitializationHelper.h"
24 #include "VxVertex/RecVertex.h"
25 #include "VxJetVertex/VxJetCandidate.h"
26 #include "VxVertex/VxTrackAtVertex.h"
27 #include "VxJetVertex/VxVertexOnJetAxis.h"
28 #include "VxJetVertex/RecVertexPositions.h"
29 #include "VxJetVertex/JetVtxParamDefs.h"
30 #include "TrkVertexFitterInterfaces/IVertexLinearizedTrackFactory.h"
31 #include "TrkTrack/Track.h"
32 #include "CxxUtils/sincos.h"
33 //#include "TrkVertexFitterUtils/FullLinearizedTrackFactory.h"
34 
35 namespace Trk
36 {
37 
38  namespace {
39  int numRow(int numVertex) {
40  return numVertex+5;
41  }
42 
43  Amg::Vector3D getSingleVtxPositionWithSignFlip(const Amg::VectorX & myPosition,
44  int numVertex,
45  bool signFlipTreatment) {
46 
47  int numbRow=numRow(numVertex);
48  double xv=myPosition[Trk::jet_xv];
49  double yv=myPosition[Trk::jet_yv];
50  double zv=myPosition[Trk::jet_zv];
51  double phi=myPosition[Trk::jet_phi];
52  double theta=myPosition[Trk::jet_theta];
53  double dist=0.;
54  CxxUtils::sincos sc_theta (theta);
55  CxxUtils::sincos sc_phi (phi);
56  if (numbRow>=0) {
57  dist=myPosition[numbRow];
58  if (fabs(dist)*sc_theta.sn>300.) {//MAX 30cm
59  dist=dist/fabs(dist)*300./sc_theta.sn;
60  }
61  if (dist<0) {
62  if (signFlipTreatment) {
63  dist=-dist;
64  } else {
65  dist=0.;
66  }
67  }
68  }
69  return Amg::Vector3D(xv+dist*sc_phi.cs*sc_theta.sn,
70  yv+dist*sc_phi.sn*sc_theta.sn,
71  zv+dist*sc_theta.cs);
72  }
73 
74  }//end anonymous namespace
75 
76  JetFitterInitializationHelper::JetFitterInitializationHelper(const std::string& t, const std::string& n, const IInterface* p) :
77  AthAlgTool(t,n,p),
78  m_linearizedFactory("Trk::FullLinearizedTrackFactory", this),
79  m_errphiJetAxis(0.07),
80  m_erretaJetAxis(0.065)
81  {
82  declareProperty("errphiJetAxis",m_errphiJetAxis);
83  declareProperty("erretaJetAxis",m_erretaJetAxis);
84  declareProperty("LinearizedTrackFactory",m_linearizedFactory);
85  declareInterface< JetFitterInitializationHelper >(this) ;
86 
87  }
88 
89 
90 
91 
92 
93  JetFitterInitializationHelper::~JetFitterInitializationHelper() = default;
94 
95 
96  StatusCode JetFitterInitializationHelper::initialize() {
97 
98  StatusCode sc=m_linearizedFactory.retrieve();
99  if(sc.isFailure()) {
100  ATH_MSG_ERROR( " Unable to retrieve "<<m_linearizedFactory );
101  return StatusCode::FAILURE;
102  }
103 
104 
105  return StatusCode::SUCCESS;
106 
107  }
108 
109 
116  VxJetCandidate * JetFitterInitializationHelper::initializeJetCandidate(const std::vector<const Trk::ITrackLink*> & vectorOfLink,
117  const RecVertex* primaryVertex,
118  const Amg::Vector3D* jetdirection,
119  const Amg::Vector3D* linearizationjetdirection) const
120  {
121 
122  ATH_MSG_VERBOSE (" Entered initializeJetCandidate() ");
123 
124  VxJetCandidate* myJetCandidate=new VxJetCandidate();
125 
126  std::vector<Trk::VxVertexOnJetAxis*> setOfVertices=myJetCandidate->getVerticesOnJetAxis();
127  std::vector<Trk::VxTrackAtVertex*>* setOfTracks=myJetCandidate->vxTrackAtVertex();
128 
129  std::vector<const Trk::ITrackLink*>::const_iterator vectorOfLinkBegin=vectorOfLink.begin();
130  std::vector<const Trk::ITrackLink*>::const_iterator vectorOfLinkEnd=vectorOfLink.end();
131 
132  for (std::vector<const Trk::ITrackLink*>::const_iterator vectorOfLinkIter=vectorOfLinkBegin;
133  vectorOfLinkIter!=vectorOfLinkEnd;++vectorOfLinkIter)
134  {
135  std::vector<Trk::VxTrackAtVertex*> temp_vector_tracksAtVertex;
136  Trk::VxTrackAtVertex* newVxTrack=new Trk::VxTrackAtVertex((*vectorOfLinkIter)->clone());
137  temp_vector_tracksAtVertex.push_back(newVxTrack);
138  setOfTracks->push_back(newVxTrack);
139  setOfVertices.push_back(new Trk::VxVertexOnJetAxis(temp_vector_tracksAtVertex));
140  }
141  myJetCandidate->setVerticesOnJetAxis(setOfVertices);
142  return initializeJetClusters(myJetCandidate,primaryVertex,jetdirection,linearizationjetdirection);
143 
144  }
145 
146 
147 
148 
149  VxJetCandidate * JetFitterInitializationHelper::initializeJetCandidate(const std::vector<const Trk::TrackParticleBase*> & vectorOfTP,
150  const RecVertex* primaryVertex,
151  const Amg::Vector3D* jetdirection,
152  const Amg::Vector3D* linearizationjetdirection) const {
153 
154 
155  //creates VxJetCandidate. Constructor takes care of adding VxTrackAtVertex
156  //and creating one VxVertexOnJetAxis for each added track
157 
158  VxJetCandidate* myJetCandidate=new VxJetCandidate(vectorOfTP);
159 
160 
161  return initializeJetClusters(myJetCandidate,primaryVertex,jetdirection,linearizationjetdirection);
162 
163  }
164 
165  VxJetCandidate * JetFitterInitializationHelper::initializeJetCandidate(const std::vector<const Trk::Track*> & vectorOfT,
166  const RecVertex* primaryVertex,
167  const Amg::Vector3D* jetdirection,
168  const Amg::Vector3D* linearizationjetdirection) const {
169 
170 
171  //creates VxJetCandidate. Constructor takes care of adding VxTrackAtVertex
172  //and creating one VxVertexOnJetAxis for each added track
173 
174  VxJetCandidate* myJetCandidate=new VxJetCandidate(vectorOfT);
175 
176  return initializeJetClusters(myJetCandidate,primaryVertex,jetdirection,linearizationjetdirection);
177 
178  }
179 
180  VxJetCandidate * JetFitterInitializationHelper::initializeJetClusters(VxJetCandidate* myJetCandidate,
181  const RecVertex* primaryVertex,
182  const Amg::Vector3D* jetdirection,
183  const Amg::Vector3D* linearizationjetdirection) const {
184 
185  //now create a new m_fittedPositions for the VxJetCandidate
186  //start from position...
187 
188  if (primaryVertex==nullptr) {
189  std::cout << "ERROR. No valid primary vertex pointer provided to the JetFitterInitializationHelper." << std::endl;
190  throw std::runtime_error ("No valid primary vertex pointer provided to the JetFitterInitializationHelper.");
191  }
192  AmgVector(5) startPosition;
193  startPosition[Trk::jet_xv]=primaryVertex->position().x();
194  startPosition[Trk::jet_yv]=primaryVertex->position().y();
195  startPosition[Trk::jet_zv]=primaryVertex->position().z();
196 
197  if (jetdirection!=nullptr) {
198  startPosition[Trk::jet_theta]=jetdirection->theta();
199  startPosition[Trk::jet_phi]=jetdirection->phi();
200  } else {
201  std::cout << "JetFitterInitializationHelper: Error! no starting jet direction provided. Using (0,0)" << std::endl;
202  startPosition[Trk::jet_theta]=0;
203  startPosition[Trk::jet_phi]=0;
204  }
205 
206  //override default setting...
207  std::pair<double,double> phiAndThetaError(m_errphiJetAxis,m_erretaJetAxis);
208 
209  /*
210  if (jetdirection!=0)
211  {
212 
213  //override default setting...
214  phiAndThetaError=getPhiAndThetaError(*jetdirection);
215 
216  std::cout << " Using phi error: " << phiAndThetaError.first << " and eta error: " << phiAndThetaError.second << " for pt: " << jetdirection->perp() <<
217  " and eta: " << jetdirection->pseudoRapidity() << std::endl;
218 
219  }
220  */
221 
222  AmgSymMatrix(3) primaryCovariance(primaryVertex->covariancePosition().block<3,3>(0,0));
223  AmgSymMatrix(5) startCovariance; startCovariance.setZero();
224  startCovariance.block<3,3>(0,0) = primaryCovariance;
225  startCovariance(Trk::jet_theta,Trk::jet_theta) =
226  std::pow(phiAndThetaError.second*sin(startPosition(Trk::jet_theta)),2);
227  startCovariance(Trk::jet_phi,Trk::jet_phi) = std::pow(phiAndThetaError.first,2);
228 
229  RecVertexPositions startRecVertexPositions(startPosition,
230  startCovariance,
231  0.,0.);
232 
233  //initialize the RecVertexPositions object of the VxJetCandidate
234  myJetCandidate->setRecVertexPositions(startRecVertexPositions);
235  myJetCandidate->setConstraintVertexPositions(startRecVertexPositions);
236 
237  VertexPositions linVertexPositions;
238  if (linearizationjetdirection!=nullptr) {
239  Amg::VectorX linPosition=startPosition;
240  linPosition[Trk::jet_theta]=linearizationjetdirection->theta();
241  linPosition[Trk::jet_phi]=linearizationjetdirection->phi();
242  linVertexPositions=VertexPositions(linPosition);
243  } else {
244  linVertexPositions=startRecVertexPositions;
245  }
246 
247  myJetCandidate->setLinearizationVertexPositions(linVertexPositions);
248  //initialize the linearizationPosition exactly to the same object or
249  //to something custom if requested by an additional argument
250 
251  updateTrackNumbering(myJetCandidate);
252 
253  const VxVertexOnJetAxis* primaryVertexJC(myJetCandidate->getPrimaryVertex());
254 
255  if (primaryVertexJC==nullptr) {
256 
257  // VxVertexOnJetAxis* newPrimaryVertex=new VxVertexOnJetAxis();
258  VxVertexOnJetAxis newPrimaryVertex;
259  //set numVertex of primaryVertex to -10
260  newPrimaryVertex.setNumVertex(-10);
261  // newPrimaryVertex->setLinearizationPosition(0.);//should be the same as default, but...
262  myJetCandidate->setPrimaryVertex(&newPrimaryVertex);
263 
264  } else {
265 
266  ATH_MSG_WARNING ("Primary Vertex was already initialized. Check...");
267 
268  }
269  return myJetCandidate;
270  }
271 
272 
273  void JetFitterInitializationHelper::updateTrackNumbering(VxJetCandidate* myJetCandidate) {
274 
275  const std::vector<VxVertexOnJetAxis*> & associatedVertices=myJetCandidate->getVerticesOnJetAxis();
276 
277  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=associatedVertices.begin();
278  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=associatedVertices.end();
279 
280  int numTrack(0);//start from 0 in counting the vertex "clusters"
281  //Horrible but a map is not suited here
282 
283  if (!associatedVertices.empty()) {//Was that your intention? to be checked... 15.03.2007
284  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;++VtxIter) {
285  VxVertexOnJetAxis* myVertex=(*VtxIter);
286  if (myVertex!=nullptr) {
287  myVertex->setNumVertex(numTrack);
288  numTrack+=1;
289  } else {
290  std::cout << "Warning in JetFitterInitializationHelper.Inconsistency found. Pointer to VxVertexOnJetAxis should be different from zero. Skipping track..." << std::endl;
291  throw std::runtime_error ("Warning in JetFitterInitializationHelper.Inconsistency found. Pointer to VxVertexOnJetAxis should be different from zero. Skipping track...");
292  }
293  }
294 
295  int sizeOfRecVertex=myJetCandidate->getRecVertexPositions().position().rows();
296 
297  //if the size of the RecVertexPositions is not big enough, enlarge it...
298  if (numRow(numTrack)>sizeOfRecVertex) {
299 
300  //Added 2. October 2014 !! (BUG...)
301  myJetCandidate->setRecVertexPositions(myJetCandidate->getConstraintVertexPositions());
302 
303  Amg::VectorX myPosition = myJetCandidate->getRecVertexPositions().position();
304  Amg::MatrixX myCovariance = myJetCandidate->getRecVertexPositions().covariancePosition();
305  Amg::VectorX newPosition(numRow(numTrack)); newPosition.setZero();
306  newPosition.segment(0,myPosition.rows()) = myPosition;
307  Amg::MatrixX newCovariance(numRow(numTrack),numRow(numTrack));
308  newCovariance.setZero();
309  newCovariance.block(0,0,myCovariance.rows(),myCovariance.cols()) = myCovariance;
310  for (int i=sizeOfRecVertex;i<numRow(numTrack);++i) {
311  newCovariance(i,i)=500.*500.;
312  }
313 
314  RecVertexPositions newRecVertexPositions(newPosition,
315  newCovariance,
316  myJetCandidate->getRecVertexPositions().fitQuality().chiSquared(),
317  myJetCandidate->getRecVertexPositions().fitQuality().numberDoF());
318 
319 
320  Amg::VectorX myPositionLinearization = myJetCandidate->getLinearizationVertexPositions().position();
321  Amg::VectorX newPositionLinearization(numRow(numTrack));
322  newPositionLinearization.setZero();
323  newPositionLinearization.segment(0,myPositionLinearization.rows()) = myPositionLinearization;
324 
325  myJetCandidate->setRecVertexPositions(newRecVertexPositions);//needed here?
326  myJetCandidate->setConstraintVertexPositions(newRecVertexPositions);
327  myJetCandidate->setLinearizationVertexPositions(newPositionLinearization);
328 
329  } else if (numRow(numTrack)<sizeOfRecVertex) {
330  std::cout << "Strange: size of RecVertexPosition's position in JetFitterInitializationHelper is bigger than actual numTracks plus 5. CHECK..." << std::endl;
331  throw std::runtime_error ("Strange: size of RecVertexPosition's position in JetFitterInitializationHelper is bigger than actual numTracks plus 5. CHECK...");
332  }
333 
334  }
335  //succesfully initialized ordering (+ enlarging of RecVertexPositions if needed)
336  }
337 
338  void JetFitterInitializationHelper::linearizeAllTracks(VxJetCandidate* myJetCandidate,
339  bool signFlipTreatment,
340  double maxdistance) const {
341 
342  const VertexPositions & myLinVertexPosition=myJetCandidate->getLinearizationVertexPositions();
343  const Amg::VectorX & myPosition=myLinVertexPosition.position();
344 
345  const VxVertexOnJetAxis* myPrimary=myJetCandidate->getPrimaryVertex();
346  const std::vector<VxTrackAtVertex*> & primaryVectorTracks=myPrimary->getTracksAtVertex();
347 
348  Amg::Vector3D primary3Pos = myPosition.segment(0,3);
349  const Amg::Vector3D& primaryVertexPos(primary3Pos);
350 
351  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksBegin=primaryVectorTracks.begin();
352  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksEnd=primaryVectorTracks.end();
353 
354  for (std::vector<VxTrackAtVertex*>::const_iterator primaryVectorIter=primaryVectorTracksBegin;
355  primaryVectorIter!=primaryVectorTracksEnd;++primaryVectorIter) {
356 
357 // std::cout << " New track to linearize at PV" << primaryVertexPos << std::endl;
358 
359  const Trk::LinearizedTrack* linTrack=(*primaryVectorIter)->linState();
360 
361  if (linTrack!=nullptr) {
362  // std::cout << "distance is: " << (linTrack->linearizationPoint()-primary3Pos).mag() << std::endl;
363  if ((linTrack->linearizationPoint()-primary3Pos).mag()>maxdistance) {
364  // std::cout << " redoing linearization" << std::endl;
365  m_linearizedFactory->linearize(**primaryVectorIter,primaryVertexPos);
366  }
367  } else {
368  // std::cout << " linearizing for the first time " << std::endl;
369  m_linearizedFactory->linearize(**primaryVectorIter,primaryVertexPos);
370  }
371 
372 
373  }
374 
375  const std::vector<VxVertexOnJetAxis*> & associatedVertices=myJetCandidate->getVerticesOnJetAxis();
376 
377  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=associatedVertices.begin();
378  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=associatedVertices.end();
379 
380  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;++VtxIter) {
381 
382  int numVertex=(*VtxIter)->getNumVertex();
383  Amg::Vector3D secondaryVertexPos(getSingleVtxPositionWithSignFlip(myPosition,numVertex,signFlipTreatment));
384 
385 // std::cout << " Considering linearization at n. vertex " << numVertex << " pos " << secondaryVertexPos << std::endl;
386 
387  const std::vector<VxTrackAtVertex*> & tracksAtVertex=(*VtxIter)->getTracksAtVertex();
388 
389  const std::vector<VxTrackAtVertex*>::const_iterator TracksBegin=tracksAtVertex.begin();
390  const std::vector<VxTrackAtVertex*>::const_iterator TracksEnd=tracksAtVertex.end();
391 
392  for (std::vector<VxTrackAtVertex*>::const_iterator TrackVectorIter=TracksBegin;
393  TrackVectorIter!=TracksEnd;++TrackVectorIter) {
394 
395  const Trk::LinearizedTrack* linTrack=(*TrackVectorIter)->linState();
396 
397  if (linTrack!=nullptr) {
398  // std::cout << "distance not primary is: " << (linTrack->linearizationPoint()-secondaryVertexPos.position()).mag() << std::endl;
399  if ((linTrack->linearizationPoint()-secondaryVertexPos).mag()>maxdistance) {
400  // std::cout << " redoing linearization" << std::endl;
401  m_linearizedFactory->linearize(**TrackVectorIter,secondaryVertexPos);
402  }
403  } else {
404  // std::cout << " linearizing for the first time " << std::endl;
405  m_linearizedFactory->linearize(**TrackVectorIter,secondaryVertexPos);
406  }
407 
408 
409 
410  }
411 
412  }
413 
414  }//end linearizeAllTracks
415 
416 }//end namespace
RecVertex.h
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
Trk::VxJetCandidate::getVerticesOnJetAxis
const std::vector< VxVertexOnJetAxis * > & getVerticesOnJetAxis(void) const
Definition: VxJetCandidate.cxx:543
Amg::VectorX
Eigen::Matrix< double, Eigen::Dynamic, 1 > VectorX
Dynamic Vector - dynamic allocation.
Definition: EventPrimitives.h:30
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
Trk::VxTrackAtVertex
The VxTrackAtVertex is a common class for all present TrkVertexFitters The VxTrackAtVertex is designe...
Definition: VxTrackAtVertex.h:77
Trk::jet_theta
@ jet_theta
Definition: JetVtxParamDefs.h:28
Trk::JetFitterInitializationHelper::JetFitterInitializationHelper
JetFitterInitializationHelper(const std::string &t, const std::string &n, const IInterface *p)
Constructor.
Definition: JetFitterInitializationHelper.cxx:92
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JetVtxParamDefs.h
VxVertexOnJetAxis.h
VxJetCandidate.h
sincos.h
Helper to simultaneously calculate sin and cos of the same angle.
Trk::JetFitterInitializationHelper::m_linearizedFactory
ToolHandle< IVertexLinearizedTrackFactory > m_linearizedFactory
Definition: JetFitterInitializationHelper.h:138
Trk::VxVertexOnJetAxis
VxVertexOnJetAxis inherits from Vertex.
Definition: VxVertexOnJetAxis.h:79
Trk::jet_xv
@ jet_xv
Definition: JetVtxParamDefs.h:27
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::JetFitterInitializationHelper::~JetFitterInitializationHelper
~JetFitterInitializationHelper()
Destructor.
Trk::JetFitterInitializationHelper::linearizeAllTracks
void linearizeAllTracks(VxJetCandidate *, bool signfliptreatment=false, double maxdistance=1.) const
Calls the linearization of all the tracks (adds the Linearized Track data member to every VxTrackAtVe...
Definition: JetFitterInitializationHelper.cxx:354
Trk::RecVertex
Trk::RecVertex inherits from Trk::Vertex.
Definition: RecVertex.h:44
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Trk::JetFitterInitializationHelper::initializeJetClusters
VxJetCandidate * initializeJetClusters(VxJetCandidate *myJetCandidate, const RecVertex *primaryVertex, const Amg::Vector3D *jetdirection=0, const Amg::Vector3D *linearizationjetdirection=0) const
Internal method to initialized a VxJetCandidate.
Definition: JetFitterInitializationHelper.cxx:196
Trk::JetFitterInitializationHelper::updateTrackNumbering
static void updateTrackNumbering(VxJetCandidate *)
Does the update of the ordering of the vertices along the jetaxis.
Definition: JetFitterInitializationHelper.cxx:289
Track.h
JetFitterInitializationHelper.h
Trk::AmgSymMatrix
AmgSymMatrix(5) &GXFTrackState
Definition: GXFTrackState.h:156
Trk::VxJetCandidate::getPrimaryVertex
const VxVertexOnJetAxis * getPrimaryVertex(void) const
Definition: VxJetCandidate.cxx:551
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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
Trk::JetFitterInitializationHelper::m_errphiJetAxis
float m_errphiJetAxis
Error on phi on the flight direction you want to initialize the fit with (set errphiJetAxis by JobOpt...
Definition: JetFitterInitializationHelper.h:148
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:731
Trk::theta
@ theta
Definition: ParamDefs.h:66
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
AmgVector
AmgVector(4) T2BSTrackFilterTool
Definition: T2BSTrackFilterTool.cxx:114
Trk::jet_yv
@ jet_yv
Definition: JetVtxParamDefs.h:27
VxTrackAtVertex.h
Trk::JetFitterInitializationHelper::initializeJetCandidate
VxJetCandidate * initializeJetCandidate(const std::vector< const Trk::ITrackLink * > &vectorOfLink, const RecVertex *primaryVertex, const Amg::Vector3D *jetdirection=0, const Amg::Vector3D *linearizationjetdirection=0) const
Initialize the JetCandidate using a vector of Trk::ITrackLink* - needed for example if you run on ESD...
Definition: JetFitterInitializationHelper.cxx:132
Trk::Vertex::position
const Amg::Vector3D & position() const
return position of vertex
Definition: Vertex.cxx:72
Trk::VxJetCandidate::setPrimaryVertex
void setPrimaryVertex(const VxVertexOnJetAxis *)
Definition: VxJetCandidate.cxx:559
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
Trk::jet_zv
@ jet_zv
position x,y,z of primary vertex
Definition: JetVtxParamDefs.h:27
Trk::VxJetCandidate
Definition: VxJetCandidate.h:72
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::VxJetCandidate::setLinearizationVertexPositions
void setLinearizationVertexPositions(const Trk::VertexPositions &)
Definition: VxJetCandidate.cxx:539
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DeMoScan.first
bool first
Definition: DeMoScan.py:536
IVertexLinearizedTrackFactory.h
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
CxxUtils::sincos
Helper to simultaneously calculate sin and cos of the same angle.
Definition: sincos.h:39
Trk::JetFitterInitializationHelper::initialize
virtual StatusCode initialize() override
Definition: JetFitterInitializationHelper.cxx:112
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
Trk::phi
@ phi
Definition: ParamDefs.h:75
Trk::VxJetCandidate::setVerticesOnJetAxis
void setVerticesOnJetAxis(const std::vector< VxVertexOnJetAxis * > &)
Definition: VxJetCandidate.cxx:547
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
AthAlgTool
Definition: AthAlgTool.h:26
Trk::LinearizedTrack::linearizationPoint
const Amg::Vector3D & linearizationPoint() const
An access to an actual linearization point.
Definition: LinearizedTrack.h:154
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
Trk::JetFitterInitializationHelper::m_erretaJetAxis
float m_erretaJetAxis
Error on eta on the flight direction you want to initialize the fit with (set erretaJetAxis by JobOpt...
Definition: JetFitterInitializationHelper.h:158
RecVertexPositions.h
Trk::LinearizedTrack
Definition: LinearizedTrack.h:43
Generated on Fri Apr 25 2025 21:12:51 for ATLAS Offline Software by   doxygen 1.8.18