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 TrackingUtilities::Vector2D &pos2D, double signedRadius=0.0, double weight=1.0)
	Appends the observed position.
std::size_t	append (const TrackingUtilities::CDCWireHit &wireHit, TrackingUtilities::ERightLeft rlInfo=TrackingUtilities::ERightLeft::c_Unknown)
	Appends the hit circle at wire reference position without a right left passage hypotheses.
std::size_t	append (const TrackingUtilities::CDCWireHit *wireHit, TrackingUtilities::ERightLeft rlInfo=TrackingUtilities::ERightLeft::c_Unknown)
	Appends the position information of the given wire hit to the stored observations.
std::size_t	append (const TrackingUtilities::CDCRLWireHit &rlWireHit)
	Appends the hit circle at wire reference position with a right left passage hypotheses.
std::size_t	append (const TrackingUtilities::CDCRLWireHitPair &rlWireHitPair)
	Appends the two observed position.
std::size_t	append (const TrackingUtilities::CDCRLWireHitTriple &rlWireHitTriple)
	Appends the three observed position.
std::size_t	append (const TrackingUtilities::CDCFacet &facet)
	Appends the three observed position.
std::size_t	append (const TrackingUtilities::CDCRecoHit2D &recoHit2D)
	Appends the hit using the reconstructed position if useRecoPos indicates it.
std::size_t	append (const TrackingUtilities::CDCRecoHit3D &recoHit3D)
	Appends the observed position.
std::size_t	appendRange (const TrackingUtilities::CDCSegment2D &segment2D)
	Appends all reconstructed hits from the two dimensional segment.
std::size_t	appendRange (const TrackingUtilities::CDCSegment3D &segment3D)
	Appends all reconstructed hits from the three dimensional segment.
std::size_t	appendRange (const TrackingUtilities::CDCAxialSegmentPair &axialSegmentPair)
	Appends all reconstructed hits from the two axial segments,.
std::size_t	appendRange (const TrackingUtilities::CDCTrack &track)
	Appends all reconstructed hits from the three dimensional track.
std::size_t	appendRange (const std::vector< const CDC::CDCWire * > &wires)
	Appends all the reference wire positions.
std::size_t	appendRange (const TrackingUtilities::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.
TrackingUtilities::Vector2D	getFrontPos2D () const
	Get the position of the first observation.
TrackingUtilities::Vector2D	getBackPos2D () const
	Get the position of the first observation.
double	getTotalPerpS (const TrackingUtilities::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 TrackingUtilities::CDCTrajectory2D &trajectory2D) const
	Checks if the last position of these observations lies at greater travel distance than the first.
TrackingUtilities::EForwardBackward	isCoaligned (const TrackingUtilities::CDCTrajectory2D &trajectory2D) const
	Checks if the last observation in the vector lies at greater or lower travel distance than the last observation.
TrackingUtilities::Vector2D	getCentralPoint () const
	Extracts the observation center that is at the index in the middle.
void	passiveMoveBy (const TrackingUtilities::Vector2D &origin)
	Moves all observations passively such that the given vector becomes to origin of the new coordinate system.
TrackingUtilities::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 TrackingUtilities::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 48 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 55 of file CDCObservations2D.h.

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

Member Function Documentation

append() [1/8]

std::size_t append

(

const TrackingUtilities::CDCFacet &

facet

)

Appends the three observed position.

Definition at line 156 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 TrackingUtilities::CDCRecoHit2D &

recoHit2D

)

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

Definition at line 167 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 TrackingUtilities::CDCRecoHit3D &

recoHit3D

)

Appends the observed position.

Definition at line 208 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 TrackingUtilities::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 109 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 TrackingUtilities::CDCRLWireHitPair &

rlWireHitPair

)

Appends the two observed position.

Definition at line 145 of file CDCObservations2D.cc.

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

append() [6/8]

std::size_t append

(

const TrackingUtilities::CDCRLWireHitTriple &

rlWireHitTriple

)

Appends the three observed position.

Definition at line 150 of file CDCObservations2D.cc.

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

append() [7/8]

