Belle II Software  release-05-01-25
CDCRecoHit.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2012, 2015 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Guofu Cao, Martin Heck, Tobias Schlüter *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <cdc/dataobjects/CDCRecoHit.h>
12 
13 //Comment out the following line since it introduces dependence on cdclib (or circular dependence betw. cdc_objects and cdclib).
14 //#include <cdc/geometry/CDCGeometryPar.h>
15 #include <genfit/WireTrackCandHit.h>
16 #include <genfit/AbsTrackRep.h>
17 #include <genfit/RKTrackRep.h>
18 #include <genfit/TrackPoint.h>
19 #include <genfit/AbsFitterInfo.h>
20 #include <genfit/Exception.h>
21 #include <genfit/HMatrixU.h>
22 
23 using namespace std;
24 using namespace Belle2;
25 using namespace CDC;
26 
27 std::unique_ptr<ADCCountTranslatorBase> CDCRecoHit::s_adcCountTranslator = 0;
28 std::unique_ptr<CDCGeometryTranslatorBase> CDCRecoHit::s_cdcGeometryTranslator = 0;
29 std::unique_ptr<TDCCountTranslatorBase> CDCRecoHit::s_tdcCountTranslator = 0;
30 bool CDCRecoHit::s_useTrackTime = false;
31 //temp4cosmics
32 bool CDCRecoHit::s_cosmics = false;
33 
34 
35 void CDCRecoHit::setTranslators(ADCCountTranslatorBase* const adcCountTranslator,
36  CDCGeometryTranslatorBase* const cdcGeometryTranslator,
37  TDCCountTranslatorBase* const tdcCountTranslator,
38  //temp4cosmics bool useTrackTime)
39  bool useTrackTime, bool cosmics)
40 {
41  s_adcCountTranslator.reset(adcCountTranslator);
42  s_cdcGeometryTranslator.reset(cdcGeometryTranslator);
43  s_tdcCountTranslator.reset(tdcCountTranslator);
44  s_useTrackTime = useTrackTime;
45  //temp4cosmics
46  s_cosmics = cosmics;
47 }
48 
49 CDCRecoHit::CDCRecoHit()
50  : genfit::AbsMeasurement(1),
51  m_tdcCount(0), m_adcCount(0), m_wireID(WireID()), m_cdcHit(NULL), m_leftRight(0)
52 {
53 }
54 
55 CDCRecoHit::CDCRecoHit(const CDCHit* cdcHit, const genfit::TrackCandHit* trackCandHit)
56  : genfit::AbsMeasurement(1), m_cdcHit(cdcHit), m_leftRight(0)
57 {
59  B2FATAL("Can't produce CDCRecoHits without setting of the translators.");
60  }
61 
62  // get information from cdcHit into local variables.
63  m_wireID = cdcHit->getID();
64  m_tdcCount = cdcHit->getTDCCount();
65  m_adcCount = cdcHit->getADCCount();
66 
67  // set l-r info
68  const genfit::WireTrackCandHit* aTrackCandHitPtr = dynamic_cast<const genfit::WireTrackCandHit*>(trackCandHit);
69  if (aTrackCandHitPtr) {
70  signed char lrInfo = aTrackCandHitPtr->getLeftRightResolution();
71  B2DEBUG(250, "l/r: " << int(lrInfo));
72  setLeftRightResolution(lrInfo);
73  }
74 }
75 
77 {
78  return new CDCRecoHit(*this);
79 }
80 
81 
83 {
84  // We find the plane in two steps: first we neglect wire sag to get
85  // a good estimate of the z coordinate of the crossing. Then we use
86  // this z coordinate to find the point of closest approach to the
87  // sagging wire and its local direction.
88 
89  // Don't use clone: we don't want to extrapolate covariances if
90  // state is a genfit::MeasuredStateOnPlane.
91  genfit::StateOnPlane st(state);
92 
93  const TVector3& noSagWire1(s_cdcGeometryTranslator->getWireBackwardPosition(m_wireID));
94  const TVector3& noSagWire2(s_cdcGeometryTranslator->getWireForwardPosition(m_wireID));
95 
96  // unit vector along the wire
97  TVector3 noSagWireDirection = noSagWire2 - noSagWire1;
98  noSagWireDirection.SetMag(1.);
99 
100  // point of closest approach
101  const genfit::AbsTrackRep* rep = state.getRep();
102  rep->extrapolateToLine(st, noSagWire1, noSagWireDirection);
103  const TVector3& noSagPoca = rep->getPos(st);
104 
105  double zPOCA = (noSagWire1.Z()
106  + noSagWireDirection.Dot(noSagPoca - noSagWire1) * noSagWireDirection.Z());
107 
108  // Now re-extrapolate taking Z of trajectory into account.
109  const TVector3& wire1(s_cdcGeometryTranslator->getWireBackwardPosition(m_wireID, zPOCA));
110  const TVector3& wire2(s_cdcGeometryTranslator->getWireForwardPosition(m_wireID, zPOCA));
111 
112  // unit vector along the wire (will become V of plane)
113  TVector3 wireDirection = wire2 - wire1;
114  wireDirection.SetMag(1.);
115 
116  // point of closest approach
117  rep->extrapolateToLine(st, wire1, wireDirection);
118  const TVector3& poca = rep->getPos(st);
119  TVector3 dirInPoca = rep->getMom(st);
120  dirInPoca.SetMag(1.);
121  const TVector3& pocaOnWire = wire1 + wireDirection.Dot(poca - wire1) * wireDirection;
122  //temp
123  // std::cout << (noSagWire1 + noSagWireDirection.Dot(noSagPoca - noSagWire1) * noSagWireDirection).y() <<" "<< pocaOnWire.y() <<" " << (noSagWire1 + noSagWireDirection.Dot(noSagPoca - noSagWire1) * noSagWireDirection - pocaOnWire).y() << std::endl;
124  // std::cout << (noSagWire1 + noSagWireDirection.Dot(noSagPoca - noSagWire1) * noSagWireDirection).Perp() <<" "<< pocaOnWire.Perp() << std::endl;
125  // std::cout << (noSagWire1 + noSagWireDirection.Dot(noSagPoca - noSagWire1) * noSagWireDirection).z() <<" "<< pocaOnWire.z() << std::endl;
126 
127  // check if direction is parallel to wire
128  if (fabs(wireDirection.Angle(dirInPoca)) < 0.01) {
129  genfit::Exception exc("CDCRecoHit::constructPlane(): Cannot construct detector plane, direction is parallel to wire", __LINE__,
130  __FILE__);
131  throw exc;
132  }
133 
134  // construct orthogonal (unit) vector
135  const TVector3& U = wireDirection.Cross(dirInPoca);
136 
137  genfit::SharedPlanePtr pl = genfit::SharedPlanePtr(new genfit::DetPlane(pocaOnWire, U, wireDirection));
138  //pl->Print();
139  return pl;
140 }
141 
142 std::vector<genfit::MeasurementOnPlane*> CDCRecoHit::constructMeasurementsOnPlane(const genfit::StateOnPlane& state) const
143 {
144  double z = state.getPos().Z();
145  const TVector3& p = state.getMom();
146  // Calculate alpha and theta. A description was given by H. Ozaki in
147  // https://indico.mpp.mpg.de/getFile.py/access?contribId=5&sessionId=3&resId=0&materialId=slides&confId=3195
148 
149 //Comment out the following 2 lines since they introduce dependence on cdclib (or circular dependence betw. cdc_objects and cdclib).
150 // double alpha = CDCGeometryPar::Instance().getAlpha(state.getPlane()->getO(), p);
151 // double theta = CDCGeometryPar::Instance().getTheta(p);
152 
153 //N.B. The folowing 8 lines are tentative to avoid the circular dependence mentioned above ! The definitions of alpha and theta should be identical to those defined in CDCGeometryPar.
154  const double wx = state.getPlane()->getO().x();
155  const double wy = state.getPlane()->getO().y();
156  const double px = p.x();
157  const double py = p.y();
158  const double cross = wx * py - wy * px;
159  const double dot = wx * px + wy * py;
160  double alpha = atan2(cross, dot);
161  double theta = atan2(p.Perp(), p.z());
162  /*
163  double alpha0 = CDCGeometryPar::Instance().getAlpha(state.getPlane()->getO(), p);
164  double theta0 = CDCGeometryPar::Instance().getTheta(p);
165  if (alpha != alpha0) {
166  std::cout <<"alpha,alpha0= " << alpha <<" "<< alpha0 << std::endl;
167  exit(-1);
168  }
169  if (theta != theta0) {;
170  std::cout <<"theta,theta0= " << theta <<" "<< theta0 << std::endl;
171  exit(-2);
172  }
173  */
174 
175  double trackTime = s_useTrackTime ? state.getTime() : 0;
176  //temp4cosmics
177  // std::cout <<"phi,trackTime= " << atan2(py,px) <<" "<< trackTime << std::endl;
178  if (s_cosmics) {
179  if (atan2(py, px) > 0.) {
180  // if (atan2(wy,wx) > 0.) {
181  trackTime *= -1.;
182  }
183  }
184 
185  // The meaning of the left / right flag (called
186  // 'ambiguityDiscriminator' in TDCCounTranslatorBase) is inferred
187  // from CDCGeometryPar::getNewLeftRightRaw().
188  double mL = s_tdcCountTranslator->getDriftLength(m_tdcCount, m_wireID, trackTime,
189  false, //left
190  z, alpha, theta, m_adcCount);
191  double mR = s_tdcCountTranslator->getDriftLength(m_tdcCount, m_wireID, trackTime,
192  true, //right
193  z, alpha, theta, m_adcCount);
194  double VL = s_tdcCountTranslator->getDriftLengthResolution(mL, m_wireID,
195  false, //left
196  z, alpha, theta);
197  double VR = s_tdcCountTranslator->getDriftLengthResolution(mR, m_wireID,
198  true, //right
199  z, alpha, theta);
200 
201  // static to avoid constructing these over and over.
202  static TVectorD m(1);
203  static TMatrixDSym cov(1);
204 
205  m(0) = mR;
206  cov(0, 0) = VR;
207  auto mopR = new genfit::MeasurementOnPlane(m, cov, state.getPlane(), state.getRep(),
208  constructHMatrix(state.getRep()));
209  m(0) = -mL; // Convert from unsigned drift length to signed coordinate.
210  cov(0, 0) = VL;
211  auto mopL = new genfit::MeasurementOnPlane(m, cov, state.getPlane(), state.getRep(),
212  constructHMatrix(state.getRep()));
213 
214  // set left/right weights
215  if (m_leftRight < 0) {
216  mopL->setWeight(1);
217  mopR->setWeight(0);
218  } else if (m_leftRight > 0) {
219  mopL->setWeight(0);
220  mopR->setWeight(1);
221  } else {
222  // In absence of L/R information set equal weight for mirror hits.
223  // We have this weight decrease as the drift distance increases.
224  // Since the average will always be close to the wire, the bias
225  // introduced by the averaged hit would increase as the drift
226  // radius increases. Reducing the initial weight effectively
227  // counteracts this. This way the DAF can figure the ambiguities
228  // out quickly.
229  //
230  // Wire spacing in the radial direction according to TDR is 10 mm
231  // in the innermost superlayer, 18 mm otherwise. Use these values
232  // times a safety margin of 1.5 as upper bound for the drift
233  // radii. The max distance between the mirror hits is twice the
234  // maximal drift radius.
235  double rMax = 1.5 * (m_wireID.getISuperLayer() == 0 ? 1. : 1.8);
236  double weight = 0.5 * pow(std::max(0., 1 - (mR + mL) / 2 / rMax), 2);
237  mopL->setWeight(weight);
238  mopR->setWeight(weight);
239  }
240 
241  // Ignore hits with negative drift times. For these, the
242  // TDCCountTranslator returns a negative drift length.
243  if (mL < 0. || mR < 0.) {
244  B2DEBUG(150, "Ignoring hit with negative drift time.");
245  mopL->setWeight(0);
246  mopR->setWeight(0);
247  }
248 
249  return {mopL, mopR};
250 }
251 
252 
254 {
255  if (!dynamic_cast<const genfit::RKTrackRep*>(rep)) {
256  B2FATAL("CDCRecoHit can only handle state vectors of type RKTrackRep!");
257  }
258 
259  return new genfit::HMatrixU();
260 }
261 
262 
264 {
265  double z = state.getPos().Z();
266  const TVector3& p = state.getMom();
267  // Calculate alpha and theta. A description was given by H. Ozaki in
268  // https://indico.mpp.mpg.de/getFile.py/access?contribId=5&sessionId=3&resId=0&materialId=slides&confId=3195
269 
270 //Comment out the following 2 lines since they introduce dependence on cdclib (or circular dependence betw. cdc_objects and cdclib).
271 // double alpha = CDCGeometryPar::Instance().getAlpha(state.getPlane()->getO(), p);
272 // double theta = CDCGeometryPar::Instance().getTheta(p);
273 
274 //N.B. The folowing 8 lines are tentative to avoid the circular dependence mentioned above ! The definitions of alpha and theta should be identical to those defined in CDCGeometryPar.
275  const double wx = state.getPlane()->getO().x();
276  const double wy = state.getPlane()->getO().y();
277  const double px = p.x();
278  const double py = p.y();
279  const double cross = wx * py - wy * px;
280  const double dot = wx * px + wy * py;
281  double alpha = atan2(cross, dot);
282  double theta = atan2(p.Perp(), p.z());
283  /*
284  double alpha0 = CDCGeometryPar::Instance().getAlpha(state.getPlane()->getO(), p);
285  double theta0 = CDCGeometryPar::Instance().getTheta(p);
286  if (alpha != alpha0) {
287  std::cout <<"alpha,alpha0= " << alpha <<" "<< alpha0 << std::endl;
288  exit(-1);
289  }
290  if (theta != theta0) {;
291  std::cout <<"theta,theta0= " << theta <<" "<< theta0 << std::endl;
292  exit(-2);
293  }
294  */
295 
296  double trackTime = s_useTrackTime ? state.getTime() : 0;
297 
298  // The meaning of the left / right flag (called
299  // 'ambiguityDiscriminator' in TDCCounTranslatorBase) is inferred
300  // from CDCGeometryPar::getNewLeftRightRaw().
301  auto fL = [&](const double & t) -> double {
302  return s_tdcCountTranslator->getDriftLength(m_tdcCount, m_wireID, t,
303  false, //left
304  z, alpha, theta, m_adcCount); };
305  auto fR = [&](const double & t) -> double {
306  return s_tdcCountTranslator->getDriftLength(m_tdcCount, m_wireID, t,
307  true, //right
308  z, alpha, theta, m_adcCount); };
309 
310  // Calculate derivative for all left and right mirror hit.
311  //
312  // It's a polynomial, but let's not meddle with the innard of the
313  // CDC code for now.
314  //
315  // The algorithm follows the one in TF1::Derivative() :
316  // df(x) = (4 D(h/2) - D(h)) / 3
317  // with D(h) = (f(x + h) - f(x - h)) / (2 h).
318  double rightShort[2], rightFull[2];
319  double leftShort[2], leftFull[2];
320  const double defaultStepT = 1e-3 * trackTime;
321  double stepT;
322  {
323  double temp = trackTime + defaultStepT / 2;
324  // Find the actual size of the step, which will differ from
325  // defaultStepX due to roundoff. This is the step-size we will
326  // use for this direction. Idea taken from Numerical Recipes,
327  // 3rd ed., section 5.7.
328  //
329  // Note that if a number is exactly representable, it's double
330  // will also be exact. Outside denormals, this also holds for
331  // halving. Unless the exponent changes (which it only will in
332  // the vicinity of zero) adding or subtracing doesn't make a
333  // difference.
334  //
335  // We determine the roundoff error for the half-step. If this
336  // is exactly representable, the full step will also be.
337  stepT = 2 * (temp - trackTime);
338 
339  rightShort[0] = fL(trackTime + .5 * stepT);
340  rightShort[1] = fR(trackTime + .5 * stepT);
341  }
342  {
343  leftShort[0] = fL(trackTime - .5 * stepT);
344  leftShort[1] = fR(trackTime - .5 * stepT);
345  }
346  {
347  rightFull[0] = fL(trackTime + stepT);
348  rightFull[1] = fR(trackTime + stepT);
349  }
350  {
351  leftFull[0] = fL(trackTime - stepT);
352  leftFull[1] = fR(trackTime - stepT);
353  }
354 
355  // Calculate the derivatives for the individual components of
356  // the track parameters.
357  double derivFull[2];
358  double derivShort[2];
359  for (size_t j = 0; j < 2; ++j) {
360  derivFull[j] = (rightFull[j] - leftFull[j]) / (2.*stepT);
361  derivShort[j] = (rightShort[j] - leftShort[j]) / stepT;
362  }
363  //std::cout << rightShort[0] << " " << derivShort[0] << " " << trackTime << std::endl;
364  return { +(4.*derivShort[0] - derivFull[0]) / 3.,
365  -(4.*derivShort[1] - derivFull[1]) / 3.};
366 }
367 
368 
369 
371  B2Vector3D& trackDir,
372  const genfit::AbsTrackRep* rep,
373  bool usePlaneFromFit)
374 {
375  const genfit::TrackPoint* tp = this->getTrackPoint();
376  if (!tp) {
377  B2ERROR("No genfit::TrackPoint for CDCRecoHit.");
378  return false;
379  }
380  const genfit::AbsFitterInfo* fi = tp->getFitterInfo(rep);
381  if (!fi) {
382  B2DEBUG(200, "No genfit::AbsFitterInfo for this CDCRecoHit.");
383  return false;
384  }
385 
386  const genfit::MeasuredStateOnPlane& mop = fi->getFittedState();
387  B2Vector3D fittedPoca = mop.getPos();
388  // constructPlane places the coordinate center in the POCA to the
389  // wire. Using this is the default behavior. If this should be too
390  // slow, as it has to re-evaluate the POCA, alternatively the user
391  // can set usePlaneFromFit which uses the plane determined by the
392  // track fit.
393  B2Vector3D pocaOnWire = (usePlaneFromFit
394  ? mop.getPlane()->getO()
395  : this->constructPlane(mop)->getO());
396 
397  // The vector from the wire to the track.
398  pointingVector = fittedPoca - pocaOnWire;
399 
400  trackDir = mop.getMom();
401  trackDir.SetMag(1.);
402  return true;
403 }
Belle2::CDC::TDCCountTranslatorBase
Base class for translation of Drift Time into Drift Length.
Definition: TDCCountTranslatorBase.h:36
genfit::Exception
Exception class for error handling in GENFIT (provides storage for diagnostic information)
Definition: Exception.h:48
genfit::TrackPoint
Object containing AbsMeasurement and AbsFitterInfo objects.
Definition: TrackPoint.h:46
Belle2::WireID
Class to identify a wire inside the CDC.
Definition: WireID.h:44
genfit::SharedPlanePtr
std::shared_ptr< genfit::DetPlane > SharedPlanePtr
Shared Pointer to a DetPlane.
Definition: SharedPlanePtr.h:40
Belle2::CDCRecoHit::setLeftRightResolution
void setLeftRightResolution(int lr)
select how to resolve the left/right ambiguity: -1: negative (left) side on vector (wire direction) x...
Definition: CDCRecoHit.h:111
Belle2::B2Vector3::SetMag
void SetMag(DataType mag)
Set magnitude keeping theta and phi constant.
Definition: B2Vector3.h:181
genfit::MeasuredStateOnPlane
#StateOnPlane with additional covariance matrix.
Definition: MeasuredStateOnPlane.h:39
Belle2::CDCRecoHit::getFlyByDistanceVector
bool getFlyByDistanceVector(B2Vector3D &pointingVector, B2Vector3D &trackDir, const genfit::AbsTrackRep *rep=NULL, bool usePlaneFromFit=false)
Get the vector pointing from the wire to the fitted trajectory as well as the direction of the track ...
Definition: CDCRecoHit.cc:370
Belle2::CDCHit::getID
unsigned short getID() const
Getter for encoded wire number.
Definition: CDCHit.h:204
genfit::AbsFitterInfo
This class collects all information needed and produced by a specific AbsFitter and is specific to on...
Definition: AbsFitterInfo.h:42
Belle2::CDCHit
Class containing the result of the unpacker in raw data and the result of the digitizer in simulation...
Definition: CDCHit.h:51
Belle2::WireID::getISuperLayer
unsigned short getISuperLayer() const
Getter for Super-Layer.
Definition: WireID.h:140
Belle2::CDCHit::getTDCCount
short getTDCCount() const
Getter for TDC count.
Definition: CDCHit.h:230
Belle2::CDCRecoHit::m_leftRight
signed char m_leftRight
Flag showing left/right passage.
Definition: CDCRecoHit.h:164
genfit::StateOnPlane
A state with arbitrary dimension defined in a DetPlane.
Definition: StateOnPlane.h:47
genfit
Defines for I/O streams used for error and debug printing.
Definition: AlignablePXDRecoHit.h:19
Belle2::CDCRecoHit::m_tdcCount
unsigned short m_tdcCount
TDC Count as out of CDCHit.
Definition: CDCRecoHit.h:152
Belle2::CDCRecoHit::timeDerivativesMeasurementsOnPlane
std::vector< double > timeDerivativesMeasurementsOnPlane(const genfit::StateOnPlane &state) const
Get the time derivative of the MesuredStateOnPlane (derived from the track fit).
Definition: CDCRecoHit.cc:263
genfit::TrackCandHit
Hit object for use in TrackCand.
Definition: TrackCandHit.h:34
genfit::AbsTrackRep
Abstract base class for a track representation.
Definition: AbsTrackRep.h:66
Belle2::CDCRecoHit::constructPlane
genfit::SharedPlanePtr constructPlane(const genfit::StateOnPlane &state) const override
Methods that actually interface to Genfit.
Definition: CDCRecoHit.cc:82
Belle2::CDCRecoHit::constructMeasurementsOnPlane
std::vector< genfit::MeasurementOnPlane * > constructMeasurementsOnPlane(const genfit::StateOnPlane &state) const override
build MeasurementsOnPlane
Definition: CDCRecoHit.cc:142
Belle2::CDCRecoHit::constructHMatrix
virtual const genfit::HMatrixU * constructHMatrix(const genfit::AbsTrackRep *) const override
construct error matrix
Definition: CDCRecoHit.cc:253
Belle2::CDC::CDCGeometryTranslatorBase
Abstract Base class for the geometry translator.
Definition: CDCGeometryTranslatorBase.h:33
Belle2::CDCRecoHit::s_adcCountTranslator
static std::unique_ptr< CDC::ADCCountTranslatorBase > s_adcCountTranslator
Object for ADC Count translation.
Definition: CDCRecoHit.h:131
Belle2::CDCRecoHit
This class is used to transfer CDC information to the track fit.
Definition: CDCRecoHit.h:43
Belle2::CDCRecoHit::clone
CDCRecoHit * clone() const override
Creating a copy of this hit.
Definition: CDCRecoHit.cc:76
Belle2::B2Vector3< double >
Belle2::CDCHit::getADCCount
unsigned short getADCCount() const
Getter for integrated charge.
Definition: CDCHit.h:241
genfit::RKTrackRep
AbsTrackRep with 5D track parameterization in plane coordinates: (q/p, u', v', u, v)
Definition: RKTrackRep.h:72
genfit::TrackPoint::getFitterInfo
AbsFitterInfo * getFitterInfo(const AbsTrackRep *rep=nullptr) const
Get fitterInfo for rep. Per default, use cardinal rep.
Definition: TrackPoint.cc:170
Belle2::CDCRecoHit::m_wireID
WireID m_wireID
Wire Identifier.
Definition: CDCRecoHit.h:158
genfit::AbsTrackRep::extrapolateToLine
virtual double extrapolateToLine(StateOnPlane &state, const TVector3 &linePoint, const TVector3 &lineDirection, bool stopAtBoundary=false, bool calcJacobianNoise=false) const =0
Extrapolates the state to the POCA to a line, and returns the extrapolation length and,...
Belle2::CDCRecoHit::s_cosmics
static bool s_cosmics
Switch to use cosmic events, or physics events from IP.
Definition: CDCRecoHit.h:147
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::CDCRecoHit::s_tdcCountTranslator
static std::unique_ptr< CDC::TDCCountTranslatorBase > s_tdcCountTranslator
Object for getting drift-length and -resolution.
Definition: CDCRecoHit.h:137
Belle2::CDCRecoHit::m_adcCount
unsigned short m_adcCount
ADC Count as out of CDCHit.
Definition: CDCRecoHit.h:155
genfit::HMatrixU
AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization.
Definition: HMatrixU.h:37
genfit::AbsTrackRep::getPos
virtual TVector3 getPos(const StateOnPlane &state) const =0
Get the cartesian position of a state.
Belle2::CDCRecoHit::s_cdcGeometryTranslator
static std::unique_ptr< CDC::CDCGeometryTranslatorBase > s_cdcGeometryTranslator
Object for geometry translation.
Definition: CDCRecoHit.h:134
Belle2::CDC::ADCCountTranslatorBase
Abstract Base class for the ADC count translator.
Definition: ADCCountTranslatorBase.h:33
genfit::DetPlane
Detector plane.
Definition: DetPlane.h:59
genfit::AbsTrackRep::getMom
virtual TVector3 getMom(const StateOnPlane &state) const =0
Get the cartesian momentum vector of a state.
Belle2::CDCRecoHit::CDCRecoHit
CDCRecoHit()
Default Constructor for ROOT IO.
Definition: CDCRecoHit.cc:49
genfit::WireTrackCandHit
Hit object for use in TrackCand.
Definition: WireTrackCandHit.h:34
genfit::MeasurementOnPlane
Measured coordinates on a plane.
Definition: MeasurementOnPlane.h:46
Belle2::CDCRecoHit::s_useTrackTime
static bool s_useTrackTime
Whether to use the track time or not when building the measurementOnPlane.
Definition: CDCRecoHit.h:142