MyTrack.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/ContainedObject.h>
#include <GaudiKernel/KeyedContainer.h>
#include <GaudiKernel/ObjectVector.h>
#include <GaudiKernel/SharedObjectsContainer.h>
#include <GaudiKernel/SmartRefVector.h>
#include <GaudiTestSuite/Event.h>
 
namespace Gaudi {
  namespace TestSuite {
 
    // Forward declarations
    class MyVertex;
    template <class T>
    class GaudiObjectHandler;
 
    // CLID definition
    static const CLID& CLID_MyTrack = 1355;

    // class MyTrack : public ContainedObject {
    class GAUDI_API MyTrack
#ifdef __PLAIN_GAUDI
        : public ContainedObject
#else
        : public KeyedObject<int>
#endif
    {
      friend class GaudiObjectHandler<MyTrack>;
 
    public:
      // ======================================================================
      typedef std::vector<MyTrack*> Vector;
      typedef std::vector<const MyTrack*> ConstVector;
      typedef SharedObjectsContainer<MyTrack> Selection;
#ifdef __PLAIN_GAUDI
      typedef ObjectVector<MyTrack> Container;
#else
      typedef KeyedContainer<MyTrack, Containers::HashMap> Container;
#endif
      // ======================================================================
    protected:
      float m_px, m_py, m_pz;
      SmartRef<Event> m_event;
      SmartRef<MyVertex> m_originVertex;
      SmartRefVector<MyVertex> m_decayVertices;
 
    public:
      MyTrack();
      MyTrack( float x, float y, float z );
      MyTrack( const MyTrack& t );
      ~MyTrack() override;
      const CLID&        clID() const override { return classID(); }
      static const CLID& classID() { return CLID_MyTrack; }
      float px() const { return m_px; }
      float py() const { return m_py; }
      float pz() const { return m_pz; }
      void setPx( float px ) { m_px = px; }
      void setPy( float py ) { m_py = py; }
      void setPz( float pz ) { m_pz = pz; }

      const Event* event() const { return m_event; }
      void setEvent( Event* evt ) { m_event = evt; }
      const MyVertex* originVertex() const;

      void setOriginVertex( MyVertex* origin );

      const SmartRefVector<MyVertex>& decayVertices() const;

      void addDecayVertex( MyVertex* vtx );

      void removeDecayVertex( MyVertex* vtx );

      StreamBuffer& serialize( StreamBuffer& s ) const override;
      StreamBuffer& serialize( StreamBuffer& s ) override;
    };
 
// Definition of all container types of MCParticle
#ifdef __PLAIN_GAUDI
    typedef ObjectVector<MyTrack> MyTrackVector;
#else
    typedef KeyedContainer<MyTrack> MyTrackVector;
#endif
  } // namespace TestSuite
} // namespace Gaudi
 
#include "MyVertex.h"
 
namespace Gaudi {
  namespace TestSuite {

    inline const MyVertex* MyTrack::originVertex() const { return m_originVertex; }

    inline void MyTrack::setOriginVertex( MyVertex* origin ) { m_originVertex = origin; }

    inline const SmartRefVector<MyVertex>& MyTrack::decayVertices() const { return m_decayVertices; }

    inline void MyTrack::addDecayVertex( MyVertex* vtx ) { m_decayVertices.push_back( SmartRef<MyVertex>( vtx ) ); }

    inline void MyTrack::removeDecayVertex( MyVertex* vtx ) {
      SmartRefVector<MyVertex>::iterator i;
      for ( i = m_decayVertices.begin(); i != m_decayVertices.end(); ++i ) {
        if ( i->target() == vtx ) {
          m_decayVertices.erase( i );
          return;
        }
      }
    }

    inline StreamBuffer& MyTrack::serialize( StreamBuffer& s ) const {
#ifdef __PLAIN_GAUDI
      ContainedObject::serialize( s );
#else
      KeyedObject<int>::serialize( s );
#endif
      return s << m_event( this ) << m_originVertex( this ) << m_decayVertices( this ) << m_px << m_py << m_pz;
    }

    inline StreamBuffer& MyTrack::serialize( StreamBuffer& s ) {
#ifdef __PLAIN_GAUDI
      ContainedObject::serialize( s );
#else
      KeyedObject<int>::serialize( s );
#endif
      return s >> m_event( this ) >> m_originVertex( this ) >> m_decayVertices( this ) >> m_px >> m_py >> m_pz;
    }
  } // namespace TestSuite
} // namespace Gaudi