CDCObservations2D Class Reference

Class serving as a storage of observed drift circles to present to the Riemann fitter. More...

#include <CDCObservations2D.h>

Public Member Functions
	CDCObservations2D (EFitPos fitPos=EFitPos::c_RecoPos, EFitVariance fitVariance=EFitVariance::c_Proper)
	Constructor taking the flag if the reconstructed position of the hits should be used when they are available The default is to use the wire position and the drift length signed by the right left passage hypotheses.
std::size_t	size () const
	Returns the number of observations stored.
double *	data ()
	Return the pointer to the number buffer.
bool	empty () const
	Returns true if there are no observations stored.
void	clear ()
	Removes all observations stored.
void	reserve (std::size_t nObservations)
	Reserves enough space for nObservations.
double	getX (int iObservation) const
	Getter for the x value of the observation at the given index.
double	getY (int iObservation) const
	Getter for the y value of the observation at the given index.
double	getDriftLength (int iObservation) const
	Getter for the signed drift radius of the observation at the given index.
double	getWeight (int iObservation) const
	Getter for the weight / inverse variance of the observation at the given index.
std::size_t	fill (double x, double y, double signedRadius=0.0, double weight=1.0)
	Appends the observed position.
std::size_t	fill (const Vector2D &pos2D, double signedRadius=0.0, double weight=1.0)
	Appends the observed position.
std::size_t	append (const CDCWireHit &wireHit, ERightLeft rlInfo=ERightLeft::c_Unknown)
	Appends the hit circle at wire reference position without a right left passage hypotheses.
std::size_t	append (const CDCWireHit *wireHit, ERightLeft rlInfo=ERightLeft::c_Unknown)
	Appends the position information of the given wire hit to the stored observations.
std::size_t	append (const CDCRLWireHit &rlWireHit)
	Appends the hit circle at wire reference position with a right left passage hypotheses.
std::size_t	append (const CDCRLWireHitPair &rlWireHitPair)
	Appends the two observed position.
std::size_t	append (const CDCRLWireHitTriple &rlWireHitTriple)
	Appends the three observed position.
std::size_t	append (const CDCFacet &facet)
	Appends the three observed position.
std::size_t	append (const CDCRecoHit2D &recoHit2D)
	Appends the hit using the reconstructed position if useRecoPos indicates it.
std::size_t	append (const CDCRecoHit3D &recoHit3D)
	Appends the observed position.
std::size_t	appendRange (const CDCSegment2D &segment2D)
	Appends all reconstructed hits from the two dimensional segment.
std::size_t	appendRange (const CDCSegment3D &segment3D)
	Appends all reconstructed hits from the three dimensional segment.
std::size_t	appendRange (const CDCAxialSegmentPair &axialSegmentPair)
	Appends all reconstructed hits from the two axial segments,.
std::size_t	appendRange (const CDCTrack &track)
	Appends all reconstructed hits from the three dimensional track.
std::size_t	appendRange (const std::vector< const CDCWire * > &wires)
	Appends all the reference wire positions.
std::size_t	appendRange (const CDCWireHitSegment &wireHits)
	Appends all the wire hit reference positions with the pseudo variance.
template<class ARange >
std::size_t	appendRange (const ARange &range)
	Append all hits from a generic range.
Vector2D	getFrontPos2D () const
	Get the position of the first observation.
Vector2D	getBackPos2D () const
	Get the position of the first observation.
double	getTotalPerpS (const CDCTrajectory2D &trajectory2D) const
	Calculate the total transverse travel distance traversed by these observations comparing the travel distance of first and last position.
bool	isForwardTrajectory (const CDCTrajectory2D &trajectory2D) const
	Checks if the last position of these observations lies at greater travel distance than the first.
EForwardBackward	isCoaligned (const CDCTrajectory2D &trajectory2D) const
	Checks if the last observation in the vector lies at greater or lower travel distance than the last observation.
Vector2D	getCentralPoint () const
	Extracts the observation center that is at the index in the middle.
void	passiveMoveBy (const Vector2D &origin)
	Moves all observations passively such that the given vector becomes to origin of the new coordinate system.
Vector2D	centralize ()
	Picks one observation as a reference point and transform all observations to that new origin.
