#include <BeamspotVertexPreProcessor.h>

Inheritance diagram for Trk::BeamspotVertexPreProcessor:

Collaboration diagram for Trk::BeamspotVertexPreProcessor:

Public Member Functions
	BeamspotVertexPreProcessor (const std::string &type, const std::string &name, const IInterface *parent)

virtual	~BeamspotVertexPreProcessor ()

virtual StatusCode	initialize ()

virtual StatusCode	finalize ()

virtual DataVector< Track > *	processTrackCollection (const DataVector< Track > *trks)
	Main processing of track collection. More...

void	accumulateVTX (AlignTrack *alignTrack)
	methods added for the full VTX fit: More...

void	solveVTX ()

virtual void	printSummary ()
	Print processing summary to logfile. More...

virtual void	setLogStream (std::ostream *os)
	sets the output stream for the logfile More...

virtual void	setNtuple (TFile *)
	Sets output ntuple file, to be implemented if needed for detector-specific implementation. More...

virtual StatusCode	fillNtuple ()
	writes tree and histogrms to ntuple More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Protected Attributes
std::ostream *	m_logStream
	logfile output stream More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	prepareAllTracksVector ()

bool	isAssociatedToPV (const Track track, const xAOD::VertexContainer vertices)

bool	isAssociatedToVertex (const Track track, const xAOD::Vertex vertex)

bool	selectVertices (const xAOD::Vertex *vtx) const

bool	selectUpdatedVertices (const xAOD::Vertex *updatedVtx) const

const xAOD::Vertex *	findVertexCandidate (const Track *track) const

const VertexOnTrack *	provideVotFromVertex (const Track track, const xAOD::Vertex &vtx) const

const VertexOnTrack *	provideVotFromBeamspot (const Track *track) const

void	provideVtxBeamspot (const AlignVertex b, AmgSymMatrix(3) q, Amg::Vector3D *v) const

const Track *	doConstraintRefit (ToolHandle< IGlobalTrackFitter > &fitter, const Track track, const VertexOnTrack vot, const ParticleHypothesis &particleHypothesis) const

bool	doBeamspotConstraintTrackSelection (const Track *track)

AlignTrack *	doTrackRefit (const Track *track)

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ToolHandle< IGlobalTrackFitter >	m_trackFitter
	normal track fitter More...

ToolHandle< IGlobalTrackFitter >	m_SLTrackFitter

ToolHandle< IExtrapolator >	m_extrapolator
	straight line track fitter More...

ToolHandle< InDet::IInDetTrackSelectionTool >	m_trkSelector
	new track selector tool More...

ToolHandle< InDet::IInDetTrackSelectionTool >	m_BSTrackSelector
	new track selector tool for tracks to be used with beam-spot constraint More...

ToolHandle< ITrackToVertexIPEstimator >	m_trackToVertexIPEstimatorTool

ToolHandle< Trk::IAlignModuleTool >	m_alignModuleTool
	Pointer to AlignModuleTool. More...

SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

std::string	m_PVContainerName
	the name of the primary vertex container More...

bool	m_runOutlierRemoval
	switch whether to run outlier logics or not More...

bool	m_selectVertices
	do vertex selection More...

int	m_particleNumber
	type of material interaction in extrapolation More...

bool	m_doTrkSelection
	to activate the preprocessor track selection More...

bool	m_doBSTrackSelection
	the selection mechanism which is based on cutting the perigee parameters, pt, etc. More...

bool	m_doAssociatedToPVSelection
	the selection mechanism that only use the tracks associated to PV More...

unsigned int	m_constraintMode

std::string	m_compareMethod
	the method used to judge whether two tracks are the same track More...

std::vector< std::string >	m_interestedVertexContainers

std::vector< std::pair< const xAOD::Vertex *, std::vector< VxTrackAtVertex > > >	m_allTracksVector

bool	m_doBeamspotConstraint
	do beamspot constraint More...

bool	m_doPrimaryVertexConstraint
	do vertex constraint More...

bool	m_doFullVertexConstraint
	do GX full vertex constraint More...

bool	m_doNormalRefit
	provide tracks in the case failed BS, PV and FullVertex constraints. More...

double	m_maxPt
	Max pT range for refitting tracks. More...

bool	m_refitTracks
	flag to refit tracks More...

bool	m_storeFitMatrices
	flag to store derivative and covariance matrices after refit More...

bool	m_useSingleFitter
	only use 1 fitter for refitting track More...

double	m_BSScalingFactor
	scaling factor on beasmpot width More...

double	m_PVScalingFactor
	scaling factor on primary vertex position error More...

int	m_minTrksInVtx
	requirement to the minimal number of tracks in the vertex More...

int	m_nTracks

std::vector< int >	m_trackTypeCounter

int	m_nFailedNormalRefits

int	m_nFailedBSRefits

int	m_nFailedPVRefits

DataVector< AlignVertex >	m_AlignVertices
	collection of AlignVertices used in FullVertex constraint option More...

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 54 of file BeamspotVertexPreProcessor.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

◆ BeamspotVertexPreProcessor()

Trk::BeamspotVertexPreProcessor::BeamspotVertexPreProcessor	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 48 of file BeamspotVertexPreProcessor.cxx.

   : AthAlgTool(type,name,parent)
   , m_trackFitter("Trk::GlobalChi2Fitter/InDetTrackFitter")
   , m_SLTrackFitter("")
   , m_extrapolator("Trk::Extrapolator/AtlasExtrapolator")
   , m_trkSelector("")
   , m_BSTrackSelector("")
   , m_alignModuleTool("Trk::AlignModuleTool/AlignModuleTool")
   , m_PVContainerName("PrimaryVertices")
   , m_runOutlierRemoval(false)
   , m_selectVertices(true)
   , m_particleNumber(3)                          // 3=pion, 0=non-interacting
   , m_doTrkSelection (true)
   , m_doBSTrackSelection(false)
   , m_doAssociatedToPVSelection(true)
   , m_constraintMode(0)
   , m_compareMethod("compareAddress")
   , m_doBeamspotConstraint(true)
   , m_doPrimaryVertexConstraint(false)
   , m_doFullVertexConstraint(false)
   , m_doNormalRefit(true)
   , m_maxPt(0.)
   , m_refitTracks(true)
   , m_storeFitMatrices(true)
   , m_useSingleFitter(false)
   , m_BSScalingFactor(1.)
   , m_PVScalingFactor(1.)
   , m_minTrksInVtx(3)
   , m_nTracks(0)
   , m_trackTypeCounter(AlignTrack::NTrackTypes,0)
   , m_nFailedNormalRefits(0)
   , m_nFailedBSRefits(0)
   , m_nFailedPVRefits(0)
 {
   declareInterface<IAlignTrackPreProcessor>(this);
   declareProperty("RefitTracks",               m_refitTracks      );
   declareProperty("PVContainerName",           m_PVContainerName    );
   declareProperty("TrackFitter",               m_trackFitter      );
   declareProperty("SLTrackFitter",             m_SLTrackFitter      );
   declareProperty("UseSingleFitter",           m_useSingleFitter    );
   declareProperty("Extrapolator",              m_extrapolator             );
   declareProperty("TrackToVertexIPEstimatorTool", m_trackToVertexIPEstimatorTool);
   declareProperty("RunOutlierRemoval",         m_runOutlierRemoval        );
   declareProperty("AlignModuleTool",           m_alignModuleTool          );
   declareProperty("ParticleNumber",            m_particleNumber           );
   declareProperty("TrackSelector",             m_trkSelector              );
   declareProperty("DoTrackSelection",          m_doTrkSelection           );
   declareProperty("BSConstraintTrackSelector", m_BSTrackSelector          );
   declareProperty("DoBSTrackSelection",        m_doBSTrackSelection       );
   declareProperty("DoAssociatedToPVSelection", m_doAssociatedToPVSelection);
   declareProperty("DoBSConstraint",            m_doBeamspotConstraint     ,"Constrain tracks to the beamspot (x,y) position");
   declareProperty("DoPVConstraint",            m_doPrimaryVertexConstraint,"Constrain tracks to the associated primary vertex (x,y,z) position");
   declareProperty("DoFullVertex",              m_doFullVertexConstraint   ,"Full 3D vertex constraint.  Note DoPVConstraint needs to be set to true to use this option. If DoBSConstraint vertex position will be constrained to the BS" );
   declareProperty("ConstraintMode",            m_constraintMode           );
   declareProperty("StoreFitMatrices",          m_storeFitMatrices         );
   declareProperty("BeamspotScalingFactor",     m_BSScalingFactor          );
   declareProperty("PrimaryVertexScalingFactor",m_PVScalingFactor          );
   declareProperty("MinTrksInVtx",              m_minTrksInVtx             );
   declareProperty("doNormalRefit"             ,m_doNormalRefit            );
   declareProperty("maxPt"                     ,m_maxPt            );
  
  
   std::vector<std::string> defaultInterestedVertexContainers;
   defaultInterestedVertexContainers.emplace_back("PrimaryVertices");       // MD: Maybe only the first container?
   //defaultInterestedVertexContainers.push_back("V0UnconstrVertices");  //   : does not seem to exist in files -> check later again
   m_interestedVertexContainers = defaultInterestedVertexContainers;
  
   m_logStream = nullptr;
 }

