InDet::InDetTrackSplitterTool Class Reference

This tool is used for splitting tracks in different segments and returning fitted tracks that have the corrisponding hits associated with them. More...

#include <InDetTrackSplitterTool.h>

Inheritance diagram for InDet::InDetTrackSplitterTool:

Collaboration diagram for InDet::InDetTrackSplitterTool:

Public Member Functions
	InDetTrackSplitterTool (std::string const &, std::string const &, IInterface const *)
	default constructor
virtual	~InDetTrackSplitterTool ()
	default destructor
virtual StatusCode	initialize ()
	standard Athena-Algorithm methods
virtual StatusCode	finalize ()
virtual void	splitTracks (TrackCollection const *inputTracks) const
	Takes a trackCollection, splits them according to upper and lower parts and fills two track collections, one with upper tracks and one with lower tracks which are accessed via getUpperTracks and getLowerTracks.
virtual std::pair< Trk::Track *, Trk::Track * >	splitInUpperLowerTrack (Trk::Track const &input, bool siliconHitsOnly=false) const
	Splits a single input track into upper and lower parts (based on global y) returns a pair of track the first being the upper.
virtual Trk::Track *	stripTrack (Trk::Track const &input, bool removeSilicon=true, bool applyConstraint=true) const
	Takes a combined ID track and either 1) if removeSilicon = true Strips off the Si hits.
virtual std::pair< Trk::Track *, Trk::Track * >	splitInOddEvenHitsTrack (Trk::Track const &input) const
	Splits a single input track into odd and even parts (with logic to aviod splitting SCT space points)
std::string const	UpperTracksKey () const
	Return the names of the track collections stored in storeGate.
std::string const	LowerTracksKey () const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static InterfaceID const &	interfaceID ()
	Retrieve interface ID.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	trackIsCandidate (Trk::Track const &inputTrack) const
	Track selection applied in the splitTracks method (for the moment this is just a d0 cut requiring the track went through TRT cavity.
std::vector< Trk::MeasurementBase const * >	getSCTHits (Trk::Track const &input) const
	Return a vector of the SCT hits on track.
std::vector< Trk::MeasurementBaseconst * >::iterator	findSCTHitsFromSameSpacePoint (Trk::MeasurementBase const *sctHit, std::vector< Trk::MeasurementBase const * > &listOfSCTHits) const
	Logic to check if there is another SCT hit associated with the input hit, which forms a space point.
bool	isConstrained (unsigned int nPixelHits, unsigned int nSCTHits, unsigned int nTRTHits, unsigned int nPseudomeasurements) const
	Logic to check if the track is constrained given the number of various types of hits.
Trk::Track *	stripSiFromTrack (Trk::Track const &input) const
	Strip the Si hits, fit the remaining with a theta, z0 constraint.
Trk::PseudoMeasurementOnTrack const *	makeThetaZ0Constraint (Trk::Perigee const *originialPerigee) const
	Make the theta and z0 constraint.
Trk::Track *	stripTRTFromTrack (Trk::Track const &input, bool applyConstraint=true) const
	Strip the TRT hits, fit the remaining with a qOverP constraint.
Trk::PseudoMeasurementOnTrack const *	makePConstraint (Trk::Perigee const *originialPerigee, Trk::StraightLineSurface const *trtSurf) const
	Make the qOverP constraint.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::WriteHandleKey< TrackCollection >	m_outputUpperTracksName
	Output track collection names recorded in storgate.
SG::WriteHandleKey< TrackCollection >	m_outputLowerTracksName
ToolHandle< Trk::ITrackFitter >	m_trkfitter
	Helper Functions.
TRT_ID const *	m_trtid {}
SCT_ID const *	m_sctid {}
bool	m_keepmaterial
	Do we use the material on the input track.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

This tool is used for splitting tracks in different segments and returning fitted tracks that have the corrisponding hits associated with them.

Currently it is for seen to split tracks in:

• Upper and Lower tracks (for cosmics)
• Tracks using alternating hits. (odd and even)
• Strip a combined (Si+TRT) track of its Si hits refit remianing TRT-Only hits with theta and z0 constraint from input track.
• Strip a combined (Si+TRT) track of its TRT hits refit remianing Si-Only hits with qOverP constraint from input track.

Usages: 1) If you have a single track and want to split in to upper and lower do:

m_trackSplitterTool->splitInUpperLowerTrack(inputtrack); ->splitInOddEvenHitsTrack(inputtrack);

this call return a std::pair containing the split tracks

3) If you have a single track and want to strip ether Si or TRT hits do:

m_trackSplitterTool->stripTrack(inputtrack,true); //For removing the Si Hits m_trackSplitterTool->stripTrack(inputtrack,false);//For removing the TRT Hits

2) If you have a track collection and want to create track collections with upper and lower tracks do

m_trackSplitterTool->splitTracks(inputTracks);

then retrieve the collection from storeGate with the names m_outputUpperTracksName, m_outputLowerTracksName

Author

John Alison

Definition at line 81 of file InDetTrackSplitterTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

InDetTrackSplitterTool()

InDet::InDetTrackSplitterTool::InDetTrackSplitterTool	(	std::string const &	type,
		std::string const &	name,
		IInterface const *	parent )

default constructor

A method to determine which half track the hit belongs to.

Definition at line 81 of file InDetTrackSplitterTool.cxx.

                                                                                                                              :
  AthAlgTool( type, name, parent ),
  m_trkfitter("Trk::GlobalChi2Fitter/InDetTrackFitter")
{
 
  declareInterface<IInDetTrackSplitterTool>(this);
  declareProperty("TrackFitter", m_trkfitter);
  declareProperty("OutputUpperTracksName", m_outputUpperTracksName="splitUpperTracks");
  declareProperty("OutputLowerTracksName", m_outputLowerTracksName="splitLowerTracks");
  declareProperty("KeepMaterialStates",m_keepmaterial=true);
}

