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. More...
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 552 of file GXFTrajectory.cxx.

                                           {
    return m_brems;
  }

caloElossState()

GXFTrackState * Trk::GXFTrajectory::caloElossState

(

)

Definition at line 639 of file GXFTrajectory.cxx.

                                               {
    return m_caloelossstate;
  }

chi2()

double Trk::GXFTrajectory::chi2

(

)

const

Definition at line 503 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 422 of file GXFTrajectory.cxx.

                                      {
    return m_converged;
  }

errors()

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

(

)

Definition at line 602 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 648 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 668 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 630 of file GXFTrajectory.cxx.

                              {
    return m_mass;
  }

nDOF()

int Trk::GXFTrajectory::nDOF

(

)

const

Definition at line 519 of file GXFTrajectory.cxx.

                                {
    return m_ndof;
  }

numberOfBrems()

int Trk::GXFTrajectory::numberOfBrems

(

)

const

Definition at line 469 of file GXFTrajectory.cxx.

                                          {
    return m_nbrems;
  }

numberOfFitParameters()

int Trk::GXFTrajectory::numberOfFitParameters

(

)

const

Definition at line 496 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 430 of file GXFTrajectory.cxx.

                                        {
    return m_nhits;
  }

numberOfOutliers()

int Trk::GXFTrajectory::numberOfOutliers

(

)

const

Definition at line 434 of file GXFTrajectory.cxx.

                                            {
    return m_noutl;
  }

numberOfPerigeeParameters()

int Trk::GXFTrajectory::numberOfPerigeeParameters

(

)

const

Definition at line 492 of file GXFTrajectory.cxx.

                                                     {
    return m_nperpars;
  }

numberOfPseudoMeasurements()

int Trk::GXFTrajectory::numberOfPseudoMeasurements

(

)

const

Definition at line 454 of file GXFTrajectory.cxx.

                                                      {
    return m_npseudo;
  }

numberOfScatterers()

int Trk::GXFTrajectory::numberOfScatterers

(

)

const

Definition at line 458 of file GXFTrajectory.cxx.

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

numberOfSiliconHits()

int Trk::GXFTrajectory::numberOfSiliconHits

(

)

const

Definition at line 438 of file GXFTrajectory.cxx.

                                               {
    return m_nsihits;
  }

numberOfTRTHits()

int Trk::GXFTrajectory::numberOfTRTHits

(

)

const

Definition at line 442 of file GXFTrajectory.cxx.

                                           {
    return m_ntrthits;
  }

numberOfTRTPrecHits()

int Trk::GXFTrajectory::numberOfTRTPrecHits

(

)

const

Definition at line 446 of file GXFTrajectory.cxx.

                                               {
    return m_ntrtprechits;
  }

numberOfTRTTubeHits()

int Trk::GXFTrajectory::numberOfTRTTubeHits

(

)

const

Definition at line 450 of file GXFTrajectory.cxx.

                                               {
    return m_ntrttubehits;
  }

numberOfUpstreamBrems()

int Trk::GXFTrajectory::numberOfUpstreamBrems

(

)

const

Definition at line 488 of file GXFTrajectory.cxx.

                                                 {
    return m_nupstreambrems;
  }

numberOfUpstreamScatterers()

int Trk::GXFTrajectory::numberOfUpstreamScatterers

(

)

const

Definition at line 481 of file GXFTrajectory.cxx.

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

numberOfUpstreamStates()

int Trk::GXFTrajectory::numberOfUpstreamStates

(

)

const

Definition at line 477 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 426 of file GXFTrajectory.cxx.

                                  {
    return m_prefit;
  }

prevchi2()

double Trk::GXFTrajectory::prevchi2

(

)

const

Definition at line 507 of file GXFTrajectory.cxx.

                                       {
    return m_prevchi2;
  }

quality()

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

(

void

)

const

Definition at line 694 of file GXFTrajectory.cxx.

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

referenceParameters()

const TrackParameters * Trk::GXFTrajectory::referenceParameters

(

)

Definition at line 343 of file GXFTrajectory.cxx.

                                                            {
    return m_refpar.get();
  }

reset()

void Trk::GXFTrajectory::reset

(

)

Definition at line 412 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 688 of file GXFTrajectory.cxx.

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

resetReferenceParameters()

void Trk::GXFTrajectory::resetReferenceParameters

(

)

Definition at line 347 of file GXFTrajectory.cxx.

                                               {
    m_refpar.reset(nullptr);
  }

residuals()

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

(

)

