TrackParticleBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
                          TrackParticleBase.h  -  Description
                             -------------------
    authors : Edward.Moyse@cern.ch (based on TrackParticleBase from andreas.wildauer@cern.ch, fredrik.akesson@cern.ch)
 
    Adding the TrackInfo to be stored at the AOD level: 2009-1-29
    author: Kirill.Prokofiev@cern.ch
    
 ***************************************************************************/
#ifndef TRKPARTICLEBASE_TRKTRACKPARTICLEBASE_H
#define TRKPARTICLEBASE_TRKTRACKPARTICLEBASE_H
 
// includes for datamembers
#include "AthLinks/ElementLink.h"
#include "TrkTrack/TrackCollection.h" // typedef
#include "VxVertex/VxContainer.h"     // typedef
#include "TrkEventPrimitives/VertexType.h"
 
#include "TrkTrack/Track.h"           // no forward declare for now because needed in cast
#include <vector>
#include "TrkParameters/TrackParameters.h"    // no forward declare for now because needed in cast
#include "TrkTrack/TrackInfo.h"       // no forward declaration: we are storing the value 
 
 
class MsgStream;
class TrackParticleBaseCnv_p1;
 
namespace Trk
{
  typedef VertexType TrackParticleOrigin;
 
  class VxCandidate;
  class TrackSummary;
  class FitQuality;
  
  class TrackParticleBase
  {
  public:

    TrackParticleBase();
                                                                               
    TrackParticleBase(  const Track*                            trk, 
                        const TrackParticleOrigin                    vertexType, 
                        const VxCandidate*                      vxCandidate, 
                        const TrackSummary*                     trkSummary, 
                        std::vector<const TrackParameters*>&     parameters,
                        const TrackParameters*                   definingParameter,
                        const FitQuality*                       fitQuality);
    
    TrackParticleBase (const ElementLink<TrackCollection>& trackLink,
                       const Trk::TrackParticleOrigin trkPrtOrigin, 
                       const ElementLink<VxContainer>& vxCandidate,
                       std::unique_ptr<Trk::TrackSummary> trkSummary,
                       // passes ownership of elements.
                       std::vector<const Trk::TrackParameters*>&&  parameters,
                       std::unique_ptr<Trk::FitQuality> fitQuality,
                       const TrackInfo& info);

    TrackParticleBase(const TrackParticleBase &);

    TrackParticleBase &operator= (const TrackParticleBase &);
    TrackParticleBase &operator= (TrackParticleBase &&) noexcept;
    
    virtual ~TrackParticleBase();
    
    double                                          charge() const; 

    const Track*                               originalTrack() const;

    const VxCandidate*                         reconstructedVertex() const;
 
    const ElementLink<VxContainer>&            reconstructedVertexLink() const;

    TrackParticleOrigin                             particleOriginType() const;
    
    const TrackParameters&                      definingParameters() const;   

    const std::vector<const TrackParameters*>&  trackParameters() const;   

    const ElementLink< TrackCollection >*           trackElementLink() const;   

    const TrackSummary*                        trackSummary() const;   

    const FitQuality *                         fitQuality() const;
    
    const Perigee* perigee() const;
 
    void setStorableObject(const TrackCollection* trackColl);
    void setStorableObject(const VxContainer* vxColl);
    void setTrackLink ( const TrackCollection *  cont, const Track * track);
    
    virtual MsgStream&    dump( MsgStream& out ) const ;
    virtual std::ostream& dump( std::ostream& out ) const ;
                                                  
    const TrackInfo& info() const; 
    
  protected:
    friend class ::TrackParticleBaseCnv_p1;

    ElementLink< TrackCollection >              m_originalTrack; 
        
    TrackParticleOrigin                         m_trackParticleOrigin; 
    ElementLink< VxContainer >                  m_elVxCandidate; 
    
    std::vector<const TrackParameters*> m_trackParameters; 
    
    const TrackSummary*                    m_trackSummary; 

    const FitQuality*                      m_fitQuality; 
    
                                         
     TrackInfo  m_trackInfo;    
    
  };
     
  MsgStream& operator << ( MsgStream& sl, const TrackParticleBase& trackParticleBase);
 
  std::ostream& operator << ( std::ostream& sl, const TrackParticleBase& trackParticleBase);
    
  inline double TrackParticleBase::charge(void) const
  {
    return definingParameters().charge();
  }
 
  inline const Track* TrackParticleBase::originalTrack() const
  {
    if (m_originalTrack.isValid()){
      return *m_originalTrack;
    } 
      return nullptr;
    
  }
 
  inline
  const VxCandidate* TrackParticleBase::reconstructedVertex() const
  {
    if (m_elVxCandidate.isValid()) {
      return *m_elVxCandidate;
    } 
    
      return nullptr;
    
  }
 
  inline const ElementLink<VxContainer>& TrackParticleBase::reconstructedVertexLink() const
  {
    return m_elVxCandidate;
  }
 
 inline const ElementLink< TrackCollection >*  TrackParticleBase::trackElementLink() const
  {
     return &m_originalTrack;
  }
 
  inline TrackParticleOrigin TrackParticleBase::particleOriginType() const {
    return m_trackParticleOrigin;
  }
  
  inline const TrackParameters& TrackParticleBase::definingParameters() const {
    return *( m_trackParameters.back() );
  }
 
  inline const std::vector<const TrackParameters*>& TrackParticleBase::trackParameters() const {
    return m_trackParameters;
  }  
 
  inline const TrackSummary* TrackParticleBase::trackSummary() const {
    return m_trackSummary;
  }
 
  inline void TrackParticleBase::setStorableObject(const TrackCollection* trackColl) {
    m_originalTrack.setStorableObject(*trackColl);
  }
  
  inline void TrackParticleBase::setStorableObject(const VxContainer* vxColl) {
    m_elVxCandidate.setStorableObject(*vxColl);
  }
  
  inline const FitQuality* TrackParticleBase::fitQuality() const {
    return m_fitQuality;
  }
  
  inline const Perigee* TrackParticleBase::perigee() const
  {
    return dynamic_cast<const Perigee*>( &(definingParameters()) );
  }
  
  inline 
  void TrackParticleBase::setTrackLink ( const TrackCollection *  cont, const Track * track) 
  {
     if ( m_originalTrack.isValid() ) { m_originalTrack.reset();
}
     m_originalTrack.toContainedElement( *cont, track);
  }
  
  inline const TrackInfo& TrackParticleBase::info() const
  {
    return m_trackInfo;
  }
 
}
 
#endif