SND@LHC Software
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
gbl::GblPoint Class Reference

Point on trajectory. More...

#include <GblPoint.h>

Public Member Functions

 GblPoint (const TMatrixD &aJacobian)
 Create a point.
 
 GblPoint (const SMatrix55 &aJacobian)
 
virtual ~GblPoint ()
 
void addMeasurement (const TMatrixD &aProjection, const TVectorD &aResiduals, const TVectorD &aPrecision, double minPrecision=0.)
 Add a measurement to a point.
 
void addMeasurement (const TMatrixD &aProjection, const TVectorD &aResiduals, const TMatrixDSym &aPrecision, double minPrecision=0.)
 Add a measurement to a point.
 
void addMeasurement (const TVectorD &aResiduals, const TVectorD &aPrecision, double minPrecision=0.)
 Add a measurement to a point.
 
void addMeasurement (const TVectorD &aResiduals, const TMatrixDSym &aPrecision, double minPrecision=0.)
 Add a measurement to a point.
 
unsigned int hasMeasurement () const
 Check for measurement at a point.
 
void getMeasurement (SMatrix55 &aProjection, SVector5 &aResiduals, SVector5 &aPrecision) const
 Retrieve measurement of a point.
 
void getMeasTransformation (TMatrixD &aTransformation) const
 Get measurement transformation (from diagonalization).
 
void addScatterer (const TVectorD &aResiduals, const TVectorD &aPrecision)
 Add a (thin) scatterer to a point.
 
void addScatterer (const TVectorD &aResiduals, const TMatrixDSym &aPrecision)
 Add a (thin) scatterer to a point.
 
bool hasScatterer () const
 Check for scatterer at a point.
 
void getScatterer (SMatrix22 &aTransformation, SVector2 &aResiduals, SVector2 &aPrecision) const
 Retrieve scatterer of a point.
 
void getScatTransformation (TMatrixD &aTransformation) const
 Get scatterer transformation (from diagonalization).
 
void addLocals (const TMatrixD &aDerivatives)
 Add local derivatives to a point.
 
unsigned int getNumLocals () const
 Retrieve number of local derivatives from a point.
 
const TMatrixD & getLocalDerivatives () const
 Retrieve local derivatives from a point.
 
void addGlobals (const std::vector< int > &aLabels, const TMatrixD &aDerivatives)
 Add global derivatives to a point.
 
unsigned int getNumGlobals () const
 Retrieve number of global derivatives from a point.
 
std::vector< int > getGlobalLabels () const
 Retrieve global derivatives labels from a point.
 
const TMatrixD & getGlobalDerivatives () const
 Retrieve global derivatives from a point.
 
void setLabel (unsigned int aLabel)
 Define label of point (by GBLTrajectory constructor)
 
unsigned int getLabel () const
 Retrieve label of point.
 
void setOffset (int anOffset)
 Define offset for point (by GBLTrajectory constructor)
 
int getOffset () const
 Retrieve offset for point.
 
const SMatrix55 & getP2pJacobian () const
 Retrieve point-to-(previous)point jacobian.
 
void addPrevJacobian (const SMatrix55 &aJac)
 Define jacobian to previous scatterer (by GBLTrajectory constructor)
 
void addNextJacobian (const SMatrix55 &aJac)
 Define jacobian to next scatterer (by GBLTrajectory constructor)
 
void getDerivatives (int aDirection, SMatrix22 &matW, SMatrix22 &matWJ, SVector2 &vecWd) const
 Retrieve derivatives of local track model.
 
void printPoint (unsigned int level=0) const
 Print GblPoint.
 

Private Attributes

unsigned int theLabel
 Label identifying point.
 
int theOffset
 Offset number at point if not negative (else interpolation needed)
 
SMatrix55 p2pJacobian
 Point-to-point jacobian from previous point.
 
SMatrix55 prevJacobian
 Jacobian to previous scatterer (or first measurement)
 
SMatrix55 nextJacobian
 Jacobian to next scatterer (or last measurement)
 
unsigned int measDim
 Dimension of measurement (1-5), 0 indicates absence of measurement.
 
SMatrix55 measProjection
 Projection from measurement to local system.
 
