Vertex_v1.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
// System include(s):
#include <cmath>
 
// EDM include(s):
#include "xAODCore/AuxStoreAccessorMacros.h"
#include "EventPrimitives/EventPrimitivesHelpers.h"
 
// Local include(s):
#include "xAODTracking/versions/Vertex_v1.h"
#include "xAODTracking/TrackParticleContainer.h"
 
namespace xAOD {
 
   Vertex_v1::Vertex_v1()
      : SG::AuxElement(),
        m_position(),
        m_covariance() {
 
   }
 
   Vertex_v1::Vertex_v1( const Vertex_v1& other )
      : SG::AuxElement(other),
        m_position( other.m_position ),
        m_covariance( other.m_covariance ){
      //copy aux store content (only the stuffs already loaded in memory!)
      this->makePrivateStore( other );
   }
 
   Vertex_v1& Vertex_v1::operator=( const Vertex_v1& tp ) {
 
      // Check if anything needs to be done:
      if( this == &tp ) {
         return *this;
      }
 
      // If the object doesn't have an auxiliary store yet, make a private
      // one for it:
      if( ( ! hasStore() ) && ( ! container() ) ) {
         makePrivateStore();
      }
 
      // copy the cache
      m_position = tp.m_position;
      m_covariance = tp.m_covariance;
 
      // Now let the base class copy the auxiliary contents:
      SG::AuxElement::operator=( tp );
 
      // Return the object:
      return *this;
   }
 
   Type::ObjectType Vertex_v1::type() const {
 
      return Type::Vertex;
   }

   //
   //                Implementation of the primitive accessors
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( Vertex_v1, float, x, setX )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( Vertex_v1, float, y, setY )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( Vertex_v1, float, z, setZ )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( Vertex_v1, uint8_t, hasValidTime, setHasValidTime )
 
   AUXSTORE_OBJECT_SETTER_AND_GETTER( Vertex_v1, std::vector< float >,
                                      covariance, setCovariance )
 
   float Vertex_v1::time() const {
      static const SG::AuxElement::Accessor< uint8_t > acc("hasValidTime");
      if( !acc.isAvailable( *this) || !static_cast<bool>(hasValidTime()) ) throw std::runtime_error( "Unavailable Vertex time requested" );
      static const SG::AuxElement::Accessor< float > accTime("time");
      return accTime( *this );
   }
 
   float Vertex_v1::timeResolution() const {
     static const SG::AuxElement::Accessor< uint8_t > acc("hasValidTime");
     if( !acc.isAvailable( *this) || !static_cast<bool>(hasValidTime()) ) throw std::runtime_error( "Unavailable Vertex timeResolution requested" );
     static const SG::AuxElement::Accessor< float > accTimeRes("timeResolution");
     return accTimeRes( *this );
   }
 
   void Vertex_v1::setTime(float time) {
     static const SG::AuxElement::Accessor< float > acc("time");
     acc( *this ) = time;
   }
 
   void Vertex_v1::setTimeResolution(float timeRes) {
     static const SG::AuxElement::Accessor< float > acc("timeResolution");
     acc( *this ) = timeRes;
   }
 
   //

   //                  Implementation of the Eigen functions
   //
 
   const Amg::Vector3D& Vertex_v1::position() const {
 
      // Cache the position if necessary:
      if( ! m_position.isValid() ) {
         Amg::Vector3D tmpPosition;
         tmpPosition( 0 ) = x();
         tmpPosition( 1 ) = y();
         tmpPosition( 2 ) = z();
         m_position.set(tmpPosition);
      }
 
      // Return the object:
      return *(m_position.ptr());
   }
 
   void Vertex_v1::setPosition( const Amg::Vector3D& position ) {
 
      // Set the primitive variables using the simple functions:
      setX( position( 0 ) );
      setY( position( 1 ) );
      setZ( position( 2 ) );
      // Reset the cache
      // This will enforce float precision level on the values of 
      // m_position. The effect of this float conversion has been 
      // discussed in ATLASRECTS-7671 
      m_position.reset();
   }
 
   const AmgSymMatrix(3)& Vertex_v1::covariancePosition() const {
 
      // Cache the covariance matrix if necessary:
      if( ! m_covariance.isValid() ) {
         // The matrix is now cached:
        AmgSymMatrix(3) tmpCovariance;
    Amg::expand(covariance().begin(),covariance().end(),tmpCovariance);
    m_covariance.set(tmpCovariance);
      }
      // Return the cached object:
      return *(m_covariance.ptr());
   }
 
   void Vertex_v1::setCovariancePosition( const AmgSymMatrix(3)& cov ) {
 
     // The to-be persistent variable:
     std::vector< float > vec;
     Amg::compress(cov,vec);
 
     // Set the persistent variable:
     setCovariance( vec );
     // This will enforce float precision level on the values of 
     // m_covariance. The effect of this float conversion has been 
     // discussed in ATLASRECTS-7671 
     m_covariance.reset();
   }
 
   //

   //
   //            Implementation of the fit quality functions
   //
 
   AUXSTORE_PRIMITIVE_GETTER( Vertex_v1, float, chiSquared )
   AUXSTORE_PRIMITIVE_GETTER( Vertex_v1, float, numberDoF )
 
