d2/d7f/TrackParticle__v1_8h_source.html

// Dear emacs, this is -*- c++ -*-


/*

  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration

*/


#ifndef XAODTRACKING_VERSIONS_TRACKPARTICLE_V1_H

#define XAODTRACKING_VERSIONS_TRACKPARTICLE_V1_H


// System include(s):

#include <bitset>

extern "C" {

#   include <stdint.h>

}


// Core include(s):

#include "AthLinks/ElementLink.h"

#include "AthContainers/DataVector.h"

#include "CxxUtils/CachedValue.h"


// xAOD include(s):

#include "xAODBase/IParticle.h"

#include "xAODTracking/TrackingDetails.h"

#include "xAODTracking/TrackingPrimitives.h"


#ifndef XAOD_ANALYSIS

// Athena includes

#include "TrkParameters/TrackParameters.h"

#include "TrkTrack/TrackCollection.h"

#endif // not XAOD_ANALYSIS


// ROOT include(s):

#include "Math/Vector4D.h"


//Already include the DataVector specialization for this type

#include "xAODTracking/TrackParticleContainerFwd.h"

namespace xAOD {


  class TrackParticle_v1 : public IParticle {


  public:


    TrackParticle_v1();

    ~TrackParticle_v1();

    TrackParticle_v1(const TrackParticle_v1& o );

    TrackParticle_v1& operator=(const TrackParticle_v1& tp );


        virtual double           pt() const override final;

        virtual double           eta() const override final;

        virtual double           phi() const override final;

        virtual double           m() const override final;

        virtual double           e() const override final;

        virtual double           rapidity() const override final;


        typedef IParticle::FourMom_t FourMom_t;


        virtual FourMom_t p4() const override final;


        typedef ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> > GenVecFourMom_t;


        GenVecFourMom_t genvecP4() const;


        virtual Type::ObjectType type() const override final;


        float charge() const;

        float d0() const;

        float z0() const;

        float phi0() const;

        float theta() const;

        float qOverP() const;

        float time() const;

        float timeResolution() const;

        uint8_t hasValidTime() const;

        DefiningParameters_t definingParameters() const;

        const ParametersCovMatrix_t definingParametersCovMatrix() const;

        ParametersCovMatrixFilled_t definingParametersCovMatrixFilled() const;

        const std::vector< float >& definingParametersCovMatrixDiagVec() const;

        const std::vector< float >& definingParametersCovMatrixOffDiagVec() const;

        std::vector<float> definingParametersCovMatrixVec() const;

        bool definingParametersCovMatrixOffDiagCompr() const ;

        void setDefiningParameters(float d0, float z0, float phi0, float theta, float qOverP);

        void setDefiningParameters(float d0, float z0, float phi0, float theta, float qOverP, float time);

        void setTime(float time);

        void setTimeResolution(float timeResolution);

        void setHasValidTime(uint8_t hasValidTime);

        void setDefiningParametersCovMatrix(const ParametersCovMatrix_t& cov);

        void setDefiningParametersCovMatrixDiagVec( const std::vector< float >& vec );

        void setDefiningParametersCovMatrixOffDiagVec( const std::vector< float >& vec );

        void setDefiningParametersCovMatrixVec(const std::vector<float>& cov);

        void compressDefiningParametersCovMatrixOffDiag();

        float vx() const;

        float vy() const;

        float vz() const;

        void setParametersOrigin(float x, float y, float z);


#ifndef XAOD_ANALYSIS

        const Trk::Perigee& perigeeParameters() const;

#endif // not XAOD_ANALYSIS


        size_t numberOfParameters() const;

        const CurvilinearParameters_t trackParameters(unsigned int index) const;

        float parameterX(unsigned int index) const;

        float parameterY(unsigned int index) const;

        float parameterZ(unsigned int index) const;

        float parameterPX(unsigned int index) const;

        float parameterPY(unsigned int index) const;

        float parameterPZ(unsigned int index) const;

        void setTrackParameters(std::vector<std::vector<float> >& parameters);

        ParametersCovMatrix_t trackParameterCovarianceMatrix(unsigned int index) const;