std::size_t	getNObservationsWithDriftRadius () const
	Returns the number of observations having a drift radius radius.
EFitPos	getFitPos () const
	Getter for the indicator that the reconstructed position should be favoured.
void	setFitPos (EFitPos fitPos)
	Setter for the indicator that the reconstructed position should be favoured.
void	setFitVariance (EFitVariance fitVariance)
	Setter for the indicator that the drift variance should be used.

Static Public Member Functions
static double	getPseudoDriftLengthVariance (double driftLength, double driftLengthVariance)
	Gets the pseudo variance.
static double	getPseudoDriftLengthVariance (const CDCWireHit &wireHit)
	Calculate the pseudo variance from the drift length and its variance.

Private Attributes
std::vector< double >	m_observations
	Memory for the individual observations.
EFitPos	m_fitPos
	Indicator which positional information should preferably be extracted from hits in calls to append.
EFitVariance	m_fitVariance
	Indicator which variance information should preferably be extracted from hits in calls to append.

Detailed Description

Class serving as a storage of observed drift circles to present to the Riemann fitter.

Definition at line 43 of file CDCObservations2D.h.

Constructor & Destructor Documentation

CDCObservations2D()

CDCObservations2D ( EFitPos  fitPos = EFitPos::c_RecoPos, EFitVariance  fitVariance = EFitVariance::c_Proper  )

inlineexplicit

Constructor taking the flag if the reconstructed position of the hits should be used when they are available The default is to use the wire position and the drift length signed by the right left passage hypotheses.

Definition at line 50 of file CDCObservations2D.h.

        : m_fitPos(fitPos)
        , m_fitVariance(fitVariance)
      {
      }

Member Function Documentation

append() [1/8]

std::size_t append

(

const CDCFacet &

facet

)

Appends the three observed position.

Definition at line 154 of file CDCObservations2D.cc.

{
  if (m_fitPos == EFitPos::c_RecoPos) {
    return append(facet.getStartRecoHit2D()) + append(facet.getMiddleRecoHit2D()) +
           append(facet.getEndRecoHit2D());
  } else {
    const CDCRLWireHitTriple& rlWireHitTriple = facet;
    return append(rlWireHitTriple);
  }
}

append() [2/8]

std::size_t append

(

const CDCRecoHit2D &

recoHit2D

)

Appends the hit using the reconstructed position if useRecoPos indicates it.

Definition at line 165 of file CDCObservations2D.cc.

{
  Vector2D fitPos2D;
  double signedDriftLength = 0;
  if (m_fitPos == EFitPos::c_RecoPos) {
    fitPos2D = recoHit2D.getRecoPos2D();
    signedDriftLength = 0;
 
    // Fall back to the rl circle in case position is not setup
    if (fitPos2D.hasNAN()) {
      fitPos2D = recoHit2D.getWire().getRefPos2D();
      signedDriftLength = recoHit2D.getSignedRefDriftLength();
    }
 
  } else if (m_fitPos == EFitPos::c_RLDriftCircle) {
    fitPos2D = recoHit2D.getWire().getRefPos2D();
    signedDriftLength = recoHit2D.getSignedRefDriftLength();
  } else if (m_fitPos == EFitPos::c_WirePos) {
    fitPos2D = recoHit2D.getWire().getRefPos2D();
    signedDriftLength = 0;
  }
 
  const double driftLength = recoHit2D.getRefDriftLength();
  const ERightLeft rlInfo = recoHit2D.getRLInfo();
 
  double variance = recoHit2D.getRefDriftLengthVariance();
  if (m_fitVariance == EFitVariance::c_Unit) {
    variance = 1;
  } else if (m_fitVariance == EFitVariance::c_Nominal) {
    variance = CDCWireHit::c_simpleDriftLengthVariance;
  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
    variance = std::fabs(driftLength);
  } else if (m_fitVariance == EFitVariance::c_Pseudo or abs(rlInfo) != 1) {
    // Fall back to the pseudo variance if the rl information is not known
    variance = getPseudoDriftLengthVariance(driftLength, variance);
  } else if (m_fitVariance == EFitVariance::c_Proper) {
    variance = recoHit2D.getRefDriftLengthVariance();
  }
  return fill(fitPos2D, signedDriftLength, 1 / variance);
}

append() [3/8]

std::size_t append

