Trk::GXFTrajectory Class Reference

Internal representation of the track, used in the track fit. More...

#include <GXFTrajectory.h>

Collaboration diagram for Trk::GXFTrajectory:

Public Member Functions
	GXFTrajectory ()
	GXFTrajectory (const GXFTrajectory &rhs)
GXFTrajectory &	operator= (const GXFTrajectory &rhs)
	GXFTrajectory (GXFTrajectory &&rhs)=default
GXFTrajectory &	operator= (GXFTrajectory &&rhs)=default
	~GXFTrajectory ()=default
bool	addMeasurementState (std::unique_ptr< GXFTrackState >, int index=-1)
void	addMaterialState (std::unique_ptr< GXFTrackState >, int index=-1)
void	addBasicState (std::unique_ptr< GXFTrackState >, int index=-1)
void	setReferenceParameters (std::unique_ptr< const TrackParameters >)
void	setScatteringAngles (std::vector< std::pair< double, double > > &)
void	setBrems (std::vector< double > &)
void	setNumberOfPerigeeParameters (int)
void	setConverged (bool)
void	reset ()
void	setPrefit (int)
void	setOutlier (int, bool isoutlier=true)
void	setPrevChi2 (double)
void	setChi2 (double)
void	setMass (double)
void	conditionalSetCalorimeterEnergyLossState (GXFTrackState *)
std::pair< GXFTrackState *, GXFTrackState * >	findFirstLastMeasurement (void)
bool	hasKink (void)
int	numberOfScatterers () const
void	setNumberOfScatterers (int)
int	numberOfBrems () const
void	setNumberOfBrems (int)
int	numberOfUpstreamStates () const
int	numberOfUpstreamScatterers () const
int	numberOfUpstreamBrems () const
int	numberOfPerigeeParameters () const
int	numberOfFitParameters () const
int	numberOfSiliconHits () const
int	numberOfTRTPrecHits () const
int	numberOfTRTTubeHits () const
int	numberOfTRTHits () const
int	numberOfHits () const
int	numberOfPseudoMeasurements () const
int	numberOfOutliers () const
void	updateTRTHitCount (int index, float oldError)
const std::vector< std::unique_ptr< GXFTrackState > > &	trackStates () const
std::vector< std::unique_ptr< GXFTrackState > > &	trackStates ()
std::vector< std::pair< double, double > > &	scatteringAngles ()
std::vector< std::pair< double, double > > &	scatteringSigmas ()
std::vector< double > &	brems ()
const TrackParameters *	referenceParameters ()
bool	converged () const
int	prefit () const
void	resetReferenceParameters ()
double	chi2 () const
double	prevchi2 () const
int	nDOF () const
Amg::VectorX &	residuals ()
Amg::VectorX &	errors ()
Amg::MatrixX &	weightedResidualDerivatives ()
double	totalX0 () const
double	totalEnergyLoss () const
double	mass () const
GXFTrackState *	caloElossState ()
std::vector< std::pair< const Layer *, const Layer * > > &	upstreamMaterialLayers ()
void	resetCovariances (void)
std::unique_ptr< const FitQuality >	quality (void) const

Public Attributes
bool	m_straightline
MagneticFieldProperties	m_fieldprop = Trk::FullField

Private Attributes
std::vector< std::unique_ptr< GXFTrackState > >	m_states
	The vector of track states, i.e.
int	m_ndof
double	m_chi2
double	m_prevchi2
int	m_nperpars
int	m_nscatterers
int	m_ncaloscatterers
int	m_nbrems
int	m_nupstreamstates
int	m_nupstreamscatterers
int	m_nupstreamcaloscatterers
int	m_nupstreambrems
int	m_nhits
int	m_noutl
int	m_nsihits
int	m_ntrthits
int	m_ntrtprechits
int	m_ntrttubehits
int	m_npseudo
int	m_nmeasoutl
std::unique_ptr< const TrackParameters >	m_refpar
bool	m_converged
std::vector< std::pair< double, double > >	m_scatteringangles
std::vector< std::pair< double, double > >	m_scatteringsigmas
std::vector< double >	m_brems
Amg::VectorX	m_res
Amg::VectorX	m_errors
Amg::MatrixX	m_weightresderiv
double	m_totx0
double	m_toteloss
double	m_mass
int	m_prefit
GXFTrackState *	m_caloelossstate
std::vector< std::pair< const Layer *, const Layer * > >	m_upstreammat

Detailed Description

Internal representation of the track, used in the track fit.

Author

thijs.nosp@m..cor.nosp@m.nelis.nosp@m.sen@.nosp@m.cern..nosp@m.ch

Definition at line 31 of file GXFTrajectory.h.

Constructor & Destructor Documentation

GXFTrajectory() [1/3]

Trk::GXFTrajectory::GXFTrajectory

(

)