◆ ~BeamspotVertexPreProcessor()

Trk::BeamspotVertexPreProcessor::~BeamspotVertexPreProcessor ( )

virtualdefault

Member Function Documentation

◆ accumulateVTX()

void Trk::BeamspotVertexPreProcessor::accumulateVTX ( AlignTrack * )

virtual

methods added for the full VTX fit:

Reimplemented from Trk::IAlignTrackPreProcessor.

Definition at line 954 of file BeamspotVertexPreProcessor.cxx.

                                                                      {
  
   if( !m_doFullVertexConstraint ) return;
  
   AlignVertex*  alignVertex = alignTrack->getVtx();
  
   ATH_MSG_DEBUG( " In accumulateVTX ");
   if( !alignVertex ) {
     ATH_MSG_DEBUG( "This alignTrack is not associated to any vertex -> return. ");
     return;
   }
  
   // get pointers so we can reuse them if they're valid
   const Amg::MatrixX           * ptrWeights   = alignTrack->weightMatrix();
   const Amg::MatrixX           * ptrWeightsFD = alignTrack->weightMatrixFirstDeriv();
   const Amg::VectorX           * ptrResiduals = alignTrack->residualVector();
   const std::vector<AlignModuleDerivatives> * ptrDerivs    = alignTrack->derivatives();
  
   // check if pointers are valid
   if (!ptrWeights || !ptrWeightsFD || !ptrResiduals || !ptrDerivs) {
     msg(MSG::ERROR)<<"something missing from alignTrack!"<<endmsg;
     if (!ptrWeights)   msg(MSG::ERROR)<<"no weights!"<<endmsg;
     if (!ptrWeightsFD) msg(MSG::ERROR)<<"no weights for first deriv!"<<endmsg;
     if (!ptrResiduals) msg(MSG::ERROR)<<"no residuals!"<<endmsg;
     if (!ptrDerivs)    msg(MSG::ERROR)<<"no derivatives!"<<endmsg;
     return;
   }
  
   // get vectors
   const Amg::VectorX&                  residuals     = *ptrResiduals;
   std::vector<AlignModuleDerivatives>  derivatives   = *ptrDerivs;
  
   // get weight matrices
   const Amg::MatrixX&          weights           = *ptrWeights;
   const Amg::MatrixX&          weightsFirstDeriv = *ptrWeightsFD;
   ATH_MSG_VERBOSE("weights="<<weights);
   ATH_MSG_VERBOSE("weightsFirstDeriv="<<weightsFirstDeriv);
  
   // get all alignPars and all derivatives
   ATH_MSG_DEBUG("accumulateVTX: The derivative vector size is  " << derivatives.size() );
   std::vector<AlignModuleDerivatives>::iterator derivIt     = derivatives.begin();
   std::vector<AlignModuleDerivatives>::iterator derivIt_end = derivatives.end();
  
   std::vector<Amg::VectorX*> allDerivatives[3];
   //    CLHEP::HepVector*  VTXDerivatives[3];
   Amg::VectorX  VTXDerivatives[3];
   const int    WSize(weights.cols());
   Amg::MatrixX WF(3,WSize);
   std::vector<AlignModuleVertexDerivatives> derivX;
  
   for ( ; derivIt!=derivIt_end ; ++derivIt) {
  
     // get AlignModule
     const AlignModule* module=derivIt->first;
  
  
     // get alignment parameters
     if( module ) {
       Amg::MatrixX   F(3,WSize);
       std::vector<Amg::VectorX>& deriv_vec = derivIt->second;
       ATH_MSG_VERBOSE( "accumulateVTX: The deriv_vec size is  " << deriv_vec.size() );
       DataVector<AlignPar>* alignPars = m_alignModuleTool->getAlignPars(module);
       int nModPars = alignPars->size();
       if ((nModPars+3) != (int)deriv_vec.size() ) {
         ATH_MSG_ERROR("accumulateVTX: Derivatives w.r.t. the vertex seem to be missing");
         return;
       }
       for (int i=0;i<3;i++) {
         allDerivatives[i].push_back(&deriv_vec[nModPars+i]);
         for (int j=0;j<WSize;j++) {
           F(i,j) = deriv_vec[nModPars+i][j];
         }
       }
  
       // prepare the X object in the AlignVertex:
       WF += F * weights;
  
     } else {
       ATH_MSG_ERROR("accumulateVTX: Derivatives do not have a valid pointer to the module.");
       return;
     }
   }
  
  
   // second loop to fill the X object:
   derivIt     = derivatives.begin();
   for ( ; derivIt!=derivIt_end ; ++derivIt) {
  
     // get AlignModule
     const AlignModule* module=derivIt->first;
  
  
     // get alignment parameters
     if( module ) {
       std::vector<Amg::VectorX>& deriv_vec = derivIt->second;
       std::vector<Amg::VectorX> drdaWF;
       ATH_MSG_DEBUG("accumulateVTX: The deriv_vec size is  "
                     << deriv_vec.size());
       DataVector<AlignPar>* alignPars = m_alignModuleTool->getAlignPars(module);
       int nModPars = alignPars->size();
       if ((nModPars + 3) != (int)deriv_vec.size()) {
         ATH_MSG_ERROR(
             "accumulateVTX: Derivatives w.r.t. the vertex seem to be missing");
         return;
       }
       drdaWF.reserve(nModPars);
       for (int i = 0; i < nModPars; i++) {
         drdaWF.emplace_back(2.0 * (WF)*deriv_vec[i]);
       }
       ATH_MSG_DEBUG("accumulateVTX: derivX incremented by:  " << drdaWF);
       // now add contribution from this track to the X object:
       derivX.emplace_back(module,std::move(drdaWF));
  
     } else {
       ATH_MSG_ERROR("accumulateVTX: Derivatives do not have a valid pointer to the module.");
       return;
     }
   }
  
  
  
   // prepare derivatives w.r.t. the vertex position:
   int nmodules = allDerivatives[0].size();
   msg(MSG::DEBUG) << "accumulateVTX: allDerivatives size is  " << nmodules << endmsg;
   for( int ii=0; ii<3; ++ii ) {
     VTXDerivatives[ii] = (*(allDerivatives[ii])[0]);
     for( int jj=1; jj<nmodules; ++jj ) {
       VTXDerivatives[ii] += (*(allDerivatives[ii])[jj]);
     }
   }
  
  
   AmgVector(3)     vtxV;
   AmgSymMatrix(3)  vtxM;
  
   Amg::VectorX RHM= weightsFirstDeriv * residuals;
   ATH_MSG_DEBUG("RHM: "<<RHM);
  
   for (int ipar=0;ipar<3;ipar++) {
  
     // calculate first derivative
     //  CLHEP::HepMatrix derivativesT = (*(VTXDerivatives[ipar])).T();
     Amg::MatrixX derivativesT = (VTXDerivatives[ipar]).transpose();
     ATH_MSG_DEBUG("derivativesT (size "<<derivativesT.cols()<<"): "<<derivativesT);
  
     Amg::MatrixX  tempV = (2.* derivativesT * RHM);
     vtxV[ipar] = tempV(0,0);
  
     for (int jpar=ipar;jpar<3;jpar++) {
  
       // calculate second derivatives
       Amg::MatrixX RHM2 = weights * (VTXDerivatives[jpar]);
  
       Amg::MatrixX  tempM = (2.* derivativesT * RHM2);
       vtxM(ipar,jpar) = tempM(0,0);
  
     }
  
   }
  
   // increment the vtx algebra objects:
  
   alignVertex->incrementVector(vtxV);
   alignVertex->incrementMatrix(vtxM);
   //   ATH_MSG_DEBUG("accumulateVTX: derivX size = "<< derivX->size());
   alignVertex->addDerivatives(&derivX);
  
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ doBeamspotConstraintTrackSelection()

bool Trk::BeamspotVertexPreProcessor::doBeamspotConstraintTrackSelection ( const Track * track )

private

Definition at line 677 of file BeamspotVertexPreProcessor.cxx.

                                                                                       {
  
   const xAOD::VertexContainer* vertices = nullptr;
   const xAOD::Vertex* vertex = nullptr;
   bool haveVertex = false;
  
   // retrieve the primary vertex if needed
   if(m_doAssociatedToPVSelection) {
  
     if(evtStore()->retrieve( vertices, m_PVContainerName ).isFailure()) {
       msg(MSG::ERROR)<<"Cannot retrieve the \'"<<m_PVContainerName<<"\' vertex collection from StoreGate"<<endmsg;
       m_doAssociatedToPVSelection = false;
     } else {
       // if there is no vertex, we can't associate the tracks to it
       if(vertices) {
         ATH_MSG_DEBUG("Primary vertex collection for this event has "<<vertices->size()<<" vertices");
         if (vertices->size()<2){
           ATH_MSG_DEBUG("Only Dummy vertex present, no Primary vertices.");
         } else {
           vertex = (*vertices)[0];
           haveVertex = true;
         }
       }
       else
         ATH_MSG_DEBUG("Could not retrieve primary vertex collection from the StoreGate");
     }
   }
  
  
   if( ( m_doAssociatedToPVSelection && haveVertex && vertex && isAssociatedToPV(track,vertices) ) ||
       ( m_doBSTrackSelection        && m_BSTrackSelector->accept(*track) ) ){
  
     if (m_maxPt > 0 )
       {
     const Trk::Perigee* perigee = track->perigeeParameters();
     if (!perigee) {
       ATH_MSG_DEBUG("NO perigee on this track");
       return false;
     }
     const double qoverP = perigee->parameters()[Trk::qOverP] * 1000.;
     double pt = 0.;
     if (qoverP != 0 )
       pt = std::abs(1.0/qoverP)*sin(perigee->parameters()[Trk::theta]);
     ATH_MSG_DEBUG( " pt  : "<< pt );
     if (pt > m_maxPt)
       return false;
       } //maxPt selection
     ATH_MSG_DEBUG("this track passes the beamspot track selection, will do beamspot constraint on it ");
     return true;
   }
   else return false;
 }

◆ doConstraintRefit()

const Track * Trk::BeamspotVertexPreProcessor::doConstraintRefit	(	ToolHandle< IGlobalTrackFitter > &	fitter,
		const Track *	track,
		const VertexOnTrack *	vot,
		const ParticleHypothesis &	particleHypothesis
	)		const

private

Definition at line 638 of file BeamspotVertexPreProcessor.cxx.

 {
   const EventContext& ctx = Gaudi::Hive::currentContext();
   const Track* newTrack = nullptr;
  
   if(vot){
  
     std::vector<const MeasurementBase *> measurementCollection;
     measurementCollection.push_back(vot);
     // add all other measurements
     DataVector<const MeasurementBase>::const_iterator imeas     = track->measurementsOnTrack()->begin();
     DataVector<const MeasurementBase>::const_iterator imeas_end = track->measurementsOnTrack()->end();
     for ( ; imeas != imeas_end ; ++imeas)  measurementCollection.push_back(*imeas);
  
     if( m_doFullVertexConstraint ) {
       // get track parameters at the vertex:
       const PerigeeSurface&         surface=vot->associatedSurface();
       ATH_MSG_DEBUG(" Track reference surface will be:  " << surface);
       const TrackParameters* parsATvertex=m_extrapolator->extrapolateTrack(ctx, *track, surface).release();
  
       ATH_MSG_DEBUG(" Track will be refitted at this surface  ");
       newTrack = (fitter->fit(ctx, measurementCollection,
                              *parsATvertex, m_runOutlierRemoval, particleHypothesis)).release();
       delete parsATvertex;
     } else {
       newTrack = (fitter->fit(ctx,
                              measurementCollection, *(track->trackParameters()->front()),
                              m_runOutlierRemoval, particleHypothesis)).release();
     }
      //     delete vot;
   }
  
   return newTrack;
 }

◆ doTrackRefit()

AlignTrack * Trk::BeamspotVertexPreProcessor::doTrackRefit ( const Track * track )

private

Definition at line 731 of file BeamspotVertexPreProcessor.cxx.

                                                                        {
  
   AlignTrack * alignTrack = nullptr;
   const Track* newTrack = nullptr;
   const VertexOnTrack* vot = nullptr;
   const xAOD::Vertex*    vtx = nullptr;
   AlignTrack::AlignTrackType type = AlignTrack::Unknown;
   // configuration of the material effects needed for track fitter
   ParticleHypothesis particleHypothesis = Trk::ParticleSwitcher::particle[m_particleNumber];
  
   // initialization the GX2 track fitter
   ToolHandle<Trk::IGlobalTrackFitter> fitter = m_trackFitter;
   if (!m_useSingleFitter && AlignTrack::isSLTrack(track) )
       fitter = m_SLTrackFitter;
  
   IGlobalTrackFitter::AlignmentCache alignCache;
  
   ATH_MSG_DEBUG( "doTrackRefit ** START ** ");
  
   if(m_doPrimaryVertexConstraint){
     vot = provideVotFromVertex(track, vtx);
     if( !vot )  ATH_MSG_INFO( "VoT not found for this track! ");
     if( !vtx )  ATH_MSG_INFO( "VTX pointer not found for this track! ");
     if(vot){
       newTrack = doConstraintRefit(fitter, track, vot, particleHypothesis);
       type = AlignTrack::VertexConstrained;
       // this track failed the PV constraint reift
       if (!newTrack)  {
         ++m_nFailedPVRefits;
         msg(MSG::ERROR)<<"VertexConstraint track refit failed! "<<endmsg;
       }
     }
   }
  
   if( !newTrack && m_doBeamspotConstraint && doBeamspotConstraintTrackSelection(track) ){
       vot = provideVotFromBeamspot(track);
       if(vot){
         newTrack = doConstraintRefit(fitter, track, vot, particleHypothesis);
         type = AlignTrack::BeamspotConstrained;
         // this track failed the BS constraint reift
         if (!newTrack)  {
           ++m_nFailedBSRefits;
           msg(MSG::ERROR)<<"BSConstraint track refit failed! "<<endmsg;
         }
       }
   }
  
  
   //Refit to get full fitter covariance matrix
   // @TODO This is a little inefficienct and should
   // be addressed when the alignment code is made MT safe
   if(newTrack){
     Trk::Track* tmpTrk =  fitter->alignmentFit(alignCache,*newTrack,m_runOutlierRemoval,particleHypothesis);
     delete newTrack;
     newTrack = tmpTrk;
     if(!tmpTrk){
       if(type == AlignTrack::VertexConstrained)
       {
         ++m_nFailedPVRefits;
         ATH_MSG_ERROR("VertexConstraint track refit2 failed! ");
       }else if(type == AlignTrack::BeamspotConstrained)
       {
         ++m_nFailedPVRefits;
         ATH_MSG_ERROR("BSConstraint track refit2 failed! ");
       }
     }
   }
  
   if(!newTrack && m_doNormalRefit){
       newTrack = fitter->alignmentFit(alignCache,*track,m_runOutlierRemoval,particleHypothesis);
       type = AlignTrack::NormalRefitted;
       // this track failed the normal reift
       if (!newTrack)   {
         ++m_nFailedNormalRefits;
         msg(MSG::ERROR)<<"Normal track refit failed! "<<endmsg;
       }
   }
  
  
  
  
  
   if(newTrack) {
     alignTrack = new AlignTrack(*newTrack);
     // set original track pointer
     alignTrack->setOriginalTrack(track);
     // set the refit type
     alignTrack->setType(type);
  
  
     if (msgLvl(MSG::DEBUG) || msgLvl(MSG::VERBOSE)) {
       msg(MSG::DEBUG)<<"before refit: "<<endmsg;
       msg(MSG::DEBUG)<< *track <<endmsg;
       if (msgLvl(MSG::VERBOSE))   AlignTrack::dumpLessTrackInfo(*track,msg(MSG::DEBUG));
  
       msg(MSG::DEBUG)<<"after refit: "<<endmsg;
       msg(MSG::DEBUG)<< *newTrack <<endmsg;
       if (msgLvl(MSG::VERBOSE))   AlignTrack::dumpLessTrackInfo(*newTrack,msg(MSG::DEBUG));
     }
  
     if(AlignTrack::VertexConstrained == type || AlignTrack::BeamspotConstrained == type) alignTrack->doFindPerigee();
  
     if (m_storeFitMatrices) {
       alignTrack->setFullCovarianceMatrix(alignCache.m_fullCovarianceMatrix);
       alignTrack->setDerivativeMatrix(alignCache.m_derivMatrix);
     }
     delete newTrack;
  
     if( m_doFullVertexConstraint && vtx!=nullptr && type == AlignTrack::VertexConstrained ){
     // try to log the track-vertex association in the AlignVertex object:
       bool ifound=false;
       for (AlignVertex* ivtx : m_AlignVertices) {
         if( (ivtx->originalVertex())==vtx ) {
           ifound = true;
         }
       }
       if( !ifound ) {
         AlignVertex*  avtx=new AlignVertex(vtx);
         ATH_MSG_DEBUG(" New AlignVertex has ben created.");
  
         // Beam Spot constraint on the vertex:
         if( m_doBeamspotConstraint && (xAOD::VxType::PriVtx == vtx->vertexType() || xAOD::VxType::PileUp == vtx->vertexType()) && vtx->vxTrackAtVertex().size()>4 ) {     // a beam line verex
           ATH_MSG_DEBUG(" The Beam Spot constraint will be added to the vertex.." );
           AmgSymMatrix(3)     qtemp;
           AmgVector(3)        vtemp;
           provideVtxBeamspot(avtx, &qtemp, &vtemp);
           (qtemp)(2,2) = 1000000.0;                  // disable Z constraint
           avtx->setConstraint( &qtemp, &vtemp);
         }
  
         m_AlignVertices.push_back(avtx);
       }
     }
      // increment counters
      ++m_trackTypeCounter[type];
      ++m_nTracks;
  
   }
   // garbage collection:
   if(vot)  delete vot;
  
   ATH_MSG_DEBUG( "doTrackRefit ** COMPLETED ** ");
   return alignTrack;
 }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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

◆ fillNtuple()

virtual StatusCode Trk::IAlignTrackPreProcessor::fillNtuple ( )

inlinevirtualinherited

writes tree and histogrms to ntuple

Definition at line 54 of file IAlignTrackPreProcessor.h.

54 { return StatusCode::SUCCESS; }

◆ finalize()

StatusCode Trk::BeamspotVertexPreProcessor::finalize ( )

virtual

Definition at line 1167 of file BeamspotVertexPreProcessor.cxx.

 {
   ATH_MSG_INFO("BeamspotVertexPreProcessor::finalize()");
  
   return StatusCode::SUCCESS;
 }

◆ findVertexCandidate()

const xAOD::Vertex * Trk::BeamspotVertexPreProcessor::findVertexCandidate ( const Track * track ) const

private

Definition at line 372 of file BeamspotVertexPreProcessor.cxx.

                                                                                           {
  
   const xAOD::Vertex* findVxCandidate = nullptr;
   //VxTrackAtVertex* findVxTrack = 0;
  
   std::vector< std::pair< const xAOD::Vertex*, std::vector<VxTrackAtVertex> > >::const_iterator iter    = m_allTracksVector.begin();
   std::vector< std::pair< const xAOD::Vertex*, std::vector<VxTrackAtVertex> > >::const_iterator iterEnd = m_allTracksVector.end();
  
   for(; iter != iterEnd; ++iter){
     std::pair< const xAOD::Vertex*, std::vector<VxTrackAtVertex> > thisPair = *iter;
     //ATH_MSG_DEBUG(" this VxCandidate* and vector<VxTrackAtVertex*>* Pair: "<< *(thisPair.first));
  
     std::vector<VxTrackAtVertex>::iterator iVxTrackBegin  = (thisPair.second).begin();
     std::vector<VxTrackAtVertex>::iterator iVxTrackEnd    = (thisPair.second).end();
     Trk::CompareTwoTracks thisCompare(track, m_compareMethod);
  
     std::vector<VxTrackAtVertex>::iterator findResult = std::find_if(iVxTrackBegin, iVxTrackEnd, thisCompare);
  
     if(findResult != iVxTrackEnd){
       ATH_MSG_DEBUG("the found VxTrackAtVertex: "<<*findResult);
       findVxCandidate      = thisPair.first;
       //findVxTrack          = findResult;
       break;
     }
   }
  
   //if  ( !(findVxCandidate && findVxTrack) )
   //  ATH_MSG_DEBUG("the track don't not belongs to any interested Vertex! ");
  
   return findVxCandidate;
 }

◆ initialize()

StatusCode Trk::BeamspotVertexPreProcessor::initialize ( )

virtual

Definition at line 125 of file BeamspotVertexPreProcessor.cxx.

 {
   ATH_MSG_INFO("BeamspotVertexPreProcessor::initialize()");
  
   // configure main track selector if requested
   if (!m_trkSelector.empty()) {
     if (m_trkSelector.retrieve().isFailure())
       msg(MSG::ERROR)<<"Failed to retrieve tool "<<m_trkSelector<<". No Track Selection will be done."<<endmsg;
     else
       ATH_MSG_INFO("Retrieved " << m_trkSelector);
   }
  
   if (m_refitTracks) {
     // configure main track fitter
     if(m_trackFitter.retrieve().isFailure()) {
        msg(MSG::FATAL) << "Could not get " << m_trackFitter << endmsg;
        return StatusCode::FAILURE;
     }
     ATH_MSG_INFO("Retrieved " << m_trackFitter);
  
     // configure straight-line track fitter if requested
     if (!m_useSingleFitter) {
       if (m_SLTrackFitter.retrieve().isFailure()) {
         msg(MSG::FATAL) << "Could not get " << m_SLTrackFitter << endmsg;
         return StatusCode::FAILURE;
       }
       ATH_MSG_INFO("Retrieved " << m_SLTrackFitter);
     }
  
     // TrackToVertexIPEstimator
     if (m_trackToVertexIPEstimatorTool.retrieve().isFailure()) {
       if(msgLvl(MSG::FATAL)) msg(MSG::FATAL) << "Can not retrieve TrackToVertexIPEstimator of type " << m_trackToVertexIPEstimatorTool.typeAndName() << endmsg;
       return StatusCode::FAILURE;
     } else {
       ATH_MSG_INFO ( "Retrieved TrackToVertexIPEstimator Tool " << m_trackToVertexIPEstimatorTool.typeAndName() );
     }
  
     // configure Atlas extrapolator
     if (m_extrapolator.retrieve().isFailure()) {
       msg(MSG::FATAL) << "Failed to retrieve tool "<<m_extrapolator<<endmsg;
       return StatusCode::FAILURE;
     }
     ATH_MSG_INFO("Retrieved " << m_extrapolator);
  
     // configure beam-spot conditions service
     ATH_CHECK(m_beamSpotKey.initialize());
  
  
     // configure beam-spot track selector if requested
     if(m_doBSTrackSelection) {
       if(m_BSTrackSelector.empty()) {
         msg(MSG::FATAL) << "Requested BeamSpot track selection but Track Selector not configured"<< endmsg;
         return StatusCode::FAILURE;
       }
       if (m_BSTrackSelector.retrieve().isFailure()) {
          msg(MSG::FATAL) << "Could not get " << m_BSTrackSelector<< endmsg;
          return StatusCode::FAILURE;
       }
       ATH_MSG_INFO("Retrieved " << m_BSTrackSelector);
     }
  
   }  // end of 'if (m_refitTracks)'
  
   else if (m_doBeamspotConstraint) {
     msg(MSG::FATAL)<<"Requested beam-spot constraint but RefitTracks is False."<<endmsg;
     return StatusCode::FAILURE;
   }
  
   if( m_doFullVertexConstraint && m_doPrimaryVertexConstraint ) {
     if ( m_alignModuleTool.retrieve().isFailure() ) {
       ATH_MSG_FATAL("Failed to retrieve tool " << m_alignModuleTool);
       return StatusCode::FAILURE;
     }
     else {
       ATH_MSG_INFO("Retrieved tool " << m_alignModuleTool);
  
       ATH_MSG_INFO("************************************************************************");
       ATH_MSG_INFO("*                                                                      *");
       ATH_MSG_INFO("* You have requested the Full Vertex Constraint option.                *");
       ATH_MSG_INFO("* It is your duty to assure that all detector elements                 *");
       ATH_MSG_INFO("* used for track fitting are also loaded in the alignment framework!!! *");
       ATH_MSG_INFO("*                                                                      *");
       ATH_MSG_INFO("* Also make sure the accurate track covariance matrix                  *");
       ATH_MSG_INFO("* is returned by the GlobalChi2Fitter!                                 *");
       ATH_MSG_INFO("*                                                                      *");
       ATH_MSG_INFO("************************************************************************");
     }
  
   }
   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()

const InterfaceID & IAlignTrackPreProcessor::interfaceID ( )

inlinestaticinherited

Definition at line 70 of file IAlignTrackPreProcessor.h.

   {
     return IID_Trk_IAlignTrackPreProcessor;
   }

◆ isAssociatedToPV()

bool Trk::BeamspotVertexPreProcessor::isAssociatedToPV	(	const Track *	track,
		const xAOD::VertexContainer *	vertices
	)

private

Definition at line 295 of file BeamspotVertexPreProcessor.cxx.

 {
   if(!vertices)
       return false;
  
   xAOD::VertexContainer::const_iterator vtxEnd   = vertices->end();
   xAOD::VertexContainer::const_iterator vtxIter  = vertices->begin();
  
   for ( ; vtxIter != vtxEnd  && (*vtxIter)->vertexType() == 1; ++vtxIter ){
         if (isAssociatedToVertex(track, *vtxIter)) return true;
   }
   return false;
 }

◆ isAssociatedToVertex()

bool Trk::BeamspotVertexPreProcessor::isAssociatedToVertex	(	const Track *	track,
		const xAOD::Vertex *	vertex
	)

private

Definition at line 311 of file BeamspotVertexPreProcessor.cxx.

 {
   if(!vertex)
     return false;
  
   std::vector<VxTrackAtVertex >  vertexTracks = vertex->vxTrackAtVertex();
   Trk::CompareTwoTracks thisCompare(track, m_compareMethod);
  
   std::vector<VxTrackAtVertex >::const_iterator iVxTrackBegin = vertexTracks.begin();
   std::vector<VxTrackAtVertex >::const_iterator iVxTrackEnd   = vertexTracks.end();
  
   std::vector<VxTrackAtVertex>::const_iterator findResult = std::find_if(iVxTrackBegin, iVxTrackEnd, thisCompare);
  
   return findResult != iVxTrackEnd;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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.

◆ prepareAllTracksVector()

void Trk::BeamspotVertexPreProcessor::prepareAllTracksVector ( )

private

Definition at line 328 of file BeamspotVertexPreProcessor.cxx.

                                                        {
  
   // do clean up firstly
   m_allTracksVector.clear();
   const xAOD::VertexContainer* thisContainer = nullptr;
   //xAODVertices
   std::vector<std::string>::const_iterator strs_iter = m_interestedVertexContainers.begin();
   std::vector<std::string>::const_iterator strs_end  = m_interestedVertexContainers.end();
  
   for(; strs_iter != strs_end; ++strs_iter){
  
     if (evtStore()->contains<xAOD::VertexContainer>(*strs_iter)) {
       if (evtStore()->retrieve(thisContainer,*strs_iter).isFailure() ) {
         ATH_MSG_DEBUG ("Could not retrieve xAOD vertex container with key "+(*strs_iter));
         continue;
       }
       else {
  
         xAOD::VertexContainer::const_iterator vtxEnd   = thisContainer->end();
         xAOD::VertexContainer::const_iterator vtxIter  = thisContainer->begin();
  
         for(; vtxIter != vtxEnd; ++vtxIter){
           if(m_selectVertices && !selectVertices(*vtxIter)) {
             ATH_MSG_DEBUG("this vertex did not pass the primary vertex selection...");
             continue;
           }
           // MD: extra check to make sure - maybe not needed?
           if ((*vtxIter)->vxTrackAtVertexAvailable()){
  
             std::vector<VxTrackAtVertex> vtxTracks = (*vtxIter)->vxTrackAtVertex();
             m_allTracksVector.emplace_back(*vtxIter,vtxTracks);
           }
           else {
             ATH_MSG_DEBUG("this vertex did not pass the vxTrackAtVertexAvailable() call...");
             continue;
           }
         }
       }
     }
   }
   ATH_MSG_DEBUG("m_allTracksVector size: "<<m_allTracksVector.size());
 }

◆ printSummary()

void Trk::BeamspotVertexPreProcessor::printSummary ( )

virtual

Print processing summary to logfile.

Reimplemented from Trk::IAlignTrackPreProcessor.

Definition at line 1143 of file BeamspotVertexPreProcessor.cxx.

 {
   if(m_logStream) {
  
     *m_logStream<<"*************************************************************"<<std::endl;
     *m_logStream<<"******        BeamspotVertexPreProcessor summary       ******"<<std::endl;
     *m_logStream<<"*"<<std::endl;
     *m_logStream<<"* number of created AlignTracks :  "<<m_nTracks<<std::endl;
     if(m_nTracks>0) {
       *m_logStream<<"* --------------------------------------------"<<std::endl;
       for(int i=0; i<AlignTrack::NTrackTypes; ++i) {
         if(m_trackTypeCounter[i]>0)
           *m_logStream<<"*           "<<(AlignTrack::AlignTrackType)i<<":  "<<m_trackTypeCounter[i]<<std::endl;
         }
     }
     *m_logStream<<"*"<<std::endl;
     *m_logStream<<"* number of failed normal refits :              " << m_nFailedNormalRefits << std::endl;
     *m_logStream<<"* number of failed refits with primary vertex : " << m_nFailedPVRefits     << std::endl;
     *m_logStream<<"* number of failed refits with beam-spot :      " << m_nFailedBSRefits     << std::endl;
     *m_logStream<<"*"<<std::endl;
   }
 }

◆ processTrackCollection()

DataVector< Track > * Trk::BeamspotVertexPreProcessor::processTrackCollection ( const DataVector< Track > * trks )

virtual

Main processing of track collection.

The method should create AlignTracks but fill them into a collection of Tracks. The reason is that AlignTracks are needed further in the alignment processing but we want to store the newly created TrackCollection into StoreGate.

Implements Trk::IAlignTrackPreProcessor.

Definition at line 880 of file BeamspotVertexPreProcessor.cxx.

 {
   ATH_MSG_DEBUG("BeamspotVertexPreProcessor::processTrackCollection()");
  
   if( !tracks || (tracks->empty()) )
     return nullptr;
  
   // Clear the AlignVertex container (will destruct the objects it owns as well!)
   m_AlignVertices.clear();
  
  
   if(m_doPrimaryVertexConstraint)
     prepareAllTracksVector();
  
   // the output collection of AlignTracks
   // we define it as collection of Tracks but fill AlignTracks inside
   DataVector<Track> * newTrks = new DataVector<Track>;
  
   int index(0);
   // loop over tracks
   TrackCollection::const_iterator itr     = tracks->begin();
   TrackCollection::const_iterator itr_end = tracks->end();
  
   ATH_MSG_DEBUG( "Starting loop on input track collection: "<<index);
   for ( ; itr != itr_end; ++itr, ++index) {
     ATH_MSG_DEBUG("Processing track "<<index);
     const Track* track = *itr;
     AlignTrack * alignTrack = nullptr;
     if (not track) continue;
  
     // check whether the track passes the basic selection
     if (m_doTrkSelection) {
       ATH_MSG_DEBUG( "Testing track selection on track: "<<index);
       if ((not m_trkSelector.empty()) and (not m_trkSelector->accept(*track))) continue;
     } // appliying track selection
  
     if(m_refitTracks){
       ATH_MSG_DEBUG( "Refitting track: "<<index );
       alignTrack = doTrackRefit(track);
  
       // 2nd track check after refit
       if(alignTrack && !m_trkSelector.empty()) {
     // refitted track loses the summary information, restoring it here
     alignTrack->setTrackSummary( std::make_unique<Trk::TrackSummary> (*track->trackSummary()) );
     // do not check for FullVertex tracks:
         if( !(alignTrack->getVtx()) ) {
       if( m_doTrkSelection && !m_trkSelector->accept(*alignTrack))
         continue;
     }
       }
       else {
         ATH_MSG_DEBUG( "Refit of track " << index << " ended with no alignTrack" );
       }
     } else {
       ATH_MSG_DEBUG( "No Track refit for track " << index << " --> building new aligntrack");
       alignTrack = new AlignTrack(*track);
       alignTrack->setOriginalTrack(track);
       alignTrack->setType(AlignTrack::Original);
     }
     // add the new align track to the collection
     if (alignTrack)  newTrks->push_back(alignTrack);
   } // end of loop over tracks
  
   ATH_MSG_INFO( "Processing of input track collection completed (size: " << tracks->size() << "). Size of the alignTrack collection: " << newTrks->size() );
   // delete the collection if it's empty
   if (newTrks->empty()) {
     delete newTrks;
     return nullptr;
   }
  
   return newTrks;
 }

◆ provideVotFromBeamspot()

const VertexOnTrack * Trk::BeamspotVertexPreProcessor::provideVotFromBeamspot ( const Track * track ) const

private

Definition at line 518 of file BeamspotVertexPreProcessor.cxx.

                                                                                                {
  
   const EventContext& ctx = Gaudi::Hive::currentContext();
   const VertexOnTrack * vot = nullptr;
   SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
   Amg::Vector3D  bpos = beamSpotHandle->beamPos();
   ATH_MSG_DEBUG("beam spot: "<<bpos);
   float beamSpotX = bpos.x();
   float beamSpotY = bpos.y();
   float beamSpotZ = bpos.z();
   float beamTiltX = beamSpotHandle->beamTilt(0);
   float beamTiltY = beamSpotHandle->beamTilt(1);
   float beamSigmaX = m_BSScalingFactor * beamSpotHandle->beamSigma(0);
   float beamSigmaY = m_BSScalingFactor * beamSpotHandle->beamSigma(1);
   //float beamSigmaZ = m_scalingFactor * beamSpotHandle->beamSigma(2);
  
   ATH_MSG_DEBUG("running refit with beam-spot");
  
  
   float z0 = track->perigeeParameters()->parameters()[Trk::z0];
   float beamX = beamSpotX + std::tan(beamTiltX) * (z0-beamSpotZ);
   float beamY = beamSpotY + std::tan(beamTiltY) * (z0-beamSpotZ);
   Amg::Vector3D  BSC(beamX, beamY, z0);
   ATH_MSG_DEBUG("constructing beam point (x,y,z) = ( "<<beamX<<" , "<<beamY<<" , "<<z0<<" )");
   std::optional<PerigeeSurface> surface = std::nullopt;
   Amg::MatrixX  errorMatrix;
   LocalParameters beamSpotParameters;
  
   // covariance matrix of the beam-spot
   AmgSymMatrix(2) beamSpotCov;
   beamSpotCov.setZero();
   beamSpotCov(0,0) = beamSigmaX * beamSigmaX;
   beamSpotCov(1,1) = beamSigmaY * beamSigmaY;
  
   if(m_constraintMode == 0) {
  
     const Amg::Vector3D&  globPos(BSC);
     surface.emplace(globPos);
  
     // create a measurement for the beamspot
     DefinedParameter Par0(0.,Trk::d0);
     beamSpotParameters = LocalParameters(Par0);
  
     // calculate perigee parameters wrt. beam-spot
     const Perigee* perigee = nullptr;
     std::unique_ptr<const Trk::TrackParameters> tmp =
       m_extrapolator->extrapolateTrack(ctx, *track, *surface);
     // pass ownership only if of correct type
     if (tmp && tmp->associatedSurface().type() == Trk::SurfaceType::Perigee) {
       perigee = static_cast<const Perigee*>(tmp.release());
     }
  
     if (!perigee) {
       const Perigee * trackPerigee = track->perigeeParameters();
       if ( trackPerigee && trackPerigee->associatedSurface() == *surface )
         perigee = trackPerigee->clone();
     }
     if (not perigee){
       //WARNING
       ATH_MSG_WARNING("Perigee is nullptr in "<<__FILE__<<":"<<__LINE__);
       //exit
       return vot;
     }
  
     Eigen::Matrix<double,1,2> jacobian;
     jacobian.setZero();
     //perigee is dereferenced here, must not be nullptr
     double ptInv   =  1./perigee->momentum().perp();
     jacobian(0,0) = -ptInv * perigee->momentum().y();
     jacobian(0,1) =  ptInv * perigee->momentum().x();
  
     // MD: changed -> reversed order of matrix multiplication
     errorMatrix = Amg::MatrixX( jacobian*(beamSpotCov*jacobian.transpose()));
     if( errorMatrix.cols() != 1  )
          ATH_MSG_FATAL("Similarity transpose done incorrectly");
     delete perigee;
   }
   if (surface){
     vot = new VertexOnTrack(std::move(beamSpotParameters),
                             std::move(errorMatrix),
                             *surface);
   } else {
     ATH_MSG_WARNING("surface is nullptr in "<<__FILE__<<":"<<__LINE__);
   }
   if (vot){
     ATH_MSG_DEBUG(" the VertexOnTrack objects created from BeamSpot are " << *vot);
   }
  
   return vot;
 }

◆ provideVotFromVertex()

const VertexOnTrack * Trk::BeamspotVertexPreProcessor::provideVotFromVertex	(	const Track *	track,
		const xAOD::Vertex *&	vtx
	)		const

private

vertex as perigeeSurface

Definition at line 405 of file BeamspotVertexPreProcessor.cxx.

                                                                                                                       {
  
   const EventContext& ctx = Gaudi::Hive::currentContext();
   const VertexOnTrack * vot       = nullptr;
   const xAOD::Vertex* tmpVtx      = nullptr;
   const xAOD::Vertex* updatedVtx  = nullptr;
  
   const xAOD::Vertex* findVtx = findVertexCandidate(track);
  
   ATH_MSG_DEBUG("findVtx in provideVotFromVertex: "<<findVtx);
  
   if (!( nullptr==findVtx) ) {
     vtx    = findVtx;
  
     if( m_doFullVertexConstraint ) {
       updatedVtx = new xAOD::Vertex(*vtx);
       //updatedVtx = vtx->clone();   // no clone option for xAODvertex
     } else {
       tmpVtx = new xAOD::Vertex(*vtx);
       //tmpVtx = vtx->clone();  // no clone option for xAODvertex
       updatedVtx = m_trackToVertexIPEstimatorTool->getUnbiasedVertex(track->perigeeParameters(), vtx ); // MD: new function call
     }
  
  
     if(updatedVtx){
  
       if(!selectUpdatedVertices(updatedVtx))
         return vot;
  
       if( !m_doFullVertexConstraint )
         ATH_MSG_DEBUG(" updated Vertex by KalmanVertexUpdator: "<<updatedVtx);
  
  
       Amg::Vector3D  globPos(updatedVtx->position()); //look
       const PerigeeSurface surface(globPos);
       const Perigee* perigee = nullptr;
       std::unique_ptr<const Trk::TrackParameters> tmp =
         m_extrapolator->extrapolateTrack(ctx, *track, surface);
       //pass ownership only if of correct type
       if (tmp && tmp->associatedSurface().type() == Trk::SurfaceType::Perigee) {
          perigee = static_cast<const Perigee*> (tmp.release());
       }
       if (!perigee) {
         const Perigee * trackPerigee = track->perigeeParameters();
         if ( trackPerigee && trackPerigee->associatedSurface() == surface )
           perigee = trackPerigee->clone();
       }
       //if the perigee is still nonsense ...
       if (not perigee){
         //clean up
         if (updatedVtx!= tmpVtx) delete updatedVtx;
         delete tmpVtx;
         //WARNING
         ATH_MSG_WARNING("Perigee is nullptr in "<<__FILE__<<":"<<__LINE__);
         //exit
         return vot;
       }
  
       // create the Jacobian matrix from Cartisian to Perigee
       AmgMatrix(2,3) Jacobian;
       Jacobian.setZero();
       //perigee is dereferenced here, must not be nullptr!
       double ptInv                               =  1./perigee->momentum().perp();
       Jacobian(0,0)                              = -ptInv*perigee->momentum().y();
       Jacobian(0,1)                              =  ptInv*perigee->momentum().x();
       Jacobian(1,2)                              =  1.0;
  
       ATH_MSG_DEBUG(" Jacobian matrix from Cartesian to Perigee: "<< Jacobian);
  
       AmgSymMatrix(3) vtxCov = updatedVtx->covariancePosition(); // MD: that was NULL before?
       //std::cout  << " before PV scaling : "<< vtxCov << std::endl;
  
       vtxCov *= m_PVScalingFactor * m_PVScalingFactor;
       //std::cout  << " after PV scaling : "<< vtxCov << std::endl;
  
       Amg::MatrixX errorMatrix;
       if( m_doFullVertexConstraint ) {
         AmgSymMatrix(3)  tmpCov;
         tmpCov.setZero();
         tmpCov(0,0) = 1.e-10 ;
         tmpCov(1,1) = 1.e-10;
         tmpCov(2,2) = 1.e-10;
         errorMatrix = Amg::MatrixX( tmpCov.similarity(Jacobian) );
       } else {
         errorMatrix = Amg::MatrixX( vtxCov.similarity(Jacobian) );
       }
       delete perigee;
  
       // in fact, in most of the normal situation, pointer tmpVtx and updatedVtx are the same. You can check the source code
       // But for safety, I would like to delete them seperately
       // sroe(2016.09.23): This would result in an illegal double delete, if they really point to the same thing!
       // http://stackoverflow.com/questions/9169774/what-happens-in-a-double-delete
       if (tmpVtx != updatedVtx){
         delete updatedVtx;
       }
       delete tmpVtx;
       tmpVtx=nullptr;
       updatedVtx=nullptr;
  
       LocalParameters localParams = Trk::LocalParameters(Amg::Vector2D(0,0));
  
       // VertexOnTrack Object
       vot = new VertexOnTrack(std::move(localParams), std::move(errorMatrix), surface);
       ATH_MSG_DEBUG("the VertexOnTrack created from vertex: "<<*vot);
     }
   }
  
   return vot;
  
 }

◆ provideVtxBeamspot()

void Trk::BeamspotVertexPreProcessor::provideVtxBeamspot	(	const AlignVertex *	b,
		AmgSymMatrix(3) *	q,
		Amg::Vector3D *	v
	)		const

private

Definition at line 610 of file BeamspotVertexPreProcessor.cxx.

                                                                                                                   {
  
   SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
   Amg::Vector3D bpos = beamSpotHandle->beamPos();
   ATH_MSG_DEBUG("beam spot: "<<bpos);
   float beamSpotX = bpos.x();
   float beamSpotY = bpos.y();
   float beamSpotZ = bpos.z();
   float beamTiltX = beamSpotHandle->beamTilt(0);
   float beamTiltY = beamSpotHandle->beamTilt(1);
   float beamSigmaX = m_BSScalingFactor * beamSpotHandle->beamSigma(0);
   float beamSigmaY = m_BSScalingFactor * beamSpotHandle->beamSigma(1);
   float beamSigmaZ = m_BSScalingFactor * beamSpotHandle->beamSigma(2);
  
  
   float z0 = b->originalPosition()->z();
   (*v)(0) = beamSpotX + std::tan(beamTiltX) * (z0-beamSpotZ);
   (*v)(1) = beamSpotY + std::tan(beamTiltY) * (z0-beamSpotZ);
   (*v)(2) = beamSpotZ;
   (*q)(0,0) = beamSigmaX*beamSigmaX;
   (*q)(1,1) = beamSigmaY*beamSigmaY;
   (*q)(2,2) = beamSigmaZ*beamSigmaZ;
  
   ATH_MSG_DEBUG("VTX constraint point (x,y,z) = ( "<< (*v)[0] <<" , "<< (*v)[1] <<" , "<< (*v)[2] <<" )");
   ATH_MSG_DEBUG("VTX constraint size  (x,y,z) = ( "<< beamSigmaX <<" , "<< beamSigmaY <<" , "<< beamSigmaZ <<" )");
 }

◆ 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();
   }

◆ selectUpdatedVertices()

bool Trk::BeamspotVertexPreProcessor::selectUpdatedVertices ( const xAOD::Vertex * updatedVtx ) const

private

Definition at line 273 of file BeamspotVertexPreProcessor.cxx.

                                                                                    {
  
     if (vtx->numberDoF() <= 0){
       ATH_MSG_WARNING(" VERY STRANGE!!! , the updated vertex has been rejected as non-positive DoF: "<< vtx->numberDoF() <<" the type of this vertex:"<<  vtx->vertexType() );
       return false;
     }
  
     if (int(vtx->vxTrackAtVertex().size()) < m_minTrksInVtx){
       ATH_MSG_DEBUG(" the updated vertex has been rejected as vxTrackAtVertex size:  "<< vtx->vxTrackAtVertex().size() );
       return false;
     }
  
     if ((vtx->covariancePosition())(0,0)<=0  ||
         (vtx->covariancePosition())(1,1)<=0  ||
         (vtx->covariancePosition())(2,2)<=0){
       ATH_MSG_WARNING(" VERY STRANGE!!! , this updated vertex has been rejected as negative diagonal error matrix ");
       return false;
     }
     return true;
 }

◆ selectVertices()

bool Trk::BeamspotVertexPreProcessor::selectVertices ( const xAOD::Vertex * vtx ) const

private

Definition at line 255 of file BeamspotVertexPreProcessor.cxx.

                                                                             {
  
     if(0 == vtx->vertexType()) {
       ATH_MSG_DEBUG("this primary vertex has been rejected as type dummy");
       return false;
     }
     if (vtx->numberDoF() <= 0){
       ATH_MSG_WARNING(" VERY STRANGE!!!, this primary vertex has been rejected as non-positive DoF "<< vtx->numberDoF() <<" the type of this vertex: "<<  vtx->vertexType() );
       return false;
     }
     if (int(vtx->vxTrackAtVertex().size()) < m_minTrksInVtx){
       ATH_MSG_DEBUG(" this primary vertex vxTrackAtVertex size:  "<< vtx->vxTrackAtVertex().size() );
       return false;
     }
     return true;
 }

◆ setLogStream()

virtual void Trk::IAlignTrackPreProcessor::setLogStream ( std::ostream * os )

inlinevirtualinherited

sets the output stream for the logfile

Definition at line 48 of file IAlignTrackPreProcessor.h.

48 { m_logStream = os; }

◆ setNtuple()

virtual void Trk::IAlignTrackPreProcessor::setNtuple ( TFile * )

inlinevirtualinherited

Sets output ntuple file, to be implemented if needed for detector-specific implementation.

Definition at line 51 of file IAlignTrackPreProcessor.h.

51 {}

◆ solveVTX()

void Trk::BeamspotVertexPreProcessor::solveVTX ( )

virtual

Reimplemented from Trk::IAlignTrackPreProcessor.

Definition at line 1125 of file BeamspotVertexPreProcessor.cxx.

                                           {
  
   if( m_doFullVertexConstraint ){
     ATH_MSG_DEBUG("In solveVTX. Number of vertices = " << m_AlignVertices.size() );
     for (AlignVertex* ivtx : m_AlignVertices) {
       if( ivtx->Ntracks()>1 ) {
         ivtx->fitVertex();
        } else {
          msg(MSG::WARNING) << "This vertex contains " << ivtx->Ntracks() << " tracks. No solution possible." <<endmsg;
        }
  
        ATH_MSG_DEBUG( "This vertex contains " << ivtx->Ntracks() << " tracks.");
        if( msgLvl(MSG::DEBUG) )  ivtx->dump(msg(MSG::DEBUG));
     }
   }
 }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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.

◆ 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);
       }
     }
   }