SVector5 measResiduals
 Measurement residuals.
 
SVector5 measPrecision
 Measurement precision (diagonal of inverse covariance matrix)
 
bool transFlag
 Transformation exists?
 
TMatrixD measTransformation
 Transformation of diagonalization (of meas. precision matrix)
 
bool scatFlag
 Scatterer present?
 
SMatrix22 scatTransformation
 Transformation of diagonalization (of scat. precision matrix)
 
SVector2 scatResiduals
 Scattering residuals (initial kinks if iterating)
 
SVector2 scatPrecision
 Scattering precision (diagonal of inverse covariance matrix)
 
TMatrixD localDerivatives
 Derivatives of measurement vs additional local (fit) parameters.
 
std::vector< int > globalLabels
 Labels of global (MP-II) derivatives.
 
TMatrixD globalDerivatives
 Derivatives of measurement vs additional global (MP-II) parameters.
 

Detailed Description

Point on trajectory.

User supplied point on (initial) trajectory.

Must have jacobian for propagation from previous point. May have:

  1. Measurement (1D - 5D)
  2. Scatterer (thin, 2D kinks)
  3. Additional local parameters (with derivatives). Fitted together with track parameters.
  4. Additional global parameters (with labels and derivatives). Not fitted, only passed on to (binary) file for fitting with Millepede-II.

Definition at line 48 of file GblPoint.h.

Constructor & Destructor Documentation

◆ GblPoint() [1/2]

gbl::GblPoint::GblPoint ( const TMatrixD &  aJacobian)

Create a point.

Create point on (initial) trajectory. Needs transformation jacobian from previous point.

Parameters
[in]aJacobianTransformation jacobian from previous point

Definition at line 18 of file GblPoint.cc.

18 :
19 theLabel(0), theOffset(0), measDim(0), transFlag(false), measTransformation(), scatFlag(
20 false), localDerivatives(), globalLabels(), globalDerivatives() {
21
22 for (unsigned int i = 0; i < 5; ++i) {
23 for (unsigned int j = 0; j < 5; ++j) {
24 p2pJacobian(i, j) = aJacobian(i, j);
25 }
26 }
27}
gbl::GblPoint::localDerivatives
TMatrixD localDerivatives
Derivatives of measurement vs additional local (fit) parameters.
Definition GblPoint.h:107
gbl::GblPoint::globalLabels
std::vector< int > globalLabels
Labels of global (MP-II) derivatives.
Definition GblPoint.h:108
gbl::GblPoint::measTransformation
TMatrixD measTransformation
Transformation of diagonalization (of meas. precision matrix)
Definition GblPoint.h:102
gbl::GblPoint::scatFlag
bool scatFlag
Scatterer present?
Definition GblPoint.h:103
gbl::GblPoint::measDim
unsigned int measDim
Dimension of measurement (1-5), 0 indicates absence of measurement.
Definition GblPoint.h:97
gbl::GblPoint::transFlag
bool transFlag
Transformation exists?
Definition GblPoint.h:101
gbl::GblPoint::theLabel
unsigned int theLabel
Label identifying point.
Definition GblPoint.h:92
gbl::GblPoint::theOffset
int theOffset
Offset number at point if not negative (else interpolation needed)
Definition GblPoint.h:93
gbl::GblPoint::globalDerivatives
TMatrixD globalDerivatives
Derivatives of measurement vs additional global (MP-II) parameters.
Definition GblPoint.h:109
gbl::GblPoint::p2pJacobian
SMatrix55 p2pJacobian
Point-to-point jacobian from previous point.
Definition GblPoint.h:94
ShipAna.i
int i
Definition ShipAna.py:86
conditionsDatabase.snd_conDB.j
int j
Definition snd_conDB.py:197

◆ GblPoint() [2/2]

gbl::GblPoint::GblPoint ( const SMatrix55 &  aJacobian)

Definition at line 29 of file GblPoint.cc.

29 :
30 theLabel(0), theOffset(0), p2pJacobian(aJacobian), measDim(0), transFlag(
31 false), measTransformation(), scatFlag(false), localDerivatives(), globalLabels(), globalDerivatives() {
32
33}