(

const CDCRecoHit3D &

recoHit3D

)

Appends the observed position.

Definition at line 206 of file CDCObservations2D.cc.

{
  Vector2D fitPos2D = recoHit3D.getRecoPos2D();
  double signedDriftLength = 0;
  if (m_fitPos == EFitPos::c_RecoPos) {
    fitPos2D = recoHit3D.getRecoPos2D();
    signedDriftLength = 0;
  } else if (m_fitPos == EFitPos::c_RLDriftCircle) {
    fitPos2D = recoHit3D.getRecoWirePos2D();
    signedDriftLength = recoHit3D.getSignedRecoDriftLength();
  } else if (m_fitPos == EFitPos::c_WirePos) {
    fitPos2D = recoHit3D.getRecoWirePos2D();
    signedDriftLength = 0;
  }
 
  const double driftLength = std::fabs(recoHit3D.getSignedRecoDriftLength());
  const ERightLeft rlInfo = recoHit3D.getRLInfo();
 
  double variance = recoHit3D.getRecoDriftLengthVariance();
  if (m_fitVariance == EFitVariance::c_Unit) {
    variance = 1;
  } else if (m_fitVariance == EFitVariance::c_Nominal) {
    variance = CDCWireHit::c_simpleDriftLengthVariance;
  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
    variance = std::fabs(driftLength);
  } else if (m_fitVariance == EFitVariance::c_Pseudo or abs(rlInfo) != 1) {
    // Fall back to the pseudo variance if the rl information is not known
    variance = getPseudoDriftLengthVariance(driftLength, variance);
  } else if (m_fitVariance == EFitVariance::c_Proper) {
    variance = recoHit3D.getRecoDriftLengthVariance();
  }
  return fill(fitPos2D, signedDriftLength, 1 / variance);
}

append() [4/8]

std::size_t append

(

const CDCRLWireHit &

rlWireHit

)

Appends the hit circle at wire reference position with a right left passage hypotheses.

Note

Observations are skipped, if one of the contained variables is NAN.

The left right passage information is always set to the right left passage hypotheses of the give hit.

Parameters

rlWireHit

Hit information to be appended as observation. XY position, signed drift length and inverse variance are taken at the wire reference position.

Returns

Number of observations added. One if the observation was added. Zero if one of the given variables is NAN.

Definition at line 107 of file CDCObservations2D.cc.

{
  const ERightLeft rlInfo = rlWireHit.getRLInfo();
 
  const double driftLength = rlWireHit.getRefDriftLength();
  const double driftLengthVariance = rlWireHit.getRefDriftLengthVariance();
 
  const Vector2D& wireRefPos2D = rlWireHit.getRefPos2D();
 
  double signedDriftLength = 0;
  if (m_fitPos == EFitPos::c_RLDriftCircle and isValid(rlInfo)) {
    signedDriftLength = static_cast<double>(rlInfo) * driftLength;
  } else {
    signedDriftLength = 0;
  }
 
  double variance = 1;
  if (m_fitVariance == EFitVariance::c_Unit) {
    variance = 1;
  } else if (m_fitVariance == EFitVariance::c_Nominal) {
    variance = CDCWireHit::c_simpleDriftLengthVariance;
  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
    variance = fabs(driftLength);
  } else if (m_fitVariance == EFitVariance::c_Pseudo) {
    variance = getPseudoDriftLengthVariance(driftLength, driftLengthVariance);
  } else if (m_fitVariance == EFitVariance::c_Proper) {
    if (abs(rlInfo) != 1) {
      variance = getPseudoDriftLengthVariance(driftLength, driftLengthVariance);
    } else {
      variance = driftLengthVariance;
    }
  }
 
  return fill(wireRefPos2D, signedDriftLength, 1 / variance);
}

append() [5/8]

std::size_t append

(

const CDCRLWireHitPair &

rlWireHitPair

)

Appends the two observed position.

Definition at line 143 of file CDCObservations2D.cc.

{
  return append(rlWireHitPair.getFromRLWireHit()) + append(rlWireHitPair.getToRLWireHit());
}

append() [6/8]

std::size_t append

(

const CDCRLWireHitTriple &

rlWireHitTriple

)

Appends the three observed position.

Definition at line 148 of file CDCObservations2D.cc.