Definition at line 15 of file GXFTrajectory.cxx.

                               {
    m_straightline = true;
    m_ndof = 0;
    m_nperpars = -1;
    m_nscatterers = 0;
    m_ncaloscatterers = 0;
    m_nbrems = 0;
    m_nupstreamstates = 0;
    m_nupstreamscatterers = 0;
    m_nupstreamcaloscatterers = 0;
    m_nupstreambrems = 0;
    m_nsihits = 0;
    m_ntrthits = 0;
    m_ntrtprechits = 0;
    m_ntrttubehits = 0;
    m_npseudo = 0;
    m_nhits = 0;
    m_noutl = 0;
    m_nmeasoutl = 0;
    m_chi2 = 0;
    m_prevchi2 = 0;
    m_converged = false;
    m_prefit = 0;
    m_refpar.reset(nullptr);
    m_totx0 = 0;
    m_toteloss = 0;
    m_mass = 0;
    m_caloelossstate = nullptr;
  }

GXFTrajectory() [2/3]

Trk::GXFTrajectory::GXFTrajectory

(

const GXFTrajectory &

rhs

)

Definition at line 45 of file GXFTrajectory.cxx.

    : m_straightline (rhs.m_straightline),
      m_fieldprop (rhs.m_fieldprop),
      m_ndof (rhs.m_ndof),
      m_chi2 (rhs.m_chi2),
      m_prevchi2 (rhs.m_prevchi2),
      m_nperpars (rhs.m_nperpars),
      m_nscatterers (rhs.m_nscatterers),
      m_ncaloscatterers (rhs.m_ncaloscatterers),
      m_nbrems (rhs.m_nbrems),
      m_nupstreamstates (rhs.m_nupstreamstates),
      m_nupstreamscatterers (rhs.m_nupstreamscatterers),
      m_nupstreamcaloscatterers (rhs.m_nupstreamcaloscatterers),
      m_nupstreambrems (rhs.m_nupstreambrems),
      m_nhits (rhs.m_nhits),
      m_noutl (rhs.m_noutl),
      m_nsihits (rhs.m_nsihits),
      m_ntrthits (rhs.m_ntrthits),
      m_ntrtprechits (rhs.m_ntrtprechits),
      m_ntrttubehits (rhs.m_ntrttubehits),
      m_npseudo (rhs.m_npseudo),
      m_nmeasoutl (rhs.m_nmeasoutl),
      m_refpar(rhs.m_refpar != nullptr ? rhs.m_refpar->clone() : nullptr),
      m_converged (rhs.m_converged),
      m_scatteringangles (rhs.m_scatteringangles),
      m_scatteringsigmas (rhs.m_scatteringsigmas),
      m_brems (rhs.m_brems),
      m_res (rhs.m_res),
      m_errors (rhs.m_errors),
      m_weightresderiv (rhs.m_weightresderiv),
      m_totx0 (rhs.m_totx0),
      m_toteloss (rhs.m_toteloss),
      m_mass (rhs.m_mass),
      m_prefit (rhs.m_prefit),
      m_caloelossstate (nullptr),
      m_upstreammat (rhs.m_upstreammat)
  {
 
    m_states.reserve(rhs.m_states.size());
    for (const std::unique_ptr<GXFTrackState> & i : rhs.m_states) {
      m_states.emplace_back(std::make_unique<GXFTrackState>(*i));
    }
 
    if (rhs.m_caloelossstate != nullptr) {
      for (auto & state : m_states) {
        conditionalSetCalorimeterEnergyLossState(state.get());
      }
    }
  }

GXFTrajectory() [3/3]

Trk::GXFTrajectory::GXFTrajectory ( GXFTrajectory && rhs )

default

~GXFTrajectory()

Trk::GXFTrajectory::~GXFTrajectory ( )

default

Member Function Documentation

addBasicState()

void Trk::GXFTrajectory::addBasicState	(	std::unique_ptr< GXFTrackState >	state,
		int	index = -1 )

Definition at line 266 of file GXFTrajectory.cxx.

                                                                                 {
    if (index == -1) {
      m_states.push_back(std::move(state));
    } else {
      m_states.insert(m_states.begin() + index, std::move(state));
    }
  }

addMaterialState()

void Trk::GXFTrajectory::addMaterialState	(	std::unique_ptr< GXFTrackState >	state,
		int	index = -1 )

Definition at line 224 of file GXFTrajectory.cxx.

                                                                                    {
    GXFMaterialEffects *meff = state->materialEffects();
 
    if (state->getStateType(TrackStateOnSurface::Scatterer)) {
      m_nscatterers++;
 
      if (meff->deltaE() == 0) {
        m_ncaloscatterers++;
      }
    }
 
    if (meff->sigmaDeltaE() > 0) {
      m_nbrems++;
      conditionalSetCalorimeterEnergyLossState(state.get());
    }
 
    m_toteloss += std::abs(meff->deltaE());
    m_totx0 += meff->x0();
 
    if (index == -1) {
      m_states.push_back(std::move(state));
 
      if (meff->sigmaDeltaE() > 0) {
        m_brems.push_back(meff->delta_p());
      }
    } else {
      m_states.insert(m_states.begin() + index, std::move(state));
      int previousbrems = 0;
 
      for (int i = 0; i < index; i++) {
        if ((m_states[i]->materialEffects() != nullptr)
            && m_states[i]->materialEffects()->sigmaDeltaE() > 0) {
          previousbrems++;
        }
      }
 
      if (meff->sigmaDeltaE() > 0) {
        m_brems.insert(m_brems.begin() + previousbrems, meff->delta_p());
      }
    }
  }

