BasicSingleVertexState Class Reference

#include <BasicSingleVertexState.h>

Inheritance diagram for BasicSingleVertexState:

Public Member Functions
	BasicSingleVertexState ()
	BasicSingleVertexState (const GlobalPoint &pos, const GlobalError &posErr, const double &weightInMix=1.0)
	BasicSingleVertexState (const GlobalPoint &pos, const GlobalWeight &posWeight, const double &weightInMix=1.0)
	BasicSingleVertexState (const AlgebraicVector3 &weightTimesPosition, const GlobalWeight &posWeight, const double &weightInMix=1.0)
	BasicSingleVertexState (const GlobalPoint &pos, const GlobalError &posErr, const double time, const double timeError, const double &weightInMix=1.0)
	BasicSingleVertexState (const GlobalPoint &pos, const GlobalWeight &posWeight, const double time, const double timeWeight, const double &weightInMix=1.0)
	BasicSingleVertexState (const AlgebraicVector3 &weightTimesPosition, const GlobalWeight &posWeight, const double weightTimesTime, const double timeWeight, const double &weightInMix=1.0)
	BasicSingleVertexState (const GlobalPoint &pos, const double time, const GlobalError &posTimeErr, const double &weightInMix=1.0)
	BasicSingleVertexState (const GlobalPoint &pos, const double time, const GlobalWeight &posTimeWeight, const double &weightInMix=1.0)
	BasicSingleVertexState (const AlgebraicVector4 &weightTimesPosition, const GlobalWeight &posTimeWeight, const double &weightInMix=1.0)
pointer	clone () const override
GlobalError	error () const override
GlobalError	error4D () const override
bool	is4D () const override
bool	isValid () const override
GlobalPoint	position () const override
double	time () const override
double	timeError () const override
GlobalWeight	weight () const override
GlobalWeight	weight4D () const override
double	weightInMixture () const override
AlgebraicVector3	weightTimesPosition () const override
AlgebraicVector4	weightTimesPosition4D () const override
Public Member Functions inherited from BasicVertexState
virtual std::vector< VertexState >	components () const
virtual	~BasicVertexState ()

Private Member Functions
void	computeError () const
void	computePosition () const
void	computeWeight () const
void	computeWeightTimesPos () const

Private Attributes
GlobalError	theErr
bool	theErrAvailable
GlobalPoint	thePos
bool	thePosAvailable
double	theTime
bool	theTimeAvailable
GlobalWeight	theWeight
bool	theWeightAvailable
double	theWeightInMix
AlgebraicVector4	theWeightTimesPos
bool	theWeightTimesPosAvailable
bool	valid
bool	vertexIs4D

Additional Inherited Members
Public Types inherited from BasicVertexState
using	pointer = Proxy::pointer
using	Proxy = ProxyBase11< BasicVertexState >
Static Public Member Functions inherited from BasicVertexState
template<typename T , typename... Args>
static std::shared_ptr< BasicVertexState >	build (Args &&... args)

Detailed Description

Single state measurement of a vertex. Some data is calculated on demand to improve performance.

Definition at line 12 of file BasicSingleVertexState.h.

Constructor & Destructor Documentation

BasicSingleVertexState() [1/10]

BasicSingleVertexState::BasicSingleVertexState

(

)

Constructors

Definition at line 9 of file BasicSingleVertexState.cc.

    : thePos(GlobalPoint(0, 0, 0)),
      theTime(dNaN),
      theErr(AlgebraicSymMatrix44()),
      theWeight(AlgebraicSymMatrix44()),
      theWeightTimesPos(AlgebraicVector4()),
      theWeightInMix(0.),
      thePosAvailable(false),
      theTimeAvailable(false),
      theErrAvailable(false),
      theWeightAvailable(false),
      theWeightTimesPosAvailable(false),
      valid(false),
      vertexIs4D(false) {}

BasicSingleVertexState() [2/10]