Member Data Documentation

◆ m_alignModuleTool

ToolHandle<Trk::IAlignModuleTool> Trk::BeamspotVertexPreProcessor::m_alignModuleTool

private

Pointer to AlignModuleTool.

Definition at line 109 of file BeamspotVertexPreProcessor.h.

◆ m_AlignVertices

DataVector<AlignVertex> Trk::BeamspotVertexPreProcessor::m_AlignVertices

private

collection of AlignVertices used in FullVertex constraint option

Definition at line 146 of file BeamspotVertexPreProcessor.h.

◆ m_allTracksVector

std::vector< std::pair< const xAOD::Vertex*, std::vector<VxTrackAtVertex> > > Trk::BeamspotVertexPreProcessor::m_allTracksVector

private

Definition at line 125 of file BeamspotVertexPreProcessor.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> Trk::BeamspotVertexPreProcessor::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

private

Definition at line 111 of file BeamspotVertexPreProcessor.h.

◆ m_BSScalingFactor

double Trk::BeamspotVertexPreProcessor::m_BSScalingFactor

private

scaling factor on beasmpot width

Definition at line 136 of file BeamspotVertexPreProcessor.h.

◆ m_BSTrackSelector

ToolHandle<InDet::IInDetTrackSelectionTool> Trk::BeamspotVertexPreProcessor::m_BSTrackSelector