addMeasurementState()

bool Trk::GXFTrajectory::addMeasurementState	(	std::unique_ptr< GXFTrackState >	state,
		int	index = -1 )

Definition at line 166 of file GXFTrajectory.cxx.

                                                                                       {
    if (!m_states.empty() && (m_states.back()->measurement() != nullptr)) {
      const MeasurementBase *meas = m_states.back()->measurement();
      const MeasurementBase *meas2 = state->measurement();
 
      if (
        &meas->associatedSurface() == &meas2->associatedSurface() &&
        meas->localParameters().parameterKey() == meas2->localParameters().parameterKey() &&
        state->measurementType() != TrackState::MM
      ) {
        return false;
      }
    }
 
    int nmeas = 0;
    double *errors = state->measurementErrors();
 
    for (int i = 0; i < 5; i++) {
      if (errors[i] > 0) {
        nmeas++;
      }
    }
 
    if (state->getStateType(TrackStateOnSurface::Measurement)) {
      m_ndof += nmeas;
    } else {
      m_nmeasoutl += nmeas;
      m_noutl++;
    }
 
    if (state->measurementType() != TrackState::Pseudo) {
      m_nhits++;
    }
 
    if (state->measurementType() == TrackState::Pixel
        || state->measurementType() == TrackState::SCT) {
      m_nsihits++;
    }
 
    if (state->measurementType() == TrackState::TRT) {
      m_ntrthits++;
      if (errors[0]<1) m_ntrtprechits++;
      if (errors[0]>1) m_ntrttubehits++;
    }
 
    if (state->measurementType() == TrackState::Pseudo) {
      m_npseudo++;
    }
 
    if (index == -1) {
      m_states.push_back(std::move(state));
    } else {
      m_states.insert(m_states.begin() + index, std::move(state));
    }
 
    return true;
  }

brems()

std::vector< double > & Trk::GXFTrajectory::brems

(

)

Definition at line 543 of file GXFTrajectory.cxx.

                                           {
    return m_brems;
  }

caloElossState()

GXFTrackState * Trk::GXFTrajectory::caloElossState

(

)

Definition at line 630 of file GXFTrajectory.cxx.

                                               {
    return m_caloelossstate;
  }

chi2()

double Trk::GXFTrajectory::chi2

(

)

const

Definition at line 494 of file GXFTrajectory.cxx.

                                   {
    return m_chi2;
  }

conditionalSetCalorimeterEnergyLossState()

void Trk::GXFTrajectory::conditionalSetCalorimeterEnergyLossState

(

GXFTrackState *

state

)

Definition at line 148 of file GXFTrajectory.cxx.

                                                                                    {
    constexpr double perpThreshold = 1400;
    constexpr double zThreshold = 3700;
 
    const GXFMaterialEffects *meff = state->materialEffects();
    const TrackParameters *par = state->trackParameters();
 
    if (
      meff != nullptr &&
      par != nullptr &&
      meff->sigmaDeltaE() > 0 &&
      meff->sigmaDeltaPhi() == 0 &&
      (par->position().perp() > perpThreshold || std::abs(par->position().z()) > zThreshold)
    ) {
      m_caloelossstate = state;
    }
  }

converged()

bool Trk::GXFTrajectory::converged

(

)

const

Definition at line 413 of file GXFTrajectory.cxx.

                                      {
    return m_converged;
  }

errors()

Amg::VectorX & Trk::GXFTrajectory::errors

(

)

Definition at line 593 of file GXFTrajectory.cxx.

                                     {
    if (m_errors.size() == 0) {
      m_errors.setZero(numberOfBrems() + m_ndof + m_nperpars + m_nmeasoutl);
    }
    return m_errors;
  }

findFirstLastMeasurement()

std::pair< GXFTrackState *, GXFTrackState * > Trk::GXFTrajectory::findFirstLastMeasurement

(

void

)

Definition at line 639 of file GXFTrajectory.cxx.

                                                                                        {
    GXFTrackState *firstmeasstate = nullptr;
    GXFTrackState *lastmeasstate = nullptr;
 
    for (std::unique_ptr<GXFTrackState> & hit : trackStates()) {
      if (hit->measurement() != nullptr) {
        if (firstmeasstate == nullptr) {
          firstmeasstate = hit.get();
        }
        lastmeasstate = hit.get();
      }
    }
 
    if (firstmeasstate == nullptr) {
      throw std::logic_error("no first measurement.");
    }
 
    return std::make_pair(firstmeasstate, lastmeasstate);
  }