BasicSingleVertexState::BasicSingleVertexState	(	const GlobalPoint &	pos,
		const GlobalError &	posErr,
		const double &	weightInMix = 1.0
	)

Definition at line 24 of file BasicSingleVertexState.cc.

    : thePos(pos),
      theTime(dNaN),
      theErr(posErr),
      theWeight(AlgebraicSymMatrix44()),
      theWeightTimesPos(AlgebraicVector4()),
      theWeightInMix(weightInMix),
      thePosAvailable(true),
      theTimeAvailable(false),
      theErrAvailable(true),
      theWeightAvailable(false),
      theWeightTimesPosAvailable(false),
      valid(true),
      vertexIs4D(false) {}

BasicSingleVertexState() [3/10]

BasicSingleVertexState::BasicSingleVertexState	(	const GlobalPoint &	pos,
		const GlobalWeight &	posWeight,
		const double &	weightInMix = 1.0
	)

Definition at line 41 of file BasicSingleVertexState.cc.

    : thePos(pos),
      theTime(dNaN),
      theErr(AlgebraicSymMatrix44()),
      theWeight(posWeight),
      theWeightTimesPos(AlgebraicVector4()),
      theWeightInMix(weightInMix),
      thePosAvailable(true),
      theTimeAvailable(false),
      theErrAvailable(false),
      theWeightAvailable(true),
      theWeightTimesPosAvailable(false),
      valid(true),
      vertexIs4D(false) {}

BasicSingleVertexState() [4/10]

BasicSingleVertexState::BasicSingleVertexState	(	const AlgebraicVector3 &	weightTimesPosition,
		const GlobalWeight &	posWeight,
		const double &	weightInMix = 1.0
	)

Definition at line 58 of file BasicSingleVertexState.cc.

    : thePos(GlobalPoint(0, 0, 0)),
      theTime(dNaN),
      theErr(AlgebraicSymMatrix44()),
      theWeight(posWeight),
      theWeightTimesPos(weightTimesPosition[0], weightTimesPosition[1], weightTimesPosition[2], 0),
      theWeightInMix(weightInMix),
      thePosAvailable(false),
      theTimeAvailable(false),
      theErrAvailable(false),
      theWeightAvailable(true),
      theWeightTimesPosAvailable(true),
      valid(true),
      vertexIs4D(false) {}

BasicSingleVertexState() [5/10]

BasicSingleVertexState::BasicSingleVertexState	(	const GlobalPoint &	pos,
		const GlobalError &	posErr,
		const double	time,
		const double	timeError,
		const double &	weightInMix = 1.0
	)

Definition at line 76 of file BasicSingleVertexState.cc.

References theErr.

    : thePos(pos),
      theTime(time),
      theErr(posErr),
      theWeight(AlgebraicSymMatrix44()),
      theWeightTimesPos(AlgebraicVector4()),
      theWeightInMix(weightInMix),
      thePosAvailable(true),
      theTimeAvailable(true),
      theErrAvailable(true),
      theWeightAvailable(false),
      theWeightTimesPosAvailable(false),
      valid(true),
      vertexIs4D(true) {
  // You dumb bastard. It's not a schooner, its a sailboat.
  GlobalError timeErrMat(0., 0., 0., 0., 0., 0., 0., 0., 0., timeErr * timeErr);
  theErr = theErr + timeErrMat;
}

BasicSingleVertexState() [6/10]

BasicSingleVertexState::BasicSingleVertexState	(	const GlobalPoint &	pos,
		const GlobalWeight &	posWeight,
		const double	time,
		const double	timeWeight,
		const double &	weightInMix = 1.0
	)

Definition at line 99 of file BasicSingleVertexState.cc.

References theWeight.

    : thePos(pos),
      theTime(time),
      theErr(AlgebraicSymMatrix44()),
      theWeight(posWeight),
      theWeightTimesPos(AlgebraicVector4()),
      theWeightInMix(weightInMix),
      thePosAvailable(true),
      theTimeAvailable(true),
      theErrAvailable(false),
      theWeightAvailable(true),
      theWeightTimesPosAvailable(false),
      valid(true),
      vertexIs4D(true) {
  GlobalWeight timeWeightMat(0., 0., 0., 0., 0., 0., 0., 0., 0., timeWeight);
  theWeight = theWeight + timeWeightMat;
}