◆ ~GblPoint()

gbl::GblPoint::~GblPoint ( )
virtual

Definition at line 35 of file GblPoint.cc.

35 {
36}

Member Function Documentation

◆ addGlobals()

void gbl::GblPoint::addGlobals ( const std::vector< int > &  aLabels,
const TMatrixD &  aDerivatives 
)

Add global derivatives to a point.

Point needs to have a measurement.

Parameters
[in]aLabelsGlobal derivatives labels
[in]aDerivativesGlobal derivatives (matrix)

Definition at line 298 of file GblPoint.cc.

299 {
300 if (measDim) {
301 globalLabels = aLabels;
302 globalDerivatives.ResizeTo(aDerivatives);
303 if (transFlag) {
304 globalDerivatives = measTransformation * aDerivatives;
305 } else {
306 globalDerivatives = aDerivatives;
307 }
308
309 }
310}

◆ addLocals()

void gbl::GblPoint::addLocals ( const TMatrixD &  aDerivatives)

Add local derivatives to a point.

Point needs to have a measurement.

Parameters
[in]aDerivativesLocal derivatives (matrix)

Definition at line 271 of file GblPoint.cc.

271 {
272 if (measDim) {
273 localDerivatives.ResizeTo(aDerivatives);
274 if (transFlag) {
275 localDerivatives = measTransformation * aDerivatives;
276 } else {
277 localDerivatives = aDerivatives;
278 }
279 }
280}

◆ addMeasurement() [1/4]

void gbl::GblPoint::addMeasurement ( const TMatrixD &  aProjection,
const TVectorD &  aResiduals,
const TMatrixDSym &  aPrecision,
double  minPrecision = 0. 
)

Add a measurement to a point.

Add measurement (in meas. system) with arbitrary precision (inverse covariance) matrix. Will be diagonalized. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters
[in]aProjectionProjection from local to measurement system
[in]aResidualsMeasurement residuals
[in]aPrecisionMeasurement precision (matrix)
[in]minPrecisionMinimal precision to accept measurement

Definition at line 72 of file GblPoint.cc.

74 {
75 measDim = aResiduals.GetNrows();
76 TMatrixDSymEigen measEigen(aPrecision);
77 measTransformation.ResizeTo(measDim, measDim);
78 measTransformation = measEigen.GetEigenVectors();
79 measTransformation.T();
80 transFlag = true;
81 TVectorD transResiduals = measTransformation * aResiduals;
82 TVectorD transPrecision = measEigen.GetEigenValues();
83 TMatrixD transProjection = measTransformation * aProjection;
84 unsigned int iOff = 5 - measDim;
85 for (unsigned int i = 0; i < measDim; ++i) {
86 measResiduals(iOff + i) = transResiduals[i];
87 measPrecision(iOff + i) = (
88 transPrecision[i] >= minPrecision ? transPrecision[i] : 0.);
89 for (unsigned int j = 0; j < measDim; ++j) {
90 measProjection(iOff + i, iOff + j) = transProjection(i, j);
91 }
92 }
93}
gbl::GblPoint::measPrecision
SVector5 measPrecision
Measurement precision (diagonal of inverse covariance matrix)
Definition GblPoint.h:100
gbl::GblPoint::measProjection
SMatrix55 measProjection
Projection from measurement to local system.
Definition GblPoint.h:98
gbl::GblPoint::measResiduals
SVector5 measResiduals
Measurement residuals.
Definition GblPoint.h:99

◆ addMeasurement() [2/4]

void gbl::GblPoint::addMeasurement ( const TMatrixD &  aProjection,
const TVectorD &  aResiduals,
const TVectorD &  aPrecision,
double  minPrecision = 0. 
)

Add a measurement to a point.

Add measurement (in meas. system) with diagonal precision (inverse covariance) matrix. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters
[in]aProjectionProjection from local to measurement system
[in]aResidualsMeasurement residuals
[in]aPrecisionMeasurement precision (diagonal)
[in]minPrecisionMinimal precision to accept measurement

Definition at line 47 of file GblPoint.cc.