private

new track selector tool for tracks to be used with beam-spot constraint

Definition at line 104 of file BeamspotVertexPreProcessor.h.

◆ m_compareMethod

std::string Trk::BeamspotVertexPreProcessor::m_compareMethod

private

the method used to judge whether two tracks are the same track

Definition at line 123 of file BeamspotVertexPreProcessor.h.

◆ m_constraintMode

unsigned int Trk::BeamspotVertexPreProcessor::m_constraintMode

private

Definition at line 121 of file BeamspotVertexPreProcessor.h.

◆ 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_doAssociatedToPVSelection

bool Trk::BeamspotVertexPreProcessor::m_doAssociatedToPVSelection

private

the selection mechanism that only use the tracks associated to PV

Definition at line 119 of file BeamspotVertexPreProcessor.h.

◆ m_doBeamspotConstraint

bool Trk::BeamspotVertexPreProcessor::m_doBeamspotConstraint

private

do beamspot constraint

Definition at line 126 of file BeamspotVertexPreProcessor.h.

◆ m_doBSTrackSelection

bool Trk::BeamspotVertexPreProcessor::m_doBSTrackSelection

private

the selection mechanism which is based on cutting the perigee parameters, pt, etc.

Definition at line 118 of file BeamspotVertexPreProcessor.h.