   void Vertex_v1::setFitQuality( float chiSquared, float numberDoF ) {
 
      static const Accessor< float > acc1( "chiSquared" );
      static const Accessor< float > acc2( "numberDoF" );
      acc1( *this ) = chiSquared;
      acc2( *this ) = numberDoF;
 
      return;
   }
 
   //
 
   AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( Vertex_v1, short, VxType::VertexType,
                                        vertexType )
   AUXSTORE_PRIMITIVE_SETTER_WITH_CAST( Vertex_v1, short, VxType::VertexType,
                                        vertexType, setVertexType )
 
#ifndef XAOD_ANALYSIS
   static const SG::AuxElement::Accessor< std::vector< Trk::VxTrackAtVertex > >
   vxVertAcc( "vxTrackAtVertex" );

   std::vector< Trk::VxTrackAtVertex >& Vertex_v1::vxTrackAtVertex() {
 
      return vxVertAcc( *this );
   }

   const std::vector< Trk::VxTrackAtVertex >&
   Vertex_v1::vxTrackAtVertex() const {
 
      return vxVertAcc( *this );
   }

   bool Vertex_v1::vxTrackAtVertexAvailable() const {
 
      return vxVertAcc.isAvailable( *this );
   }
#endif // not XAOD_ANALYSIS

   //
   //         Implementation of the track particle handling functions
   //

   static const SG::AuxElement::Accessor< Vertex_v1::TrackParticleLinks_t >
      trackAcc( "trackParticleLinks" );
   static const SG::AuxElement::Accessor< std::vector< float > >
      weightTrackAcc( "trackWeights" );

   static const SG::AuxElement::Accessor< Vertex_v1::NeutralParticleLinks_t >
      neutralAcc( "neutralParticleLinks" );
   static const SG::AuxElement::Accessor< std::vector< float > >
      weightNeutralAcc( "neutralWeights" );
 
   AUXSTORE_OBJECT_SETTER_AND_GETTER( Vertex_v1,
                                      Vertex_v1::TrackParticleLinks_t,
                                      trackParticleLinks,
                                      setTrackParticleLinks )
   AUXSTORE_OBJECT_SETTER_AND_GETTER( Vertex_v1, std::vector< float >,
                                      trackWeights, setTrackWeights )
 
   AUXSTORE_OBJECT_SETTER_AND_GETTER( Vertex_v1,
                                      Vertex_v1::NeutralParticleLinks_t,
                                      neutralParticleLinks,
                                      setNeutralParticleLinks )
   AUXSTORE_OBJECT_SETTER_AND_GETTER( Vertex_v1, std::vector< float >,
                                      neutralWeights, setNeutralWeights )
 
 
   const TrackParticle* Vertex_v1::trackParticle( size_t i ) const {
 
      if( ! trackAcc.isAvailable( *this ) ) {
         return nullptr;
      }
      if( ( trackAcc( *this ).size() <= i ) ||
          ( ! trackAcc( *this )[ i ].isValid() ) ) {
         return nullptr;
      }
 
      return ( *( trackAcc( *this )[ i ] ) );
   }
 
   float Vertex_v1::trackWeight( size_t i ) const {
 
      if( weightTrackAcc( *this ).size() <= i ) {
         return -1.0;
      }
      return weightTrackAcc( *this )[ i ];
   }
 
   size_t Vertex_v1::nTrackParticles() const {
 
      if( ! trackAcc.isAvailable( *this ) ) {
         return 0;
      }
 
      return trackAcc( *this ).size();
   }
 
 
   const NeutralParticle* Vertex_v1::neutralParticle( size_t i ) const {
 
      if( ! neutralAcc.isAvailable( *this ) ) {
         return nullptr;
      }
      if( ( neutralAcc( *this ).size() <= i ) ||
          ( ! neutralAcc( *this )[ i ].isValid() ) ) {
         return nullptr;
      }
 
      return ( *( neutralAcc( *this )[ i ] ) );
   }
 
   float Vertex_v1::neutralWeight( size_t i ) const {
 
      if( weightNeutralAcc( *this ).size() <= i ) {
         return -1.0;
      }
      return weightNeutralAcc( *this )[ i ];
   }
 
   size_t Vertex_v1::nNeutralParticles() const {
 
      if( ! neutralAcc.isAvailable( *this ) ) {
         return 0;
      }
 
      return neutralAcc( *this ).size();
   }
 
 
 
 
   void
   Vertex_v1::addTrackAtVertex( const ElementLink< TrackParticleContainer >& tr,
                                float weight ) {
 
      trackAcc( *this ).push_back( tr );
      weightTrackAcc( *this ).push_back( weight );
      return;
   }
 
   void
   Vertex_v1::addNeutralAtVertex( const ElementLink< NeutralParticleContainer >& tr,
                                float weight ) {
 
      neutralAcc( *this ).push_back( tr );
      weightNeutralAcc( *this ).push_back( weight );
      return;
   }
 
   void Vertex_v1::clearTracks() {
 
      trackAcc( *this ).clear();
      weightTrackAcc( *this ).clear();
      return;
   }
 
   void Vertex_v1::clearNeutrals() {
 
      neutralAcc( *this ).clear();
      weightNeutralAcc( *this ).clear();
      return;
   }
 
   /*
    * Reset the cache
    */
   void Vertex_v1::resetCache() {
      m_position.reset();
      m_covariance.reset();
      return;
   }
 
} // namespace xAOD