{
  return append(rlWireHitTriple.getStartRLWireHit()) +
         append(rlWireHitTriple.getMiddleRLWireHit()) + append(rlWireHitTriple.getEndRLWireHit());
}

append() [7/8]

std::size_t append	(	const CDCWireHit &	wireHit,
		ERightLeft	rlInfo = ERightLeft::c_Unknown
	)

Appends the hit circle at wire reference position without a right left passage hypotheses.

Note

Observations are skipped, if one of the contained variables is NAN.

The left right passage information is always set to ERightLeft::c_Right, since on specific assumption can be made from the wire hit alone.

Parameters

wireHit	Hit information to be appended as observation. XY position, drift length and inverse variance are taken at the wire reference position.
rlInfo	Right left passage information with which the drift length should be signed.

Returns

Number of observations added. One if the observation was added. Zero if one of the given variables is NAN.

Definition at line 67 of file CDCObservations2D.cc.

{
  const Vector2D& wireRefPos2D = wireHit.getRefPos2D();
 
  double signedDriftLength = 0;
  if (m_fitPos == EFitPos::c_RLDriftCircle and isValid(rlInfo)) {
    signedDriftLength = static_cast<double>(rlInfo) * wireHit.getRefDriftLength();
  } else {
    signedDriftLength = 0;
  }
 
  double variance = 1;
  if (m_fitVariance == EFitVariance::c_Unit) {
    variance = 1;
  } else if (m_fitVariance == EFitVariance::c_Nominal) {
    variance = CDCWireHit::c_simpleDriftLengthVariance;
  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
    const double driftLength = wireHit.getRefDriftLength();
    variance = fabs(driftLength);
  } else if (m_fitVariance == EFitVariance::c_Pseudo) {
    variance = getPseudoDriftLengthVariance(wireHit);
  } else if (m_fitVariance == EFitVariance::c_Proper) {
    if (abs(rlInfo) != 1) {
      variance = getPseudoDriftLengthVariance(wireHit);
    } else {
      variance = wireHit.getRefDriftLengthVariance();
    }
  }
  return fill(wireRefPos2D, signedDriftLength, 1 / variance);
}

append() [8/8]

std::size_t append	(	const CDCWireHit *	wireHit,
		ERightLeft	rlInfo = ERightLeft::c_Unknown
	)

Appends the position information of the given wire hit to the stored observations.

Optionally includes the drift length with the given right left orientation

Parameters

wireHit	Hit information to be appended as observation.
rlInfo	Right left passage information with which the drift length should be signed.

Returns

Number of observations added. One if the observation was added. Zero if one of the given variables is NAN.

Definition at line 98 of file CDCObservations2D.cc.

{
  if (wireHit) {
    return append(*(wireHit), rlInfo);
  } else {
    return 0;
  }
}

appendRange() [1/7]

std::size_t appendRange ( const ARange &  range )

inline

Append all hits from a generic range.

Definition at line 252 of file CDCObservations2D.h.

      {
        std::size_t nAppendedHits = 0;
        using std::begin;
        using std::end;
        for (const auto& item : range) {
          nAppendedHits += append(item);
        }
        return nAppendedHits;
      }

appendRange() [2/7]

std::size_t appendRange

(

const CDCAxialSegmentPair &

axialSegmentPair

)

Appends all reconstructed hits from the two axial segments,.

Returns

Number of added hits

Definition at line 258 of file CDCObservations2D.cc.

{
  std::size_t nAppendedHits = 0;
  const CDCSegment2D* ptrStartSegment2D = axialSegmentPair.getStartSegment();
  if (ptrStartSegment2D) {
    const CDCSegment2D& startSegment2D = *ptrStartSegment2D;
    nAppendedHits += appendRange(startSegment2D);
  }
 
  const CDCSegment2D* ptrEndSegment2D = axialSegmentPair.getEndSegment();
  if (ptrEndSegment2D) {
    const CDCSegment2D& endSegment2D = *ptrEndSegment2D;
    nAppendedHits += appendRange(endSegment2D);
  }
  return nAppendedHits;
}

appendRange() [3/7]

std::size_t appendRange

(

const CDCSegment2D &

segment2D

)

Appends all reconstructed hits from the two dimensional segment.

Returns