BasicSingleVertexState() [7/10]

BasicSingleVertexState::BasicSingleVertexState	(	const AlgebraicVector3 &	weightTimesPosition,
		const GlobalWeight &	posWeight,
		const double	weightTimesTime,
		const double	timeWeight,
		const double &	weightInMix = 1.0
	)

Definition at line 121 of file BasicSingleVertexState.cc.

References theWeight.

    : thePos(GlobalPoint(0, 0, 0)),
      theTime(dNaN),
      theErr(AlgebraicSymMatrix44()),
      theWeight(posWeight),
      theWeightTimesPos(weightTimesPosition[0], weightTimesPosition[1], weightTimesPosition[2], weightTimesTime),
      theWeightInMix(weightInMix),
      thePosAvailable(false),
      theTimeAvailable(false),
      theErrAvailable(false),
      theWeightAvailable(true),
      theWeightTimesPosAvailable(true),
      valid(true),
      vertexIs4D(true) {
  GlobalWeight timeWeightMat(0., 0., 0., 0., 0., 0., 0., 0., 0., timeWeight);
  theWeight = theWeight + timeWeightMat;
}

BasicSingleVertexState() [8/10]

BasicSingleVertexState::BasicSingleVertexState	(	const GlobalPoint &	pos,
		const double	time,
		const GlobalError &	posTimeErr,
		const double &	weightInMix = 1.0
	)

Definition at line 144 of file BasicSingleVertexState.cc.

    : thePos(pos),
      theTime(time),
      theErr(posTimeErr),
      theWeight(AlgebraicSymMatrix44()),
      theWeightTimesPos(AlgebraicVector4()),
      theWeightInMix(weightInMix),
      thePosAvailable(true),
      theTimeAvailable(true),
      theErrAvailable(true),
      theWeightAvailable(false),
      theWeightTimesPosAvailable(false),
      valid(true),
      vertexIs4D(true) {}

BasicSingleVertexState() [9/10]

BasicSingleVertexState::BasicSingleVertexState	(	const GlobalPoint &	pos,
		const double	time,
		const GlobalWeight &	posTimeWeight,
		const double &	weightInMix = 1.0
	)

Definition at line 162 of file BasicSingleVertexState.cc.

    : thePos(pos),
      theTime(time),
      theErr(AlgebraicSymMatrix44()),
      theWeight(posTimeWeight),
      theWeightTimesPos(AlgebraicVector4()),
      theWeightInMix(weightInMix),
      thePosAvailable(true),
      theTimeAvailable(true),
      theErrAvailable(false),
      theWeightAvailable(true),
      theWeightTimesPosAvailable(false),
      valid(true),
      vertexIs4D(true) {}

BasicSingleVertexState() [10/10]

BasicSingleVertexState::BasicSingleVertexState	(	const AlgebraicVector4 &	weightTimesPosition,
		const GlobalWeight &	posTimeWeight,
		const double &	weightInMix = 1.0
	)

Definition at line 180 of file BasicSingleVertexState.cc.

    : thePos(GlobalPoint(0, 0, 0)),
      theTime(dNaN),
      theErr(AlgebraicSymMatrix44()),
      theWeight(posWeight),
      theWeightTimesPos(weightTimesPosition),
      theWeightInMix(weightInMix),
      thePosAvailable(false),
      theTimeAvailable(false),
      theErrAvailable(false),
      theWeightAvailable(true),
      theWeightTimesPosAvailable(true),
      valid(true),
      vertexIs4D(true) {}

Member Function Documentation

clone()

pointer BasicSingleVertexState::clone ( void  ) const

inlineoverridevirtual

Access methods

Implements BasicVertexState.