◆ m_doFullVertexConstraint

bool Trk::BeamspotVertexPreProcessor::m_doFullVertexConstraint

private

do GX full vertex constraint

Definition at line 128 of file BeamspotVertexPreProcessor.h.

◆ m_doNormalRefit

bool Trk::BeamspotVertexPreProcessor::m_doNormalRefit

private

provide tracks in the case failed BS, PV and FullVertex constraints.

Definition at line 129 of file BeamspotVertexPreProcessor.h.

◆ m_doPrimaryVertexConstraint

bool Trk::BeamspotVertexPreProcessor::m_doPrimaryVertexConstraint

private

do vertex constraint

Definition at line 127 of file BeamspotVertexPreProcessor.h.

◆ m_doTrkSelection

bool Trk::BeamspotVertexPreProcessor::m_doTrkSelection

private

to activate the preprocessor track selection

Definition at line 117 of file BeamspotVertexPreProcessor.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_extrapolator

ToolHandle<IExtrapolator> Trk::BeamspotVertexPreProcessor::m_extrapolator

private

straight line track fitter

track extrapolator

Definition at line 100 of file BeamspotVertexPreProcessor.h.

◆ m_interestedVertexContainers

std::vector<std::string> Trk::BeamspotVertexPreProcessor::m_interestedVertexContainers