hasKink()

bool Trk::GXFTrajectory::hasKink

(

void

)

Definition at line 659 of file GXFTrajectory.cxx.

                                  {
    for (auto & hit : trackStates()) {
      if (
        hit->measurementType() == TrackState::Pseudo &&
        hit->getStateType(TrackStateOnSurface::Outlier)
      ) {
        continue;
      }
 
      if (
        (hit->materialEffects() != nullptr) &&
        hit->materialEffects()->isKink()
      ) {
        return true;
      }
    }
 
    return false;
  }

mass()

double Trk::GXFTrajectory::mass

(

)

const

Definition at line 621 of file GXFTrajectory.cxx.

                              {
    return m_mass;
  }

nDOF()

int Trk::GXFTrajectory::nDOF

(

)

const

Definition at line 510 of file GXFTrajectory.cxx.

                                {
    return m_ndof;
  }

numberOfBrems()

int Trk::GXFTrajectory::numberOfBrems

(

)

const

Definition at line 460 of file GXFTrajectory.cxx.

                                          {
    return m_nbrems;
  }

numberOfFitParameters()

int Trk::GXFTrajectory::numberOfFitParameters

(

)

const

Definition at line 487 of file GXFTrajectory.cxx.

                                                 {
    if (m_prefit == 1) {
      return m_nperpars + numberOfBrems() + numberOfScatterers();
    }
    return m_nperpars + numberOfBrems() + 2 * numberOfScatterers();
  }

numberOfHits()

int Trk::GXFTrajectory::numberOfHits

(

)

const

Definition at line 421 of file GXFTrajectory.cxx.

                                        {
    return m_nhits;
  }

numberOfOutliers()

int Trk::GXFTrajectory::numberOfOutliers

(

)

const

Definition at line 425 of file GXFTrajectory.cxx.

                                            {
    return m_noutl;
  }

numberOfPerigeeParameters()

int Trk::GXFTrajectory::numberOfPerigeeParameters

(

)

const

Definition at line 483 of file GXFTrajectory.cxx.

                                                     {
    return m_nperpars;
  }

numberOfPseudoMeasurements()

int Trk::GXFTrajectory::numberOfPseudoMeasurements

(

)

const

Definition at line 445 of file GXFTrajectory.cxx.

                                                      {
    return m_npseudo;
  }

numberOfScatterers()

int Trk::GXFTrajectory::numberOfScatterers

(

)

const

Definition at line 449 of file GXFTrajectory.cxx.

                                              {
    if (m_prefit != 0) {
      return m_ncaloscatterers;
    }
    return m_nscatterers;
  }

numberOfSiliconHits()

int Trk::GXFTrajectory::numberOfSiliconHits

(

)

const

Definition at line 429 of file GXFTrajectory.cxx.

                                               {
    return m_nsihits;
  }

numberOfTRTHits()

int Trk::GXFTrajectory::numberOfTRTHits

(

)

const

Definition at line 433 of file GXFTrajectory.cxx.

                                           {
    return m_ntrthits;
  }

numberOfTRTPrecHits()

int Trk::GXFTrajectory::numberOfTRTPrecHits

(

)

const

Definition at line 437 of file GXFTrajectory.cxx.

                                               {
    return m_ntrtprechits;
  }

numberOfTRTTubeHits()

int Trk::GXFTrajectory::numberOfTRTTubeHits

(

)

const

Definition at line 441 of file GXFTrajectory.cxx.

                                               {
    return m_ntrttubehits;
  }

numberOfUpstreamBrems()

int Trk::GXFTrajectory::numberOfUpstreamBrems

(

)

const

Definition at line 479 of file GXFTrajectory.cxx.

                                                 {
    return m_nupstreambrems;
  }

numberOfUpstreamScatterers()

int Trk::GXFTrajectory::numberOfUpstreamScatterers

(

)

const

Definition at line 472 of file GXFTrajectory.cxx.

                                                      {
    if (m_prefit == 0) {
      return m_nupstreamscatterers;
    }
    return m_nupstreamcaloscatterers;
  }

numberOfUpstreamStates()

int Trk::GXFTrajectory::numberOfUpstreamStates

(

)

const

Definition at line 468 of file GXFTrajectory.cxx.

                                                  {
    return m_nupstreamstates;
  }

operator=() [1/2]

GXFTrajectory & Trk::GXFTrajectory::operator=

(

const GXFTrajectory &

rhs

)

