TwoBodyDecayTrajectory Class Reference

#include <TwoBodyDecayTrajectory.h>

Inheritance diagram for TwoBodyDecayTrajectory:

Public Types
typedef std::pair< ConstRecHitContainer, ConstRecHitContainer >	ConstRecHitCollection
typedef TransientTrackingRecHit::ConstRecHitContainer	ConstRecHitContainer
Public Types inherited from ReferenceTrajectoryBase
enum	MaterialEffects {   none, multipleScattering, energyLoss, combined,   breakPoints, brokenLinesCoarse, brokenLinesFine, localGBL,   curvlinGBL }
typedef ReferenceCountingPointer< ReferenceTrajectoryBase >	ReferenceTrajectoryPtr

Public Member Functions
virtual TwoBodyDecayTrajectory *	clone (void) const
const std::pair< int, int >	numberOfRecHits (void)
	TwoBodyDecayTrajectory (const TwoBodyDecayTrajectoryState &tsos, const ConstRecHitCollection &recHits, const MagneticField *magField, const reco::BeamSpot &beamSpot, const ReferenceTrajectoryBase::Config &config)
	TwoBodyDecayTrajectory (void)
	~TwoBodyDecayTrajectory (void)
Public Member Functions inherited from ReferenceTrajectoryBase
const AlgebraicMatrix &	derivatives () const
const Eigen::MatrixXd &	gblExtDerivatives () const
const Eigen::VectorXd &	gblExtMeasurements () const
const Eigen::VectorXd &	gblExtPrecisions () const
std::vector< std::pair< std::vector< gbl::GblPoint >, Eigen::MatrixXd > > &	gblInput ()
bool	isValid ()
const AlgebraicMatrix &	localToTrajectory () const
const AlgebraicSymMatrix &	measurementErrors () const
const AlgebraicVector &	measurements () const
int	nominalField () const
unsigned int	numberOfHitMeas () const
unsigned int	numberOfHits () const
unsigned int	numberOfPar () const
unsigned int	numberOfVirtualMeas () const
unsigned int	numberOfVirtualPar () const
const AlgebraicSymMatrix &	parameterErrors () const
bool	parameterErrorsAvailable () const
const AlgebraicVector &	parameters () const
const TransientTrackingRecHit::ConstRecHitContainer &	recHits () const
void	setParameterErrors (const AlgebraicSymMatrix &error)
const AlgebraicSymMatrix &	trajectoryPositionErrors () const
const AlgebraicVector &	trajectoryPositions () const
const std::vector< TrajectoryStateOnSurface > &	trajectoryStates () const
const AlgebraicMatrix &	trajectoryToCurv () const
virtual	~ReferenceTrajectoryBase ()

Private Member Functions
bool	construct (const TwoBodyDecayTrajectoryState &state, const ConstRecHitCollection &recHits, const MagneticField *field, const reco::BeamSpot &beamSpot)
void	constructSingleTsosWithErrors (const TrajectoryStateOnSurface &tsos, int iTsos, const MagneticField *field)
void	constructTsosVecWithErrors (const ReferenceTrajectory &traj1, const ReferenceTrajectory &traj2, const MagneticField *field)

Private Attributes
const bool	constructTsosWithErrors_
const MaterialEffects	materialEffects_
const PropagationDirection	propDir_
std::pair< int, int >	theNumberOfRecHits
const bool	useRefittedState_

Additional Inherited Members
Protected Member Functions inherited from ReferenceTrajectoryBase
unsigned int	numberOfUsedRecHits (const TransientTrackingRecHit::ConstRecHitContainer &recHits) const
	ReferenceTrajectoryBase (unsigned int nPar, unsigned int nHits, unsigned int nVirtualPar, unsigned int nVirtualMeas)