Definition at line 55 of file BasicSingleVertexState.h.

{ return build<BasicSingleVertexState>(*this); }

computeError()

void BasicSingleVertexState::computeError ( ) const

private

Definition at line 290 of file BasicSingleVertexState.cc.

References GlobalErrorBase< T, ErrorWeightType >::matrix(), GlobalErrorBase< T, ErrorWeightType >::matrix4D(), theErr, theErrAvailable, valid, vertexIs4D, and weight4D().

Referenced by error(), error4D(), and timeError().

                                                {
  if (!valid)
    throw VertexException("BasicSingleVertexState::computeError::invalid");
  int ifail;
  if (vertexIs4D) {
    theErr = weight4D().matrix4D().Inverse(ifail);
    if (ifail != 0)
      throw VertexException("BasicSingleVertexState::could not invert weight matrix");
  } else {
    theErr = weight4D().matrix().Inverse(ifail);
    if (ifail != 0)
      throw VertexException("BasicSingleVertexState::could not invert weight matrix");
  }
  theErrAvailable = true;
}

computePosition()

void BasicSingleVertexState::computePosition ( ) const

private

Definition at line 280 of file BasicSingleVertexState.cc.

References error4D(), GlobalErrorBase< T, ErrorWeightType >::matrix4D(), thePos, thePosAvailable, theTime, theTimeAvailable, valid, and weightTimesPosition4D().

Referenced by position(), and time().

                                                   {
  if (!valid)
    throw VertexException("BasicSingleVertexState::computePosition::invalid");
  AlgebraicVector4 pos = error4D().matrix4D() * weightTimesPosition4D();
  thePos = GlobalPoint(pos[0], pos[1], pos[2]);
  theTime = pos[3];
  thePosAvailable = true;
  theTimeAvailable = true;
}

computeWeight()

void BasicSingleVertexState::computeWeight ( ) const

private

Definition at line 306 of file BasicSingleVertexState.cc.

References error4D(), GlobalErrorBase< T, ErrorWeightType >::matrix(), GlobalErrorBase< T, ErrorWeightType >::matrix4D(), theWeight, theWeightAvailable, valid, and vertexIs4D.

Referenced by weight(), and weight4D().

                                                 {
  if (!valid)
    throw VertexException("BasicSingleVertexState::computeWeight::invalid");
  int ifail;
  if (vertexIs4D) {
    theWeight = error4D().matrix4D().Inverse(ifail);
    if (ifail != 0)
      throw VertexException("BasicSingleVertexState::could not invert error matrix");
  } else {
    theWeight = error4D().matrix().Inverse(ifail);
    if (ifail != 0)
      throw VertexException("BasicSingleVertexState::could not invert error matrix");
  }
  theWeightAvailable = true;
}

computeWeightTimesPos()

void BasicSingleVertexState::computeWeightTimesPos ( ) const

private

Definition at line 322 of file BasicSingleVertexState.cc.