~InDetTrackSplitterTool()

InDet::InDetTrackSplitterTool::~InDetTrackSplitterTool ( )

virtualdefault

default destructor

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode InDet::InDetTrackSplitterTool::finalize ( )

virtual

Definition at line 133 of file InDetTrackSplitterTool.cxx.

{
  msg(MSG::DEBUG) << "In finalize() "<< endmsg;
  return StatusCode::SUCCESS;
}

findSCTHitsFromSameSpacePoint()

std::vector< Trk::MeasurementBaseconst * >::iterator InDet::InDetTrackSplitterTool::findSCTHitsFromSameSpacePoint ( Trk::MeasurementBase const * sctHit, std::vector< Trk::MeasurementBase const * > & listOfSCTHits ) const

private

Logic to check if there is another SCT hit associated with the input hit, which forms a space point.

Logic to check if there is another SCT hit associated with the input hit, which forms a space point (used for not breaking up SCT space points, when splitting Odd/Even)

Definition at line 908 of file InDetTrackSplitterTool.cxx.

                                                                                                                                                                                                   {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "in findSCTHitsFromSameSpacePoint " << endmsg;
  std::vector<Trk::MeasurementBase const*>::iterator result = listOfSCTHits.end();
 
  Trk::RIO_OnTrack const* rio = dynamic_cast<Trk::RIO_OnTrack const*>(sctHit);
  if(rio){
    Identifier const& surfaceid = (rio->identify());
 
    int targetEta = m_sctid->eta_module(surfaceid);
    int targetPhi = m_sctid->phi_module(surfaceid);
 
    std::vector<Trk::MeasurementBase const*>::const_iterator meas = listOfSCTHits.begin();
    std::vector<Trk::MeasurementBase const*>::const_iterator measEnd = listOfSCTHits.end();
    for(;meas != measEnd; ++meas){
      Trk::RIO_OnTrack const* candidateRio = dynamic_cast<Trk::RIO_OnTrack const*>(*meas);
      if(candidateRio){
  Identifier const& candidateSurfaceid = (candidateRio->identify());
  if(m_sctid->eta_module(candidateSurfaceid) == targetEta && m_sctid->phi_module(candidateSurfaceid) == targetPhi){
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Found another hit in the SpacePoint " << endmsg;
    result = find(listOfSCTHits.begin(), listOfSCTHits.end(), *meas);
  }
      }
    }
  }
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Leaving findSCTHitsFromSameSpacePoint " << endmsg;
  return result;
}

getSCTHits()

std::vector< Trk::MeasurementBase const * > InDet::InDetTrackSplitterTool::getSCTHits ( Trk::Track const & input ) const

private

Return a vector of the SCT hits on track.

Return a vector of the SCT hits on track (used for not breaking up SCT space points, when splitting Odd/Even)

order the hits in y

Definition at line 877 of file InDetTrackSplitterTool.cxx.

                                                                                                        {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "In getSCTHits " << endmsg;
  std::vector<Trk::MeasurementBase const*> SCTHits;
 
  DataVector<Trk::MeasurementBase const>::const_iterator meas = input.measurementsOnTrack()->begin();
  DataVector<Trk::MeasurementBase const>::const_iterator measEnd = input.measurementsOnTrack()->end();
  for(;meas != measEnd; ++meas){
 
    Trk::RIO_OnTrack const* rio = dynamic_cast<Trk::RIO_OnTrack const*>(*meas);
 
    if(rio){
      Identifier const& surfaceid = (rio->identify());
      if(m_trtid->is_sct(surfaceid)){
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "we've found an SCT hit " << endmsg;
  SCTHits.push_back(*meas);
      }
    }
  }
 
  //if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "sorting the hits " << endmsg;
  //std::sort(SCTHits.begin(), SCTHits.end(), InDetTrackSplitterHelpers::CompareYPosition );
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Leaving getSCTHits " << endmsg;
  return SCTHits;
}

initialize()

StatusCode InDet::InDetTrackSplitterTool::initialize ( )

virtual

standard Athena-Algorithm methods

Get TRT helper

Get SCT helper

Fitter

Definition at line 98 of file InDetTrackSplitterTool.cxx.

