Trk::BeamspotVertexPreProcessor Class Reference

#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 () override
virtual StatusCode	finalize () override
virtual DataVector< Track > *	processTrackCollection (const DataVector< Track > *trks) override
	Main processing of track collection.
void	accumulateVTX (AlignTrack *alignTrack) override
	methods added for the full VTX fit:
void	solveVTX () override
virtual void	printSummary () override
	Print processing summary to logfile.
virtual void	setLogStream (std::ostream *os)
	sets the output stream for the logfile
virtual void	setNtuple (TFile *)
	Sets output ntuple file, to be implemented if needed for detector-specific implementation.
virtual StatusCode	fillNtuple ()
	writes tree and histogrms to ntuple
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 const InterfaceID &	interfaceID ()

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.

Protected Attributes
std::ostream *	m_logStream = nullptr
	logfile output stream

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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< IGlobalTrackFitter >	m_trackFitter
ToolHandle< IGlobalTrackFitter >	m_SLTrackFitter
ToolHandle< IExtrapolator >	m_extrapolator
ToolHandle< InDet::IInDetTrackSelectionTool >	m_trkSelector
ToolHandle< InDet::IInDetTrackSelectionTool >	m_BSTrackSelector
ToolHandle< ITrackToVertexIPEstimator >	m_trackToVertexIPEstimatorTool
PublicToolHandle< IAlignModuleTool >	m_alignModuleTool
	Pointer to AlignModuleTool.
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey
SG::ReadHandleKey< xAOD::VertexContainer >	m_PVContainerName
BooleanProperty	m_runOutlierRemoval
IntegerProperty	m_particleNumber
BooleanProperty	m_doTrkSelection
BooleanProperty	m_doBSTrackSelection
BooleanProperty	m_doAssociatedToPVSelection
UnsignedIntegerProperty	m_constraintMode {this, "ConstraintMode", 0}
std::vector< std::pair< const xAOD::Vertex *, std::vector< VxTrackAtVertex > > >	m_allTracksVector
BooleanProperty	m_doBeamspotConstraint
BooleanProperty	m_doPrimaryVertexConstraint
BooleanProperty	m_doFullVertexConstraint
BooleanProperty	m_doNormalRefit
DoubleProperty	m_maxPt
BooleanProperty	m_refitTracks
BooleanProperty	m_storeFitMatrices
BooleanProperty	m_useSingleFitter
DoubleProperty	m_BSScalingFactor
DoubleProperty	m_PVScalingFactor
IntegerProperty	m_minTrksInVtx
int	m_nTracks = 0
std::vector< int >	m_trackTypeCounter {}
int	m_nFailedNormalRefits = 0
int	m_nFailedBSRefits = 0
int	m_nFailedPVRefits = 0
DataVector< AlignVertex >	m_AlignVertices
	collection of AlignVertices used in FullVertex constraint option
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

Definition at line 52 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 35 of file BeamspotVertexPreProcessor.cxx.

  : AthAlgTool(type,name,parent)
  , m_trackTypeCounter(AlignTrack::NTrackTypes,0)
{
  declareInterface<IAlignTrackPreProcessor>(this);
}

~BeamspotVertexPreProcessor()

Trk::BeamspotVertexPreProcessor::~BeamspotVertexPreProcessor ( )

virtualdefault

Member Function Documentation

accumulateVTX()

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

overridevirtual

methods added for the full VTX fit:

Reimplemented from Trk::IAlignTrackPreProcessor.