49 {
50 measDim = aResiduals.GetNrows();
51 unsigned int iOff = 5 - measDim;
52 for (unsigned int i = 0; i < measDim; ++i) {
53 measResiduals(iOff + i) = aResiduals[i];
54 measPrecision(iOff + i) = (
55 aPrecision[i] >= minPrecision ? aPrecision[i] : 0.);
56 for (unsigned int j = 0; j < measDim; ++j) {
57 measProjection(iOff + i, iOff + j) = aProjection(i, j);
58 }
59 }
60}

◆ addMeasurement() [3/4]

void gbl::GblPoint::addMeasurement ( const TVectorD &  aResiduals,
const TMatrixDSym &  aPrecision,
double  minPrecision = 0. 
)

Add a measurement to a point.

Add measurement in local system with arbitrary precision (inverse covariance) matrix. Will be diagonalized. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters
[in]aResidualsMeasurement residuals
[in]aPrecisionMeasurement precision (matrix)
[in]minPrecisionMinimal precision to accept measurement

Definition at line 124 of file GblPoint.cc.

125 {
126 measDim = aResiduals.GetNrows();
127 TMatrixDSymEigen measEigen(aPrecision);
128 measTransformation.ResizeTo(measDim, measDim);
129 measTransformation = measEigen.GetEigenVectors();
130 measTransformation.T();
131 transFlag = true;
132 TVectorD transResiduals = measTransformation * aResiduals;
133 TVectorD transPrecision = measEigen.GetEigenValues();
134 unsigned int iOff = 5 - measDim;
135 for (unsigned int i = 0; i < measDim; ++i) {
136 measResiduals(iOff + i) = transResiduals[i];
137 measPrecision(iOff + i) = (
138 transPrecision[i] >= minPrecision ? transPrecision[i] : 0.);
139 for (unsigned int j = 0; j < measDim; ++j) {
140 measProjection(iOff + i, iOff + j) = measTransformation(i, j);
141 }
142 }
143}

◆ addMeasurement() [4/4]

void gbl::GblPoint::addMeasurement ( const TVectorD &  aResiduals,
const TVectorD &  aPrecision,
double  minPrecision = 0. 
)

Add a measurement to a point.

Add measurement in local system with diagonal precision (inverse covariance) matrix. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters
[in]aResidualsMeasurement residuals
[in]aPrecisionMeasurement precision (diagonal)
[in]minPrecisionMinimal precision to accept measurement

Definition at line 103 of file GblPoint.cc.

104 {
105 measDim = aResiduals.GetNrows();
106 unsigned int iOff = 5 - measDim;
107 for (unsigned int i = 0; i < measDim; ++i) {
108 measResiduals(iOff + i) = aResiduals[i];
109 measPrecision(iOff + i) = (
110 aPrecision[i] >= minPrecision ? aPrecision[i] : 0.);
111 }
112 measProjection = ROOT::Math::SMatrixIdentity();
113}

◆ addNextJacobian()

void gbl::GblPoint::addNextJacobian ( const SMatrix55 &  aJac)

Define jacobian to next scatterer (by GBLTrajectory constructor)

Parameters
[in]aJacJacobian

Definition at line 379 of file GblPoint.cc.

379 {
380 nextJacobian = aJac;
381}
gbl::GblPoint::nextJacobian
SMatrix55 nextJacobian
Jacobian to next scatterer (or last measurement)
Definition GblPoint.h:96

◆ addPrevJacobian()

void gbl::GblPoint::addPrevJacobian ( const SMatrix55 &  aJac)

Define jacobian to previous scatterer (by GBLTrajectory constructor)

Parameters
[in]aJacJacobian

Definition at line 362 of file GblPoint.cc.