bool	useRecHit (const TransientTrackingRecHit::ConstRecHitPointer &hitPtr) const
Protected Attributes inherited from ReferenceTrajectoryBase
AlgebraicMatrix	theDerivatives
Eigen::MatrixXd	theGblExtDerivatives
Eigen::VectorXd	theGblExtMeasurements
Eigen::VectorXd	theGblExtPrecisions
std::vector< std::pair< std::vector< gbl::GblPoint >, Eigen::MatrixXd > >	theGblInput
AlgebraicMatrix	theInnerLocalToTrajectory
AlgebraicMatrix	theInnerTrajectoryToCurvilinear
AlgebraicVector	theMeasurements
AlgebraicSymMatrix	theMeasurementsCov
int	theNomField
unsigned int	theNumberOfHits
unsigned int	theNumberOfPars
unsigned int	theNumberOfVirtualMeas
unsigned int	theNumberOfVirtualPars
bool	theParamCovFlag
AlgebraicSymMatrix	theParameterCov
AlgebraicVector	theParameters
TransientTrackingRecHit::ConstRecHitContainer	theRecHits
AlgebraicSymMatrix	theTrajectoryPositionCov
AlgebraicVector	theTrajectoryPositions
std::vector< TrajectoryStateOnSurface >	theTsosVec
bool	theValidityFlag
Static Protected Attributes inherited from ReferenceTrajectoryBase
static unsigned int	nMeasPerHit {2}

Detailed Description

Definition at line 14 of file TwoBodyDecayTrajectory.h.

Member Typedef Documentation

typedef std::pair< ConstRecHitContainer, ConstRecHitContainer > TwoBodyDecayTrajectory::ConstRecHitCollection

Definition at line 20 of file TwoBodyDecayTrajectory.h.

typedef TransientTrackingRecHit::ConstRecHitContainer TwoBodyDecayTrajectory::ConstRecHitContainer

Definition at line 19 of file TwoBodyDecayTrajectory.h.

Constructor & Destructor Documentation

TwoBodyDecayTrajectory::TwoBodyDecayTrajectory	(	const TwoBodyDecayTrajectoryState &	tsos,
		const ConstRecHitCollection &	recHits,
		const MagneticField *	magField,
		const reco::BeamSpot &	beamSpot,
		const ReferenceTrajectoryBase::Config &	config
	)

Definition at line 15 of file TwoBodyDecayTrajectory.cc.

References construct(), ReferenceTrajectoryBase::Config::hitsAreReverse, and ReferenceTrajectoryBase::theValidityFlag.

                                                                                            :
  ReferenceTrajectoryBase(
     TwoBodyDecayParameters::dimension, recHits.first.size() + recHits.second.size(),
     (config.materialEffects >= breakPoints) ? 2*(recHits.first.size() + recHits.second.size())-4 : 0,
     (config.materialEffects >= breakPoints) ? 2*(recHits.first.size() + recHits.second.size())-3 : 1 ),
  materialEffects_(config.materialEffects),
  propDir_(config.propDir),
  useRefittedState_(config.useRefittedState),
  constructTsosWithErrors_(config.constructTsosWithErrors)

{
  if ( config.hitsAreReverse )
  {
    TransientTrackingRecHit::ConstRecHitContainer::const_reverse_iterator itRecHits;
    ConstRecHitCollection fwdRecHits;

    fwdRecHits.first.reserve( recHits.first.size() );
    for ( itRecHits = recHits.first.rbegin(); itRecHits != recHits.first.rend(); ++itRecHits )
    {
      fwdRecHits.first.push_back( *itRecHits );
    }

    fwdRecHits.second.reserve( recHits.second.size() );
    for ( itRecHits = recHits.second.rbegin(); itRecHits != recHits.second.rend(); ++itRecHits )
    {
      fwdRecHits.second.push_back( *itRecHits );
    }

    theValidityFlag = this->construct(tsos, fwdRecHits, magField, beamSpot);
  }
  else
  {
    theValidityFlag = this->construct(tsos, recHits, magField, beamSpot);
  }
}

TwoBodyDecayTrajectory::TwoBodyDecayTrajectory

(

void

)

Definition at line 56 of file TwoBodyDecayTrajectory.cc.

  : ReferenceTrajectoryBase( 0, 0, 0, 0),
  materialEffects_(none),
  propDir_(anyDirection),
  useRefittedState_(false),
  constructTsosWithErrors_(false)
{}

TwoBodyDecayTrajectory::~TwoBodyDecayTrajectory ( void  )

inline

Definition at line 30 of file TwoBodyDecayTrajectory.h.

{}

Member Function Documentation

virtual TwoBodyDecayTrajectory* TwoBodyDecayTrajectory::clone ( void  ) const

inlinevirtual

Implements ReferenceTrajectoryBase.

Definition at line 32 of file TwoBodyDecayTrajectory.h.

    { return new TwoBodyDecayTrajectory( *this ); }