std::size_t append	(	const TrackingUtilities::CDCWireHit &	wireHit,
		TrackingUtilities::ERightLeft	rlInfo = TrackingUtilities::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 69 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 TrackingUtilities::CDCWireHit *	wireHit,
		TrackingUtilities::ERightLeft	rlInfo = TrackingUtilities::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 100 of file CDCObservations2D.cc.

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

appendRange() [1/7]

template<class ARange>

std::size_t appendRange ( const ARange & range )

inline

Append all hits from a generic range.

Definition at line 259 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 std::vector< const CDC::CDCWire * > &

wires

)

Appends all the reference wire positions.

Note

For cross check to Legendre finder.

Returns

Number of added hits

Definition at line 286 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;
}

appendRange() [3/7]

std::size_t appendRange

(

const TrackingUtilities::CDCAxialSegmentPair &

axialSegmentPair

)

Appends all reconstructed hits from the two axial segments,.

Returns

Number of added hits

Definition at line 260 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() [4/7]

std::size_t appendRange

(

const TrackingUtilities::CDCSegment2D &

segment2D

)

Appends all reconstructed hits from the two dimensional segment.

Returns

Number of added hits

Definition at line 242 of file CDCObservations2D.cc.

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

appendRange() [5/7]

std::size_t appendRange

(

const TrackingUtilities::CDCSegment3D &

segment3D

)

Appends all reconstructed hits from the three dimensional segment.

Returns

Number of added hits

Definition at line 251 of file CDCObservations2D.cc.

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

appendRange() [6/7]

std::size_t appendRange

(

const TrackingUtilities::CDCTrack &

track

)

Appends all reconstructed hits from the three dimensional track.

Returns

Number of added hits

Definition at line 277 of file CDCObservations2D.cc.

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

appendRange() [7/7]

std::size_t appendRange

(

const TrackingUtilities::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 300 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;
}

centralize()

Vector2D centralize

(

)

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

Definition at line 354 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 101 of file CDCObservations2D.h.

      {
        m_observations.clear();
      }

data()

double * data ( )

inline

Return the pointer to the number buffer.

Definition at line 89 of file CDCObservations2D.h.

      {
        return m_observations.data();
      }

empty()

bool empty ( ) const

inline

Returns true if there are no observations stored.

Definition at line 95 of file CDCObservations2D.h.

      {
        return m_observations.empty();
      }

fill() [1/2]

std::size_t fill	(	const TrackingUtilities::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 64 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 41 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()

TrackingUtilities::Vector2D getBackPos2D ( ) const

inline

Get the position of the first observation.

Definition at line 277 of file CDCObservations2D.h.

      {
        return empty() ? TrackingUtilities::Vector2D() : TrackingUtilities::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 330 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 125 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 321 of file CDCObservations2D.h.

      {
        return m_fitPos;
      }

getFrontPos2D()

TrackingUtilities::Vector2D getFrontPos2D ( ) const

inline

Get the position of the first observation.

Definition at line 271 of file CDCObservations2D.h.

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

getNObservationsWithDriftRadius()

std::size_t getNObservationsWithDriftRadius

(

)

const

Returns the number of observations having a drift radius radius.

Definition at line 316 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 TrackingUtilities::CDCWireHit & wireHit )

static

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

Definition at line 34 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 73 of file CDCObservations2D.h.

      {
        return driftLength * driftLength + driftLengthVariance;
      }

getTotalPerpS()

double getTotalPerpS

(

const TrackingUtilities::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 311 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 131 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 113 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 119 of file CDCObservations2D.h.

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

isCoaligned()

TrackingUtilities::EForwardBackward isCoaligned ( const TrackingUtilities::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 302 of file CDCObservations2D.h.

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

isForwardTrajectory()

bool isForwardTrajectory ( const TrackingUtilities::CDCTrajectory2D & trajectory2D ) const

inline

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

Definition at line 292 of file CDCObservations2D.h.

      {
        return getTotalPerpS(trajectory2D) > 0.0;
      }

passiveMoveBy()

void passiveMoveBy

(

const TrackingUtilities::Vector2D &

origin

)

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

Definition at line 347 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 107 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 327 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 333 of file CDCObservations2D.h.

      {
        m_fitVariance = fitVariance;
      }

size()

std::size_t size ( ) const

inline

Returns the number of observations stored.

Definition at line 83 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 350 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 357 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 343 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