Definition at line 836 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) {
    ATH_MSG_ERROR("something missing from alignTrack!");
    if (!ptrWeights)   ATH_MSG_ERROR("no weights!");
    if (!ptrWeightsFD) ATH_MSG_ERROR("no weights for first deriv!");
    if (!ptrResiduals) ATH_MSG_ERROR("no residuals!");
    if (!ptrDerivs)    ATH_MSG_ERROR("no derivatives!");
    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<const Amg::VectorX*> allDerivatives[3];
  Amg::VectorX  VTXDerivatives[3];
  const int    WSize(weights.cols());
  Amg::MatrixX WF(3,WSize);
  std::vector<AlignModuleVertexDerivatives> derivX;
 
  for (const auto& deriv : derivatives) {
    // get AlignModule
    const AlignModule* module=deriv.first;
 
    // get alignment parameters
    if( module ) {
      Amg::MatrixX   F(3,WSize);
      const std::vector<Amg::VectorX>& deriv_vec = deriv.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) != std::ssize(deriv_vec)) {
        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:
  for (const auto& deriv : derivatives) {
    // get AlignModule
    const AlignModule* module=deriv.first;
 
    // get alignment parameters
    if( module ) {
      const std::vector<Amg::VectorX>& deriv_vec = deriv.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) != std::ssize(deriv_vec)) {
        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();
  ATH_MSG_DEBUG("accumulateVTX: allDerivatives size is  " << nmodules);
  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
    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()

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

doBeamspotConstraintTrackSelection()

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

private

Definition at line 559 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) {
 
    const EventContext& ctx = Gaudi::Hive::currentContext();
    SG::ReadHandle<xAOD::VertexContainer> vtxReadHandle(m_PVContainerName, ctx);
    if(!vtxReadHandle.isValid()){
      ATH_MSG_ERROR("Cannot retrieve the \'"<<m_PVContainerName<<"\' vertex collection from StoreGate");
      m_doAssociatedToPVSelection = false;
    } else {
      vertices = vtxReadHandle.cptr();
      // 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 521 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
    const auto &measurements =  *(track->measurementsOnTrack());
    for(const MeasurementBase* meas : measurements)
      measurementCollection.push_back(meas);
 
    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();
    }
  }
 
  return newTrack;
}

doTrackRefit()

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

private

Definition at line 617 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];
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // 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;
        ATH_MSG_DEBUG("VertexConstraint track refit failed! ");
      }
    }
  }
 
  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 refit
        if (!newTrack)  {
          ++m_nFailedBSRefits;
          ATH_MSG_DEBUG("BSConstraint track refit failed! ");
        }
      }
  }
 
 
  //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(ctx,alignCache,*newTrack,m_runOutlierRemoval,particleHypothesis);
    delete newTrack;
    newTrack = tmpTrk;
    if(!tmpTrk){
      if(type == AlignTrack::VertexConstrained)
      {
        ++m_nFailedPVRefits;
        ATH_MSG_DEBUG("VertexConstraint track refit2 failed! ");
      }else if(type == AlignTrack::BeamspotConstrained)
      {
        ++m_nFailedPVRefits;
        ATH_MSG_DEBUG("BSConstraint track refit2 failed! ");
      }
    }
  }
 
  if(!newTrack && m_doNormalRefit){
      newTrack = fitter->alignmentFit(ctx,alignCache,*track,m_runOutlierRemoval,particleHypothesis);
      type = AlignTrack::NormalRefitted;
      // this track failed the normal refit
      if (!newTrack)   {
        ++m_nFailedNormalRefits;
        ATH_MSG_DEBUG("Normal track refit failed! ");
      }
  }
 
 
 
 
 
  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)) {
      ATH_MSG_DEBUG("before refit: "<< *track);
      if (msgLvl(MSG::VERBOSE)) AlignTrack::dumpLessTrackInfo(*track,msg(MSG::DEBUG));
 
      ATH_MSG_DEBUG("after refit: "<< *newTrack);
      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.get());
      alignTrack->setDerivativeMatrix(alignCache.m_derivMatrix.get());
    }
    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()

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

fillNtuple()

virtual StatusCode Trk::IAlignTrackPreProcessor::fillNtuple ( )

inlinevirtualinherited

writes tree and histogrms to ntuple

Definition at line 54 of file IAlignTrackPreProcessor.h.

{ return StatusCode::SUCCESS; }

finalize()

StatusCode Trk::BeamspotVertexPreProcessor::finalize ( )

overridevirtual

Definition at line 1037 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 275 of file BeamspotVertexPreProcessor.cxx.

                                                                                          {
 
  const xAOD::Vertex* findVxCandidate = nullptr;
 
  for(const auto& thisPair : m_allTracksVector){
    auto iVxTrackBegin  = thisPair.second.begin();
    auto iVxTrackEnd    = thisPair.second.end();
    Trk::CompareTwoTracks thisCompare(track, "compareAddress");
 
    auto findResult = std::find_if(iVxTrackBegin, iVxTrackEnd, thisCompare);
 
    if(findResult != iVxTrackEnd){
      ATH_MSG_DEBUG("the found VxTrackAtVertex: "<<*findResult);
      findVxCandidate      = thisPair.first;
      break;
    }
  }
 
  return findVxCandidate;
}

initialize()

StatusCode Trk::BeamspotVertexPreProcessor::initialize ( )

overridevirtual