        void setTrackParameterCovarianceMatrix(unsigned int index, std::vector<float>& cov);

        xAOD::ParameterPosition parameterPosition(unsigned int index) const;

        bool indexOfParameterAtPosition(unsigned int& index, ParameterPosition position) const;

        void setParameterPosition(unsigned int index, ParameterPosition pos);

#ifndef XAOD_ANALYSIS

        const Trk::CurvilinearParameters curvilinearParameters(unsigned int index) const;

#endif // not XAOD_ANALYSIS


    float radiusOfFirstHit() const;

    void setRadiusOfFirstHit(float radius);


    uint64_t identifierOfFirstHit() const;

    void setIdentifierOfFirstHit( uint64_t id);


    float beamlineTiltX() const;

    void  setBeamlineTiltX(float tiltX);


    float beamlineTiltY() const;

    void  setBeamlineTiltY(float tiltY);


    uint32_t hitPattern() const;

    void setHitPattern(uint32_t hitpattern);


    uint8_t numberOfUsedHitsdEdx() const;

    void setNumberOfUsedHitsdEdx(uint8_t numhits);


    uint8_t numberOfIBLOverflowsdEdx() const;

    void setNumberOfIBLOverflowsdEdx(uint8_t numoverflows);


        float chiSquared() const;

        float  numberDoF() const;

        void setFitQuality(float chiSquared, float numberDoF);


        void setTrackProperties (const TrackProperties properties) ;

        void setPatternRecognitionInfo(const std::bitset<xAOD::NumberOfTrackRecoInfo>& patternReco) ;

        void setPatternRecognitionInfo(uint64_t patternReco) ;

        void setTrackFitter(const TrackFitter fitter)  ;

        void setParticleHypothesis(const ParticleHypothesis hypo);

        TrackProperties trackProperties() const;

        std::bitset<NumberOfTrackRecoInfo>  patternRecoInfo() const;

        ParticleHypothesis particleHypothesis() const;

        TrackFitter trackFitter() const;


        bool summaryValue(uint8_t& value, const SummaryType &information) const;

        bool summaryValue(float& value, const SummaryType &information) const;

        void setSummaryValue(uint8_t& value, const SummaryType &information);

        void setSummaryValue(float& value, const SummaryType &information);


#ifndef XAOD_ANALYSIS

        const ElementLink< TrackCollection >& trackLink() const;

         void setTrackLink(const ElementLink< TrackCollection >& track);

         const Trk::Track* track() const;

#endif // not XAOD_ANALYSIS


      void resetCache();


private:


      using covMatrixIndex = TrackingDetails::covMatrixIndex;

      static const std::size_t COVMATRIX_OFFDIAG_VEC_COMPR_SIZE = TrackingDetails::COVMATRIX_OFFDIAG_VEC_COMPR_SIZE;

      typedef std::vector< std::pair<covMatrixIndex,covMatrixIndex> > covMatrixIndexPairVec;

      static const covMatrixIndexPairVec& covMatrixComprIndexPairs();


#if ( ! defined(XAOD_ANALYSIS) )

# ifdef __CLING__

      // If Cling sees the declaration below, then we get mysterious

      // errors during auto-parsing.  On the other hand, if we hide

      // it completely, then we can run into memory corruption problems

      // if instances of this class are created from Python,

      // since Cling will then be allocating a block of the wrong size

      // (see !63818).  However, everything dealing with this member

      // is out-of-line (including ctors/dtor/assignment), and it also

      // declared as transient.  Thus, for the Cling case, we can replace

      // it with padding of the correct size.

      char m_perigeeParameters[sizeof(CxxUtils::CachedValue<Trk::Perigee>)];

# else

     CxxUtils::CachedValue<Trk::Perigee> m_perigeeParameters;

# endif

#endif // not XAOD_ANALYSIS


    }; // class Track Particle


  } // namespace xAOD


// Finish declaration of IParticle as a base class of TrackParticle_v1

DATAVECTOR_BASE_FIN( xAOD::TrackParticle_v1, xAOD::IParticle );


#endif // XAODTRACKING_VERSIONS_TrackParticle_v1_H