bool TwoBodyDecayTrajectory::construct ( const TwoBodyDecayTrajectoryState &  state, const ConstRecHitCollection &  recHits, const MagneticField *  field, const reco::BeamSpot &  beamSpot  )

private

Definition at line 65 of file TwoBodyDecayTrajectory.cc.

References cuy::col, mps_alisetup::config, constructTsosVecWithErrors(), constructTsosWithErrors_, TwoBodyDecayParameters::covariance(), TwoBodyDecayTrajectoryState::decayParameters(), TwoBodyDecayTrajectoryState::derivatives(), ReferenceTrajectoryBase::derivatives(), ReferenceTrajectoryBase::gblInput(), ReferenceTrajectoryBase::Config::hitsAreReverse, ReferenceTrajectoryBase::isValid(), ReferenceTrajectoryBase::localGBL, ReferenceTrajectoryBase::localToTrajectory(), ResonanceBuilder::mass, TwoBodyDecayParameters::mass, materialEffects_, ReferenceTrajectoryBase::measurementErrors(), ReferenceTrajectoryBase::measurements(), ReferenceTrajectoryBase::nominalField(), ReferenceTrajectoryBase::numberOfHitMeas(), ReferenceTrajectoryBase::numberOfHits(), ReferenceTrajectoryBase::numberOfPar(), ReferenceTrajectoryBase::numberOfVirtualMeas(), ReferenceTrajectoryBase::numberOfVirtualPar(), TwoBodyDecayParameters::parameters(), TwoBodyDecayTrajectoryState::particleMass(), TwoBodyDecayTrajectoryState::primaryMass(), TwoBodyDecayTrajectoryState::primaryWidth(), propDir_, ReferenceTrajectoryBase::theDerivatives, ReferenceTrajectoryBase::theGblExtDerivatives, ReferenceTrajectoryBase::theGblExtMeasurements, ReferenceTrajectoryBase::theGblExtPrecisions, ReferenceTrajectoryBase::theGblInput, ReferenceTrajectoryBase::theMeasurements, ReferenceTrajectoryBase::theMeasurementsCov, ReferenceTrajectoryBase::theNomField, ReferenceTrajectoryBase::theNumberOfHits, ReferenceTrajectoryBase::theNumberOfPars, theNumberOfRecHits, ReferenceTrajectoryBase::theNumberOfVirtualMeas, ReferenceTrajectoryBase::theNumberOfVirtualPars, ReferenceTrajectoryBase::theParameters, ReferenceTrajectoryBase::theRecHits, ReferenceTrajectoryBase::theTrajectoryPositionCov, ReferenceTrajectoryBase::theTrajectoryPositions, ReferenceTrajectoryBase::theTsosVec, ReferenceTrajectoryBase::trajectoryPositions(), TwoBodyDecayTrajectoryState::trajectoryStates(), ReferenceTrajectoryBase::trajectoryStates(), ReferenceTrajectoryBase::Config::useBeamSpot, and useRefittedState_.

Referenced by TwoBodyDecayTrajectory().