Definition at line 95 of file GXFTrajectory.cxx.

                                                                     {
    if (this != &rhs) {
      m_straightline = rhs.m_straightline;
      m_fieldprop = rhs.m_fieldprop;
      m_ndof = rhs.m_ndof;
      m_nperpars = rhs.m_nperpars;
      m_nscatterers = rhs.m_nscatterers;
      m_ncaloscatterers = rhs.m_ncaloscatterers;
      m_nbrems = rhs.m_nbrems;
      m_nupstreamstates = rhs.m_nupstreamstates;
      m_nupstreamscatterers = rhs.m_nupstreamscatterers;
      m_nupstreamcaloscatterers = rhs.m_nupstreamcaloscatterers;
      m_nupstreambrems = rhs.m_nupstreambrems;
      m_nsihits = rhs.m_nsihits;
      m_ntrthits = rhs.m_ntrthits;
      m_ntrtprechits = rhs.m_ntrtprechits;
      m_ntrttubehits = rhs.m_ntrttubehits;
      m_nhits = rhs.m_nhits;
      m_npseudo = rhs.m_npseudo;
      m_noutl = rhs.m_noutl;
      m_nmeasoutl = rhs.m_nmeasoutl;
      m_chi2 = rhs.m_chi2;
      m_prevchi2 = rhs.m_prevchi2;
      m_converged = rhs.m_converged;
      m_prefit = rhs.m_prefit;
      m_refpar.reset(rhs.m_refpar != nullptr ? rhs.m_refpar->clone() : nullptr);
 
      m_states.clear();
      for (const std::unique_ptr<GXFTrackState> & i : rhs.m_states) {
        m_states.push_back(std::make_unique<GXFTrackState>(*i));
      }
 
      m_scatteringangles = rhs.m_scatteringangles;
      m_scatteringsigmas = rhs.m_scatteringsigmas;
      m_brems = rhs.m_brems;
      m_res = rhs.m_res;
      m_errors = rhs.m_errors;
      m_weightresderiv = rhs.m_weightresderiv;
      m_totx0 = rhs.m_totx0;
      m_toteloss = rhs.m_toteloss;
      m_mass = rhs.m_mass;
      m_caloelossstate = nullptr;
 
      if (rhs.m_caloelossstate != nullptr) {
        for (auto & state : m_states) {
          conditionalSetCalorimeterEnergyLossState(state.get());
        }
      }
      m_upstreammat = rhs.m_upstreammat;
    }
    return *this;
  }

operator=() [2/2]

GXFTrajectory & Trk::GXFTrajectory::operator= ( GXFTrajectory && rhs )

default

prefit()

int Trk::GXFTrajectory::prefit

(

)

const

Definition at line 417 of file GXFTrajectory.cxx.

                                  {
    return m_prefit;
  }

prevchi2()

double Trk::GXFTrajectory::prevchi2

(

)

const

Definition at line 498 of file GXFTrajectory.cxx.

                                       {
    return m_prevchi2;
  }

quality()

std::unique_ptr< const FitQuality > Trk::GXFTrajectory::quality

(

void

)

const

Definition at line 685 of file GXFTrajectory.cxx.

                                                                   {
    return std::make_unique<const FitQuality>(chi2(), nDOF());
  }

referenceParameters()

const TrackParameters * Trk::GXFTrajectory::referenceParameters

(

)

Definition at line 334 of file GXFTrajectory.cxx.

                                                            {
    return m_refpar.get();
  }

reset()

void Trk::GXFTrajectory::reset

(

)

Definition at line 403 of file GXFTrajectory.cxx.

                            {
    m_res.resize(0);
    m_weightresderiv.resize(0, 0);
    m_errors.resize(0);
    m_scatteringangles.clear();
    m_scatteringsigmas.clear();
    m_converged = false;
    m_refpar.reset(nullptr);
  }

resetCovariances()

void Trk::GXFTrajectory::resetCovariances

(

void

)

Definition at line 679 of file GXFTrajectory.cxx.

                                           {
    for (std::unique_ptr<GXFTrackState> & hit : trackStates()) {
      hit->setTrackCovariance(nullptr);
    }
  }

resetReferenceParameters()

void Trk::GXFTrajectory::resetReferenceParameters

(

)

Definition at line 338 of file GXFTrajectory.cxx.

                                               {
    m_refpar.reset(nullptr);
  }

residuals()

Amg::VectorX & Trk::GXFTrajectory::residuals

(

)

Definition at line 586 of file GXFTrajectory.cxx.

                                        {
    if (m_res.size() == 0) {
      m_res.setZero(numberOfBrems() + m_ndof + m_nperpars + m_nmeasoutl);
    }
    return m_res;
  }

scatteringAngles()

std::vector< std::pair< double, double > > & Trk::GXFTrajectory::scatteringAngles

(

)