362 {
363 int ifail = 0;
364// to optimize: need only two last rows of inverse
365// prevJacobian = aJac.InverseFast(ifail);
366// block matrix algebra
367 SMatrix23 CA = aJac.Sub<SMatrix23>(3, 0)
368 * aJac.Sub<SMatrix33>(0, 0).InverseFast(ifail); // C*A^-1
369 SMatrix22 DCAB = aJac.Sub<SMatrix22>(3, 3) - CA * aJac.Sub<SMatrix32>(0, 3); // D - C*A^-1 *B
370 DCAB.InvertFast();
371 prevJacobian.Place_at(DCAB, 3, 3);
372 prevJacobian.Place_at(-DCAB * CA, 3, 0);
373}
SMatrix33
ROOT::Math::SMatrix< double, 3 > SMatrix33
Definition GblPoint.h:28
SMatrix32
ROOT::Math::SMatrix< double, 3, 2 > SMatrix32
Definition GblPoint.h:27
SMatrix22
ROOT::Math::SMatrix< double, 2 > SMatrix22
Definition GblPoint.h:23
SMatrix23
ROOT::Math::SMatrix< double, 2, 3 > SMatrix23
Definition GblPoint.h:24
gbl::GblPoint::prevJacobian
SMatrix55 prevJacobian
Jacobian to previous scatterer (or first measurement)
Definition GblPoint.h:95

◆ addScatterer() [1/2]

void gbl::GblPoint::addScatterer ( const TVectorD &  aResiduals,
const TMatrixDSym &  aPrecision 
)

Add a (thin) scatterer to a point.

Add scatterer with arbitrary precision (inverse covariance) matrix. Will be diagonalized. Changes local track direction.

The precision matrix for the local slopes is defined by the angular scattering error theta_0 and the scalar products c_1, c_2 of the offset directions in the local frame with the track direction: 

       (1 - c_1*c_1 - c_2*c_2)   |  1 - c_1*c_1     - c_1*c_2  |
  P =  ~~~~~~~~~~~~~~~~~~~~~~~ * |                             |
           theta_0*theta_0       |    - c_1*c_2   1 - c_2*c_2  |
Parameters
[in]aResidualsScatterer residuals
[in]aPrecisionScatterer precision (matrix)

Definition at line 214 of file GblPoint.cc.

215 {
216 scatFlag = true;
217 TMatrixDSymEigen scatEigen(aPrecision);
218 TMatrixD aTransformation = scatEigen.GetEigenVectors();
219 aTransformation.T();
220 TVectorD transResiduals = aTransformation * aResiduals;
221 TVectorD transPrecision = scatEigen.GetEigenValues();
222 for (unsigned int i = 0; i < 2; ++i) {
223 scatResiduals(i) = transResiduals[i];
224 scatPrecision(i) = transPrecision[i];
225 for (unsigned int j = 0; j < 2; ++j) {
226 scatTransformation(i, j) = aTransformation(i, j);
227 }
228 }
229}
gbl::GblPoint::scatResiduals
SVector2 scatResiduals
Scattering residuals (initial kinks if iterating)
Definition GblPoint.h:105
gbl::GblPoint::scatTransformation
SMatrix22 scatTransformation
Transformation of diagonalization (of scat. precision matrix)
Definition GblPoint.h:104
gbl::GblPoint::scatPrecision
SVector2 scatPrecision
Scattering precision (diagonal of inverse covariance matrix)
Definition GblPoint.h:106

◆ addScatterer() [2/2]

void gbl::GblPoint::addScatterer ( const TVectorD &  aResiduals,
const TVectorD &  aPrecision 
)

Add a (thin) scatterer to a point.

Add scatterer with diagonal precision (inverse covariance) matrix. Changes local track direction.

Parameters
[in]aResidualsScatterer residuals
[in]aPrecisionScatterer precision (diagonal of inverse covariance matrix)

Definition at line 188 of file GblPoint.cc.

189 {
190 scatFlag = true;
191 scatResiduals(0) = aResiduals[0];
192 scatResiduals(1) = aResiduals[1];
193 scatPrecision(0) = aPrecision[0];
194 scatPrecision(1) = aPrecision[1];
195 scatTransformation = ROOT::Math::SMatrixIdentity();
196}

◆ getDerivatives()

void gbl::GblPoint::getDerivatives ( int  aDirection,
SMatrix22 &  matW,
SMatrix22 &  matWJ,
SVector2 &  vecWd 
) const

Retrieve derivatives of local track model.

