ParticleID.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 <GaudiKernel/HashMap.h>
#include <GaudiKernel/Kernel.h>
#include <cmath>
#include <cstdint>
#include <iosfwd>
#include <string>
#include <tuple>
 
namespace Gaudi {
  class GAUDI_API ParticleID final {
  public:
    enum Location { nj = 1, nq3, nq2, nq1, nl, nr, n, n8, n9, n10 };
    enum Quark { down = 1, up, strange, charm, bottom, top, bottom_prime, top_prime, first = down, last = top_prime };

    explicit ParticleID( const int pid = 0 ) { setPid( pid ); }

    int pid() const { return m_pid; }
    constexpr unsigned int abspid() const { return 0 > m_pid ? -m_pid : m_pid; }
    void setPid( const int pid ) { m_pid = pid; }

    bool isValid() const;
    bool isSM() const;
    bool isMeson() const;
    bool isBaryon() const;
    bool isDiQuark() const;
    bool isHadron() const;
    bool isLepton() const;
    bool isNucleus() const;
    bool isQuark() const;

    bool hasQuarks() const;
    bool hasQuark( const Quark& q ) const;
    bool hasDown() const { return hasQuark( down ); }
    bool hasUp() const { return hasQuark( up ); }
    bool hasStrange() const { return hasQuark( strange ); }
    bool hasCharm() const { return hasQuark( charm ); }
    bool hasBottom() const { return hasQuark( bottom ); }
    bool hasTop() const { return hasQuark( top ); }
    bool hasBottomPrime() const { return hasQuark( bottom_prime ); }
    bool hasTopPrime() const { return hasQuark( top_prime ); }

    int threeCharge() const;
    int jSpin() const;
    int sSpin() const;
    int lSpin() const;

    int Z() const;
    int A() const;
    int nLambda() const;

    int fundamentalID() const;

    int extraBits() const;
    constexpr unsigned short digit( const Location& loc ) const {
      constexpr std::uint32_t pows[10] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
      return ( abspid() / pows[loc - 1] ) % 10;
    }

    bool operator==( const ParticleID& o ) const { return m_pid == o.m_pid; }
    bool operator!=( const ParticleID& o ) const { return m_pid != o.m_pid; }
    bool operator<( const ParticleID& o ) const {
      const unsigned int i1( abspid() ), i2( o.abspid() );
      return std::tie( i1, m_pid ) < std::tie( i2, o.m_pid );
    }

    std::ostream& fillStream( std::ostream& s ) const;
    std::string toString() const;
    static std::ostream& printLocation( const long l, std::ostream& s );
    static std::string printLocation( const long l );
    static std::ostream& printQuark( const long q, std::ostream& s );
    static std::string printQuark( const long q );
 
  private:
    int m_pid{ 0 };
  };
 
  // Inline stream operators.
  inline std::ostream& operator<<( std::ostream& s, const Gaudi::ParticleID& o ) { return o.fillStream( s ); }
  inline std::ostream& operator<<( std::ostream& s, Gaudi::ParticleID::Location l ) {
    return Gaudi::ParticleID::printLocation( l, s );
  }

  inline std::ostream& operator<<( std::ostream& s, Gaudi::ParticleID::Quark q ) {
    return Gaudi::ParticleID::printQuark( q, s );
  }
} // namespace Gaudi
 
namespace GaudiUtils {
  template <>
  struct Hash<Gaudi::ParticleID> {
    inline size_t operator()( const Gaudi::ParticleID& s ) const { return (size_t)s.pid(); }
  };
  template <>
  struct Hash<const Gaudi::ParticleID> {
    inline size_t operator()( const Gaudi::ParticleID& s ) const { return (size_t)s.pid(); }
  };
  template <>
  struct Hash<Gaudi::ParticleID&> {
    inline size_t operator()( const Gaudi::ParticleID& s ) const { return (size_t)s.pid(); }
  };
  template <>
  struct Hash<const Gaudi::ParticleID&> {
    inline size_t operator()( const Gaudi::ParticleID& s ) const { return (size_t)s.pid(); }
  };
} // namespace GaudiUtils
namespace std {
  inline Gaudi::ParticleID abs( const Gaudi::ParticleID& p ) { return Gaudi::ParticleID( p.abspid() ); }
} // namespace std