Definition at line 514 of file GXFTrajectory.cxx.

                                                                       {
    if (m_scatteringangles.empty() && numberOfScatterers() > 0) {
      m_scatteringsigmas.clear();
      m_scatteringsigmas.reserve(numberOfScatterers());
      m_scatteringangles.reserve(numberOfScatterers());
      for (auto & state : m_states) {
        if ((*state).getStateType(TrackStateOnSurface::Scatterer)
            && ((m_prefit == 0) || (*state).materialEffects()->deltaE() == 0)) {
          const double scatphi = (*state).materialEffects()->deltaPhi();
          const double scattheta = (*state).materialEffects()->deltaTheta();
          m_scatteringangles.emplace_back(scatphi, scattheta);
          const double sigmascatphi = (*state).materialEffects()->sigmaDeltaPhi();
          const double sigmascattheta = (*state).materialEffects()->sigmaDeltaTheta();
          m_scatteringsigmas.
            emplace_back(sigmascatphi, sigmascattheta);
        }
      }
    }
    return m_scatteringangles;
  }

scatteringSigmas()

std::vector< std::pair< double, double > > & Trk::GXFTrajectory::scatteringSigmas

(

)

Definition at line 536 of file GXFTrajectory.cxx.

                                    {
    if (m_scatteringsigmas.empty() && numberOfScatterers() > 0) {
      scatteringAngles();
    }
    return m_scatteringsigmas;
  }

setBrems()

void Trk::GXFTrajectory::setBrems

(

std::vector< double > &

brems

)

Definition at line 565 of file GXFTrajectory.cxx.

                                                     {
    // if (m_prefit==1) return;
    m_brems = brems;
    int bremno = 0;
    for (auto & state : m_states) {
      if (((*state).materialEffects() != nullptr)
          && (*state).materialEffects()->sigmaDeltaE() > 0) {
        (*state).materialEffects()->setdelta_p(m_brems[bremno]);
        bremno++;
      }
    }
  }

setChi2()

void Trk::GXFTrajectory::setChi2

(

double

chi2

)

Definition at line 502 of file GXFTrajectory.cxx.

                                         {
    m_chi2 = chi2;
  }

setConverged()

void Trk::GXFTrajectory::setConverged

(

bool

isconverged

)

Definition at line 399 of file GXFTrajectory.cxx.

                                                   {
    m_converged = isconverged;
  }

setMass()

void Trk::GXFTrajectory::setMass

(

double

mass

)

Definition at line 626 of file GXFTrajectory.cxx.

                                      {
    m_mass = mass;
  }

setNumberOfBrems()

void Trk::GXFTrajectory::setNumberOfBrems

(

int

nbrem

)

Definition at line 464 of file GXFTrajectory.cxx.

                                                {
    m_nbrems = nbrem;
  }

setNumberOfPerigeeParameters()

void Trk::GXFTrajectory::setNumberOfPerigeeParameters

(

int

nperpar

)

Definition at line 342 of file GXFTrajectory.cxx.

                                                              {
    m_ndof -= nperpar;
    m_nperpars = nperpar;
  }

setNumberOfScatterers()

void Trk::GXFTrajectory::setNumberOfScatterers

(

int

nscat

)

Definition at line 456 of file GXFTrajectory.cxx.

                                                     {
    m_nscatterers = nscat;
  }

setOutlier()

void Trk::GXFTrajectory::setOutlier	(	int	index,
		bool	isoutlier = true )

Definition at line 347 of file GXFTrajectory.cxx.

                                                          {
    if (isoutlier && m_states[index]->getStateType(TrackStateOnSurface::Outlier)) {
      return;
    }
 
    if (!isoutlier && m_states[index]->getStateType(TrackStateOnSurface::Measurement)) {
      return;
    }
 
    int nmeas = 0;
    double *errors = m_states[index]->measurementErrors();
 
    for (int i = 0; i < 5; i++) {
      if (errors[i] > 0) {
        nmeas++;
      }
    }
 
    if (isoutlier) {
      m_ndof -= nmeas;
      m_states[index]->resetStateType(TrackStateOnSurface::Outlier);
      m_nmeasoutl += nmeas;
      m_noutl++;
      m_states[index]->setFitQuality({});
    } else {
      m_ndof += nmeas;
      m_states[index]->resetStateType(TrackStateOnSurface::Measurement);
      m_nmeasoutl -= nmeas;
      m_noutl--;
    }
  }

setPrefit()

void Trk::GXFTrajectory::setPrefit

(

int

isprefit

)

Definition at line 395 of file GXFTrajectory.cxx.

                                            {
    m_prefit = isprefit;
  }

setPrevChi2()

void Trk::GXFTrajectory::setPrevChi2

(

double

chi2

)

Definition at line 506 of file GXFTrajectory.cxx.

                                             {
    m_prevchi2 = chi2;
  }

setReferenceParameters()

void Trk::GXFTrajectory::setReferenceParameters

(

std::unique_ptr< const TrackParameters >

per

)