Number of added hits

Definition at line 240 of file CDCObservations2D.cc.

{
  std::size_t nAppendedHits = 0;
  for (const CDCRecoHit2D& recoHit2D : segment2D) {
    nAppendedHits += append(recoHit2D);
  }
  return nAppendedHits;
}

appendRange() [4/7]

std::size_t appendRange

(

const CDCSegment3D &

segment3D

)

Appends all reconstructed hits from the three dimensional segment.

Returns

Number of added hits

Definition at line 249 of file CDCObservations2D.cc.

{
  std::size_t nAppendedHits = 0;
  for (const CDCRecoHit3D& recoHit3D : segment3D) {
    nAppendedHits += append(recoHit3D);
  }
  return nAppendedHits;
}

appendRange() [5/7]

std::size_t appendRange

(

const CDCTrack &

track

)

Appends all reconstructed hits from the three dimensional track.

Returns

Number of added hits

Definition at line 275 of file CDCObservations2D.cc.

{
  std::size_t nAppendedHits = 0;
  for (const CDCRecoHit3D& recoHit3D : track) {
    nAppendedHits += append(recoHit3D);
  }
  return nAppendedHits;
}

appendRange() [6/7]

std::size_t appendRange

(

const CDCWireHitSegment &

wireHits

)

Appends all the wire hit reference positions with the pseudo variance.

Note

For cross check to Legendre finder.

Returns

Number of added hits

Definition at line 298 of file CDCObservations2D.cc.

{
  std::size_t nAppendedHits = 0;
  for (const CDCWireHit* ptrWireHit : wireHits) {
    if (not ptrWireHit) continue;
    const CDCWireHit& wireHit = *ptrWireHit;
    nAppendedHits += append(wireHit);
  }
  return nAppendedHits;
}

appendRange() [7/7]

std::size_t appendRange

(

const std::vector< const CDCWire * > &

wires

)

Appends all the reference wire positions.

Note

For cross check to Legendre finder.

Returns

Number of added hits

Definition at line 284 of file CDCObservations2D.cc.

{
  std::size_t nAppendedHits = 0;
  for (const CDCWire* ptrWire : wires) {
    if (not ptrWire) continue;
    const CDCWire& wire = *ptrWire;
    const Vector2D& wirePos = wire.getRefPos2D();
    const double driftLength = 0.0;
    const double weight = 1.0;
    nAppendedHits += fill(wirePos, driftLength, weight);
  }
  return nAppendedHits;
}

centralize()

Vector2D centralize

(

)

Picks one observation as a reference point and transform all observations to that new origin.

Definition at line 352 of file CDCObservations2D.cc.

{
  // Pick an observation at the center
  Vector2D centralPoint = getCentralPoint();
  passiveMoveBy(centralPoint);
  return centralPoint;
}

clear()

void clear ( )

inline

Removes all observations stored.

Definition at line 96 of file CDCObservations2D.h.

      {
        m_observations.clear();
      }

data()

double * data ( )

inline

Return the pointer to the number buffer.

Definition at line 84 of file CDCObservations2D.h.

      {
        return m_observations.data();
      }

empty()

bool empty ( ) const

inline

Returns true if there are no observations stored.

Definition at line 90 of file CDCObservations2D.h.

      {
        return m_observations.empty();
      }

fill() [1/2]

std::size_t fill	(	const Vector2D &	pos2D,
		double	signedRadius = 0.0,
		double	weight = 1.0
	)

Appends the observed position.

Note

Observations are skipped, if one of the given variables is NAN.

Parameters

pos2D	X, Y coordinate of the center of the observed circle.
signedRadius	The radius of the observed circle signed with right left passage hypotheses. Defaults to 0.
weight	The relative weight of the observation. In order to generate a unit less chi^2 measure the weight should be chosen as the inverse variance of the drift length. Defaults to 1.

Returns

Number of observations added. One if the observation was added. Zero if one of the given variables is NAN.

Definition at line 62 of file CDCObservations2D.cc.

{
  return fill(pos2D.x(), pos2D.y(), signedRadius, weight);
}

fill() [2/2]

std::size_t fill	(	double	x,
		double	y,
		double	signedRadius = 0.0,
		double	weight = 1.0
	)

Appends the observed position.

Note

