ATLAS Offline Software
JetFitterInitializationHelper.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /***************************************************************************
6  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 "TrkVertexFitterUtils/FullLinearizedTrackFactory.h"
33 
34 namespace Trk
35 {
36 
37  namespace {
38  int numRow(int numVertex) {
39  return numVertex+5;
40  }
41 
42  Amg::Vector3D getSingleVtxPositionWithSignFlip(const Amg::VectorX & myPosition,
43  int numVertex,
44  bool signFlipTreatment) {
45 
46  int numbRow=numRow(numVertex);
47  double xv=myPosition[Trk::jet_xv];
48  double yv=myPosition[Trk::jet_yv];
49  double zv=myPosition[Trk::jet_zv];
50  double phi=myPosition[Trk::jet_phi];
51  double theta=myPosition[Trk::jet_theta];
52  double dist=0.;
53  if (numbRow>=0) {
54  dist=myPosition[numbRow];
55  if (fabs(dist)*sin(theta)>300.) {//MAX 30cm
56  dist=dist/fabs(dist)*300./sin(theta);
57  }
58  if (dist<0) {
59  if (signFlipTreatment) {
60  dist=-dist;
61  } else {
62  dist=0.;
63  }
64  }
65  }
66  return Amg::Vector3D(xv+dist*cos(phi)*sin(theta),
67  yv+dist*sin(phi)*sin(theta),
68  zv+dist*cos(theta));
69  }
70 
71  }//end anonymous namespace
72 
73  JetFitterInitializationHelper::JetFitterInitializationHelper(const std::string& t, const std::string& n, const IInterface* p) :
74  AthAlgTool(t,n,p),
75  m_linearizedFactory("Trk::FullLinearizedTrackFactory", this),
76  m_errphiJetAxis(0.07),
77  m_erretaJetAxis(0.065)
78  {
79  declareProperty("errphiJetAxis",m_errphiJetAxis);
80  declareProperty("erretaJetAxis",m_erretaJetAxis);
81  declareProperty("LinearizedTrackFactory",m_linearizedFactory);
82  declareInterface< JetFitterInitializationHelper >(this) ;
83 
84  }
85 
86 
87 
88 
89 
90  JetFitterInitializationHelper::~JetFitterInitializationHelper() = default;
91 
92 
93  StatusCode JetFitterInitializationHelper::initialize() {
94 
95  StatusCode sc=m_linearizedFactory.retrieve();
96  if(sc.isFailure()) {
97  ATH_MSG_ERROR( " Unable to retrieve "<<m_linearizedFactory );
98  return StatusCode::FAILURE;
99  }
100 
101 
102  return StatusCode::SUCCESS;
103 
104  }
105 
106 
113  VxJetCandidate * JetFitterInitializationHelper::initializeJetCandidate(const std::vector<const Trk::ITrackLink*> & vectorOfLink,
114  const RecVertex* primaryVertex,
115  const Amg::Vector3D* jetdirection,
116  const Amg::Vector3D* linearizationjetdirection) const
117  {
118 
119  ATH_MSG_VERBOSE (" Entered initializeJetCandidate() ");
120 
121  VxJetCandidate* myJetCandidate=new VxJetCandidate();
122 
123  std::vector<Trk::VxVertexOnJetAxis*> setOfVertices=myJetCandidate->getVerticesOnJetAxis();
124  std::vector<Trk::VxTrackAtVertex*>* setOfTracks=myJetCandidate->vxTrackAtVertex();
125 
126  std::vector<const Trk::ITrackLink*>::const_iterator vectorOfLinkBegin=vectorOfLink.begin();
127  std::vector<const Trk::ITrackLink*>::const_iterator vectorOfLinkEnd=vectorOfLink.end();
128 
129  for (std::vector<const Trk::ITrackLink*>::const_iterator vectorOfLinkIter=vectorOfLinkBegin;
130  vectorOfLinkIter!=vectorOfLinkEnd;++vectorOfLinkIter)
131  {
132  std::vector<Trk::VxTrackAtVertex*> temp_vector_tracksAtVertex;
133  Trk::VxTrackAtVertex* newVxTrack=new Trk::VxTrackAtVertex((*vectorOfLinkIter)->clone());
134  temp_vector_tracksAtVertex.push_back(newVxTrack);
135  setOfTracks->push_back(newVxTrack);
136  setOfVertices.push_back(new Trk::VxVertexOnJetAxis(temp_vector_tracksAtVertex));
137  }
138  myJetCandidate->setVerticesOnJetAxis(setOfVertices);
139  return initializeJetClusters(myJetCandidate,primaryVertex,jetdirection,linearizationjetdirection);
140 
141  }
142 
143 
144 
145 
146  VxJetCandidate * JetFitterInitializationHelper::initializeJetCandidate(const std::vector<const Trk::TrackParticleBase*> & vectorOfTP,
147  const RecVertex* primaryVertex,
148  const Amg::Vector3D* jetdirection,
149  const Amg::Vector3D* linearizationjetdirection) const {
150 
151 
152  //creates VxJetCandidate. Constructor takes care of adding VxTrackAtVertex
153  //and creating one VxVertexOnJetAxis for each added track
154 
155  VxJetCandidate* myJetCandidate=new VxJetCandidate(vectorOfTP);
156 
157 
158  return initializeJetClusters(myJetCandidate,primaryVertex,jetdirection,linearizationjetdirection);
159 
160  }
161 
162  VxJetCandidate * JetFitterInitializationHelper::initializeJetCandidate(const std::vector<const Trk::Track*> & vectorOfT,
163  const RecVertex* primaryVertex,
164  const Amg::Vector3D* jetdirection,
165  const Amg::Vector3D* linearizationjetdirection) const {
166 
167 
168  //creates VxJetCandidate. Constructor takes care of adding VxTrackAtVertex
169  //and creating one VxVertexOnJetAxis for each added track
170 
171  VxJetCandidate* myJetCandidate=new VxJetCandidate(vectorOfT);
172 
173  return initializeJetClusters(myJetCandidate,primaryVertex,jetdirection,linearizationjetdirection);
174 
175  }
176 
177  VxJetCandidate * JetFitterInitializationHelper::initializeJetClusters(VxJetCandidate* myJetCandidate,
178  const RecVertex* primaryVertex,
179  const Amg::Vector3D* jetdirection,
180  const Amg::Vector3D* linearizationjetdirection) const {
181 
182  //now create a new m_fittedPositions for the VxJetCandidate
183  //start from position...
184 
185  if (primaryVertex==nullptr) {
186  std::cout << "ERROR. No valid primary vertex pointer provided to the JetFitterInitializationHelper." << std::endl;
187  throw std::runtime_error ("No valid primary vertex pointer provided to the JetFitterInitializationHelper.");
188  }
189  AmgVector(5) startPosition;
190  startPosition[Trk::jet_xv]=primaryVertex->position().x();
191  startPosition[Trk::jet_yv]=primaryVertex->position().y();
192  startPosition[Trk::jet_zv]=primaryVertex->position().z();
193 
194  if (jetdirection!=nullptr) {
195  startPosition[Trk::jet_theta]=jetdirection->theta();
196  startPosition[Trk::jet_phi]=jetdirection->phi();
197  } else {
198  std::cout << "JetFitterInitializationHelper: Error! no starting jet direction provided. Using (0,0)" << std::endl;
199  startPosition[Trk::jet_theta]=0;
200  startPosition[Trk::jet_phi]=0;
201  }
202 
203  //override default setting...
204  std::pair<double,double> phiAndThetaError(m_errphiJetAxis,m_erretaJetAxis);
205 
206  /*
207  if (jetdirection!=0)
208  {
209 
210  //override default setting...
211  phiAndThetaError=getPhiAndThetaError(*jetdirection);
212 
213  std::cout << " Using phi error: " << phiAndThetaError.first << " and eta error: " << phiAndThetaError.second << " for pt: " << jetdirection->perp() <<
214  " and eta: " << jetdirection->pseudoRapidity() << std::endl;
215 
216  }
217  */
218 
219  AmgSymMatrix(3) primaryCovariance(primaryVertex->covariancePosition().block<3,3>(0,0));
220  AmgSymMatrix(5) startCovariance; startCovariance.setZero();
221  startCovariance.block<3,3>(0,0) = primaryCovariance;
222  startCovariance(Trk::jet_theta,Trk::jet_theta) =
223  std::pow(phiAndThetaError.second*sin(startPosition(Trk::jet_theta)),2);
224  startCovariance(Trk::jet_phi,Trk::jet_phi) = std::pow(phiAndThetaError.first,2);
225 
226  RecVertexPositions startRecVertexPositions(startPosition,
227  startCovariance,
228  0.,0.);
229 
230  //initialize the RecVertexPositions object of the VxJetCandidate
231  myJetCandidate->setRecVertexPositions(startRecVertexPositions);
232  myJetCandidate->setConstraintVertexPositions(startRecVertexPositions);
233 
234  VertexPositions linVertexPositions;
235  if (linearizationjetdirection!=nullptr) {
236  Amg::VectorX linPosition=startPosition;
237  linPosition[Trk::jet_theta]=linearizationjetdirection->theta();
238  linPosition[Trk::jet_phi]=linearizationjetdirection->phi();
239  linVertexPositions=VertexPositions(linPosition);
240  } else {
241  linVertexPositions=startRecVertexPositions;
242  }
243 
244  myJetCandidate->setLinearizationVertexPositions(linVertexPositions);
245  //initialize the linearizationPosition exactly to the same object or
246  //to something custom if requested by an additional argument
247 
248  updateTrackNumbering(myJetCandidate);
249 
250  const VxVertexOnJetAxis* primaryVertexJC(myJetCandidate->getPrimaryVertex());
251 
252  if (primaryVertexJC==nullptr) {
253 
254  // VxVertexOnJetAxis* newPrimaryVertex=new VxVertexOnJetAxis();
255  VxVertexOnJetAxis newPrimaryVertex;
256  //set numVertex of primaryVertex to -10
257  newPrimaryVertex.setNumVertex(-10);
258  // newPrimaryVertex->setLinearizationPosition(0.);//should be the same as default, but...
259  myJetCandidate->setPrimaryVertex(&newPrimaryVertex);
260 
261  } else {
262 
263  ATH_MSG_WARNING ("Primary Vertex was already initialized. Check...");
264 
265  }
266  return myJetCandidate;
267  }
268 
269 
270  void JetFitterInitializationHelper::updateTrackNumbering(VxJetCandidate* myJetCandidate) {
271 
272  const std::vector<VxVertexOnJetAxis*> & associatedVertices=myJetCandidate->getVerticesOnJetAxis();
273 
274  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=associatedVertices.begin();
275  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=associatedVertices.end();
276 
277  int numTrack(0);//start from 0 in counting the vertex "clusters"
278  //Horrible but a map is not suited here
279 
280  if (!associatedVertices.empty()) {//Was that your intention? to be checked... 15.03.2007
281  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;++VtxIter) {
282  VxVertexOnJetAxis* myVertex=(*VtxIter);
283  if (myVertex!=nullptr) {
284  myVertex->setNumVertex(numTrack);
285  numTrack+=1;
286  } else {
287  std::cout << "Warning in JetFitterInitializationHelper.Inconsistency found. Pointer to VxVertexOnJetAxis should be different from zero. Skipping track..." << std::endl;
288  throw std::runtime_error ("Warning in JetFitterInitializationHelper.Inconsistency found. Pointer to VxVertexOnJetAxis should be different from zero. Skipping track...");
289  }
290  }
291 
292  int sizeOfRecVertex=myJetCandidate->getRecVertexPositions().position().rows();
293 
294  //if the size of the RecVertexPositions is not big enough, enlarge it...
295  if (numRow(numTrack)>sizeOfRecVertex) {
296 
297  //Added 2. October 2014 !! (BUG...)
298  myJetCandidate->setRecVertexPositions(myJetCandidate->getConstraintVertexPositions());
299 
300  Amg::VectorX myPosition = myJetCandidate->getRecVertexPositions().position();
301  Amg::MatrixX myCovariance = myJetCandidate->getRecVertexPositions().covariancePosition();
302  Amg::VectorX newPosition(numRow(numTrack)); newPosition.setZero();
303  newPosition.segment(0,myPosition.rows()) = myPosition;
304  Amg::MatrixX newCovariance(numRow(numTrack),numRow(numTrack));
305  newCovariance.setZero();
306  newCovariance.block(0,0,myCovariance.rows(),myCovariance.cols()) = myCovariance;
307  for (int i=sizeOfRecVertex;i<numRow(numTrack);++i) {
308  newCovariance(i,i)=500.*500.;
309  }
310 
311  RecVertexPositions newRecVertexPositions(newPosition,
312  newCovariance,
313  myJetCandidate->getRecVertexPositions().fitQuality().chiSquared(),
314  myJetCandidate->getRecVertexPositions().fitQuality().numberDoF());
315 
316 
317  Amg::VectorX myPositionLinearization = myJetCandidate->getLinearizationVertexPositions().position();
318  Amg::VectorX newPositionLinearization(numRow(numTrack));
319  newPositionLinearization.setZero();
320  newPositionLinearization.segment(0,myPositionLinearization.rows()) = myPositionLinearization;
321 
322  myJetCandidate->setRecVertexPositions(newRecVertexPositions);//needed here?
323  myJetCandidate->setConstraintVertexPositions(newRecVertexPositions);
324  myJetCandidate->setLinearizationVertexPositions(newPositionLinearization);
325 
326  } else if (numRow(numTrack)<sizeOfRecVertex) {
327  std::cout << "Strange: size of RecVertexPosition's position in JetFitterInitializationHelper is bigger than actual numTracks plus 5. CHECK..." << std::endl;
328  throw std::runtime_error ("Strange: size of RecVertexPosition's position in JetFitterInitializationHelper is bigger than actual numTracks plus 5. CHECK...");
329  }
330 
331  }
332  //succesfully initialized ordering (+ enlarging of RecVertexPositions if needed)
333  }
334 
335  void JetFitterInitializationHelper::linearizeAllTracks(VxJetCandidate* myJetCandidate,
336  bool signFlipTreatment,
337  double maxdistance) const {
338 
339  const VertexPositions & myLinVertexPosition=myJetCandidate->getLinearizationVertexPositions();
340  const Amg::VectorX & myPosition=myLinVertexPosition.position();
341 
342  const VxVertexOnJetAxis* myPrimary=myJetCandidate->getPrimaryVertex();
343  const std::vector<VxTrackAtVertex*> & primaryVectorTracks=myPrimary->getTracksAtVertex();
344 
345  Amg::Vector3D primary3Pos = myPosition.segment(0,3);
346  const Amg::Vector3D& primaryVertexPos(primary3Pos);
347 
348  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksBegin=primaryVectorTracks.begin();
349  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksEnd=primaryVectorTracks.end();
350 
351  for (std::vector<VxTrackAtVertex*>::const_iterator primaryVectorIter=primaryVectorTracksBegin;
352  primaryVectorIter!=primaryVectorTracksEnd;++primaryVectorIter) {
353 
354 // std::cout << " New track to linearize at PV" << primaryVertexPos << std::endl;
355 
356  const Trk::LinearizedTrack* linTrack=(*primaryVectorIter)->linState();
357 
358  if (linTrack!=nullptr) {
359  // std::cout << "distance is: " << (linTrack->linearizationPoint()-primary3Pos).mag() << std::endl;
360  if ((linTrack->linearizationPoint()-primary3Pos).mag()>maxdistance) {
361  // std::cout << " redoing linearization" << std::endl;
362  m_linearizedFactory->linearize(**primaryVectorIter,primaryVertexPos);
363  }
364  } else {
365  // std::cout << " linearizing for the first time " << std::endl;
366  m_linearizedFactory->linearize(**primaryVectorIter,primaryVertexPos);
367  }
368 
369 
370  }
371 
372  const std::vector<VxVertexOnJetAxis*> & associatedVertices=myJetCandidate->getVerticesOnJetAxis();
373 
374  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=associatedVertices.begin();
375  const std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=associatedVertices.end();
376 
377  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;++VtxIter) {
378 
379  int numVertex=(*VtxIter)->getNumVertex();
380  Amg::Vector3D secondaryVertexPos(getSingleVtxPositionWithSignFlip(myPosition,numVertex,signFlipTreatment));
381 
382 // std::cout << " Considering linearization at n. vertex " << numVertex << " pos " << secondaryVertexPos << std::endl;
383 
384  const std::vector<VxTrackAtVertex*> & tracksAtVertex=(*VtxIter)->getTracksAtVertex();
385 
386  const std::vector<VxTrackAtVertex*>::const_iterator TracksBegin=tracksAtVertex.begin();
387  const std::vector<VxTrackAtVertex*>::const_iterator TracksEnd=tracksAtVertex.end();
388 
389  for (std::vector<VxTrackAtVertex*>::const_iterator TrackVectorIter=TracksBegin;
390  TrackVectorIter!=TracksEnd;++TrackVectorIter) {
391 
392  const Trk::LinearizedTrack* linTrack=(*TrackVectorIter)->linState();
393 
394  if (linTrack!=nullptr) {
395  // std::cout << "distance not primary is: " << (linTrack->linearizationPoint()-secondaryVertexPos.position()).mag() << std::endl;
396  if ((linTrack->linearizationPoint()-secondaryVertexPos).mag()>maxdistance) {
397  // std::cout << " redoing linearization" << std::endl;
398  m_linearizedFactory->linearize(**TrackVectorIter,secondaryVertexPos);
399  }
400  } else {
401  // std::cout << " linearizing for the first time " << std::endl;
402  m_linearizedFactory->linearize(**TrackVectorIter,secondaryVertexPos);
403  }
404 
405 
406 
407  }
408 
409  }
410 
411  }//end linearizeAllTracks
412 
413 }//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:89
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JetVtxParamDefs.h
VxVertexOnJetAxis.h
VxJetCandidate.h
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
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
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:351
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:193
Trk::JetFitterInitializationHelper::updateTrackNumbering
static void updateTrackNumbering(VxJetCandidate *)
Does the update of the ordering of the vertices along the jetaxis.
Definition: JetFitterInitializationHelper.cxx:286
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:129
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
Trk::JetFitterInitializationHelper::initialize
virtual StatusCode initialize() override
Definition: JetFitterInitializationHelper.cxx:109
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 Mon Dec 23 2024 21:12:34 for ATLAS Offline Software by   doxygen 1.8.18