Linearized track model: F_u(q/p,u',u) = J*u + S*u' + d*q/p, W is inverse of S, negated for backward propagation.

Parameters
[in]aDirectionPropagation direction (>0 forward, else backward)
[out]matWW
[out]matWJW*J
[out]vecWdW*d
Exceptions
std::overflow_error: matrix S is singular.

Definition at line 393 of file GblPoint.cc.

394 {
395
396 SMatrix22 matJ;
397 SVector2 vecd;
398 if (aDirection < 1) {
399 matJ = prevJacobian.Sub<SMatrix22>(3, 3);
400 matW = -prevJacobian.Sub<SMatrix22>(3, 1);
401 vecd = prevJacobian.SubCol<SVector2>(0, 3);
402 } else {
403 matJ = nextJacobian.Sub<SMatrix22>(3, 3);
404 matW = nextJacobian.Sub<SMatrix22>(3, 1);
405 vecd = nextJacobian.SubCol<SVector2>(0, 3);
406 }
407
408 if (!matW.InvertFast()) {
409 std::cout << " GblPoint::getDerivatives failed to invert matrix: "
410 << matW << std::endl;
411 std::cout
412 << " Possible reason for singular matrix: multiple GblPoints at same arc-length"
413 << std::endl;
414 throw std::overflow_error("Singular matrix inversion exception");
415 }
416 matWJ = matW * matJ;
417 vecWd = matW * vecd;
418
419}
SVector2
ROOT::Math::SVector< double, 2 > SVector2
Definition GblPoint.h:30

◆ getGlobalDerivatives()

const TMatrixD & gbl::GblPoint::getGlobalDerivatives ( ) const

Retrieve global derivatives from a point.

Definition at line 323 of file GblPoint.cc.

323 {
324 return globalDerivatives;
325}

◆ getGlobalLabels()

std::vector< int > gbl::GblPoint::getGlobalLabels ( ) const

Retrieve global derivatives labels from a point.

Definition at line 318 of file GblPoint.cc.

318 {
319 return globalLabels;
320}

◆ getLabel()

unsigned int gbl::GblPoint::getLabel ( ) const

Retrieve label of point.

Definition at line 336 of file GblPoint.cc.

336 {
337 return theLabel;
338}

◆ getLocalDerivatives()

const TMatrixD & gbl::GblPoint::getLocalDerivatives ( ) const

Retrieve local derivatives from a point.

Definition at line 288 of file GblPoint.cc.

288 {
289 return localDerivatives;
290}

◆ getMeasTransformation()

void gbl::GblPoint::getMeasTransformation ( TMatrixD &  aTransformation) const

Get measurement transformation (from diagonalization).

Parameters
[out]aTransformationTransformation matrix

Definition at line 171 of file GblPoint.cc.

171 {
172 aTransformation.ResizeTo(measDim, measDim);
173 if (transFlag) {
174 aTransformation = measTransformation;
175 } else {
176 aTransformation.UnitMatrix();
177 }
178}

◆ getMeasurement()

void gbl::GblPoint::getMeasurement ( SMatrix55 &  aProjection,
SVector5 &  aResiduals,
SVector5 &  aPrecision 
) const

Retrieve measurement of a point.

Parameters
[out]aProjectionProjection from (diagonalized) measurement to local system
[out]aResidualsMeasurement residuals
[out]aPrecisionMeasurement precision (diagonal)

Definition at line 160 of file GblPoint.cc.

161 {
162 aProjection = measProjection;
163 aResiduals = measResiduals;
164 aPrecision = measPrecision;
165}

◆ getNumGlobals()

unsigned int gbl::GblPoint::getNumGlobals ( ) const

Retrieve number of global derivatives from a point.

Definition at line 313 of file GblPoint.cc.

313 {
314 return globalDerivatives.GetNcols();
315}

◆ getNumLocals()

unsigned int gbl::GblPoint::getNumLocals ( ) const

Retrieve number of local derivatives from a point.

Definition at line 283 of file GblPoint.cc.

283 {
284 return localDerivatives.GetNcols();
285}

◆ getOffset()

int gbl::GblPoint::getOffset ( ) const

Retrieve offset for point.

Definition at line 349 of file GblPoint.cc.

349 {
350 return theOffset;
351}

◆ getP2pJacobian()

const SMatrix55 & gbl::GblPoint::getP2pJacobian ( ) const

Retrieve point-to-(previous)point jacobian.

Definition at line 354 of file GblPoint.cc.

354 {
355 return p2pJacobian;
356}

◆ getScatterer()

void gbl::GblPoint::getScatterer ( SMatrix22 &  aTransformation,
SVector2 &  aResiduals,
SVector2 &  aPrecision 
) const

Retrieve scatterer of a point.

Parameters
[out]aTransformationScatterer transformation from diagonalization
[out]aResidualsScatterer residuals
[out]aPrecisionScatterer precision (diagonal)

Definition at line 242 of file GblPoint.cc.

243 {
244 aTransformation = scatTransformation;
245 aResiduals = scatResiduals;
246 aPrecision = scatPrecision;
247}

◆ getScatTransformation()

void gbl::GblPoint::getScatTransformation ( TMatrixD &  aTransformation) const

Get scatterer transformation (from diagonalization).

Parameters
[out]aTransformationTransformation matrix

Definition at line 253 of file GblPoint.cc.

253 {
254 aTransformation.ResizeTo(2, 2);
255 if (scatFlag) {
256 for (unsigned int i = 0; i < 2; ++i) {
257 for (unsigned int j = 0; j < 2; ++j) {
258 aTransformation(i, j) = scatTransformation(i, j);
259 }
260 }
261 } else {
262 aTransformation.UnitMatrix();
263 }
264}

◆ hasMeasurement()

unsigned int gbl::GblPoint::hasMeasurement ( ) const

Check for measurement at a point.

Get dimension of measurement (0 = none).

Returns
measurement dimension

Definition at line 150 of file GblPoint.cc.

150 {
151 return measDim;
152}

◆ hasScatterer()

bool gbl::GblPoint::hasScatterer ( ) const

Check for scatterer at a point.

Definition at line 232 of file GblPoint.cc.

232 {
233 return scatFlag;
234}

◆ printPoint()

void gbl::GblPoint::printPoint ( unsigned int  level = 0) const

Print GblPoint.

Parameters
[in]levelprint level (0: minimum, >0: more)

Definition at line 425 of file GblPoint.cc.

425 {
426 std::cout << " GblPoint";
427 if (theLabel) {
428 std::cout << ", label " << theLabel;
429 if (theOffset >= 0) {
430 std::cout << ", offset " << theOffset;
431 }
432 }
433 if (measDim) {
434 std::cout << ", " << measDim << " measurements";
435 }
436 if (scatFlag) {
437 std::cout << ", scatterer";
438 }
439 if (transFlag) {
440 std::cout << ", diagonalized";
441 }
442 if (localDerivatives.GetNcols()) {
443 std::cout << ", " << localDerivatives.GetNcols()
444 << " local derivatives";
445 }
446 if (globalDerivatives.GetNcols()) {
447 std::cout << ", " << globalDerivatives.GetNcols()
448 << " global derivatives";
449 }
450 std::cout << std::endl;
451 if (level > 0) {
452 if (measDim) {
453 std::cout << " Measurement" << std::endl;
454 std::cout << " Projection: " << std::endl << measProjection
455 << std::endl;
456 std::cout << " Residuals: " << measResiduals << std::endl;
457 std::cout << " Precision: " << measPrecision << std::endl;
458 }
459 if (scatFlag) {
460 std::cout << " Scatterer" << std::endl;
461 std::cout << " Residuals: " << scatResiduals << std::endl;
462 std::cout << " Precision: " << scatPrecision << std::endl;
463 }
464 if (localDerivatives.GetNcols()) {
465 std::cout << " Local Derivatives:" << std::endl;
466 localDerivatives.Print();
467 }
468 if (globalDerivatives.GetNcols()) {
469 std::cout << " Global Labels:";
470 for (unsigned int i = 0; i < globalLabels.size(); ++i) {
471 std::cout << " " << globalLabels[i];
472 }
473 std::cout << std::endl;
474 std::cout << " Global Derivatives:" << std::endl;
475 globalDerivatives.Print();
476 }
477 std::cout << " Jacobian " << std::endl;
478 std::cout << " Point-to-point " << std::endl << p2pJacobian
479 << std::endl;
480 if (theLabel) {
481 std::cout << " To previous offset " << std::endl << prevJacobian
482 << std::endl;
483 std::cout << " To next offset " << std::endl << nextJacobian
484 << std::endl;
485 }
486 }
487}

◆ setLabel()

void gbl::GblPoint::setLabel ( unsigned int  aLabel)

Define label of point (by GBLTrajectory constructor)

Parameters
[in]aLabelLabel identifying point

Definition at line 331 of file GblPoint.cc.

331 {
332 theLabel = aLabel;
333}

◆ setOffset()

void gbl::GblPoint::setOffset ( int  anOffset)

Define offset for point (by GBLTrajectory constructor)

Parameters
[in]anOffsetOffset number

Definition at line 344 of file GblPoint.cc.

344 {
345 theOffset = anOffset;
346}

Member Data Documentation

◆ globalDerivatives

TMatrixD gbl::GblPoint::globalDerivatives
private

Derivatives of measurement vs additional global (MP-II) parameters.

Definition at line 109 of file GblPoint.h.

◆ globalLabels

std::vector<int> gbl::GblPoint::globalLabels
private

Labels of global (MP-II) derivatives.

Definition at line 108 of file GblPoint.h.

◆ localDerivatives

TMatrixD gbl::GblPoint::localDerivatives
private

Derivatives of measurement vs additional local (fit) parameters.

Definition at line 107 of file GblPoint.h.

◆ measDim

unsigned int gbl::GblPoint::measDim
private

Dimension of measurement (1-5), 0 indicates absence of measurement.

Definition at line 97 of file GblPoint.h.

◆ measPrecision

SVector5 gbl::GblPoint::measPrecision
private

Measurement precision (diagonal of inverse covariance matrix)

Definition at line 100 of file GblPoint.h.

◆ measProjection

SMatrix55 gbl::GblPoint::measProjection
private

Projection from measurement to local system.

Definition at line 98 of file GblPoint.h.

◆ measResiduals

SVector5 gbl::GblPoint::measResiduals
private

Measurement residuals.

Definition at line 99 of file GblPoint.h.

◆ measTransformation

TMatrixD gbl::GblPoint::measTransformation
private

Transformation of diagonalization (of meas. precision matrix)

Definition at line 102 of file GblPoint.h.

◆ nextJacobian

SMatrix55 gbl::GblPoint::nextJacobian
private

Jacobian to next scatterer (or last measurement)

Definition at line 96 of file GblPoint.h.

◆ p2pJacobian

SMatrix55 gbl::GblPoint::p2pJacobian
private

Point-to-point jacobian from previous point.

Definition at line 94 of file GblPoint.h.

◆ prevJacobian

SMatrix55 gbl::GblPoint::prevJacobian
private

Jacobian to previous scatterer (or first measurement)

Definition at line 95 of file GblPoint.h.

◆ scatFlag

bool gbl::GblPoint::scatFlag
private

Scatterer present?

Definition at line 103 of file GblPoint.h.

◆ scatPrecision

SVector2 gbl::GblPoint::scatPrecision
private

Scattering precision (diagonal of inverse covariance matrix)

Definition at line 106 of file GblPoint.h.

◆ scatResiduals

SVector2 gbl::GblPoint::scatResiduals
private

Scattering residuals (initial kinks if iterating)

Definition at line 105 of file GblPoint.h.

◆ scatTransformation

SMatrix22 gbl::GblPoint::scatTransformation
private

Transformation of diagonalization (of scat. precision matrix)

Definition at line 104 of file GblPoint.h.

◆ theLabel

unsigned int gbl::GblPoint::theLabel
private

Label identifying point.

Definition at line 92 of file GblPoint.h.

◆ theOffset

int gbl::GblPoint::theOffset
private

Offset number at point if not negative (else interpolation needed)

Definition at line 93 of file GblPoint.h.

◆ transFlag

bool gbl::GblPoint::transFlag
private

Transformation exists?

Definition at line 101 of file GblPoint.h.

The documentation for this class was generated from the following files: