MyVertex.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/KeyedContainer.h>
#include <GaudiKernel/KeyedObject.h>
#include <GaudiKernel/SmartRefVector.h>
#include <GaudiTestSuite/Event.h>
#include <GaudiTestSuite/MyTrack.h>
 
namespace Gaudi {
  namespace TestSuite {
    // Forward declarations
    //    class MyTrack;
 
    // CLID definition
    static const CLID& CLID_MyVertex = 1356;

    class GAUDI_API MyVertex : public KeyedObject<int> {
    protected:
      float m_x, m_y, m_z;
      SmartRef<Event> m_event;
      SmartRef<MyTrack> m_motherParticle;
      SmartRefVector<MyTrack> m_decayParticles;
      SmartRefVector<Collision> m_collisions;
 
    public:
      MyVertex();
      MyVertex( float x, float y, float z );
      ~MyVertex() override;
      const CLID&        clID() const override { return classID(); }
      static const CLID& classID() { return CLID_MyVertex; }
      float x() const { return m_x; }
      float y() const { return m_y; }
      float z() const { return m_z; }
      void setX( float x ) { m_x = x; }
      void setY( float y ) { m_y = y; }
      void setZ( float z ) { m_z = z; }

      const Event* event() const { return m_event; }
      void setEvent( Event* evt ) { m_event = evt; }
      const MyTrack* motherParticle() const;

      void setMotherParticle( MyTrack* mother );

      const SmartRefVector<MyTrack>& decayParticles() const;

      void addDecayParticle( MyTrack* track );

      void removeDecayParticle( MyTrack* vtx );

      const SmartRefVector<Collision>& collisions() const;

      void addCollision( Collision* vtx );

      void removeCollision( Collision* vtx );

      StreamBuffer& serialize( StreamBuffer& s ) const override;
      StreamBuffer& serialize( StreamBuffer& s ) override;
    };
 
    // Definition of all container types of MCParticle
    typedef KeyedContainer<MyVertex> MyVertexVector;

    inline const MyTrack* MyVertex::motherParticle() const { return m_motherParticle; }

    inline void MyVertex::setMotherParticle( MyTrack* mother ) { m_motherParticle = mother; }

    inline const SmartRefVector<MyTrack>& MyVertex::decayParticles() const { return m_decayParticles; }

    inline void MyVertex::addDecayParticle( MyTrack* p ) { m_decayParticles.push_back( SmartRef<MyTrack>( p ) ); }

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

    inline const SmartRefVector<Collision>& MyVertex::collisions() const { return m_collisions; }

    inline void MyVertex::addCollision( Collision* c ) { m_collisions.push_back( SmartRef<Collision>( c ) ); }

    inline void MyVertex::removeCollision( Collision* c ) {
      SmartRefVector<Collision>::iterator i;
      for ( i = m_collisions.begin(); i != m_collisions.end(); ++i ) {
        if ( i->target() == c ) {
          m_collisions.erase( i );
          return;
        }
      }
    }
  } // namespace TestSuite
} // namespace Gaudi