{  
  const TwoBodyDecayTrajectoryState::TsosContainer& tsos = state.trajectoryStates(useRefittedState_);
  const TwoBodyDecayTrajectoryState::Derivatives& deriv = state.derivatives();
  double mass = state.particleMass();

  //
  // first track
  //

  // construct a trajectory (hits should be already in correct order)
  ReferenceTrajectoryBase::Config config(materialEffects_, propDir_, mass);
  config.useBeamSpot = false;
  config.hitsAreReverse = false;

  ReferenceTrajectory trajectory1(tsos.first, recHits.first, field, beamSpot, config);

  // check if construction of trajectory was successful
  if ( !trajectory1.isValid() ) return false;

  //
  // second track
  //

  ReferenceTrajectory trajectory2(tsos.second, recHits.second, field, beamSpot, config);

  if ( !trajectory2.isValid() ) return false;
  
  //
  // combine both tracks
  //
  unsigned int nLocal = deriv.first.num_row();
  unsigned int nTbd   = deriv.first.num_col();

  if (materialEffects_ >= localGBL) {
    // GBL trajectory inputs
    // convert to Eigen::MatrixXd
    Eigen::MatrixXd tbdToLocal1{nLocal, nTbd};
    for (unsigned int row = 0; row < nLocal; ++row) {
      for (unsigned int col = 0; col < nTbd; ++col) {
        tbdToLocal1(row,col) = deriv.first[row][col];
      }
    }
    // add first body
    theGblInput.push_back(std::make_pair(trajectory1.gblInput().front().first, 
                                         trajectory1.gblInput().front().second*tbdToLocal1));
    // convert to Eigen::MatrixXd
    Eigen::MatrixXd tbdToLocal2{nLocal, nTbd};
    for (unsigned int row = 0; row < nLocal; ++row) {
      for (unsigned int col = 0; col < nTbd; ++col) {
        tbdToLocal2(row,col) = deriv.second[row][col];
      }
    }
    // add second body
    theGblInput.push_back(std::make_pair(trajectory2.gblInput().front().first, 
                                         trajectory2.gblInput().front().second*tbdToLocal2));
    // add virtual mass measurement
    theGblExtDerivatives.resize(1,nTbd);
    theGblExtDerivatives.setZero();
    theGblExtDerivatives(0,TwoBodyDecayParameters::mass) = 1.0;
    theGblExtMeasurements.resize(1);
    theGblExtMeasurements(0) = state.primaryMass() - state.decayParameters()[TwoBodyDecayParameters::mass];
    theGblExtPrecisions.resize(1);
    theGblExtPrecisions(0) = 1.0 / (state.primaryWidth() * state.primaryWidth());
    // nominal field
    theNomField = trajectory1.nominalField();
  } else {
    unsigned int nHitMeas1     = trajectory1.numberOfHitMeas();
    unsigned int nVirtualMeas1 = trajectory1.numberOfVirtualMeas(); 
    unsigned int nPar1         = trajectory1.numberOfPar();
    unsigned int nVirtualPar1  = trajectory1.numberOfVirtualPar(); 
     
    // derivatives of the trajectory w.r.t. to the decay parameters
    AlgebraicMatrix fullDeriv1 = trajectory1.derivatives().sub(1,nHitMeas1+nVirtualMeas1,1,nLocal) * trajectory1.localToTrajectory() * deriv.first;

    unsigned int nHitMeas2     = trajectory2.numberOfHitMeas();
    unsigned int nVirtualMeas2 = trajectory2.numberOfVirtualMeas();  
    unsigned int nPar2         = trajectory2.numberOfPar();
    unsigned int nVirtualPar2  = trajectory2.numberOfVirtualPar();

    AlgebraicMatrix fullDeriv2 = trajectory2.derivatives().sub(1,nHitMeas2+nVirtualMeas2,1,nLocal) * trajectory2.localToTrajectory() * deriv.second;

    theNumberOfRecHits.first = recHits.first.size();
    theNumberOfRecHits.second = recHits.second.size();

    theNumberOfHits = trajectory1.numberOfHits() + trajectory2.numberOfHits(); 
    theNumberOfPars = nPar1 + nPar2;
    theNumberOfVirtualPars = nVirtualPar1 + nVirtualPar2;
    theNumberOfVirtualMeas = nVirtualMeas1 + nVirtualMeas2 + 1; // add virtual mass measurement
  
    // hit measurements from trajectory 1
    int rowOffset = 1;
    int colOffset = 1; 
    theDerivatives.sub( rowOffset, colOffset,                fullDeriv1.sub(            1, nHitMeas1,                     1, nTbd ) );
    colOffset += nTbd;
    theDerivatives.sub( rowOffset, colOffset, trajectory1.derivatives().sub(            1, nHitMeas1,            nLocal + 1, nPar1 + nVirtualPar1 ) );
    // hit measurements from trajectory 2
    rowOffset += nHitMeas1;
    colOffset = 1; 
    theDerivatives.sub( rowOffset, colOffset,                fullDeriv2.sub(            1, nHitMeas2,                     1, nTbd ) );
    colOffset += (nPar1 + nVirtualPar1 + nTbd - nLocal);
    theDerivatives.sub( rowOffset, colOffset, trajectory2.derivatives().sub(            1, nHitMeas2,            nLocal + 1, nPar2 + nVirtualPar2 ) );  
    // MS measurements from trajectory 1
    rowOffset += nHitMeas2;  
    colOffset = 1; 
    theDerivatives.sub( rowOffset, colOffset,                fullDeriv1.sub(nHitMeas1 + 1, nHitMeas1 + nVirtualMeas1,          1, nTbd ) );  
    colOffset += nTbd;
    theDerivatives.sub( rowOffset, colOffset, trajectory1.derivatives().sub(nHitMeas1 + 1, nHitMeas1 + nVirtualMeas1, nLocal + 1, nPar1 + nVirtualPar1 ) ); 
    // MS measurements from trajectory 2
    rowOffset += nVirtualMeas1;  
    colOffset = 1; 
    theDerivatives.sub( rowOffset, colOffset,                fullDeriv2.sub(nHitMeas2 + 1, nHitMeas2 + nVirtualMeas2,          1, nTbd ) );
    colOffset += (nPar1 + nVirtualPar1 + nTbd - nLocal);  
    theDerivatives.sub( rowOffset, colOffset, trajectory2.derivatives().sub(nHitMeas2 + 1, nHitMeas2 + nVirtualMeas2, nLocal + 1, nPar2 + nVirtualPar2 ) ); 
        
    theMeasurements.sub(                                         1, trajectory1.measurements().sub(            1, nHitMeas1 ) );
    theMeasurements.sub( nHitMeas1                             + 1, trajectory2.measurements().sub(            1, nHitMeas2 ) );
    theMeasurements.sub( nHitMeas1 + nHitMeas2                 + 1, trajectory1.measurements().sub(nHitMeas1 + 1, nHitMeas1 + nVirtualMeas1 ) );
    theMeasurements.sub( nHitMeas1 + nHitMeas2 + nVirtualMeas1 + 1, trajectory2.measurements().sub(nHitMeas2 + 1, nHitMeas2 + nVirtualMeas2 ) );

    theMeasurementsCov.sub(                                         1, trajectory1.measurementErrors().sub(            1, nHitMeas1 ) );
    theMeasurementsCov.sub( nHitMeas1                             + 1, trajectory2.measurementErrors().sub(            1, nHitMeas2 ) );
    theMeasurementsCov.sub( nHitMeas1 + nHitMeas2                 + 1, trajectory1.measurementErrors().sub(nHitMeas1 + 1, nHitMeas1 + nVirtualMeas1 ) );
    theMeasurementsCov.sub( nHitMeas1 + nHitMeas2 + nVirtualMeas1 + 1, trajectory2.measurementErrors().sub(nHitMeas2 + 1, nHitMeas2 + nVirtualMeas2 ) );

    theTrajectoryPositions.sub(             1, trajectory1.trajectoryPositions() );
    theTrajectoryPositions.sub( nHitMeas1 + 1, trajectory2.trajectoryPositions() );

    theTrajectoryPositionCov = state.decayParameters().covariance().similarity( theDerivatives.sub(1, nHitMeas1 + nHitMeas2, 1, 9) );

    theParameters = state.decayParameters().parameters();

    // add virtual mass measurement
    rowOffset += nVirtualMeas2;
    int indMass = rowOffset-1;
    theMeasurements[indMass] = state.primaryMass() - state.decayParameters()[TwoBodyDecayParameters::mass];
    theMeasurementsCov[indMass][indMass] = state.primaryWidth() * state.primaryWidth();
    theDerivatives[indMass][TwoBodyDecayParameters::mass] = 1.0;
  }

  theRecHits.insert( theRecHits.end(), recHits.first.begin(), recHits.first.end() );
  theRecHits.insert( theRecHits.end(), recHits.second.begin(), recHits.second.end() );

  if (constructTsosWithErrors_)
  {
    constructTsosVecWithErrors( trajectory1, trajectory2, field );
  }
  else
  {
    theTsosVec.insert( theTsosVec.end(),
               trajectory1.trajectoryStates().begin(),
               trajectory1.trajectoryStates().end() );

    theTsosVec.insert( theTsosVec.end(),
               trajectory2.trajectoryStates().begin(),
               trajectory2.trajectoryStates().end() );
  }

  return true;
}