Observations are skipped, if one of the given variables is NAN.

Parameters

x	X coordinate of the center of the observed circle.
y	Y coordinate of the center of the observed circle.
signedRadius	The radius of the observed circle signed with right left passage hypotheses. Defaults to 0.
weight	The relative weight of the observation. In order to generate a unit less chi^2 measure the weight should be chosen as the inverse variance of the drift length. Defaults to 1.

Returns

Number of observations added. One if the observation was added. Zero if one of the given variables is NAN.

Definition at line 39 of file CDCObservations2D.cc.

{
  if (std::isnan(x)) return 0;
  if (std::isnan(y)) return 0;
 
  if (std::isnan(signedRadius)) {
    B2WARNING("Signed radius is nan. Skipping observation");
    return 0;
  }
 
  if (std::isnan(weight)) {
    B2WARNING("Weight is nan. Skipping observation");
    return 0;
  }
 
  m_observations.push_back(x);
  m_observations.push_back(y);
  m_observations.push_back(signedRadius);
  m_observations.push_back(weight);
  return 1;
}

getBackPos2D()

Vector2D getBackPos2D ( ) const

inline

Get the position of the first observation.

Definition at line 270 of file CDCObservations2D.h.

      {
        return empty() ? Vector2D() : Vector2D(getX(size() - 1), getY(size() - 1));
      }

getCentralPoint()

Vector2D getCentralPoint

(

)

const

Extracts the observation center that is at the index in the middle.

Definition at line 328 of file CDCObservations2D.cc.

{
  std::size_t n = size();
  if (n == 0) return Vector2D(NAN, NAN);
  std::size_t i = n / 2;
 
  if (isEven(n)) {
    // For even number of observations use the middle one with the bigger distance from IP
    Vector2D center1(getX(i), getY(i));
    Vector2D center2(getX(i - 1), getY(i - 1));
    return center1.normSquared() > center2.normSquared() ? center1 : center2;
  } else {
    Vector2D center1(getX(i), getY(i));
    return center1;
  }
}

getDriftLength()

double getDriftLength ( int  iObservation ) const

inline

Getter for the signed drift radius of the observation at the given index.

Definition at line 120 of file CDCObservations2D.h.

      {
        return m_observations[iObservation * 4 + 2];
      }

getFitPos()

EFitPos getFitPos ( ) const

inline

Getter for the indicator that the reconstructed position should be favoured.

Definition at line 314 of file CDCObservations2D.h.

      {
        return m_fitPos;
      }

getFrontPos2D()

Vector2D getFrontPos2D ( ) const

inline

Get the position of the first observation.

Definition at line 264 of file CDCObservations2D.h.

      {
        return empty() ? Vector2D() : Vector2D(getX(0), getY(0));
      }

getNObservationsWithDriftRadius()

std::size_t getNObservationsWithDriftRadius

(

)

const

Returns the number of observations having a drift radius radius.

Definition at line 314 of file CDCObservations2D.cc.

{
  std::size_t result = 0;
  Index nObservations = size();
 
  for (Index iObservation = 0; iObservation < nObservations; ++iObservation) {
    const double driftLength = getDriftLength(iObservation);
    bool hasDriftLength = (driftLength != 0.0);
    result += hasDriftLength ? 1 : 0;
  }
 
  return result;
}

getPseudoDriftLengthVariance() [1/2]

double getPseudoDriftLengthVariance ( const CDCWireHit &  wireHit )

static

Calculate the pseudo variance from the drift length and its variance.

Definition at line 32 of file CDCObservations2D.cc.

{
  return getPseudoDriftLengthVariance(wireHit.getRefDriftLength(),
                                      wireHit.getRefDriftLengthVariance());
}

getPseudoDriftLengthVariance() [2/2]

static double getPseudoDriftLengthVariance ( double  driftLength, double  driftLengthVariance  )

inlinestatic

Gets the pseudo variance.

The pseudo drift length variance is a measure that tries to incorporate the drift length into the fit to drift circles where the right left passage ambiguity could not be resolved. In such situations only the position of an hit can be used, however if only the position that can be determined is the wire position the information of the drift length should at least weaken the gravity of that wire in relation to the fitted trajectory. The pseudo variance is therefore the square of the drift length itself (square for unit conformity) plus its reference drift length variance.

