Base.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
// Base.h 
// Header file for class Base
// Author: S.Binet<binet@cern.ch>
#ifndef PARTICLEEVENT_PARTICLEEVENTBASE_H 
#define PARTICLEEVENT_PARTICLEEVENTBASE_H 
 
// STL includes
#include <iosfwd>
 
// EventKernel includes
#include "EventKernel/IParticle.h" // for {Charge,ParticleDataType::Data}Type
 
// VxVertex includes
#include "VxVertex/VxContainer.h"
#include "VxVertex/VxCandidate.h"
#include "VxVertex/RecVertex.h"
 
// AthenaBarCode includes
#include "Navigation/AthenaBarCodeImpl.h"
#include "AthLinks/ElementLink.h"
 
// Forward declaration
 
namespace ParticleEvent {
 
class Base
{ 

  // Public methods: 
 public: 

  Base();

  explicit Base( const Base& rhs );

  Base& operator=( const Base& rhs );


  virtual ~Base(); 

  // Const methods: 


  ParticleDataType::DataType dataType() const;

  const Trk::RecVertex* origin() const;

  const ElementLink<VxContainer>& originLink() const;

  bool hasCharge() const;

  ChargeType charge() const;

  bool hasPdgId() const;

  int pdgId() const;

  std::ostream& dump( std::ostream& out ) const;
 
  const AthenaBarCodeImpl& getAthenaBarCodeImpl() const {return m_abc;}

  // Non-const methods: 
 
  // Set functions (for IParticle)
  void set_dataType( ParticleDataType::DataType x );
  void set_charge( ChargeType x );
  void set_pdgId( int x );
  void reset_charge();
  void reset_pdgId();
  void set_origin( const VxContainer* theContainer, int index );
  void set_origin( const VxContainer* theContainer, 
                   const Trk::VxCandidate * vertex );
  void set_origin( const ElementLink<VxContainer>& origin );
 
  AthenaBarCodeImpl& getAthenaBarCodeImpl() {return m_abc;}
  // Protected data: 
 private: 

  ParticleDataType::DataType m_dataType;

  ElementLink< VxContainer > m_origin;

  bool m_hasCharge;

  ChargeType m_charge;

  bool m_hasPdgId;

  int m_pdgId;

  AthenaBarCodeImpl m_abc;
 
 
}; 

// I/O functions
std::ostream& operator<<( std::ostream& out, const Base& base );

// Inline methods: 
 
inline 
Base::Base() :
  m_dataType ( ),
  m_origin   ( ),
  m_hasCharge( false ),
  m_charge   ( 0. ),
  m_hasPdgId ( false ),
  m_pdgId    ( 0 ),
  m_abc      ()
{}
 
inline
Base::Base( const Base& rhs ) :
  m_dataType ( rhs.m_dataType  ),
  m_origin   ( rhs.m_origin    ),
  m_hasCharge( rhs.m_hasCharge ),
  m_charge   ( rhs.m_charge    ),
  m_hasPdgId ( rhs.m_hasPdgId  ),
  m_pdgId    ( rhs.m_pdgId     ),
  m_abc      ( rhs.m_abc)
{}
 
inline
Base& Base::operator=( const Base& rhs )
{
  if ( this != &rhs ) {
    m_dataType  = rhs.m_dataType;
    m_origin    = rhs.m_origin;
    m_hasCharge = rhs.m_hasCharge;
    m_charge    = rhs.m_charge;
    m_hasPdgId  = rhs.m_hasPdgId;
    m_pdgId     = rhs.m_pdgId;
    m_abc       = rhs.m_abc;
  }
  return *this;
}
 
inline
Base::~Base()
{}
 
inline ParticleDataType::DataType 
Base::dataType() const 
{
  return m_dataType;
}
 
inline const Trk::RecVertex* 
Base::origin() const
{
  return (!m_origin.isValid()) 
    ? 0 
    : &(**m_origin).recVertex();
}
 
inline bool 
Base::hasCharge()  const 
{ 
  return m_hasCharge;
}
 
inline ChargeType 
Base::charge() const 
{ 
  return m_charge;
}
 
inline bool 
Base::hasPdgId() const 
{
  return m_hasPdgId;
}
 
inline int 
Base::pdgId() const 
{
  return m_pdgId;
}
 
// --------------------
// non-const interface
// --------------------
 
inline 
void 
Base::set_dataType( ParticleDataType::DataType x ) 
{ 
  m_dataType = x;
}
 
inline 
void 
Base::set_charge( ChargeType x ) 
{ 
  m_charge = x; 
  m_hasCharge = true;
}
 
inline
void 
Base::set_pdgId( int x ) 
{ 
  m_pdgId = x; 
  m_hasPdgId = true;
}
 
inline 
void 
Base::reset_charge() 
{ 
  m_hasCharge = false;
}
 
inline
void 
Base::reset_pdgId() 
{ 
  m_hasPdgId = false;
}
 
inline
void 
Base::set_origin( const VxContainer* theContainer, int index )
{
  m_origin = ElementLink< VxContainer >(*theContainer, index);
}
 
inline
void 
Base::set_origin( const VxContainer* theContainer, 
                  const Trk::VxCandidate * vertex )
{
  m_origin = ElementLink< VxContainer >
    ((vertex),*theContainer );
}
 
inline
void 
Base::set_origin( const ElementLink<VxContainer>& origin )
{
  m_origin = origin;
}
 
} //> end namespace ParticleEvent
 
#endif //> PARTICLEEVENT_PARTICLEEVENTBASE_H