ATLAS Offline Software
TrigL2Vertex.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include <cstring>
6 #include "TrigInDetEvent/TrigL2Vertex.h"
7 #include "TrkParameters/TrackParameters.h"
8 
9 TrigVertexFitInputTrack::TrigVertexFitInputTrack(const TrigInDetTrack* pT, double mass=0.0) : m_mass(mass)
10 {
11  m_nTrackType=1;m_active=true;
12  m_pTrigTrack=pT;m_pTrkTrack=NULL;
13  double Ck[5][5];
14  int i{0},j{0};
15 
16  const TrigInDetTrackFitPar* p=pT->param();
17 
18  double a=-2.0*exp(-p->eta())/(1.0+exp(-2.0*p->eta()));
19  m_u[0]=p->a0();
20  m_u[1]=p->z0();
21  m_q[0]=p->phi0();
22  m_q[1]=2.0*atan(exp(-p->eta()));
23  m_q[2]=p->pT()/1000.0;
24 
25 
26  Ck[0][0]=(*p->cov())[0];Ck[0][1]=Ck[1][0]=(*p->cov())[2];
27  Ck[0][2]=Ck[2][0]=(*p->cov())[1];Ck[0][3]=Ck[3][0]=(*p->cov())[3];
28  Ck[0][4]=Ck[4][0]=(*p->cov())[4];Ck[1][1]=(*p->cov())[9];
29  Ck[1][2]=Ck[2][1]=(*p->cov())[6];Ck[1][3]=Ck[3][1]=(*p->cov())[10];
30  Ck[1][4]=Ck[4][1]=(*p->cov())[11];Ck[2][2]=(*p->cov())[5];
31  Ck[2][3]=Ck[3][2]=(*p->cov())[7];Ck[2][4]=Ck[4][2]=(*p->cov())[8];
32  Ck[3][3]=(*p->cov())[12];Ck[3][4]=Ck[4][3]=(*p->cov())[13];
33  Ck[4][4]=(*p->cov())[14];
34  for(i=0;i<5;i++)
35  {
36  Ck[3][i]=a*Ck[3][i];Ck[i][3]=Ck[3][i];
37  }
38  Ck[3][3]*=a;
39  for(i=0;i<5;i++)
40  {
41  Ck[4][i]=Ck[4][i]/1000.0;Ck[i][4]=Ck[4][i];
42  }
43  Ck[4][4]/=1000.0;
44 
45 
46  for(i=0;i<2;i++) for(j=0;j<2;j++) m_Vuu[i][j]=Ck[i][j];
47  for(i=0;i<2;i++) for(j=0;j<3;j++) m_Vuq[i][j]=Ck[i][j+2];
48  for(i=0;i<3;i++) for(j=0;j<3;j++) m_Vqq[i][j]=Ck[i+2][j+2];
49 
50  /*
51  m_Vuu[0][0]=(*p->cov())[0];
52  m_Vuu[0][1]=m_Vuu[1][0]=(*p->cov())[2];
53  m_Vuu[1][1]=(*p->cov())[9];
54 
55  m_Vuq[0][0]=(*p->cov())[1];m_Vuq[0][1]=(*p->cov())[3]*a;
56  m_Vuq[0][2]=(*p->cov())[4]*1e-3;m_Vuq[1][0]=(*p->cov())[6];m_Vuq[1][1]=(*p->cov())[10]*a;
57  m_Vuq[1][2]=(*p->cov())[11]*1e-3;
58 
59  m_Vqq[0][0]=(*p->cov())[5];m_Vqq[0][1]=m_Vqq[1][0]=(*p->cov())[7]*a;
60  m_Vqq[0][2]=m_Vqq[2][0]=(*p->cov())[8]*1e-3;
61  m_Vqq[1][1]=(*p->cov())[12]*a*a;m_Vqq[1][2]=m_Vqq[2][1]=(*p->cov())[13]*a*1e-3;
62  m_Vqq[2][2]=(*p->cov())[14]*1e-6;
63  */
64  m_Perigee[0]=m_u[0];m_Perigee[1]=m_u[1];m_Perigee[2]=m_q[0];m_Perigee[3]=m_q[1];m_Perigee[4]=m_q[2];
65 }
66 
67 TrigVertexFitInputTrack::TrigVertexFitInputTrack(const Trk::Track* pT,double mass=0.0) : m_mass(mass)
68 {
69  double Ck[5][5];
70 
71  m_nTrackType=2;m_active=true;
72  m_pTrkTrack=pT;m_pTrigTrack=NULL;
73 
74  const Trk::Perigee* pP= pT->perigeeParameters();
75 
76  m_u[0]=pP->parameters()[Trk::d0];
77  m_u[1]=pP->parameters()[Trk::z0];
78  m_q[0]=pP->parameters()[Trk::phi0];
79  m_q[1]=pP->parameters()[Trk::theta];
80 
81  double ptC=1000.0*pP->parameters()[Trk::qOverP];
82 
83  m_q[2]=sin(pP->parameters()[Trk::theta])/ptC;
84 
85  if( pP->covariance() ){
86  // has covariance matrix
87  const AmgSymMatrix(5)* TC = pP->covariance();
88 
89  Ck[0][0]=(*TC)(Trk::d0,Trk::d0);
90  Ck[0][1]=Ck[1][0]=(*TC)(Trk::d0,Trk::z0);
91  Ck[0][2]=Ck[2][0]=(*TC)(Trk::d0,Trk::phi0);
92  Ck[0][3]=Ck[3][0]=(*TC)(Trk::d0,Trk::theta);
93  Ck[0][4]=Ck[4][0]=(*TC)(Trk::d0,Trk::qOverP);
94  Ck[1][1]=(*TC)(Trk::z0,Trk::z0);
95  Ck[1][2]=Ck[2][1]=(*TC)(Trk::z0,Trk::phi0);
96  Ck[1][3]=Ck[3][1]=(*TC)(Trk::z0,Trk::theta);
97  Ck[1][4]=Ck[4][1]=(*TC)(Trk::z0,Trk::qOverP);
98  Ck[2][2]=(*TC)(Trk::phi0,Trk::phi0);
99  Ck[2][3]=Ck[3][2]=(*TC)(Trk::phi0,Trk::theta);
100  Ck[2][4]=Ck[4][2]=(*TC)(Trk::phi0,Trk::qOverP);
101  Ck[3][3]=(*TC)(Trk::theta,Trk::theta);
102  Ck[3][4]=Ck[4][3]=(*TC)(Trk::theta,Trk::qOverP);
103  Ck[4][4]=(*TC)(Trk::qOverP,Trk::qOverP);
104 
105  const double a = cos(pP->parameters()[Trk::theta])/ptC;
106  const double b = -sin(pP->parameters()[Trk::theta])/(pP->parameters()[Trk::qOverP]*ptC);
107 
108  Ck[3][3]=Ck[3][3]+2.0*a*Ck[3][4]+a*a*Ck[4][4];
109  Ck[3][4]=Ck[4][3]=b*Ck[3][4]+a*b*Ck[4][4];
110  Ck[4][4]=b*b*Ck[4][4];
111  Ck[0][3]=Ck[3][0]=Ck[0][3]+a*Ck[0][4];Ck[0][4]*=b;Ck[4][0]=Ck[0][4];
112  Ck[1][3]=Ck[3][1]=Ck[1][3]+a*Ck[1][4];Ck[1][4]*=b;Ck[4][1]=Ck[1][4];
113  Ck[2][3]=Ck[3][2]=Ck[2][3]+a*Ck[2][4];Ck[2][4]*=b;Ck[4][2]=Ck[2][4];
114  for(int i=0;i<2;i++) for(int j=0;j<2;j++) m_Vuu[i][j]=Ck[i][j];
115  for(int i=0;i<3;i++) for(int j=0;j<3;j++) m_Vqq[i][j]=Ck[i+2][j+2];
116  for(int i=0;i<2;i++) for(int j=0;j<3;j++) m_Vuq[i][j]=Ck[i][j+2];
117 
118  m_Perigee[0]=m_u[0];m_Perigee[1]=m_u[1];m_Perigee[2]=m_q[0];m_Perigee[3]=m_q[1];m_Perigee[4]=m_q[2];
119  }
120  else{
121  m_active=false;
122  // no covariance
123  }
124 
125 }
126 
127 TrigVertexFitInputTrack::~TrigVertexFitInputTrack()
128 {
129 
130 }
131 
132 void TrigVertexFitInputTrack::setMass(double m)
133 {
134  m_mass=m;
135 }
136 
137 void TrigVertexFitInputTrack::mask()
138 {
139  m_active=false;
140 }
141 
142 void TrigVertexFitInputTrack::activate()
143 {
144  m_active=true;
145 }
146 
147 bool TrigVertexFitInputTrack::isActive()
148 {
149  return m_active;
150 }
151 
152 int TrigVertexFitInputTrack::getTrackType()
153 {
154  return m_nTrackType;
155 }
156 
157 
158 const TrigInDetTrack* TrigVertexFitInputTrack::getTrigTrack()
159 {
160  return m_pTrigTrack;
161 }
162 
163 const Trk::Track* TrigVertexFitInputTrack::getTrkTrack()
164 {
165  return m_pTrkTrack;
166 }
167 
168 void TrigVertexFitInputTrack::setIndex(int i)
169 {
170  m_index=i;
171 }
172 
173 int TrigVertexFitInputTrack::getIndex() const
174 {
175  return m_index;
176 }
177 
178 const double* TrigVertexFitInputTrack::Perigee() const
179 {
180  return &m_Perigee[0];
181 }
182 
183 double TrigVertexFitInputTrack::PerigeeCovariance(int i, int j) const
184 {
185  return m_PerigeeCovariance[i][j];
186 }
187 
188 void TrigVertexFitInputTrack::initializeVertex(class TrigL2Vertex* pV)
189 {
190  const int i = 3+m_index*3;
191  for(int j=0;j<3;j++)
192  pV->getParametersVector()[i+j]=m_q[j];
193 }
194 
195 double TrigVertexFitInputTrack::getChi2Distance(class TrigL2Vertex* pV)
196 {
197  const double C=0.02997;
198  const double B=20.84;
199  const double alpha=C*B/1000.0;
200 
201  double Sk[2][2],detr,chi2;
202  double AC[2][3],BV[2][3];
203  int i{0},j{0},k{0};
204 
205  const int shift=m_index*3;
206 
207  k=3+shift;
208  for(i=0;i<3;i++)
209  for(j=0;j<3;j++)
210  pV->m_Gk[i+k][j+k]=m_Vqq[i][j];
211 
212  initializeVertex(pV);
213  const double xv=pV->getParametersVector()[0];
214  const double yv=pV->getParametersVector()[1];
215  const double zv=pV->getParametersVector()[2];
216  const double phi0=pV->getParametersVector()[3+shift];
217  const double theta0=pV->getParametersVector()[4+shift];
218  const double P0=pV->getParametersVector()[5+shift];
219 
220  const double cosPhi0=cos(phi0);
221  const double sinPhi0=sin(phi0);
222  const double sinPsi=-alpha*(xv*cosPhi0+yv*sinPhi0)/P0;
223  if(fabs(sinPsi)>1.0) return -999.9;
224  const double cosPsi=sqrt(1.0-sinPsi*sinPsi);
225  const double psi=asin(sinPsi);
226  const double sint=sin(theta0);
227  const double ctt=cos(theta0)/sint;
228 
229  m_A[0][0]=-sin(phi0+psi)/cosPsi;
230  m_A[0][1]= cos(phi0+psi)/cosPsi;
231  m_A[0][2]=0.0;
232 
233  m_A[1][0]=-ctt*cosPhi0/cosPsi;
234  m_A[1][1]=-ctt*sinPhi0/cosPsi;
235  m_A[1][2]=1.0;
236 
237  m_B[0][0]=-xv*m_A[0][1]+yv*m_A[0][0];
238  m_B[0][1]=0.0;
239  m_B[0][2]=(1.0-1.0/cosPsi)/alpha;
240 
241  m_B[1][0]=-xv*m_A[1][1]+yv*m_A[1][0];
242  m_B[1][1]=-P0*psi/(alpha*sint*sint);
243  m_B[1][2]=ctt*(psi-sinPsi/cosPsi)/alpha;
244 
245  m_h[0]=yv*cosPhi0-xv*sinPhi0+P0*(1-cosPsi)/alpha;
246  m_h[1]=zv+P0*ctt*psi/alpha;
247 
248  m_resid[0]=m_u[0]-m_h[0];
249  m_resid[1]=m_u[1]-m_h[1];
250 
251  for(i=0;i<2;i++) for(j=0;j<2;j++) Sk[i][j]=m_Vuu[i][j];
252  for(i=0;i<2;i++) for(j=0;j<3;j++)
253  {
254  AC[i][j]=0.0;
255  for(k=0;k<3;k++) AC[i][j]+=m_A[i][k]*pV->m_Gk[k][j];
256  }
257  for(i=0;i<2;i++) for(j=0;j<2;j++)
258  {
259  for(k=0;k<3;k++) Sk[i][j]+=AC[i][k]*m_A[j][k];
260  }
261  for(i=0;i<2;i++)
262  for(j=0;j<3;j++)
263  {
264  BV[i][j]=0.0;
265  for(k=0;k<3;k++) BV[i][j]+=m_B[i][k]*m_Vqq[k][j];
266  }
267  for(i=0;i<2;i++)
268  for(j=0;j<2;j++)
269  {
270  for(k=0;k<3;k++) Sk[i][j]+=BV[i][k]*m_B[j][k];
271  }
272  Sk[0][0]-=2.0*(m_Vuq[0][0]*m_B[0][0]+m_Vuq[0][1]*m_B[0][1]+m_Vuq[0][2]*m_B[0][2]);
273  Sk[1][1]-=2.0*(m_Vuq[1][0]*m_B[1][0]+m_Vuq[1][1]*m_B[1][1]+m_Vuq[1][2]*m_B[1][2]);
274  Sk[0][1]-=m_Vuq[1][0]*m_B[0][0]+m_Vuq[1][1]*m_B[0][1]+m_Vuq[1][2]*m_B[0][2]+
275  m_Vuq[0][0]*m_B[1][0]+m_Vuq[0][1]*m_B[1][1]+m_Vuq[0][2]*m_B[1][2];
276  Sk[1][0]=Sk[0][1];
277 
278  detr=1.0/(Sk[0][0]*Sk[1][1]-Sk[0][1]*Sk[1][0]);
279  m_V[0][0]=Sk[1][1]*detr;
280  m_V[1][1]=Sk[0][0]*detr;
281  m_V[0][1]=m_V[1][0]=-Sk[0][1]*detr;
282 
283  chi2=m_V[0][0]*m_resid[0]*m_resid[0]+m_V[1][1]*m_resid[1]*m_resid[1]+
284  2.0*m_V[0][1]*m_resid[1]*m_resid[0];
285 
286  for(i=0;i<2;i++)
287  {
288  for(j=0;j<3;j++) m_D[i][j]=AC[i][j];
289  for(j=3;j<3+shift;j++)
290  {
291  m_D[i][j]=0.0;
292  for(k=0;k<3;k++)
293  m_D[i][j]+=m_A[i][k]*pV->m_Gk[k][j];
294  }
295  for(j=0;j<3;j++) m_D[i][j+3+shift]=BV[i][j]-m_Vuq[i][j];
296  }
297 
298  return chi2;
299 }
300 
301 
302 void TrigVertexFitInputTrack::updateVertex(class TrigL2Vertex* pV)
303 {
304  int i{0},j{0},k{0};
305  const int nSize=6+3*m_index;
306 
307  double K[2][MAX_SIZE_VERT_COVM];
308 
309  for(i=0;i<2;i++)
310  {
311  for(j=0;j<nSize;j++)
312  {
313  K[i][j]=0.0;
314  for(k=0;k<2;k++) K[i][j]+=m_D[k][j]*m_V[k][i];
315  }
316  }
317  for(i=0;i<nSize;i++)
318  {
319  pV->getParametersVector()[i]+=K[0][i]*m_resid[0]+K[1][i]*m_resid[1];
320  for(j=i;j<nSize;j++)
321  {
322  pV->m_Gk[i][j]-=K[0][i]*m_D[0][j]+K[1][i]*m_D[1][j];
323  pV->m_Gk[j][i]=pV->m_Gk[i][j];
324  }
325  }
326 }
327 
328 MsgStream& TrigVertexFitInputTrack::report( MsgStream& out ) const
329 {
330  out<<"Track "<<m_index<<" : mass="<<m_mass<<endmsg;
331  for(int i=0;i<2;i++)
332  {
333  out<<" u"<<i<<" = "<<m_u[i]<<" "<<m_Vuu[i][0]<<" "<<m_Vuu[i][1]<<endmsg;
334  }
335  for(int i=0;i<3;i++)
336  {
337  out<<" q"<<i<<" = "<<m_q[i]<<" "<<m_Vqq[i][0]<<" "<<m_Vqq[i][1]<<" "<<m_Vqq[i][2]<<endmsg;
338  }
339  return out;
340 }
341 
342 TrigVertexFitConstraint::TrigVertexFitConstraint(double m,
343  const TrigVertexFitInputTrack* pT1,
344  const TrigVertexFitInputTrack* pT2) : m_value(m)
345 {
346  m_trackList.clear();
347  m_trackList.push_back(pT1);
348  m_trackList.push_back(pT2);
349 }
350 
351 TrigVertexFitConstraint::TrigVertexFitConstraint(double m,
352  const TrigVertexFitInputTrack* pT1,
353  const TrigVertexFitInputTrack* pT2,
354  const TrigVertexFitInputTrack* pT3) : m_value(m)
355 {
356  m_trackList.clear();
357  m_trackList.push_back(pT1);m_trackList.push_back(pT2);m_trackList.push_back(pT3);
358 }
359 
360 
361 TrigVertexFitConstraint::~TrigVertexFitConstraint()
362 {
363  m_trackList.clear();
364 }
365 
366 double TrigVertexFitConstraint::calculateInvariantMass(TrigL2Vertex* pV)
367 {
368  const double C=0.029997;
369  const double B=20.84;
370 
371  double invMass=0.0,alpha=C*B/1000.0;
372  double P[3];double E=0.0;
373 
374  double* Rk = pV->getParametersVector();
375 
376  int offset=0;
377  for(int i=0;i<3;i++) P[i]=0.0;
378 
379  for(std::list<const TrigVertexFitInputTrack*>::iterator it=m_trackList.begin();it!=m_trackList.end();++it)
380  {
381  offset=3+3*(*it)->getIndex();
382  double mass=(*it)->getMass()/1000.0;
383  double pT=fabs(Rk[offset+2]);
384  double p=pT/sin(Rk[offset+1]);
385 
386  double psi=-asin(alpha*(Rk[0]*cos(Rk[offset])+Rk[1]*sin(Rk[offset]))/Rk[offset+2]);
387  double phiV=Rk[offset]+psi;
388  P[0]+=pT*cos(phiV);
389  P[1]+=pT*sin(phiV);
390  P[2]+=pT*cos(Rk[offset+1])/sin(Rk[offset+1]);
391  E+=sqrt(mass*mass+p*p);
392  }
393  invMass=sqrt(E*E-P[0]*P[0]-P[1]*P[1]-P[2]*P[2]);
394 
395  return invMass;
396 }
397 
398 
399 double TrigVertexFitConstraint::getChi2Distance(TrigL2Vertex* pV)
400 {
401  const double C=0.029997;
402  const double B=20.84;
403 
404  double invMass=0.0,alpha=C*B/1000.0;
405  double P[3];
406  double E=0.0;
407  int i{0},j{0};
408  bool linFailed=false;
409  double* Rk = pV->getParametersVector();
410 
411  int offset=0;
412  for(i=0;i<3;i++) P[i]=0.0;
413 
414  int nSize=3+3*pV->getTracks()->size();
415 
416  for(std::list<const TrigVertexFitInputTrack*>::iterator it=m_trackList.begin();it!=m_trackList.end();++it)
417  {
418  offset=3+3*(*it)->getIndex();
419  double mass=(*it)->getMass()/1000.0;
420  double pT=fabs(Rk[offset+2]);
421  double p=pT/sin(Rk[offset+1]);
422 
423  double psi=-asin(alpha*(Rk[0]*cos(Rk[offset])+Rk[1]*sin(Rk[offset]))/Rk[offset+2]);
424  double phiV=Rk[offset]+psi;
425  P[0]+=pT*cos(phiV);
426  P[1]+=pT*sin(phiV);
427  P[2]+=pT*cos(Rk[offset+1])/sin(Rk[offset+1]);
428  E+=sqrt(mass*mass+p*p);
429  }
430  invMass=sqrt(E*E-P[0]*P[0]-P[1]*P[1]-P[2]*P[2]);
431 
432  m_resid[0]=m_value/1000.0-invMass;
433  m_D[0][0]=0.0;m_D[0][1]=0.0;m_D[0][2]=0.0;
434 
435  for(std::list<const TrigVertexFitInputTrack*>::iterator it=m_trackList.begin();it!=m_trackList.end();++it)
436  {
437  offset=3+3*(*it)->getIndex();
438 
439  double mass=(*it)->getMass()/1000.0;
440  double Ck=(Rk[offset+2]<0.0)?-1.0:1.0;
441  double sinT=sin(Rk[offset+1]);
442  double cosT=cos(Rk[offset+1]);
443  double pT=fabs(Rk[offset+2]);
444  double p=pT/sinT;
445  double e=sqrt(p*p+mass*mass);
446  double sinF=sin(Rk[offset]);
447  double cosF=cos(Rk[offset]);
448 
449  double sinPsi=-alpha*(Rk[0]*cosF+Rk[1]*sinF)/Rk[offset+2];
450  if(fabs(sinPsi)>1.0)
451  {
452  linFailed=true;
453  break;
454  }
455  double psi=asin(sinPsi);
456  double cosPsi=sqrt(1.0-sinPsi*sinPsi);
457  double phiV=Rk[offset]+psi;
458 
459  double aCos=alpha*Ck/cosPsi;
460  double dP=P[1]*cos(phiV)-P[0]*sin(phiV);
461  double eE=E*Rk[offset+2]/(e*sinT);
462 
463  m_D[0][0]+=dP*cosF*aCos;
464  m_D[0][1]+=dP*sinF*aCos;
465  m_D[0][offset]=-dP*Ck*(Rk[offset+2]-Ck*aCos*(Rk[1]*cosF-Rk[0]*sinF));
466  m_D[0][offset+1]=(Rk[offset+2]/(sinT*sinT))*(P[2]*Ck-eE*cosT);
467  m_D[0][offset+2]=eE/sinT-Ck*(P[0]*cos(phiV)+P[1]*sin(phiV)+P[2]*cosT/sinT)+dP*Ck*sinPsi/cosPsi;
468  }
469  for(i=0;i<nSize;i++) m_D[0][i]/=invMass;
470  if(linFailed) return -999.9;
471  /*
472  for(i=0;i<nSize;i++) printf("%E ",m_D[0][i]);
473  printf("\n");
474  printf("----- numerical Jacobian -----\n");
475 
476  double oldPar, newPar, Delta, newMass, der;
477  for(i=0;i<nSize;i++)
478  {
479  oldPar=Rk[i];
480  Delta=0.00001*oldPar;
481  newPar=oldPar+Delta;
482  Rk[i]=newPar;
483  newMass=calculateInvariantMass(pV);
484  der=(newMass-invMass)/Delta;
485  m_D[1][i]=der;
486  Rk[i]=oldPar;
487  }
488  for(i=0;i<nSize;i++) printf("%E ",m_D[1][i]);
489  printf("\n");
490  printf("------------------------------\n");
491  */
492 
493  double covM=1e-12;
494 
495  for(i=0;i<nSize;i++)
496  {
497  for(j=i;j<nSize;j++)
498  {
499  double dCov=pV->m_Gk[i][j]*m_D[0][i]*m_D[0][j];
500  if(i!=j) dCov*=2.0;
501  covM+=dCov;
502  }
503  }
504  m_V[0][0]=1.0/covM;
505  return ((m_resid[0]*m_resid[0])*m_V[0][0]);
506 }
507 
508 void TrigVertexFitConstraint::updateVertex(TrigL2Vertex* pV)
509 {
510  double K[MAX_SIZE_VERT_COVM];
511  int i{0},j{0};
512  const int nSize=3+3*pV->getTracks()->size();
513  double gain{0};
514 
515  for(i=0;i<nSize;i++)
516  {
517  gain=0.0;
518  for(j=0;j<nSize;j++) gain+=pV->m_Gk[i][j]*m_D[0][j];
519  m_D[1][i]=gain;
520  K[i]=gain*m_V[0][0];
521  }
522  for(i=0;i<nSize;i++)
523  {
524  pV->getParametersVector()[i]+=K[i]*m_resid[0];
525  for(j=i;j<nSize;j++)
526  {
527  pV->m_Gk[i][j]-=K[i]*m_D[1][j];
528  pV->m_Gk[j][i]=pV->m_Gk[i][j];
529  }
530  }
531 }
532 
533 MsgStream& TrigVertexFitConstraint::report( MsgStream& out) const
534 {
535  out<<"Mass constraint with "<<m_trackList.size()<<" : mass="<<m_value<<endmsg;
536  return out;
537 }
538 
539 double TrigVertexFitConstraint::getValue()
540 {
541  return m_value;
542 }
543 
544 TrigL2Vertex::TrigL2Vertex()
545 {
546  m_pvConstraints=new std::list<TrigVertexFitConstraint*>;
547  m_pvTracks=new std::list<TrigVertexFitInputTrack*>;
548  m_pvConstraints->clear();m_pvTracks->clear();
549  m_nStatus=0;
550  m_nTracks=0;
551  m_P=NULL;
552  m_mass=0.0;
553  m_massVar=0.0;
554  m_chiSquared=0.0;
555  m_nDOF=0;
556  m_ready=false;
557 }
558 
559 TrigL2Vertex::~TrigL2Vertex()
560 {
561  for(std::list<TrigVertexFitInputTrack*>::iterator tIt=m_pvTracks->begin();
562  tIt!=m_pvTracks->end();++tIt)
563  {
564  delete (*tIt);
565  }
566  for(std::list<TrigVertexFitConstraint*>::iterator tIt=m_pvConstraints->begin();
567  tIt!=m_pvConstraints->end();++tIt)
568  {
569  delete (*tIt);
570  }
571  m_pvConstraints->clear();m_pvTracks->clear();
572  delete m_pvTracks;delete m_pvConstraints;
573  if(m_P!=NULL) delete m_P;
574 }
575 
576 int TrigL2Vertex::getNumberOfTracks()
577 {
578  m_nTracks=m_pvTracks->size();
579  return m_nTracks;
580 }
581 
582 bool TrigL2Vertex::prepareForFit()
583 {
584  m_nTracks=m_pvTracks->size();
585  m_nDOF=-3;
586  m_chiSquared=0.0;
587  m_ready=true;
588  return true;
589 }
590 
591 void TrigL2Vertex::reset()
592 {
593  memset(&m_Gk[0][0],0,sizeof(m_Gk));
594  m_nDOF=-3;
595  m_chiSquared=0.0;
596 }
597 
598 bool TrigL2Vertex::isVertexFitted()
599 {
600  return (m_nStatus>0);
601 }
602 
603 bool TrigL2Vertex::isMassEstimated()
604 {
605  return (m_nStatus>1);
606 }
607 
608 const TrigInDetTrackFitPar* TrigL2Vertex::getMotherTrack()
609 {
610  return m_P;
611 }
612 
613 void TrigL2Vertex::setMotherTrack(TrigInDetTrackFitPar* P)
614 {
615  m_P=P;
616 }
617 
618 double TrigL2Vertex::chi2()
619 {
620  return m_chiSquared;
621 }
622 
623 int TrigL2Vertex::ndof()
624 {
625  return m_nDOF;
626 }
627 
628 void TrigL2Vertex::addChi2(double chi2)
629 {
630  m_chiSquared+=chi2;
631 }
632 
633 void TrigL2Vertex::addNdof(int n)
634 {
635  m_nDOF+=n;
636 }
637 
638 double TrigL2Vertex::mass()
639 {
640  if(isMassEstimated()) return m_mass;
641  else return 0.0;}
642 
643 
644 double TrigL2Vertex::massVariance()
645 {
646  if(isMassEstimated()) return m_massVar;
647  else return 0.0;
648 }
649 
650 double* TrigL2Vertex::getParametersVector()
651 {
652  return &m_Rk[0];
653 }
654 
655 std::list<TrigVertexFitInputTrack*>* TrigL2Vertex::getTracks()
656 {
657  return m_pvTracks;
658 }
659 
660 std::list<TrigVertexFitConstraint*>* TrigL2Vertex::getConstraints()
661 {
662  return m_pvConstraints;
663 }
664 
665 void TrigL2Vertex::setStatus(int s)
666 {
667  m_nStatus=s;
668 }
669 
670 void TrigL2Vertex::setMass(double m)
671 {
672  m_mass=m;
673 }
674 
675 void TrigL2Vertex::setMassVariance(double v)
676 {
677  m_massVar=v;
678 }
679 
680 int TrigL2Vertex::getStatus()
681 {
682  return m_nStatus;
683 }
684 
685 bool TrigL2Vertex::isReadyForFit()
686 {
687  return m_ready;
688 }
689 
690 MsgStream& TrigL2Vertex::report( MsgStream& msg) const
691 {
692  const int nSize=3+3*m_pvTracks->size();
693 
694  for(int i=0;i<nSize;i++)
695  {
696  msg<<m_Rk[i]<<" ";
697  for(int j=0;j<nSize;j++) msg<<m_Gk[i][j]<<" ";
698  msg<<endmsg;
699  }
700  return msg;
701 }
702 
703 const TrigVertexFitInputTrack* TrigL2Vertex::contains(const TrigInDetTrack* pT)
704 {
705  TrigVertexFitInputTrack* pI=NULL;
706  for(std::list<TrigVertexFitInputTrack*>::iterator it=m_pvTracks->begin();
707  it!=m_pvTracks->end();++it)
708  {
709  if((*it)->getTrackType()!=1) continue;
710  if(pT==(*it)->getTrigTrack())
711  {
712  pI=(*it);break;
713  }
714  }
715  return pI;
716 }
717 
718 
719 const TrigVertexFitInputTrack* TrigL2Vertex::contains(const Trk::Track* pT)
720 {
721  TrigVertexFitInputTrack* pI=NULL;
722  for(std::list<TrigVertexFitInputTrack*>::iterator it=m_pvTracks->begin();
723  it!=m_pvTracks->end();++it)
724  {
725  if((*it)->getTrackType()!=2) continue;
726  if(pT==(*it)->getTrkTrack())
727  {
728  pI=(*it);break;
729  }
730  }
731  return pI;
732 }
TrigVertexFitConstraint::calculateInvariantMass
double calculateInvariantMass(TrigL2Vertex *pV)
Definition: TrigL2Vertex.cxx:366
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TrigL2Vertex::m_P
TrigInDetTrackFitPar * m_P
Definition: TrigL2Vertex.h:196
TrigVertexFitConstraint::TrigVertexFitConstraint
TrigVertexFitConstraint(double, const TrigVertexFitInputTrack *, const TrigVertexFitInputTrack *)
two-track mass constraint
Definition: TrigL2Vertex.cxx:342
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
TrigVertexFitInputTrack::setMass
void setMass(double)
sets a mass of this particle
Definition: TrigL2Vertex.cxx:132
TrigVertexFitInputTrack::m_u
double m_u[2]
Definition: TrigL2Vertex.h:93
TrigVertexFitInputTrack::getTrackType
int getTrackType()
0: L2 track, 1: EF(offline) track
Definition: TrigL2Vertex.cxx:152
TrigVertexFitConstraint::m_value
double m_value
Definition: TrigL2Vertex.h:118
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
TrigL2Vertex::setStatus
void setStatus(int)
sets vertex status flag
Definition: TrigL2Vertex.cxx:665
TrigVertexFitInputTrack::initializeVertex
void initializeVertex(class TrigL2Vertex *)
resets and fills its part of the covariance and parameter vector
Definition: TrigL2Vertex.cxx:188
TrigL2Vertex::TrigL2Vertex
TrigL2Vertex()
Definition: TrigL2Vertex.cxx:544
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TrackParameters.h
P4Helpers::invMass
double invMass(const I4Momentum &pA, const I4Momentum &pB)
invariant mass from two I4momentum references
Definition: P4Helpers.h:239
TrigVertexFitInputTrack::getTrkTrack
const Trk::Track * getTrkTrack()
getter for EF (offline) tracks
Definition: TrigL2Vertex.cxx:163
TrigL2Vertex::m_massVar
double m_massVar
Definition: TrigL2Vertex.h:192
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
TrigVertexFitConstraint::~TrigVertexFitConstraint
~TrigVertexFitConstraint()
Definition: TrigL2Vertex.cxx:361
TrigVertexFittingNode::m_D
double m_D[2][MAX_SIZE_VERT_COVM]
Definition: TrigL2Vertex.h:48
TrigVertexFitInputTrack::getIndex
int getIndex() const
to be used by TrigVertexingTool
Definition: TrigL2Vertex.cxx:173
TrigVertexFitConstraint::updateVertex
virtual void updateVertex(class TrigL2Vertex *)
implementation of abstract method from the base class
Definition: TrigL2Vertex.cxx:508
TrigVertexFitInputTrack::m_Perigee
double m_Perigee[5]
Definition: TrigL2Vertex.h:95
TrigVertexFitConstraint::getChi2Distance
virtual double getChi2Distance(class TrigL2Vertex *)
implementation of abstract method from the base class
Definition: TrigL2Vertex.cxx:399
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
TrigInDetTrackFitPar
Definition: TrigInDetTrackFitPar.h:67
TrigVertexFitInputTrack::getTrigTrack
const TrigInDetTrack * getTrigTrack()
getter for L2 tracks
Definition: TrigL2Vertex.cxx:158
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
DMTest::C
C_v1 C
Definition: C.h:26
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
skel.it
it
Definition: skel.GENtoEVGEN.py:423
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
TrigVertexFitInputTrack::m_A
double m_A[2][3]
Definition: TrigL2Vertex.h:97
TrigL2Vertex::addNdof
void addNdof(int)
increments accumulated number-of-degree-of-freedom of the fit
Definition: TrigL2Vertex.cxx:633
TRT_PAI_gasdata::AC
const float AC
Definition: TRT_PAI_gasdata.h:27
TrigVertexFitInputTrack::m_Vuq
double m_Vuq[2][3]
Definition: TrigL2Vertex.h:91
TrigVertexFitInputTrack::m_active
bool m_active
Definition: TrigL2Vertex.h:101
TrigVertexFitInputTrack::m_Vqq
double m_Vqq[3][3]
Definition: TrigL2Vertex.h:90
Trk::z0
@ z0
Definition: ParamDefs.h:70
TrigL2Vertex::reset
void reset()
resets all internal structures
Definition: TrigL2Vertex.cxx:591
TrigVertexFitConstraint::report
virtual MsgStream & report(MsgStream &) const
Definition: TrigL2Vertex.cxx:533
TrigL2Vertex::~TrigL2Vertex
~TrigL2Vertex()
Definition: TrigL2Vertex.cxx:559
TrigVertexFitInputTrack::m_pTrkTrack
const Trk::Track * m_pTrkTrack
Definition: TrigL2Vertex.h:86
TrigVertexFittingNode::m_V
double m_V[2][2]
Definition: TrigL2Vertex.h:47
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
TrigL2Vertex::getTracks
std::list< TrigVertexFitInputTrack * > * getTracks()
lists of tracks in the vertex
Definition: TrigL2Vertex.cxx:655
TrigVertexFitInputTrack::m_PerigeeCovariance
double m_PerigeeCovariance[5][5]
Definition: TrigL2Vertex.h:96
TrigL2Vertex::addChi2
void addChi2(double)
increments accumulated of the fit
Definition: TrigL2Vertex.cxx:628
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
TrigL2Vertex::ndof
int ndof()
returns accumulated number-of-degree-of-freedom of the fit
Definition: TrigL2Vertex.cxx:623
TrigVertexFitInputTrack::m_h
double m_h[2]
Definition: TrigL2Vertex.h:99
TrigL2Vertex::m_ready
bool m_ready
Definition: TrigL2Vertex.h:197
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
TrigInDetTrack
Definition: TrigInDetTrack.h:34
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
TrigL2Vertex::m_chiSquared
double m_chiSquared
Definition: TrigL2Vertex.h:191
TrigL2Vertex::prepareForFit
bool prepareForFit()
resets all internal structures + initialization of the covariance
Definition: TrigL2Vertex.cxx:582
TrigVertexFitInputTrack::activate
void activate()
sets isActive to true
Definition: TrigL2Vertex.cxx:142
MAX_SIZE_VERT_COVM
#define MAX_SIZE_VERT_COVM
Definition: TrigL2Vertex.h:14
TrigVertexFitInputTrack::m_mass
double m_mass
Definition: TrigL2Vertex.h:89
TrigL2Vertex::setMass
void setMass(double)
sets calculated mass of the vertex
Definition: TrigL2Vertex.cxx:670
TrigVertexFittingNode::m_resid
double m_resid[2]
Definition: TrigL2Vertex.h:46
TrigL2Vertex.h
TrigVertexFitInputTrack::updateVertex
virtual void updateVertex(class TrigL2Vertex *)
implementation of abstract method from the base class
Definition: TrigL2Vertex.cxx:302
TrigL2Vertex
Definition: TrigL2Vertex.h:146
TrigL2Vertex::setMassVariance
void setMassVariance(double)
sets variance of the calculated mass of the vertex
Definition: TrigL2Vertex.cxx:675
TrigVertexFitInputTrack::TrigVertexFitInputTrack
TrigVertexFitInputTrack(const TrigInDetTrack *, double)
constructor for L2 tracks
Definition: TrigL2Vertex.cxx:9
TrigVertexFitInputTrack::isActive
bool isActive()
if true this track will be used in the vertex fit otherwise it will be masked
Definition: TrigL2Vertex.cxx:147
TrigVertexFitInputTrack::mask
void mask()
sets isActive to false
Definition: TrigL2Vertex.cxx:137
TrigVertexFitInputTrack::Perigee
const double * Perigee() const
track parameters at the perigee
Definition: TrigL2Vertex.cxx:178
TrigL2Vertex::getMotherTrack
const TrigInDetTrackFitPar * getMotherTrack()
returns mother particle parameters if m_isMassEstimated() is true
Definition: TrigL2Vertex.cxx:608
TrigVertexFitInputTrack::m_pTrigTrack
const TrigInDetTrack * m_pTrigTrack
Definition: TrigL2Vertex.h:85
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigL2Vertex::m_pvTracks
std::list< TrigVertexFitInputTrack * > * m_pvTracks
Definition: TrigL2Vertex.h:189
TrigVertexFitInputTrack::m_q
double m_q[3]
Definition: TrigL2Vertex.h:94
beamspotman.n
n
Definition: beamspotman.py:731
Trk::theta
@ theta
Definition: ParamDefs.h:72
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
TrigVertexFitInputTrack::m_index
int m_index
Definition: TrigL2Vertex.h:88
TrigL2Vertex::getNumberOfTracks
int getNumberOfTracks()
Definition: TrigL2Vertex.cxx:576
TrigL2Vertex::chi2
double chi2()
returns accumulated of the fit
Definition: TrigL2Vertex.cxx:618
TrigL2Vertex::mass
double mass()
returns calculated mass of the vertex
Definition: TrigL2Vertex.cxx:638
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
TrigL2Vertex::massVariance
double massVariance()
returns variance of the calculated mass of the vertex
Definition: TrigL2Vertex.cxx:644
TrigVertexFitInputTrack::setIndex
void setIndex(int)
to be used by TrigVertexingTool
Definition: TrigL2Vertex.cxx:168
TrigVertexFitInputTrack::~TrigVertexFitInputTrack
~TrigVertexFitInputTrack()
Definition: TrigL2Vertex.cxx:127
TrigL2Vertex::contains
const TrigVertexFitInputTrack * contains(const TrigInDetTrack *)
checks whether L2 track is in the vertex
Definition: TrigL2Vertex.cxx:703
TrigL2Vertex::m_nStatus
int m_nStatus
Definition: TrigL2Vertex.h:193
TrigVertexFitInputTrack::PerigeeCovariance
double PerigeeCovariance(int, int) const
covariance of track parameters at the perigee
Definition: TrigL2Vertex.cxx:183
TrigL2Vertex::setMotherTrack
void setMotherTrack(TrigInDetTrackFitPar *)
sets mother particle parameters after kinematical fitting
Definition: TrigL2Vertex.cxx:613
Trk::d0
@ d0
Definition: ParamDefs.h:69
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
TrigL2Vertex::m_Gk
double m_Gk[MAX_SIZE_VERT_COVM][MAX_SIZE_VERT_COVM]
Definition: TrigL2Vertex.h:182
dqt_zlumi_alleff_HIST.B
B
Definition: dqt_zlumi_alleff_HIST.py:110
TrigL2Vertex::m_nTracks
int m_nTracks
Definition: TrigL2Vertex.h:185
TrigL2Vertex::m_pvConstraints
std::list< TrigVertexFitConstraint * > * m_pvConstraints
Definition: TrigL2Vertex.h:190
TrigVertexFitInputTrack::m_nTrackType
int m_nTrackType
Definition: TrigL2Vertex.h:87
TrigL2Vertex::m_Rk
double m_Rk[MAX_SIZE_VERT_COVM]
Definition: TrigL2Vertex.h:195
TrigVertexFitInputTrack::m_Vuu
double m_Vuu[2][2]
Definition: TrigL2Vertex.h:92
python.PyAthena.v
v
Definition: PyAthena.py:157
TrigL2Vertex::report
MsgStream & report(MsgStream &) const
Definition: TrigL2Vertex.cxx:690
TrigVertexFitInputTrack
Definition: TrigL2Vertex.h:62
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TrigVertexFitInputTrack::m_B
double m_B[2][3]
Definition: TrigL2Vertex.h:98
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigL2Vertex::isReadyForFit
bool isReadyForFit()
vertex status
Definition: TrigL2Vertex.cxx:685
TrigL2Vertex::getParametersVector
double * getParametersVector()
returns vector of vertex fit parameters: vertex position + refitted track momenta at-perigee (sic !...
Definition: TrigL2Vertex.cxx:650
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
TrigL2Vertex::isMassEstimated
bool isMassEstimated()
vertex status
Definition: TrigL2Vertex.cxx:603
TrigVertexFitConstraint::getValue
double getValue()
returns a mass of the constraint
Definition: TrigL2Vertex.cxx:539
TrigVertexFitInputTrack::report
virtual MsgStream & report(MsgStream &) const
Definition: TrigL2Vertex.cxx:328
TrigL2Vertex::m_mass
double m_mass
Definition: TrigL2Vertex.h:191
TrigL2Vertex::getStatus
int getStatus()
returns vertex status flag
Definition: TrigL2Vertex.cxx:680
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
TrigL2Vertex::m_nDOF
int m_nDOF
Definition: TrigL2Vertex.h:185
TrigL2Vertex::getConstraints
std::list< TrigVertexFitConstraint * > * getConstraints()
lists of all constraints imposed on the vertex
Definition: TrigL2Vertex.cxx:660
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
TrigVertexFitConstraint::m_trackList
std::list< const TrigVertexFitInputTrack * > m_trackList
Definition: TrigL2Vertex.h:117
Trk::phi0
@ phi0
Definition: ParamDefs.h:71
TrigL2Vertex::isVertexFitted
bool isVertexFitted()
vertex status
Definition: TrigL2Vertex.cxx:598
fitman.k
k
Definition: fitman.py:528
TrigVertexFitInputTrack::getChi2Distance
virtual double getChi2Distance(class TrigL2Vertex *)
implementation of abstract method from the base class
Definition: TrigL2Vertex.cxx:195
Generated on Sun Jun 30 2024 21:30:43 for ATLAS Offline Software by   doxygen 1.8.18