private

Definition at line 124 of file BeamspotVertexPreProcessor.h.

◆ m_logStream

std::ostream* Trk::IAlignTrackPreProcessor::m_logStream

protectedinherited

logfile output stream

Definition at line 66 of file IAlignTrackPreProcessor.h.

◆ m_maxPt

double Trk::BeamspotVertexPreProcessor::m_maxPt

private

Max pT range for refitting tracks.

Definition at line 131 of file BeamspotVertexPreProcessor.h.

◆ m_minTrksInVtx

int Trk::BeamspotVertexPreProcessor::m_minTrksInVtx

private

requirement to the minimal number of tracks in the vertex

Definition at line 139 of file BeamspotVertexPreProcessor.h.

◆ m_nFailedBSRefits

int Trk::BeamspotVertexPreProcessor::m_nFailedBSRefits

private

Definition at line 143 of file BeamspotVertexPreProcessor.h.

◆ m_nFailedNormalRefits

int Trk::BeamspotVertexPreProcessor::m_nFailedNormalRefits

private

Definition at line 142 of file BeamspotVertexPreProcessor.h.

◆ m_nFailedPVRefits

int Trk::BeamspotVertexPreProcessor::m_nFailedPVRefits

private

Definition at line 144 of file BeamspotVertexPreProcessor.h.