References GlobalErrorBase< T, ErrorWeightType >::matrix4D(), position(), theTime, theWeightTimesPos, theWeightTimesPosAvailable, valid, vertexIs4D, weight4D(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by weightTimesPosition(), and weightTimesPosition4D().

                                                         {
  if (!valid)
    throw VertexException("BasicSingleVertexState::computeWeightTimesPos::invalid");
  AlgebraicVector4 pos;
  pos(0) = position().x();
  pos(1) = position().y();
  pos(2) = position().z();
  if (vertexIs4D) {
    pos(3) = theTime;
  } else {
    pos(3) = 0.;
  }
  theWeightTimesPos = weight4D().matrix4D() * pos;
  theWeightTimesPosAvailable = true;
}

error()

GlobalError BasicSingleVertexState::error ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 205 of file BasicSingleVertexState.cc.

References computeError(), GlobalErrorBase< T, ErrorWeightType >::matrix(), theErr, theErrAvailable, and valid.

Referenced by Page1Parser.Page1Parser::check_for_whole_start_tag().

                                                {
  if (!valid)
    throw VertexException("BasicSingleVertexState::error::invalid");
  if (!theErrAvailable)
    computeError();
  return GlobalError(theErr.matrix());
}

error4D()

GlobalError BasicSingleVertexState::error4D ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 213 of file BasicSingleVertexState.cc.

References computeError(), theErr, theErrAvailable, and valid.

Referenced by computePosition(), and computeWeight().

                                                  {
  if (!valid)
    throw VertexException("BasicSingleVertexState::error4D::invalid");
  if (!theErrAvailable)
    computeError();
  return theErr;
}

is4D()

bool BasicSingleVertexState::is4D ( ) const

inlineoverridevirtual

Implements BasicVertexState.

Definition at line 72 of file BasicSingleVertexState.h.

References vertexIs4D.

{ return vertexIs4D; }

isValid()

bool BasicSingleVertexState::isValid ( void  ) const

inlineoverridevirtual

The validity of the vertex

Implements BasicVertexState.

Definition at line 71 of file BasicSingleVertexState.h.

References valid.

Referenced by ntupleDataFormat._Object::_checkIsValid(), and core.AutoHandle.AutoHandle::ReallyLoad().

{ return valid; }

position()

GlobalPoint BasicSingleVertexState::position ( ) const

overridevirtual

Access methods

Implements BasicVertexState.

Definition at line 197 of file BasicSingleVertexState.cc.

References computePosition(), thePos, thePosAvailable, and valid.

Referenced by computeWeightTimesPos().

                                                   {
  if (!valid)
    throw VertexException("BasicSingleVertexState::position::invalid");
  if (!thePosAvailable)
    computePosition();
  return thePos;
}

time()

double BasicSingleVertexState::time ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 221 of file BasicSingleVertexState.cc.

References computePosition(), theTime, theTimeAvailable, and valid.

                                          {
  if (!valid)
    throw VertexException("BasicSingleVertexState::time::invalid");
  if (!theTimeAvailable)
    computePosition();  // time computed with position (4-vector)
  return theTime;
}

timeError()

double BasicSingleVertexState::timeError ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 229 of file BasicSingleVertexState.cc.

References computeError(), GlobalErrorBase< T, ErrorWeightType >::matrix4D(), mathSSE::sqrt(), theErr, theTimeAvailable, and valid.

                                               {
  if (!valid)
    throw VertexException("BasicSingleVertexState::timeError::invalid");
  if (!theTimeAvailable)
    computeError();
  return std::sqrt(theErr.matrix4D()(3, 3));
}

weight()

GlobalWeight BasicSingleVertexState::weight ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 237 of file BasicSingleVertexState.cc.

References computeWeight(), GlobalErrorBase< T, ErrorWeightType >::matrix(), theWeight, theWeightAvailable, and valid.

                                                  {
  if (!valid)
    throw VertexException("BasicSingleVertexState::weight::invalid");
  if (!theWeightAvailable)
    computeWeight();
  return GlobalWeight(theWeight.matrix());
}

weight4D()

GlobalWeight BasicSingleVertexState::weight4D ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 245 of file BasicSingleVertexState.cc.

References computeWeight(), theWeight, theWeightAvailable, and valid.

Referenced by computeError(), and computeWeightTimesPos().

                                                    {
  if (!valid)
    throw VertexException("BasicSingleVertexState::weight4D::invalid");
  if (!theWeightAvailable)
    computeWeight();
  return theWeight;
}

weightInMixture()

double BasicSingleVertexState::weightInMixture ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 269 of file BasicSingleVertexState.cc.

References theWeightInMix, and valid.

                                                     {
  if (!valid)
    throw VertexException("BasicSingleVertexState::weightInMixture::invalid");
  return theWeightInMix;
}

weightTimesPosition()

AlgebraicVector3 BasicSingleVertexState::weightTimesPosition ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 253 of file BasicSingleVertexState.cc.

References computeWeightTimesPos(), theWeightTimesPos, theWeightTimesPosAvailable, and valid.

                                                                   {
  if (!valid)
    throw VertexException("BasicSingleVertexState::weightTimesPosition::invalid");
  if (!theWeightTimesPosAvailable)
    computeWeightTimesPos();
  return AlgebraicVector3(theWeightTimesPos[0], theWeightTimesPos[1], theWeightTimesPos[2]);
}

weightTimesPosition4D()

AlgebraicVector4 BasicSingleVertexState::weightTimesPosition4D ( ) const

overridevirtual

Implements BasicVertexState.

Definition at line 261 of file BasicSingleVertexState.cc.

References computeWeightTimesPos(), theWeightTimesPos, theWeightTimesPosAvailable, and valid.

Referenced by computePosition().

                                                                     {
  if (!valid)
    throw VertexException("BasicSingleVertexState::weightTimesPosition4D::invalid");
  if (!theWeightTimesPosAvailable)
    computeWeightTimesPos();
  return theWeightTimesPos;
}

Member Data Documentation

theErr

GlobalError BasicSingleVertexState::theErr

mutableprivate

Definition at line 83 of file BasicSingleVertexState.h.

Referenced by BasicSingleVertexState(), computeError(), error(), error4D(), and timeError().

theErrAvailable

bool BasicSingleVertexState::theErrAvailable

mutableprivate

Definition at line 91 of file BasicSingleVertexState.h.

Referenced by computeError(), error(), and error4D().

thePos

GlobalPoint BasicSingleVertexState::thePos

mutableprivate

Definition at line 80 of file BasicSingleVertexState.h.

Referenced by computePosition(), and position().

thePosAvailable

bool BasicSingleVertexState::thePosAvailable

mutableprivate

Definition at line 89 of file BasicSingleVertexState.h.

Referenced by computePosition(), and position().

theTime

double BasicSingleVertexState::theTime

mutableprivate

Definition at line 81 of file BasicSingleVertexState.h.

Referenced by computePosition(), computeWeightTimesPos(), and time().

theTimeAvailable

bool BasicSingleVertexState::theTimeAvailable

mutableprivate

Definition at line 90 of file BasicSingleVertexState.h.

Referenced by computePosition(), time(), and timeError().

theWeight

GlobalWeight BasicSingleVertexState::theWeight

mutableprivate

Definition at line 84 of file BasicSingleVertexState.h.

Referenced by BasicSingleVertexState(), computeWeight(), weight(), and weight4D().

theWeightAvailable

bool BasicSingleVertexState::theWeightAvailable

mutableprivate

Definition at line 92 of file BasicSingleVertexState.h.

Referenced by computeWeight(), weight(), and weight4D().

theWeightInMix

double BasicSingleVertexState::theWeightInMix

private

Definition at line 87 of file BasicSingleVertexState.h.

Referenced by weightInMixture().

theWeightTimesPos

AlgebraicVector4 BasicSingleVertexState::theWeightTimesPos

mutableprivate

Definition at line 86 of file BasicSingleVertexState.h.

Referenced by computeWeightTimesPos(), weightTimesPosition(), and weightTimesPosition4D().

theWeightTimesPosAvailable

bool BasicSingleVertexState::theWeightTimesPosAvailable

mutableprivate

Definition at line 93 of file BasicSingleVertexState.h.

Referenced by computeWeightTimesPos(), weightTimesPosition(), and weightTimesPosition4D().

valid

bool BasicSingleVertexState::valid

private

Definition at line 95 of file BasicSingleVertexState.h.

Referenced by computeError(), computePosition(), computeWeight(), computeWeightTimesPos(), error(), error4D(), isValid(), position(), time(), timeError(), weight(), weight4D(), weightInMixture(), weightTimesPosition(), and weightTimesPosition4D().

vertexIs4D

bool BasicSingleVertexState::vertexIs4D

private

Definition at line 96 of file BasicSingleVertexState.h.

Referenced by computeError(), computeWeight(), computeWeightTimesPos(), and is4D().