void TwoBodyDecayTrajectory::constructSingleTsosWithErrors ( const TrajectoryStateOnSurface &  tsos, int  iTsos, const MagneticField *  field  )

private

Definition at line 252 of file TwoBodyDecayTrajectory.cc.

References MillePedeFileConverter_cfg::e, TrajectoryStateOnSurface::localParameters(), LocalTrajectoryParameters::momentum(), ReferenceTrajectoryBase::nMeasPerHit, AlCaHLTBitMon_ParallelJobs::p, LocalTrajectoryParameters::signedInverseMomentum(), TrajectoryStateOnSurface::surface(), TrajectoryStateOnSurface::surfaceSide(), ReferenceTrajectoryBase::theTrajectoryPositionCov, ReferenceTrajectoryBase::theTsosVec, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by constructTsosVecWithErrors().

{
  AlgebraicSymMatrix55 localErrors;
  const double coeff = 1e-2;

  double invP = tsos.localParameters().signedInverseMomentum();
  LocalVector p = tsos.localParameters().momentum();

  // rough estimate for the errors of q/p, dx/dz and dy/dz, assuming that
  // sigma(px) = sigma(py) = sigma(pz) = coeff*p.
  float dpinv = coeff*( fabs(p.x()) + fabs(p.y()) + fabs(p.z()) )*invP*invP;
  float dxdir = coeff*( fabs(p.x()) + fabs(p.z()) )/p.z()/p.z();
  float dydir = coeff*( fabs(p.y()) + fabs(p.z()) )/p.z()/p.z();
  localErrors[0][0] = dpinv*dpinv;
  localErrors[1][1] = dxdir*dxdir;
  localErrors[2][2] = dydir*dydir;

  // exact values for the errors on local x and y
  localErrors[3][3] = theTrajectoryPositionCov[nMeasPerHit*iTsos][nMeasPerHit*iTsos];
  localErrors[3][4] = theTrajectoryPositionCov[nMeasPerHit*iTsos][nMeasPerHit*iTsos+1];
  localErrors[4][4] = theTrajectoryPositionCov[nMeasPerHit*iTsos+1][nMeasPerHit*iTsos+1];

  // construct tsos with local errors
  theTsosVec[iTsos] =  TrajectoryStateOnSurface( tsos.localParameters(),
                         LocalTrajectoryError( localErrors ),
                         tsos.surface(),
                         field,
                         tsos.surfaceSide() );
}