Definition at line 274 of file GXFTrajectory.cxx.

                                                                                     {
    if (m_refpar != nullptr) {
      m_refpar = std::move(per);
      return;
    }
 
    m_refpar = std::move(per);
 
    m_nupstreamstates = 0;
    m_nupstreamscatterers = 0;
    m_nupstreamcaloscatterers = 0;
    m_nupstreambrems = 0;
 
    for (const auto & state : m_states) {
      if (state->trackParameters() != nullptr) {
        const double inprod = m_refpar->momentum().dot(state->position() - m_refpar->position());
 
        if (inprod > 0) {
          return;
        }
      } else {
        const DistanceSolution distsol =
          state->associatedSurface().straightLineDistanceEstimate(m_refpar->position(), m_refpar->momentum().unit());
 
        double distance = 0;
        if (distsol.numberOfSolutions() == 1) {
          distance = distsol.first();
        } else if (distsol.numberOfSolutions() == 2) {
          distance =
            std::abs(distsol.first()) < std::abs(distsol.second()) ?
            distsol.first() :
            distsol.second();
        }
 
        if (distance > 0) {
          return;
        }
      }
 
      m_nupstreamstates++;
 
      const GXFMaterialEffects *meff = state->materialEffects();
 
      if (
        state->getStateType(TrackStateOnSurface::Scatterer) &&
        meff->sigmaDeltaTheta() != 0
      ) {
        m_nupstreamscatterers++;
 
        if (meff->deltaE() == 0) {
          m_nupstreamcaloscatterers++;
        }
      }
 
      if (meff != nullptr && meff->sigmaDeltaE() > 0) {
        m_nupstreambrems++;
      }
    }
  }

setScatteringAngles()

void Trk::GXFTrajectory::setScatteringAngles

(

std::vector< std::pair< double, double > > &

scatteringangles

)

Definition at line 549 of file GXFTrajectory.cxx.

                                                                    {
    m_scatteringangles = scatteringangles;
    int scatno = 0;
    for (auto & state : m_states) {
      if ((*state).getStateType(TrackStateOnSurface::Scatterer)
          && ((m_prefit == 0) || (*state).materialEffects()->deltaE() == 0)) {
        const double scatphi = scatteringangles[scatno].first;
        const double scattheta = scatteringangles[scatno].second;
        (*state).materialEffects()->setScatteringAngles(scatphi, scattheta);
        scatno++;
      }
    }
  }

totalEnergyLoss()

double Trk::GXFTrajectory::totalEnergyLoss

(

)

const

Definition at line 616 of file GXFTrajectory.cxx.

                                         {
    return m_toteloss;
  }

totalX0()

double Trk::GXFTrajectory::totalX0

(

)

const

Definition at line 611 of file GXFTrajectory.cxx.

                                 {
    return m_totx0;
  }

trackStates() [1/2]

std::vector< std::unique_ptr< GXFTrackState > > & Trk::GXFTrajectory::trackStates

(

)

Definition at line 582 of file GXFTrajectory.cxx.

                                                                       {
    return m_states;
  }

trackStates() [2/2]

const std::vector< std::unique_ptr< GXFTrackState > > & Trk::GXFTrajectory::trackStates

(

)

const

Definition at line 578 of file GXFTrajectory.cxx.

                                                                                   {
    return m_states;
  }

updateTRTHitCount()

void Trk::GXFTrajectory::updateTRTHitCount	(	int	index,
		float	oldError )

Definition at line 379 of file GXFTrajectory.cxx.

                                                                 {
    const double error = (m_states[index]->measurementErrors())[0];
    if (m_states[index]->getStateType(TrackStateOnSurface::Outlier)) {
      if (oldError<1) { m_ntrtprechits--; }
      else {m_ntrttubehits--; }
    }
    if (error>1 && oldError<1) { // was precison, became tube
      m_ntrttubehits++;
      m_ntrtprechits--;
    }
    else if (error<1 && oldError>1) { // was tube, became precision
      m_ntrttubehits--;
      m_ntrtprechits++;
    }
  }

upstreamMaterialLayers()

std::vector< std::pair< const Layer *, const Layer * > > & Trk::GXFTrajectory::upstreamMaterialLayers

(

)

Definition at line 635 of file GXFTrajectory.cxx.

                                          {
    return m_upstreammat;
  }

weightedResidualDerivatives()

Amg::MatrixX & Trk::GXFTrajectory::weightedResidualDerivatives

(

)

Definition at line 600 of file GXFTrajectory.cxx.

                                                          {
    if (m_weightresderiv.size() == 0) {
      m_weightresderiv.setZero(
        numberOfBrems() + m_ndof + m_nperpars + m_nmeasoutl,
        numberOfFitParameters()
      );
    }
    return m_weightresderiv;
  }

Member Data Documentation

m_brems

std::vector<double> Trk::GXFTrajectory::m_brems

private

Definition at line 139 of file GXFTrajectory.h.

m_caloelossstate

GXFTrackState* Trk::GXFTrajectory::m_caloelossstate

private

Definition at line 147 of file GXFTrajectory.h.

m_chi2

double Trk::GXFTrajectory::m_chi2

private

Definition at line 117 of file GXFTrajectory.h.