◆ m_nTracks

int Trk::BeamspotVertexPreProcessor::m_nTracks

private

Definition at line 140 of file BeamspotVertexPreProcessor.h.

◆ m_particleNumber

int Trk::BeamspotVertexPreProcessor::m_particleNumber

private

type of material interaction in extrapolation

Definition at line 116 of file BeamspotVertexPreProcessor.h.

◆ m_PVContainerName

std::string Trk::BeamspotVertexPreProcessor::m_PVContainerName

private

the name of the primary vertex container

Definition at line 113 of file BeamspotVertexPreProcessor.h.

◆ m_PVScalingFactor

double Trk::BeamspotVertexPreProcessor::m_PVScalingFactor

private

scaling factor on primary vertex position error

Definition at line 137 of file BeamspotVertexPreProcessor.h.

◆ m_refitTracks

bool Trk::BeamspotVertexPreProcessor::m_refitTracks

private

flag to refit tracks

Definition at line 133 of file BeamspotVertexPreProcessor.h.

◆ m_runOutlierRemoval

bool Trk::BeamspotVertexPreProcessor::m_runOutlierRemoval

private

switch whether to run outlier logics or not

Definition at line 114 of file BeamspotVertexPreProcessor.h.

◆ m_selectVertices

bool Trk::BeamspotVertexPreProcessor::m_selectVertices