void TwoBodyDecayTrajectory::constructTsosVecWithErrors ( const ReferenceTrajectory &  traj1, const ReferenceTrajectory &  traj2, const MagneticField *  field  )

private

Definition at line 230 of file TwoBodyDecayTrajectory.cc.

References constructSingleTsosWithErrors(), and ReferenceTrajectoryBase::trajectoryStates().

Referenced by construct().

{
  int iTsos = 0;

  std::vector< TrajectoryStateOnSurface >::const_iterator itTsos;

  for ( itTsos = traj1.trajectoryStates().begin(); itTsos != traj1.trajectoryStates().end(); itTsos++ )
  {
    constructSingleTsosWithErrors( *itTsos, iTsos, field );
    iTsos++;
  }

  for ( itTsos = traj2.trajectoryStates().begin(); itTsos != traj2.trajectoryStates().end(); itTsos++ )
  {
    constructSingleTsosWithErrors( *itTsos, iTsos, field );
    iTsos++;
  }
}

const std::pair< int, int > TwoBodyDecayTrajectory::numberOfRecHits ( void  )

inline

Number of RecHits belonging to the first and second track.

Definition at line 37 of file TwoBodyDecayTrajectory.h.

References ecalDrivenElectronSeedsParameters_cff::beamSpot.

{ return theNumberOfRecHits; }

Member Data Documentation

const bool TwoBodyDecayTrajectory::constructTsosWithErrors_

private

Definition at line 57 of file TwoBodyDecayTrajectory.h.

Referenced by construct().

const MaterialEffects TwoBodyDecayTrajectory::materialEffects_

private

Definition at line 54 of file TwoBodyDecayTrajectory.h.

Referenced by construct().

const PropagationDirection TwoBodyDecayTrajectory::propDir_

private

Definition at line 55 of file TwoBodyDecayTrajectory.h.

Referenced by construct().

std::pair< int, int > TwoBodyDecayTrajectory::theNumberOfRecHits

private

Definition at line 59 of file TwoBodyDecayTrajectory.h.

Referenced by construct().

const bool TwoBodyDecayTrajectory::useRefittedState_

private

Definition at line 56 of file TwoBodyDecayTrajectory.h.

Referenced by construct().