Definition at line 68 of file CDCObservations2D.h.

      {
        return driftLength * driftLength + driftLengthVariance;
      }

getTotalPerpS()

double getTotalPerpS

(

const CDCTrajectory2D &

trajectory2D

)

const

Calculate the total transverse travel distance traversed by these observations comparing the travel distance of first and last position.

Definition at line 309 of file CDCObservations2D.cc.

{
  return trajectory2D.calcArcLength2DBetween(getFrontPos2D(), getBackPos2D());
}

getWeight()

double getWeight ( int  iObservation ) const

inline

Getter for the weight / inverse variance of the observation at the given index.

Definition at line 126 of file CDCObservations2D.h.

      {
        return m_observations[iObservation * 4 + 3];
      }

getX()

double getX ( int  iObservation ) const

inline

Getter for the x value of the observation at the given index.

Definition at line 108 of file CDCObservations2D.h.

      {
        return m_observations[iObservation * 4];
      }

getY()

double getY ( int  iObservation ) const

inline

Getter for the y value of the observation at the given index.

Definition at line 114 of file CDCObservations2D.h.

      {
        return m_observations[iObservation * 4 + 1];
      }

isCoaligned()

EForwardBackward isCoaligned ( const CDCTrajectory2D &  trajectory2D ) const

inline

Checks if the last observation in the vector lies at greater or lower travel distance than the last observation.

Return values

EForwardBackward::c_Forward	if the last observation lies behind the first.
EForwardBackward::c_Backward	if the last observation lies before the first.

Definition at line 295 of file CDCObservations2D.h.

      {
        return static_cast<EForwardBackward>(sign(getTotalPerpS(trajectory2D)));
      }

isForwardTrajectory()

bool isForwardTrajectory ( const CDCTrajectory2D &  trajectory2D ) const

inline

Checks if the last position of these observations lies at greater travel distance than the first.

Definition at line 285 of file CDCObservations2D.h.

      {
        return getTotalPerpS(trajectory2D) > 0.0;
      }

passiveMoveBy()

void passiveMoveBy

(

const Vector2D &

origin

)

Moves all observations passively such that the given vector becomes to origin of the new coordinate system.

Definition at line 345 of file CDCObservations2D.cc.

{
  Eigen::Matrix<double, 1, 2> eigenOrigin(origin.x(), origin.y());
  EigenObservationMatrix eigenObservations = getEigenObservationMatrix(this);
  eigenObservations.leftCols<2>().rowwise() -= eigenOrigin;
}

reserve()

void reserve ( std::size_t  nObservations )

inline

Reserves enough space for nObservations.

Definition at line 102 of file CDCObservations2D.h.

      {
        m_observations.reserve(nObservations * 4);
      }

setFitPos()

void setFitPos ( EFitPos  fitPos )

inline

Setter for the indicator that the reconstructed position should be favoured.

Definition at line 320 of file CDCObservations2D.h.

      {
        m_fitPos = fitPos;
      }

setFitVariance()

void setFitVariance ( EFitVariance  fitVariance )

inline

Setter for the indicator that the drift variance should be used.

Definition at line 326 of file CDCObservations2D.h.

      {
        m_fitVariance = fitVariance;
      }

size()

std::size_t size ( ) const

inline

Returns the number of observations stored.

Definition at line 78 of file CDCObservations2D.h.

      {
        return m_observations.size() / 4;
      }

Member Data Documentation

m_fitPos

EFitPos m_fitPos

private

Indicator which positional information should preferably be extracted from hits in calls to append.

Meaning of the constants detailed in EFitPos.

Definition at line 343 of file CDCObservations2D.h.

m_fitVariance

EFitVariance m_fitVariance

private

Indicator which variance information should preferably be extracted from hits in calls to append.

Meaning of the constants detailed in EFitVariance.

Definition at line 350 of file CDCObservations2D.h.

m_observations

std::vector<double> m_observations

private

Memory for the individual observations.

Arrangement of values is x,y, drift radius, weight, x, y, .....

Definition at line 336 of file CDCObservations2D.h.

---

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

• tracking/trackFindingCDC/fitting/include/CDCObservations2D.h
• tracking/trackFindingCDC/fitting/src/CDCObservations2D.cc