ParticleProperty.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2023 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 <Gaudi/ParticleID.h>
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/PhysicalConstants.h>
#include <cmath>
#include <functional>
#include <iosfwd>
#include <limits>
#include <set>
#include <string>
#include <vector>
 
namespace Gaudi {
  namespace Interfaces {
    class IParticlePropertySvc;
  }
 
  class GAUDI_API ParticleProperty final {
  public:
    struct Compare {
      inline bool operator()( const ParticleProperty* p1, const ParticleProperty* p2 ) const {
        return p1 == p2 ? false : 0 == p1 ? true : 0 == p2 ? false : ( *p1 < *p2 );
      }
    };
 
    ParticleProperty( const std::string& name, const Gaudi::ParticleID& pid, const double charge, const double mass,
                      const double tlife, const double maxWidth, const std::string& evtgen, const int pythia );
    ParticleProperty( const std::string& name, const Gaudi::ParticleID& pid, const double charge, const double mass,
                      const double tlife, const double maxWidth );
 
    const std::string& particle() const { return m_name; }
    const std::string& name() const { return m_name; }
    const Gaudi::ParticleID& particleID() const { return m_pid; }
    const Gaudi::ParticleID& pdgID() const { return m_pid; }
    const Gaudi::ParticleID& pid() const { return m_pid; }
    double charge() const { return m_charge; }
    double mass() const { return m_mass; }
    double lifetime() const { return m_tlife; }
    double lifeTime() const { return m_tlife; }
    double ctau() const { return Gaudi::Units::c_light * lifeTime(); }
    double width() const {
      return std::abs( ctau() ) < std::numeric_limits<double>::epsilon() ? 0.0 : Gaudi::Units::hbarc / ctau();
    }
    double maxWidth() const { return m_maxWidth; } // max-width
    const Gaudi::ParticleProperty* antiParticle() const { return anti(); }
    const Gaudi::ParticleProperty* anti() const { return m_anti; }
 
    bool selfcc() const { return m_anti == this; }
 
    int threeCharge() const { return m_pid.threeCharge(); }
 
    void setAntiParticle( const ParticleProperty* p );
 
    const std::string& evtGenName() const { return m_evtgen; }
    const std::string& evtGen() const { return m_evtgen; }
    int pythiaID() const { return m_pythia; }
    int pythia() const { return m_pythia; }
 
    friend bool operator<( const ParticleProperty& lhs, const ParticleProperty& rhs ) {
      return std::tie( lhs.m_pid, lhs.m_name ) < std::tie( rhs.m_pid, rhs.m_name );
    }
 
    operator const Gaudi::ParticleID&() const { return m_pid; }
 
    std::ostream& fillStream( std::ostream& s ) const;
    std::string toString() const;
 
  private:
    std::string m_name;
    Gaudi::ParticleID m_pid;
    double m_charge;
    double m_mass;
    double m_tlife;
    double m_maxWidth;
    std::string m_evtgen;
    int m_pythia;
    const Gaudi::ParticleProperty* m_anti;
  };
} // namespace Gaudi
 
std::ostream& operator<<( std::ostream& stream, const Gaudi::ParticleProperty& pp );
 
class MsgStream;
namespace Gaudi {
  namespace ParticleProperties {
    GAUDI_API
    std::ostream& printAsTable_( const std::vector<const Gaudi::ParticleProperty*>& particles, std::ostream& stream,
                                 const Gaudi::Interfaces::IParticlePropertySvc* service = 0 );
 
    GAUDI_API
    std::string printAsTable( const std::vector<const Gaudi::ParticleProperty*>& particles,
                              const Gaudi::Interfaces::IParticlePropertySvc*     service = 0 );
 
    GAUDI_API
    MsgStream& printAsTable( const std::vector<const Gaudi::ParticleProperty*>& particles, MsgStream& stream,
                             const Gaudi::Interfaces::IParticlePropertySvc* service = 0 );
 
    GAUDI_API
    std::ostream& printAsTable_( const std::vector<Gaudi::ParticleID>& particles, std::ostream& stream,
                                 const Gaudi::Interfaces::IParticlePropertySvc* service = 0 );
 
    template <class C_, class A_>
    inline std::ostream& printAsTable_( const std::set<Gaudi::ParticleID, C_, A_>& particles, std::ostream& stream,
                                        const Gaudi::Interfaces::IParticlePropertySvc* service = 0 ) {
      return printAsTable_( std::vector<Gaudi::ParticleID>( particles.begin(), particles.end() ), stream, service );
    }
 
    GAUDI_API
    std::string printAsTable( const std::vector<Gaudi::ParticleID>&          particles,
                              const Gaudi::Interfaces::IParticlePropertySvc* service = 0 );
 
    template <class C_, class A_>
    inline std::string printAsTable( const std::set<Gaudi::ParticleID, C_, A_>&     particles,
                                     const Gaudi::Interfaces::IParticlePropertySvc* service = 0 ) {
      return printAsTable( std::vector<Gaudi::ParticleID>( particles.begin(), particles.end() ), service );
    }
 
    GAUDI_API
    MsgStream& printAsTable( const std::vector<Gaudi::ParticleID>& particles, MsgStream& stream,
                             const Gaudi::Interfaces::IParticlePropertySvc* service = 0 );
 
    template <class C_, class A_>
    inline MsgStream& printAsTable( const std::set<Gaudi::ParticleID, C_, A_>& particles, MsgStream& stream,
                                    const Gaudi::Interfaces::IParticlePropertySvc* service = 0 ) {
      return printAsTable( std::vector<Gaudi::ParticleID>( particles.begin(), particles.end() ), stream, service );
    }
  } // namespace ParticleProperties
} // namespace Gaudi
namespace Gaudi {
  namespace Utils {
    GAUDI_API
    std::ostream& toStream( const std::vector<const Gaudi::ParticleProperty*>& particles, std::ostream& stream );
  } // namespace Utils
} // namespace Gaudi
namespace std {
  GAUDI_API
  const Gaudi::ParticleProperty* abs( const Gaudi::ParticleProperty* p );
} // namespace std