private

do vertex selection

Definition at line 115 of file BeamspotVertexPreProcessor.h.

◆ m_SLTrackFitter

ToolHandle<IGlobalTrackFitter> Trk::BeamspotVertexPreProcessor::m_SLTrackFitter

private

Definition at line 99 of file BeamspotVertexPreProcessor.h.

◆ m_storeFitMatrices

bool Trk::BeamspotVertexPreProcessor::m_storeFitMatrices

private

flag to store derivative and covariance matrices after refit

Definition at line 134 of file BeamspotVertexPreProcessor.h.

◆ m_trackFitter

ToolHandle<IGlobalTrackFitter> Trk::BeamspotVertexPreProcessor::m_trackFitter

private

normal track fitter

Definition at line 98 of file BeamspotVertexPreProcessor.h.

◆ m_trackToVertexIPEstimatorTool

ToolHandle<ITrackToVertexIPEstimator> Trk::BeamspotVertexPreProcessor::m_trackToVertexIPEstimatorTool

private

Definition at line 106 of file BeamspotVertexPreProcessor.h.

◆ m_trackTypeCounter

std::vector<int> Trk::BeamspotVertexPreProcessor::m_trackTypeCounter

private

Definition at line 141 of file BeamspotVertexPreProcessor.h.

◆ m_trkSelector

ToolHandle<InDet::IInDetTrackSelectionTool> Trk::BeamspotVertexPreProcessor::m_trkSelector

private

new track selector tool

Definition at line 102 of file BeamspotVertexPreProcessor.h.

◆ m_useSingleFitter

bool Trk::BeamspotVertexPreProcessor::m_useSingleFitter

private

only use 1 fitter for refitting track

Definition at line 135 of file BeamspotVertexPreProcessor.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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ BeamspotVertexPreProcessor()

◆ ~BeamspotVertexPreProcessor()

Member Function Documentation

◆ accumulateVTX()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ doBeamspotConstraintTrackSelection()

◆ doConstraintRefit()

◆ doTrackRefit()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fillNtuple()

◆ finalize()

◆ findVertexCandidate()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ isAssociatedToPV()

◆ isAssociatedToVertex()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ prepareAllTracksVector()

◆ printSummary()

◆ processTrackCollection()

◆ provideVotFromBeamspot()

◆ provideVotFromVertex()

◆ provideVtxBeamspot()

◆ renounce()

◆ renounceArray()

◆ selectUpdatedVertices()

◆ selectVertices()

◆ setLogStream()

◆ setNtuple()

◆ solveVTX()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_alignModuleTool

◆ m_AlignVertices

◆ m_allTracksVector

◆ m_beamSpotKey

◆ m_BSScalingFactor

◆ m_BSTrackSelector

◆ m_compareMethod

◆ m_constraintMode

◆ m_detStore

◆ m_doAssociatedToPVSelection

◆ m_doBeamspotConstraint

◆ m_doBSTrackSelection

◆ m_doFullVertexConstraint

◆ m_doNormalRefit

◆ m_doPrimaryVertexConstraint

◆ m_doTrkSelection

◆ m_evtStore

◆ m_extrapolator

◆ m_interestedVertexContainers