{
 
  msg(MSG::DEBUG) << "In initialize()" << endmsg;

  if ((detStore()->retrieve(m_trtid)).isFailure()) {
    msg(MSG::WARNING) << "Problem retrieving TRTID helper" << endmsg;
    return StatusCode::SUCCESS;
  }

  if ((detStore()->retrieve(m_sctid)).isFailure()) {
    msg(MSG::WARNING) << "Problem retrieving SCT ID helper" << endmsg;
    return StatusCode::SUCCESS;
  }

  if(m_trkfitter.retrieve().isFailure()) {
    msg(MSG::WARNING) << "Could not find refit tool " << m_trkfitter  << endmsg;
    return StatusCode::SUCCESS;
  }
 
  ATH_CHECK( m_outputUpperTracksName.initialize() );
  ATH_CHECK( m_outputLowerTracksName.initialize() );
 
  msg(MSG::DEBUG) << "InDetTrackSplitterTool initialized" << endmsg;
  return StatusCode::SUCCESS;
 
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

InterfaceID const & InDet::IInDetTrackSplitterTool::interfaceID ( )

inlinestaticinherited

Retrieve interface ID.

Definition at line 25 of file IInDetTrackSplitterTool.h.

{return IID_InDetTrackSplitterTool;};

isConstrained()

bool InDet::InDetTrackSplitterTool::isConstrained ( unsigned int nPixelHits, unsigned int nSCTHits, unsigned int nTRTHits, unsigned int nPseudomeasurements ) const

private

Logic to check if the track is constrained given the number of various types of hits.

Two cases to consider, tracks with Si hits (first case in the ||), and TRT Only tracks (second case)

Definition at line 940 of file InDetTrackSplitterTool.cxx.

                                                                                                                                                            {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "In isConstrained " << endmsg;

  if( (( nPixelHits + nSCTHits) > 1 && (2*nPixelHits + nSCTHits + nTRTHits)  > 5) ||
      (nPseudomeasurements >= 1 && nTRTHits > 10)){
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Leaving isConstrained (true)" << endmsg;
    return true;
  }
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Leaving isConstrained (false)" << endmsg;
  return false;
}

LowerTracksKey()

std::string const InDet::InDetTrackSplitterTool::LowerTracksKey ( ) const

inlinevirtual

Implements InDet::IInDetTrackSplitterTool.

Definition at line 126 of file InDetTrackSplitterTool.h.

{return m_outputLowerTracksName.key();}

makePConstraint()

Trk::PseudoMeasurementOnTrack const * InDet::InDetTrackSplitterTool::makePConstraint ( Trk::Perigee const * originialPerigee, Trk::StraightLineSurface const * trtSurf ) const

private

Make the qOverP constraint.

Define the constraint parameter

Define the uncertainty on the constraint parameter

Create the constraint

Definition at line 533 of file InDetTrackSplitterTool.cxx.

                                                                                                                                                     {
 
  if( !perigee->covariance() ) return nullptr;

  Trk::DefinedParameter inputPMeasurement(perigee->parameters()[Trk::qOverP],Trk::qOverP);
  std::array<Trk::DefinedParameter,1> constraints = {inputPMeasurement};

  Amg::MatrixX constraintErrMatrix(1,1);
  constraintErrMatrix(0,0)=(*perigee->covariance())(Trk::qOverP,Trk::qOverP);

  Trk::PseudoMeasurementOnTrack* psmom = new Trk::PseudoMeasurementOnTrack(Trk::LocalParameters(constraints),
                                                                           std::move(constraintErrMatrix)  ,*trtSurf);
 
  return psmom;
}

makeThetaZ0Constraint()

Trk::PseudoMeasurementOnTrack const * InDet::InDetTrackSplitterTool::makeThetaZ0Constraint ( Trk::Perigee const * originialPerigee ) const

private

Make the theta and z0 constraint.

Define the constraint parameters

Define the uncertainty on the constraint parameters

Get the surface were the constraint will be applied (we got the constraints from the perigee, apply it there too)

Create the constriant

Debugging

Definition at line 555 of file InDetTrackSplitterTool.cxx.

                                                                                                                     {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "In makeThetaZ0Constraint" <<endmsg;
 
  if( !perigee->covariance() ) return nullptr;

  Trk::DefinedParameter inputTheta0Measurement(perigee->parameters()[Trk::theta],Trk::theta);
  Trk::DefinedParameter inputZ0Measurement(perigee->parameters()[Trk::z0],Trk::z0);
  std::array<Trk::DefinedParameter,2> constraints = {inputZ0Measurement, inputTheta0Measurement};

  Amg::MatrixX constraintErrMatrix(2,2);
  constraintErrMatrix(0,0) = (*perigee->covariance())(Trk::z0,Trk::z0);
  constraintErrMatrix(0,1) = (*perigee->covariance())(Trk::z0,Trk::theta);
  constraintErrMatrix(1,0) = (*perigee->covariance())(Trk::theta, Trk::z0);
  constraintErrMatrix(1,1) = (*perigee->covariance())(Trk::theta, Trk::theta);

  const Trk::PerigeeSurface & surface = perigee->associatedSurface();

  Trk::PseudoMeasurementOnTrack* psmom = new Trk::PseudoMeasurementOnTrack(Trk::LocalParameters(constraints),
                                                                           std::move(constraintErrMatrix)  ,
                                                                           surface);

  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Leaving makeThetaZ0Constraint" <<endmsg;
  return psmom;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

splitInOddEvenHitsTrack()

std::pair< Trk::Track *, Trk::Track * > InDet::InDetTrackSplitterTool::splitInOddEvenHitsTrack ( Trk::Track const & input ) const

virtual

Splits a single input track into odd and even parts (with logic to aviod splitting SCT space points)

Splits a single input track into upper and lower parts (based on global y) returns a pair of track the first being the upper.

The returned tracks

Get the initial perigee parameters

Get the track particle hypothisis

Get the measurements

Get SCT hits (ordered)

The odd hits

protect against breaking up space points find the sct hit in unusedSCTHits

if the SCT hits hasn't been assigned to a tracks

remove hit from unused list

find any other hits with same r phi

The even hits

protect against breaking up space points find the sct hit in unusedSCTHits

if the SCT hits hasn't been assigned to a tracks

remove hit from umused list

find any other hits with same r phi

Sort the hits.

Upper track

track must be overconstrained

lower track

Implements InDet::IInDetTrackSplitterTool.

Definition at line 595 of file InDetTrackSplitterTool.cxx.

                                                                                                              {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " In splitInOddEvenHitsTrack" <<endmsg;

  Trk::Track* oddTrack(nullptr);
  Trk::Track* evenTrack(nullptr);

  Trk::Perigee const* originalPerigee = input.perigeeParameters();

  Trk::ParticleHypothesis hypo = input.info().particleHypothesis();

  Trk::MeasurementSet oddHits;
  Trk::MeasurementSet evenHits;
 
  unsigned int totalNumberPixelHits = 0;
  unsigned int totalNumberSCTHits = 0;
  unsigned int totalNumberTRTHits = 0;
  unsigned int totalNumberHits = 0;
 
  unsigned int numberOddSCTHits = 0;
  unsigned int numberOddPixelHits = 0;
  unsigned int numberOddTRTHits = 0;
  unsigned int numberOddPseudoMeas = 0;
 
  unsigned int numberEvenPixelHits = 0;
  unsigned int numberEvenSCTHits = 0;
  unsigned int numberEvenTRTHits = 0;
  unsigned int numberEvenPseudoMeas = 0;

  std::vector<Trk::MeasurementBase const*> unusedSCTHits = getSCTHits(input);
 
  DataVector<Trk::MeasurementBase const>::const_iterator meas = input.measurementsOnTrack()->begin();
  DataVector<Trk::MeasurementBase const>::const_iterator measEnd = input.measurementsOnTrack()->end();
  for(;meas != measEnd; ++meas){
    Trk::RIO_OnTrack const* rio = dynamic_cast<Trk::RIO_OnTrack const*>(*meas);
    if(rio){
      Identifier const& surfaceid = (rio->identify());
      if(m_trtid->is_pixel(surfaceid)) ++totalNumberPixelHits;
      if(m_trtid->is_sct(surfaceid)) ++totalNumberSCTHits;
      if(m_trtid->is_trt(surfaceid)) ++totalNumberTRTHits;

      if( totalNumberHits % 2 == 1){
 
        if(m_trtid->is_pixel(surfaceid)) ++numberOddPixelHits;
        if(m_trtid->is_sct(surfaceid)) ++numberOddSCTHits;
        if(m_trtid->is_trt(surfaceid)) ++numberOddTRTHits;
 
        if(!m_trtid->is_sct(surfaceid)){
          if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "adding odd hit" <<endmsg;
          oddHits.push_back( *meas);
          ++totalNumberHits;
          }else{

            std::vector<Trk::MeasurementBase const* >::iterator result = find(unusedSCTHits.begin(), unusedSCTHits.end(),  *meas);

            if(result != unusedSCTHits.end()){
 
              if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "add the (odd) SCT hit" <<endmsg;
              oddHits.push_back( *meas);
              ++totalNumberHits;

              if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "removing the SCT hit from unused list" <<endmsg;
              unusedSCTHits.erase(result);

              result = findSCTHitsFromSameSpacePoint( *meas, unusedSCTHits);
              if(result != unusedSCTHits.end()){
                if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "adding the other (odd) SCT hit in the spacepoint" <<endmsg;
                oddHits.push_back( *result);
                if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "removing the SCT hit from unused list" <<endmsg;
                unusedSCTHits.erase(result);
              }
            }
          }
      }else{
        if(m_trtid->is_pixel(surfaceid))
          ++numberEvenPixelHits;
        if(m_trtid->is_sct(surfaceid))
          ++numberEvenSCTHits;
        if(m_trtid->is_trt(surfaceid))
          ++numberEvenTRTHits;
 
        if(!m_trtid->is_sct(surfaceid)){
          if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "add the (even) hit" <<endmsg;
          evenHits.push_back( *meas);
          ++totalNumberHits;
        }else{
          std::vector<Trk::MeasurementBase const* >::iterator result = find(unusedSCTHits.begin(), unusedSCTHits.end(), *meas);

          if(result != unusedSCTHits.end()){
 
            if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "add the (even) SCT hit" <<endmsg;
            evenHits.push_back( *meas);
            ++totalNumberHits;

            if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "removing the SCT hit from unused list" <<endmsg;
            unusedSCTHits.erase(result);

            result = findSCTHitsFromSameSpacePoint( *meas, unusedSCTHits);
            if(result != unusedSCTHits.end()){
              if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "adding the other (even) SCT hit in the spacepoint" <<endmsg;
              evenHits.push_back( *result);
              if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "removing the SCT hit from unused list" <<endmsg;
              unusedSCTHits.erase(result);
            }
          }
        }
      }
    }else{
      Trk::PseudoMeasurementOnTrack const* ps = dynamic_cast<Trk::PseudoMeasurementOnTrack const*>(*meas);
 
      if(ps){
        if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Adding an odd pseudoMeasurement" <<endmsg;
        ++numberOddPseudoMeas;
        oddHits.push_back( ps);
 
        if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Adding an even pseudoMeasurement" <<endmsg;
        ++numberEvenPseudoMeas;
        evenHits.push_back( ps);
      }
    }
  }

  //std::sort(oddHits.begin(), oddHits.end(), InDetTrackSplitterHelpers::CompareYPosition );
  //std::sort(evenHits.begin(), evenHits.end(), InDetTrackSplitterHelpers::CompareYPosition );

  if(isConstrained(numberOddPixelHits,numberOddSCTHits,numberOddTRTHits,numberOddPseudoMeas)){
 
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "before calling odd fit" << endmsg;
    oddTrack = (m_trkfitter->fit(Gaudi::Hive::currentContext(),oddHits, *originalPerigee, false, hypo)).release();
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "after calling odd fit" << endmsg;
 
    if(!oddTrack){
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Odd Fit Failed!" << endmsg ;
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
               << numberOddPixelHits << " odd Pixel hits, "
               << numberOddSCTHits << " odd SCT hits, "
               << numberOddTRTHits << " odd TRT hits"
               << numberOddPseudoMeas << "odd Pseudomeasurements"
               << endmsg;
 
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
               << totalNumberPixelHits << " total Pixel hits, "
               << totalNumberSCTHits << " total SCT hits, "
               << totalNumberTRTHits << "total TRT hits"
               << endmsg;
    }
 
  }else
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Not enough measurements on odd track. Fit fails." << endmsg ;

  if(isConstrained(numberEvenPixelHits,numberEvenSCTHits,numberEvenTRTHits,numberEvenPseudoMeas)){
 
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "before calling even fit" << endmsg;
    evenTrack = (m_trkfitter->fit(Gaudi::Hive::currentContext(),evenHits, *originalPerigee, false, hypo)).release();
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "after calling even fit" << endmsg;
 
    if(!evenTrack){
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Even Fit Failed!" << endmsg ;
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: " << numberEvenSCTHits << " even si hits and "
               << numberEvenTRTHits << "even TRT hits"<< endmsg;
 
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There were: " << totalNumberSCTHits << " total Si hits and "
               << totalNumberTRTHits << "total TRT hits"<< endmsg;
    }
 
  }else
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Not enough measurements on even track. Fit fails." << endmsg ;
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " Leaving splitInOddEvenHitsTrack" <<endmsg;
  return std::make_pair(oddTrack, evenTrack);
}

splitInUpperLowerTrack()

std::pair< Trk::Track *, Trk::Track * > InDet::InDetTrackSplitterTool::splitInUpperLowerTrack ( Trk::Track const & input, bool siliconHitsOnly = false ) const

virtual

Splits a single input track into upper and lower parts (based on global y) returns a pair of track the first being the upper.

Get the initial perigee parameters

Get the track particle hypothisis

Get the measurements

Upper track

lower track

Implements InDet::IInDetTrackSplitterTool.

Definition at line 142 of file InDetTrackSplitterTool.cxx.

                                                    {
  //std::cout << "input: " << input << std::endl;
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " In splitInUpperLowerTrack" <<endmsg;
 
  //**The returned tracks */
  Trk::Track* upperTrack(nullptr);
  Trk::Track* lowerTrack(nullptr);

  Trk::Perigee const* originalPerigee = input.perigeeParameters();

  Trk::ParticleHypothesis hypo = input.info().particleHypothesis();

  auto uppertraj = std::make_unique<Trk::TrackStates>();
  auto lowertraj = std::make_unique<Trk::TrackStates>();
 
  unsigned int totalNumberHits = 0;
 
  unsigned int totalNumberPixelHits = 0;
  unsigned int totalNumberSCTHits = 0;
  unsigned int totalNumberTRTHits = 0;
 
  unsigned int numberUpperPixelHits = 0;
  unsigned int numberUpperSCTHits = 0;
  unsigned int numberUpperTRTHits = 0;
  unsigned int numberUpperPseudoMeas = 0;
 
  unsigned int numberLowerPixelHits = 0;
  unsigned int numberLowerSCTHits = 0;
  unsigned int numberLowerTRTHits = 0;
  unsigned int numberLowerPseudoMeas = 0;
 
  //DataVector<Trk::MeasurementBase const>::const_iterator meas = input.measurementsOnTrack()->begin();
  //DataVector<Trk::MeasurementBase const>::const_iterator measEnd = input.measurementsOnTrack()->end();
  //for(;meas != measEnd; ++meas){
  //Trk::RIO_OnTrack const* rio = dynamic_cast<Trk::RIO_OnTrack const*>(*meas);
  Trk::TrackStates::const_iterator tsosit = input.trackStateOnSurfaces()->begin();
  Trk::TrackStates::const_iterator tsosEnd = input.trackStateOnSurfaces()->end();
  bool perigeeseen=false;
  for(;tsosit != tsosEnd; ++tsosit){
    if ((**tsosit).type(Trk::TrackStateOnSurface::Outlier)) continue;
    if (originalPerigee==(**tsosit).trackParameters()){
      perigeeseen=true;
      uppertraj->push_back((**tsosit).clone());
      lowertraj->push_back((**tsosit).clone());
      continue;
    }
 
    if (m_keepmaterial &&
        ((**tsosit).type(Trk::TrackStateOnSurface::Scatterer) ||
         (**tsosit).type(Trk::TrackStateOnSurface::BremPoint) ||
         (**tsosit).type(Trk::TrackStateOnSurface::CaloDeposit))) {
      if (!perigeeseen)
        uppertraj->push_back((**tsosit).clone());
      else
        lowertraj->push_back((**tsosit).clone());
      continue;
    }
    const Trk::RIO_OnTrack *rio = nullptr;
    const Trk::MeasurementBase *measb=(**tsosit).measurementOnTrack();
    if (measb) rio=dynamic_cast<const Trk::RIO_OnTrack*>(measb);
 
    if(rio){
      if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "an rio..." <<endmsg;
 
      totalNumberHits++;
 
      Identifier const& surfaceid = (rio->identify());
 
      if (m_trtid->is_pixel(surfaceid))
        ++totalNumberPixelHits;
      if (m_trtid->is_sct(surfaceid))
        ++totalNumberSCTHits;
      if (m_trtid->is_trt(surfaceid))
        ++totalNumberTRTHits;
 
      //if( (*meas)->globalPosition().y() > 0){
      if( !perigeeseen){
 
        if (m_trtid->is_pixel(surfaceid))
          ++numberUpperPixelHits;
        if (m_trtid->is_sct(surfaceid))
          ++numberUpperSCTHits;
        if (m_trtid->is_trt(surfaceid))
          ++numberUpperTRTHits;
 
        if (!siliconHitsOnly || m_trtid->is_sct(surfaceid) ||
            m_trtid->is_pixel(surfaceid))
          uppertraj->push_back((**tsosit).clone());
      }
 
      // if( (*meas)->globalPosition().y() < 0){
      if (perigeeseen) {
 
        if (m_trtid->is_pixel(surfaceid))
          ++numberLowerPixelHits;
        if (m_trtid->is_sct(surfaceid))
          ++numberLowerSCTHits;
        if (m_trtid->is_trt(surfaceid))
          ++numberLowerTRTHits;
 
        if (!siliconHitsOnly || m_trtid->is_sct(surfaceid) ||
            m_trtid->is_pixel(surfaceid))
          // m_lowerHits.push_back( *meas);
          lowertraj->push_back((**tsosit).clone());
      }
    } else {
      if (msgLvl(MSG::VERBOSE))
        msg(MSG::VERBOSE) << "Not an rio" << endmsg;
      // Trk::PseudoMeasurementOnTrack const* ps =
      // dynamic_cast<Trk::PseudoMeasurementOnTrack const*>(*measb);
      const Trk::PseudoMeasurementOnTrack* ps =
        dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(measb);
 
      if (ps) {
        if (!perigeeseen || totalNumberHits == totalNumberTRTHits) {
          if (msgLvl(MSG::DEBUG))
            msg(MSG::DEBUG) << "Adding an upper pseudoMeasurement" << endmsg;
          ++numberUpperPseudoMeas;
          uppertraj->push_back((**tsosit).clone());
        }
        if (perigeeseen || totalNumberHits == totalNumberTRTHits) {
          if (msgLvl(MSG::DEBUG))
            msg(MSG::DEBUG) << "Adding a lower pseudoMeasurement" << endmsg;
          ++numberLowerPseudoMeas;
          lowertraj->push_back((**tsosit).clone());
        }
      }
 
      const Trk::CompetingRIOsOnTrack* crot =
        dynamic_cast<const Trk::CompetingRIOsOnTrack*>(measb);
      if (crot) {
        if (!perigeeseen)
          uppertraj->push_back((**tsosit).clone());
        else
          lowertraj->push_back((**tsosit).clone());
      }
    }
  }
 
  Trk::Track upperorigtrack(input.info(),std::move(uppertraj),nullptr);
  Trk::Track lowerorigtrack(input.info(),std::move(lowertraj),nullptr);

  if(isConstrained(numberUpperPixelHits,numberUpperSCTHits,numberUpperTRTHits,numberUpperPseudoMeas)){
 
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "before calling upper fit" << endmsg;
    //m_upperTrack = m_trkfitter->fit(m_upperHits, *originalPerigee, true, hypo);
    upperTrack = (m_trkfitter->fit(Gaudi::Hive::currentContext(),upperorigtrack, false, hypo)).release();
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "after calling upper fit" << endmsg;
 
    if(!upperTrack){
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Upper Fit Failed!" << endmsg ;
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
               << numberUpperPixelHits << " upper Pixel hits, "
               << numberUpperSCTHits << " upper SCT hits, "
               << numberUpperTRTHits << "upper TRT hits"
               << numberUpperPseudoMeas << "upper Pseudomeasurements"
               << endmsg;
 
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
               << totalNumberPixelHits << " total Pixel hits, "
               << totalNumberSCTHits << " total SCT hits, "
               << totalNumberTRTHits << "total TRT hits"
               << endmsg;
 
    }
 
  }else{
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Not enough measurements on upper track. Fit fails." << endmsg ;
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
               << numberUpperPixelHits << " upper Pixel hits, "
               << numberUpperSCTHits << " upper SCT hits, "
               << numberUpperTRTHits << "upper TRT hits"
               << numberUpperPseudoMeas << "upper Pseudomeasurements"
               << endmsg;
  }

  if(isConstrained(numberLowerPixelHits,numberLowerSCTHits,numberLowerTRTHits,numberLowerPseudoMeas)){
 
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "before calling lower fit" << endmsg;
    lowerTrack = (m_trkfitter->fit(Gaudi::Hive::currentContext(),lowerorigtrack, false, hypo)).release();
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "after calling lower fit" << endmsg;
 
    if(!lowerTrack){
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Lower Fit Failed!" << endmsg ;
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
               << numberLowerPixelHits << " upper Pixel hits, "
               << numberLowerSCTHits << " upper SCT hits, "
               << numberLowerTRTHits << "upper TRT hits"
               << numberLowerPseudoMeas << "upper Pseudomeasurements"
               << endmsg;
 
      if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
               << totalNumberPixelHits << " total Pixel hits, "
               << totalNumberSCTHits << " total SCT hits, "
               << totalNumberTRTHits << "total TRT hits"
               << endmsg;
    }
 
  }else{
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Not enough measurements on lower track. Fit fails." << endmsg ;
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There was: "
             << numberLowerPixelHits << " upper Pixel hits, "
             << numberLowerSCTHits << " upper SCT hits, "
             << numberLowerTRTHits << "upper TRT hits"
             << numberLowerPseudoMeas << "upper Pseudomeasurements"
             << endmsg;
  }
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " Leaving splitInUpperLowerTrack" <<endmsg;
  return std::make_pair(upperTrack, lowerTrack);
}

splitTracks()

void InDet::InDetTrackSplitterTool::splitTracks ( TrackCollection const * inputTracks ) const

virtual

Takes a trackCollection, splits them according to upper and lower parts and fills two track collections, one with upper tracks and one with lower tracks which are accessed via getUpperTracks and getLowerTracks.

Using this method requires track to pass trackIsCandidate (for the moment this is just a d0 cut requiring the track went through TRT cavity

if went though TRT cavity

Implements InDet::IInDetTrackSplitterTool.

Definition at line 794 of file InDetTrackSplitterTool.cxx.

                                                                                      {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " In splitTracks" <<endmsg;
 
  //  const EventContext& ctx = Gaudi::Hive::currentContext();
  SG::WriteHandle<TrackCollection> upperTracks(m_outputUpperTracksName);
  if ( upperTracks.record( std::make_unique<TrackCollection>() ).isFailure() ) {
     ATH_MSG_FATAL( "Failed to record upper tracks collection " <<  m_outputUpperTracksName.key() );
  }
 
  SG::WriteHandle<TrackCollection> lowerTracks(m_outputLowerTracksName);
  if ( lowerTracks.record( std::make_unique<TrackCollection>() ).isFailure() ) {
     ATH_MSG_FATAL( "Failed to record upper tracks collection " <<  m_outputLowerTracksName.key() );
  }
 
  if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "There are: " << inputTracks->size() << " input tracks."<< endmsg;
 
  TrackCollection::const_iterator it = inputTracks->begin();
  TrackCollection::const_iterator itE = inputTracks->end();
  for (; it != itE; ++it){

    if(trackIsCandidate( **it) ){
      if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "Track is a candidate."<< endmsg;
 
      std::pair<Trk::Track*, Trk::Track*> splitTracks = this->splitInUpperLowerTrack(**it);
      //For debugging
      //std::pair<Trk::Track*, Trk::Track*> splitTracks = this->splitInOddEvenHitsTrack(**it);
 
      Trk::Track* upperTrack = splitTracks.first;
      if(upperTrack){
  if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "Upper track fit suceeded"<< endmsg;
  upperTracks->push_back( upperTrack);
      }else
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Upper track fit failed!"<< endmsg;
 
      Trk::Track* lowerTrack = splitTracks.second;
      if(lowerTrack){
  if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "Lower track fit suceeded"<< endmsg;
  lowerTracks->push_back( lowerTrack);
      }else
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Lower track fit failed!"<< endmsg;
 
    } else
      if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "Track is NOT a candidate."<< endmsg;
  }
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " Leaving splitTracks" <<endmsg;
}

stripSiFromTrack()

Trk::Track * InDet::InDetTrackSplitterTool::stripSiFromTrack ( Trk::Track const & input ) const

private

Strip the Si hits, fit the remaining with a theta, z0 constraint.

The returned track

The measurements

Get the initial perigee parameters

Get the track particle hypothisis

Create the psuesdoMeasurement with the constraints

Adding the constraint first

Fit track

Definition at line 384 of file InDetTrackSplitterTool.cxx.

                                                                                   {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "In stripSiFromTrack" <<endmsg;

  Trk::Track* outputTrack(nullptr);

  Trk::MeasurementSet TRTHits;

  Trk::Perigee const* originalPerigee = input.perigeeParameters();

  Trk::ParticleHypothesis hypo = input.info().particleHypothesis();

  Trk::PseudoMeasurementOnTrack const* constraint = makeThetaZ0Constraint(originalPerigee);

  TRTHits.push_back(constraint);
 
  unsigned int totalNumberTRTHits = 0;
 
  DataVector<Trk::MeasurementBase const>::const_iterator meas = input.measurementsOnTrack()->begin();
  DataVector<Trk::MeasurementBase const>::const_iterator measEnd = input.measurementsOnTrack()->end();
  for(;meas != measEnd; ++meas){
    Trk::RIO_OnTrack const* rio = dynamic_cast<Trk::RIO_OnTrack const*>(*meas);
 
    if(!rio){
      if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "No ROT skipping measurement." <<endmsg;
      continue;
    }
 
    Identifier const& surfaceid = (rio->identify());
 
    if(!m_trtid->is_trt(surfaceid)){
      if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "Removing Non-TRT hit." <<endmsg;
      continue;
    }
 
    ++totalNumberTRTHits;
    TRTHits.push_back(*meas);
 
  }

  // Should be Constrained !!!
  //if(isConstrained(numberUpperPixelHits,numberUpperSCTHits,numberUpperTRTHits,numberUpperPseudoMeas)){
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "before calling fit" << endmsg;
  outputTrack = (m_trkfitter->fit(Gaudi::Hive::currentContext(),TRTHits, *originalPerigee, true, hypo)).release();
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "after calling fit" << endmsg;
 
  if(!outputTrack){
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Fit Failed!" << endmsg ;
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There were: "
             << totalNumberTRTHits << "TRT hits"
             << endmsg;
  }
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Leaving stripSiFromTrack" <<endmsg;
  return outputTrack;
}

stripTrack()

Trk::Track * InDet::InDetTrackSplitterTool::stripTrack ( Trk::Track const & input, bool removeSilicon = true, bool applyConstraint = true ) const

virtual

Takes a combined ID track and either 1) if removeSilicon = true Strips off the Si hits.

Strips either the Si or the TRT and refits the track using constrants.

Then refits the remaining TRT hits using the original z0 and eta0 as constratins on the fit. 2) if removeSilicon = false Strips off the TRT hits. Then refits the remaining Si hits using the original pT and phi as constratins on the fit

The returned track

The strip the Si

The strip the TRT

Implements InDet::IInDetTrackSplitterTool.

Definition at line 362 of file InDetTrackSplitterTool.cxx.

                                                                   {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " In stripTrack" <<endmsg;

  Trk::Track* outputTrack(nullptr);

  if(removeSilicon){
    outputTrack = stripSiFromTrack(input);
  }
  else{
    outputTrack = stripTRTFromTrack(input, applyConstraint);
  }
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " Leaving stripTrack" <<endmsg;
  return outputTrack;
}

stripTRTFromTrack()

Trk::Track * InDet::InDetTrackSplitterTool::stripTRTFromTrack ( Trk::Track const & input, bool applyConstraint = true ) const

private

Strip the TRT hits, fit the remaining with a qOverP constraint.

The returned track

The measurements

Get the initial perigee parameters

Get the track particle hypothisis

Only add the constraint once

Get the position in space were the constraint will be added We'll chose the first TRT hit. (I dont think this matters, but a surface needs to be specified)

Create the psuesdoMeasurement with the constraints

Adding the constraint first

Only add the constraint once

Fit track

Definition at line 451 of file InDetTrackSplitterTool.cxx.

                                                                                                          {
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "In stripTRTFromTrack" <<endmsg;

  Trk::Track* outputTrack(nullptr);

  Trk::MeasurementSet SiHits;

  Trk::Perigee const* originalPerigee = input.perigeeParameters();

  Trk::ParticleHypothesis hypo = input.info().particleHypothesis();

  bool addedConstraint = false;
 
  unsigned int totalNumberSiHits = 0;
 
  DataVector<Trk::MeasurementBase const>::const_iterator meas = input.measurementsOnTrack()->begin();
  DataVector<Trk::MeasurementBase const>::const_iterator measEnd = input.measurementsOnTrack()->end();
  for(;meas != measEnd; ++meas){
    Trk::RIO_OnTrack const* rio = dynamic_cast<Trk::RIO_OnTrack const*>(*meas);
 
    if(!rio){
      if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "No ROT skipping measurement." <<endmsg;
      continue;
    }
 
    Identifier const& surfaceid = (rio->identify());
 
    if(applyConstraint && !addedConstraint && m_trtid->is_trt(surfaceid)){

      Trk::StraightLineSurface const* trtSurf = dynamic_cast<Trk::StraightLineSurface const*>(&(rio->associatedSurface()));
      if (not trtSurf){
        ATH_MSG_DEBUG("Cast of rio associated surface to StraightLineSurface failed.");
        continue;
      }
      Trk::PseudoMeasurementOnTrack const* constraint = makePConstraint(originalPerigee,trtSurf);

      SiHits.push_back(constraint);

      addedConstraint = true;
    }
 
    if(!m_trtid->is_sct(surfaceid) && !m_trtid->is_pixel(surfaceid)){
      if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "Removing Non-Si hit." <<endmsg;
      continue;
    }
 
    ++totalNumberSiHits;
    SiHits.push_back(*meas);
 
  }

  // Should be Constrained !!!
  //if(isConstrained(numberUpperPixelHits,numberUpperSCTHits,numberUpperTRTHits,numberUpperPseudoMeas)){
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "before calling fit" << endmsg;
  outputTrack = (m_trkfitter->fit(Gaudi::Hive::currentContext(),SiHits, *originalPerigee, false, hypo)).release();
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "after calling fit" << endmsg;
 
  if(!outputTrack){
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Fit Failed!" << endmsg ;
    if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "There were: " << totalNumberSiHits << "TRT hits" << endmsg;
  }
 
  if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Leaving stripTRTFromTrack" <<endmsg;
  return outputTrack;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

trackIsCandidate()

bool InDet::InDetTrackSplitterTool::trackIsCandidate ( Trk::Track const & inputTrack ) const

private

Track selection applied in the splitTracks method (for the moment this is just a d0 cut requiring the track went through TRT cavity.

This can be fleshed out, to have better track selection

Definition at line 847 of file InDetTrackSplitterTool.cxx.

                                                                                  {
  if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "In trackIsCandidate."<< endmsg;
  Trk::Perigee const* trackPerigee = inputTrack.perigeeParameters();
 
  if (!trackPerigee)
    {
      msg(MSG::WARNING) << "Found track with invalid perigee parameters. Not splitting." << endmsg;
      return false;
    }
 
  //Trk::Perigee const* measuredperigee = dynamic_cast<Trk::Perigee const*>( trackPerigee );
  double const d0 = trackPerigee->parameters()[Trk::d0];
 
  if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "do is: "<<  d0 << endmsg;

 
  //width of the cavity in the TRT
  if( fabs(d0) < 600){
    if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "is a candidate" << endmsg;
    return true;
  }
 
  if(msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "is NOT a candidate" << endmsg;
  return false;
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

UpperTracksKey()

std::string const InDet::InDetTrackSplitterTool::UpperTracksKey ( ) const

inlinevirtual

Return the names of the track collections stored in storeGate.

Implements InDet::IInDetTrackSplitterTool.

Definition at line 125 of file InDetTrackSplitterTool.h.

{return m_outputUpperTracksName.key();}

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_keepmaterial

bool InDet::InDetTrackSplitterTool::m_keepmaterial

private

Do we use the material on the input track.

Definition at line 176 of file InDetTrackSplitterTool.h.

m_outputLowerTracksName

SG::WriteHandleKey<TrackCollection> InDet::InDetTrackSplitterTool::m_outputLowerTracksName

private

Definition at line 167 of file InDetTrackSplitterTool.h.

m_outputUpperTracksName

SG::WriteHandleKey<TrackCollection> InDet::InDetTrackSplitterTool::m_outputUpperTracksName

private

Output track collection names recorded in storgate.

Definition at line 166 of file InDetTrackSplitterTool.h.

m_sctid

SCT_ID const* InDet::InDetTrackSplitterTool::m_sctid {}

private

Definition at line 172 of file InDetTrackSplitterTool.h.

{} ;

m_trkfitter

ToolHandle<Trk::ITrackFitter> InDet::InDetTrackSplitterTool::m_trkfitter

private

Helper Functions.

Definition at line 170 of file InDetTrackSplitterTool.h.

m_trtid

TRT_ID const* InDet::InDetTrackSplitterTool::m_trtid {}

private

Definition at line 171 of file InDetTrackSplitterTool.h.

{} ;

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• InDetTrackSplitterTool.h
• InDetTrackSplitterTool.cxx