m_converged

bool Trk::GXFTrajectory::m_converged

private

Definition at line 136 of file GXFTrajectory.h.

m_errors

Amg::VectorX Trk::GXFTrajectory::m_errors

private

Definition at line 141 of file GXFTrajectory.h.

m_fieldprop

MagneticFieldProperties Trk::GXFTrajectory::m_fieldprop = Trk::FullField

Definition at line 112 of file GXFTrajectory.h.

m_mass

double Trk::GXFTrajectory::m_mass

private

Definition at line 145 of file GXFTrajectory.h.

m_nbrems

int Trk::GXFTrajectory::m_nbrems

private

Definition at line 122 of file GXFTrajectory.h.

m_ncaloscatterers

int Trk::GXFTrajectory::m_ncaloscatterers

private

Definition at line 121 of file GXFTrajectory.h.

m_ndof

int Trk::GXFTrajectory::m_ndof

private

Definition at line 116 of file GXFTrajectory.h.

m_nhits

int Trk::GXFTrajectory::m_nhits

private

Definition at line 127 of file GXFTrajectory.h.

m_nmeasoutl

int Trk::GXFTrajectory::m_nmeasoutl

private

Definition at line 134 of file GXFTrajectory.h.

m_noutl

int Trk::GXFTrajectory::m_noutl

private

Definition at line 128 of file GXFTrajectory.h.

m_nperpars

int Trk::GXFTrajectory::m_nperpars

private

Definition at line 119 of file GXFTrajectory.h.

m_npseudo

int Trk::GXFTrajectory::m_npseudo

private

Definition at line 133 of file GXFTrajectory.h.

m_nscatterers

int Trk::GXFTrajectory::m_nscatterers

private

Definition at line 120 of file GXFTrajectory.h.

m_nsihits

int Trk::GXFTrajectory::m_nsihits

private

Definition at line 129 of file GXFTrajectory.h.

m_ntrthits

int Trk::GXFTrajectory::m_ntrthits

private

Definition at line 130 of file GXFTrajectory.h.

m_ntrtprechits

int Trk::GXFTrajectory::m_ntrtprechits

private

Definition at line 131 of file GXFTrajectory.h.

m_ntrttubehits

int Trk::GXFTrajectory::m_ntrttubehits

private

Definition at line 132 of file GXFTrajectory.h.

m_nupstreambrems

int Trk::GXFTrajectory::m_nupstreambrems

private

Definition at line 126 of file GXFTrajectory.h.

m_nupstreamcaloscatterers

int Trk::GXFTrajectory::m_nupstreamcaloscatterers

private

Definition at line 125 of file GXFTrajectory.h.

m_nupstreamscatterers

int Trk::GXFTrajectory::m_nupstreamscatterers

private

Definition at line 124 of file GXFTrajectory.h.

m_nupstreamstates

int Trk::GXFTrajectory::m_nupstreamstates

private

Definition at line 123 of file GXFTrajectory.h.

m_prefit

int Trk::GXFTrajectory::m_prefit

private

Definition at line 146 of file GXFTrajectory.h.

m_prevchi2

double Trk::GXFTrajectory::m_prevchi2

private

Definition at line 118 of file GXFTrajectory.h.

m_refpar

std::unique_ptr<const TrackParameters> Trk::GXFTrajectory::m_refpar

private

Definition at line 135 of file GXFTrajectory.h.

m_res

Amg::VectorX Trk::GXFTrajectory::m_res

private

Definition at line 140 of file GXFTrajectory.h.

m_scatteringangles

std::vector< std::pair < double, double > > Trk::GXFTrajectory::m_scatteringangles

private

Definition at line 137 of file GXFTrajectory.h.

m_scatteringsigmas

std::vector< std::pair < double, double > > Trk::GXFTrajectory::m_scatteringsigmas

private

Definition at line 138 of file GXFTrajectory.h.

m_states

std::vector<std::unique_ptr<GXFTrackState> > Trk::GXFTrajectory::m_states

private

The vector of track states, i.e.

measurements, scatterers, brem points, and holes

Definition at line 115 of file GXFTrajectory.h.

m_straightline

bool Trk::GXFTrajectory::m_straightline

Definition at line 111 of file GXFTrajectory.h.

m_toteloss

double Trk::GXFTrajectory::m_toteloss

private

Definition at line 144 of file GXFTrajectory.h.

m_totx0

double Trk::GXFTrajectory::m_totx0

private

Definition at line 143 of file GXFTrajectory.h.

m_upstreammat

std::vector< std::pair < const Layer *, const Layer *> > Trk::GXFTrajectory::m_upstreammat

private

Definition at line 148 of file GXFTrajectory.h.

m_weightresderiv

Amg::MatrixX Trk::GXFTrajectory::m_weightresderiv

private

Definition at line 142 of file GXFTrajectory.h.

---

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

• GXFTrajectory.h
• GXFTrajectory.cxx