Definition at line 49 of file BeamspotVertexPreProcessor.cxx.

{
  ATH_MSG_INFO("BeamspotVertexPreProcessor::initialize()");
 
  // configure main track selector if requested
  if (!m_trkSelector.empty()) {
    if (m_trkSelector.retrieve().isFailure())
      ATH_MSG_ERROR("Failed to retrieve tool "<<m_trkSelector<<". No Track Selection will be done.");
    else
      ATH_MSG_INFO("Retrieved " << m_trkSelector);
  }
 
  if (m_refitTracks) {
    // configure main track fitter
    if(m_trackFitter.retrieve().isFailure()) {
      ATH_MSG_FATAL("Could not get " << m_trackFitter);
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO("Retrieved " << m_trackFitter);
 
    // configure straight-line track fitter if requested
    if (!m_useSingleFitter) {
      if (m_SLTrackFitter.retrieve().isFailure()) {
        ATH_MSG_FATAL("Could not get " << m_SLTrackFitter);
        return StatusCode::FAILURE;
      }
      ATH_MSG_INFO("Retrieved " << m_SLTrackFitter);
    }
 
    // TrackToVertexIPEstimator
    if (m_trackToVertexIPEstimatorTool.retrieve().isFailure()) {
      ATH_MSG_FATAL("Can not retrieve TrackToVertexIPEstimator of type " << m_trackToVertexIPEstimatorTool.typeAndName());
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_INFO ( "Retrieved TrackToVertexIPEstimator Tool " << m_trackToVertexIPEstimatorTool.typeAndName() );
    }
 
    // configure Atlas extrapolator
    if (m_extrapolator.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool "<<m_extrapolator);
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO("Retrieved " << m_extrapolator);
 
    // configure beam-spot conditions service
    ATH_CHECK(m_beamSpotKey.initialize());
 
    ATH_CHECK(m_PVContainerName.initialize());
 
    // configure beam-spot track selector if requested
    if(m_doBSTrackSelection) {
      if(m_BSTrackSelector.empty()) {
        ATH_MSG_FATAL("Requested BeamSpot track selection but Track Selector not configured");
        return StatusCode::FAILURE;
      }
      if (m_BSTrackSelector.retrieve().isFailure()) {
    ATH_MSG_FATAL("Could not get " << m_BSTrackSelector);
    return StatusCode::FAILURE;
      }
      ATH_MSG_INFO("Retrieved " << m_BSTrackSelector);
    }
 
  }  // end of 'if (m_refitTracks)'
 
  else if (m_doBeamspotConstraint) {
    ATH_MSG_FATAL("Requested beam-spot constraint but RefitTracks is False.");
    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 218 of file BeamspotVertexPreProcessor.cxx.

{
  if(!vertices) return false;
 
  for (const xAOD::Vertex* vtx : *vertices) {
    if (vtx->vertexType() != 1) break;
    if (isAssociatedToVertex(track, vtx)) return true;
  }
 
  return false;
}

isAssociatedToVertex()

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

private

Definition at line 232 of file BeamspotVertexPreProcessor.cxx.

{
  if(!vertex) return false;
 
  std::vector<VxTrackAtVertex >  vertexTracks = vertex->vxTrackAtVertex();
  Trk::CompareTwoTracks thisCompare(track, "compareAddress");
 
  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, std::move(thisCompare));
 
  return findResult != iVxTrackEnd;
}

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.

prepareAllTracksVector()

void Trk::BeamspotVertexPreProcessor::prepareAllTracksVector ( )

private

Definition at line 248 of file BeamspotVertexPreProcessor.cxx.

                                                       {
 
  // do clean up firstly
  m_allTracksVector.clear();
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  SG::ReadHandle<xAOD::VertexContainer> vtxReadHandle(m_PVContainerName, ctx);
 
  for(const xAOD::Vertex* vtx : *vtxReadHandle){
    if(!selectVertices(vtx)) {
      ATH_MSG_DEBUG("this vertex did not pass the primary vertex selection...");
      continue;
    }
    if (vtx->vxTrackAtVertexAvailable()){
      std::vector<VxTrackAtVertex> vtxTracks = vtx->vxTrackAtVertex();
      m_allTracksVector.emplace_back(vtx, 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 ( )

overridevirtual

Print processing summary to logfile.

Reimplemented from Trk::IAlignTrackPreProcessor.

Definition at line 1013 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 )

overridevirtual

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 766 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
  ATH_MSG_DEBUG( "Starting loop on input track collection: "<<index);
  for (const auto* track : *tracks){
    ++index;
    ATH_MSG_DEBUG("Processing track "<<index);
    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 407 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);
 
  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 == 0u) {
 
    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){
      ATH_MSG_WARNING("Perigee is nullptr in "<<__FILE__<<":"<<__LINE__);
      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();
 
    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 297 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);
    } else {
      tmpVtx = new xAOD::Vertex(*vtx);
      updatedVtx = m_trackToVertexIPEstimatorTool->getUnbiasedVertex(track->perigeeParameters(), vtx );
    }
 
 
    if(updatedVtx){
 
      if(!selectUpdatedVertices(updatedVtx)){
        delete tmpVtx;
        if ( tmpVtx!= updatedVtx) delete 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();
      vtxCov *= m_PVScalingFactor * m_PVScalingFactor;
 
      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;
      perigee = nullptr;
 
      // in fact, in most of the normal situation, pointer tmpVtx and updatedVtx are the same. You can check the source code.
      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);
    }
  }
  //belt and braces approach
  delete tmpVtx;
  if ( tmpVtx!= updatedVtx) delete updatedVtx;
  return vot;
 
}

provideVtxBeamspot()

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

private

Definition at line 494 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 196 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 (static_cast<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 178 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 (static_cast<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.

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

{} 

solveVTX()

void Trk::BeamspotVertexPreProcessor::solveVTX ( )

overridevirtual

Reimplemented from Trk::IAlignTrackPreProcessor.

Definition at line 995 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 {
    ATH_MSG_WARNING("This vertex contains " << ivtx->Ntracks() << " tracks. No solution possible.");
       }
 
       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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

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

PublicToolHandle<IAlignModuleTool> Trk::BeamspotVertexPreProcessor::m_alignModuleTool

private

Initial value:

{
      this, "AlignModuleTool", "InDet::InDetAlignModuleTool/InDetAlignModuleTool"}

Pointer to AlignModuleTool.

Definition at line 111 of file BeamspotVertexPreProcessor.h.

                                                        {
      this, "AlignModuleTool", "InDet::InDetAlignModuleTool/InDetAlignModuleTool"};

m_AlignVertices

DataVector<AlignVertex> Trk::BeamspotVertexPreProcessor::m_AlignVertices

private

collection of AlignVertices used in FullVertex constraint option

Definition at line 168 of file BeamspotVertexPreProcessor.h.

m_allTracksVector

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

private

Definition at line 134 of file BeamspotVertexPreProcessor.h.

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> Trk::BeamspotVertexPreProcessor::m_beamSpotKey

private

Initial value:

{
      this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

Definition at line 114 of file BeamspotVertexPreProcessor.h.

                                                         {
      this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

m_BSScalingFactor

DoubleProperty Trk::BeamspotVertexPreProcessor::m_BSScalingFactor

private

Initial value:

{this, "BeamspotScalingFactor", 1.,
      "scaling factor on beasmpot width"}

Definition at line 154 of file BeamspotVertexPreProcessor.h.

                                    {this, "BeamspotScalingFactor", 1.,
      "scaling factor on beasmpot width"};

m_BSTrackSelector

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

private

Initial value:

{
      this, "BSConstraintTrackSelector", "",
      "new track selector tool for tracks to be used with beam-spot constraint"}

Definition at line 104 of file BeamspotVertexPreProcessor.h.

                                                               {
      this, "BSConstraintTrackSelector", "",
      "new track selector tool for tracks to be used with beam-spot constraint"};

m_constraintMode

UnsignedIntegerProperty Trk::BeamspotVertexPreProcessor::m_constraintMode {this, "ConstraintMode", 0}

private

Definition at line 132 of file BeamspotVertexPreProcessor.h.

{this, "ConstraintMode", 0};

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

BooleanProperty Trk::BeamspotVertexPreProcessor::m_doAssociatedToPVSelection

private

Initial value:

{
      this, "DoAssociatedToPVSelection", true,
      "the selection mechanism that only use the tracks associated to PV"}

Definition at line 128 of file BeamspotVertexPreProcessor.h.

                                               {
      this, "DoAssociatedToPVSelection", true,
      "the selection mechanism that only use the tracks associated to PV"};

m_doBeamspotConstraint

BooleanProperty Trk::BeamspotVertexPreProcessor::m_doBeamspotConstraint

private

Initial value:

{this, "DoBSConstraint", true,
      "Constrain tracks to the beamspot (x,y) position"}

Definition at line 136 of file BeamspotVertexPreProcessor.h.

                                          {this, "DoBSConstraint", true,
      "Constrain tracks to the beamspot (x,y) position"};

m_doBSTrackSelection

BooleanProperty Trk::BeamspotVertexPreProcessor::m_doBSTrackSelection

private

Initial value:

{this, "DoBSTrackSelection", false,
      "the selection mechanism which is based on cutting the perigee parameters, pt, etc."}

Definition at line 126 of file BeamspotVertexPreProcessor.h.

                                        {this, "DoBSTrackSelection", false,
      "the selection mechanism which is based on cutting the perigee parameters, pt, etc."};

m_doFullVertexConstraint

BooleanProperty Trk::BeamspotVertexPreProcessor::m_doFullVertexConstraint

private

Initial value:

{this, "DoFullVertex", false,
      "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"}

Definition at line 140 of file BeamspotVertexPreProcessor.h.

                                            {this, "DoFullVertex", false,
      "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"};

m_doNormalRefit

BooleanProperty Trk::BeamspotVertexPreProcessor::m_doNormalRefit

private

Initial value:

{this, "doNormalRefit", true,
      "provide tracks in the case failed BS, PV and FullVertex constraints."}

Definition at line 142 of file BeamspotVertexPreProcessor.h.

                                   {this, "doNormalRefit", true,
      "provide tracks in the case failed BS, PV and FullVertex constraints."};

m_doPrimaryVertexConstraint

BooleanProperty Trk::BeamspotVertexPreProcessor::m_doPrimaryVertexConstraint

private

Initial value:

{this, "DoPVConstraint", false,
      "Constrain tracks to the associated primary vertex (x,y,z) position"}

Definition at line 138 of file BeamspotVertexPreProcessor.h.

                                               {this, "DoPVConstraint", false,
      "Constrain tracks to the associated primary vertex (x,y,z) position"};

m_doTrkSelection

BooleanProperty Trk::BeamspotVertexPreProcessor::m_doTrkSelection

private

Initial value:

{this, "DoTrackSelection", true,
      "to activate the preprocessor track selection"}

Definition at line 124 of file BeamspotVertexPreProcessor.h.

                                    {this, "DoTrackSelection", true,
      "to activate the preprocessor track selection"};

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

Initial value:

{
      this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}

Definition at line 100 of file BeamspotVertexPreProcessor.h.

                                            {
      this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"};

m_logStream

std::ostream* Trk::IAlignTrackPreProcessor::m_logStream = nullptr

protectedinherited

logfile output stream

Definition at line 66 of file IAlignTrackPreProcessor.h.

m_maxPt

DoubleProperty Trk::BeamspotVertexPreProcessor::m_maxPt

private

Initial value:

{this, "maxPt", 0.,
      "Max pT range for refitting tracks"}

Definition at line 145 of file BeamspotVertexPreProcessor.h.

                          {this, "maxPt", 0.,
      "Max pT range for refitting tracks"};

m_minTrksInVtx

IntegerProperty Trk::BeamspotVertexPreProcessor::m_minTrksInVtx

private

Initial value:

{this, "MinTrksInVtx", 3,
      "requirement to the minimal number of tracks in the vertex"}

Definition at line 159 of file BeamspotVertexPreProcessor.h.

                                  {this, "MinTrksInVtx", 3,
      "requirement to the minimal number of tracks in the vertex"};

m_nFailedBSRefits

int Trk::BeamspotVertexPreProcessor::m_nFailedBSRefits = 0

private

Definition at line 165 of file BeamspotVertexPreProcessor.h.

m_nFailedNormalRefits

int Trk::BeamspotVertexPreProcessor::m_nFailedNormalRefits = 0

private

Definition at line 164 of file BeamspotVertexPreProcessor.h.

m_nFailedPVRefits

int Trk::BeamspotVertexPreProcessor::m_nFailedPVRefits = 0

private

Definition at line 166 of file BeamspotVertexPreProcessor.h.

m_nTracks

int Trk::BeamspotVertexPreProcessor::m_nTracks = 0

private

Definition at line 162 of file BeamspotVertexPreProcessor.h.

m_particleNumber

IntegerProperty Trk::BeamspotVertexPreProcessor::m_particleNumber

private

Initial value:

{this, "ParticleNumber", 3,
      "type of material interaction in extrapolation, 3=pion, 0=non-interacting"}

Definition at line 122 of file BeamspotVertexPreProcessor.h.

                                    {this, "ParticleNumber", 3,
      "type of material interaction in extrapolation, 3=pion, 0=non-interacting"};

m_PVContainerName

SG::ReadHandleKey<xAOD::VertexContainer> Trk::BeamspotVertexPreProcessor::m_PVContainerName

private

Initial value:

{
      this, "PVContainerName", "PrimaryVertices"}

Definition at line 117 of file BeamspotVertexPreProcessor.h.

                                                          {
      this, "PVContainerName", "PrimaryVertices"};

m_PVScalingFactor

DoubleProperty Trk::BeamspotVertexPreProcessor::m_PVScalingFactor

private

Initial value:

{this, "PrimaryVertexScalingFactor", 1.,
      "scaling factor on primary vertex position error"}

Definition at line 156 of file BeamspotVertexPreProcessor.h.

                                    {this, "PrimaryVertexScalingFactor", 1.,
      "scaling factor on primary vertex position error"};

m_refitTracks

BooleanProperty Trk::BeamspotVertexPreProcessor::m_refitTracks

private

Initial value:

{this, "RefitTracks", true,
      "flag to refit tracks"}

Definition at line 148 of file BeamspotVertexPreProcessor.h.

                                 {this, "RefitTracks", true,
      "flag to refit tracks"};

m_runOutlierRemoval

BooleanProperty Trk::BeamspotVertexPreProcessor::m_runOutlierRemoval

private

Initial value:

{this, "RunOutlierRemoval", false,
      "switch whether to run outlier logics or not"}

Definition at line 120 of file BeamspotVertexPreProcessor.h.

                                       {this, "RunOutlierRemoval", false,
      "switch whether to run outlier logics or not"};

m_SLTrackFitter

ToolHandle<IGlobalTrackFitter> Trk::BeamspotVertexPreProcessor::m_SLTrackFitter

private

Initial value:

{
      this, "SLTrackFitter", "", "straight line track fitter"}

Definition at line 98 of file BeamspotVertexPreProcessor.h.

                                                  {
      this, "SLTrackFitter", "", "straight line track fitter"};

m_storeFitMatrices

BooleanProperty Trk::BeamspotVertexPreProcessor::m_storeFitMatrices

private

Initial value:

{this, "StoreFitMatrices", true,
      "flag to store derivative and covariance matrices after refit"}

Definition at line 150 of file BeamspotVertexPreProcessor.h.

                                      {this, "StoreFitMatrices", true,
      "flag to store derivative and covariance matrices after refit"};

m_trackFitter

ToolHandle<IGlobalTrackFitter> Trk::BeamspotVertexPreProcessor::m_trackFitter

private

Initial value:

{
      this, "TrackFitter", "Trk::GlobalChi2Fitter/InDetTrackFitter",
      "normal track fitter"}

Definition at line 95 of file BeamspotVertexPreProcessor.h.

                                                {
      this, "TrackFitter", "Trk::GlobalChi2Fitter/InDetTrackFitter",
      "normal track fitter"};

m_trackToVertexIPEstimatorTool

ToolHandle<ITrackToVertexIPEstimator> Trk::BeamspotVertexPreProcessor::m_trackToVertexIPEstimatorTool

private

Initial value:

{
      this, "TrackToVertexIPEstimatorTool", ""}

Definition at line 107 of file BeamspotVertexPreProcessor.h.

                                                                        {
      this, "TrackToVertexIPEstimatorTool", ""};

m_trackTypeCounter

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

private

Definition at line 163 of file BeamspotVertexPreProcessor.h.

{};

m_trkSelector

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

private

Initial value:

{
      this, "TrackSelector", "", "new track selector tool"}

Definition at line 102 of file BeamspotVertexPreProcessor.h.

                                                           {
      this, "TrackSelector", "", "new track selector tool"};

m_useSingleFitter

BooleanProperty Trk::BeamspotVertexPreProcessor::m_useSingleFitter

private

Initial value:

{this, "UseSingleFitter", false,
      "only use 1 fitter for refitting track"}

Definition at line 152 of file BeamspotVertexPreProcessor.h.

                                     {this, "UseSingleFitter", false,
      "only use 1 fitter for refitting track"};

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:

• BeamspotVertexPreProcessor.h
• BeamspotVertexPreProcessor.cxx