Definition at line 595 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 523 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)) {
          double scatphi = (*state).materialEffects()->deltaPhi();
          double scattheta = (*state).materialEffects()->deltaTheta();
          m_scatteringangles.emplace_back(scatphi, scattheta);
          double sigmascatphi = (*state).materialEffects()->sigmaDeltaPhi();
          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 545 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 574 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 511 of file GXFTrajectory.cxx.

                                         {
    m_chi2 = chi2;
  }

setConverged()

void Trk::GXFTrajectory::setConverged

(

bool

isconverged

)

Definition at line 408 of file GXFTrajectory.cxx.

                                                   {
    m_converged = isconverged;
  }

setMass()

void Trk::GXFTrajectory::setMass

(

double

mass

)

Definition at line 635 of file GXFTrajectory.cxx.

                                      {
    m_mass = mass;
  }

setNumberOfBrems()

void Trk::GXFTrajectory::setNumberOfBrems

(

int

nbrem

)

Definition at line 473 of file GXFTrajectory.cxx.

                                                {
    m_nbrems = nbrem;
  }

setNumberOfPerigeeParameters()

void Trk::GXFTrajectory::setNumberOfPerigeeParameters

(

int

nperpar

)

Definition at line 351 of file GXFTrajectory.cxx.

                                                              {
    m_ndof -= nperpar;
    m_nperpars = nperpar;
  }

setNumberOfScatterers()

void Trk::GXFTrajectory::setNumberOfScatterers

(

int

nscat

)

Definition at line 465 of file GXFTrajectory.cxx.

                                                     {
    m_nscatterers = nscat;
  }

setOutlier()

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

Definition at line 356 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 404 of file GXFTrajectory.cxx.

                                            {
    m_prefit = isprefit;
  }

setPrevChi2()

void Trk::GXFTrajectory::setPrevChi2

(

double

chi2

)

Definition at line 515 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);
    } else {
      m_refpar = std::move(per);
      m_nupstreamstates = m_nupstreamscatterers = m_nupstreamcaloscatterers = m_nupstreambrems = 0;
 
      std::vector<std::unique_ptr<GXFTrackState>>::iterator it = m_states.begin();
      std::vector<std::unique_ptr<GXFTrackState>>::iterator it2 = m_states.begin();
 
      while (it2 != m_states.end()) {
        double distance = 0;
        bool isdownstream = false;
 
        if ((**it2).trackParameters() != nullptr) {
          distance = ((**it2).position() - m_refpar->position()).mag();
          double inprod = m_refpar->momentum().dot((**it2).position() - m_refpar->position());
 
          if (inprod > 0) {
            isdownstream = true;
          }
        } else {
          DistanceSolution distsol = (**it2).associatedSurface().straightLineDistanceEstimate(m_refpar->position(),m_refpar->momentum().unit());
 
          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) {
            isdownstream = true;
          }
 
          distance = fabs(distance);
        }
 
        if (isdownstream) {
          it = it2;
          break;
        }
 
        m_nupstreamstates++;
 
        if (
          (**it2).getStateType(TrackStateOnSurface::Scatterer) &&
          (**it2).materialEffects()->sigmaDeltaTheta() != 0
        ) {
          m_nupstreamscatterers++;
 
          if ((**it2).materialEffects()->deltaE() == 0) {
            m_nupstreamcaloscatterers++;
          }
        }
        if (
          ((**it2).materialEffects() != nullptr) &&
          (**it2).materialEffects()->sigmaDeltaE() > 0
        ) {
          m_nupstreambrems++;
        }
 
        ++it2;
      }
    }
  }

setScatteringAngles()

void Trk::GXFTrajectory::setScatteringAngles

(

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

scatteringangles

)

Definition at line 558 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)) {
        double scatphi = scatteringangles[scatno].first;
        double scattheta = scatteringangles[scatno].second;
        (*state).materialEffects()->setScatteringAngles(scatphi, scattheta);
        scatno++;
      }
    }
  }

totalEnergyLoss()

double Trk::GXFTrajectory::totalEnergyLoss

(

)

const

Definition at line 625 of file GXFTrajectory.cxx.

                                         {
    return m_toteloss;
  }

totalX0()

double Trk::GXFTrajectory::totalX0

(

)

const

Definition at line 620 of file GXFTrajectory.cxx.

                                 {
    return m_totx0;
  }

trackStates() [1/2]

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

(

)

Definition at line 591 of file GXFTrajectory.cxx.

                                                                       {
    return m_states;
  }

trackStates() [2/2]

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

(

)

const

Definition at line 587 of file GXFTrajectory.cxx.

                                                                                   {
    return m_states;
  }

updateTRTHitCount()

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

Definition at line 388 of file GXFTrajectory.cxx.

                                                                 {
    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 644 of file GXFTrajectory.cxx.

                                          {
    return m_upstreammat;
  }

weightedResidualDerivatives()

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

(

)

Definition at line 609 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