NodesPIDs.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/Decays/Nodes.h>
#include <Gaudi/Interfaces/IParticlePropertySvc.h>
#include <Gaudi/ParticleProperty.h>
#include <Gaudi/cxx/SynchronizedValue.h>
#include <GaudiKernel/MsgStream.h>
#include <algorithm>
 
namespace Gaudi::Decays {
  namespace Nodes {
    class GAUDI_API Any : public Decays::iNode {
    public:
      Any* clone() const override;
      bool operator()( const Gaudi::ParticleID& /* p */ ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
    };
 
    class GAUDI_API Pid : public Decays::iNode {
    public:
      Pid( const Decays::Decay::Item& item );
      Pid( const Gaudi::ParticleProperty* item );
      Pid( const Gaudi::ParticleID& item );
      Pid( const std::string& item );
      Pid* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return check( pid ); }
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
 
    public:
      bool check( Gaudi::ParticleID pid ) const { return pid == m_item.pid(); }
 
      const Decays::Decay::Item& item() const { return m_item; }
      operator const Decays::Decay::Item&() const { return item(); }
 
    private:
      Decays::Decay::Item m_item;
    };
 
    class GAUDI_API CC : public Pid {
    public:
      CC( const Decays::Decay::Item& item );
      CC( const Gaudi::ParticleProperty* item );
      CC( Gaudi::ParticleID item );
      CC( const std::string& item );
      CC( const Decays::Nodes::Pid& pid );
      CC* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return pid.abspid() == item().pid().abspid(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Lepton : public Any {
    public:
      Lepton* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return pid.isLepton(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Nu : public Lepton {
    public:
      Nu* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override {
        return pid.isLepton() && ( 0 == pid.threeCharge() );
      }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Ell : public Lepton {
    public:
      Ell* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override {
        return pid.isLepton() && ( 0 != pid.threeCharge() );
      }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API EllPlus : public Ell {
    public:
      EllPlus* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override {
        return pid.isLepton() && ( 0 < pid.threeCharge() );
      }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
    class GAUDI_API EllMinus : public Ell {
    public:
      EllMinus* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override {
        return pid.isLepton() && ( 0 > pid.threeCharge() );
      }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Hadron : public Any {
    public:
      Hadron* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return pid.isHadron(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Meson : public Hadron {
    public:
      Meson* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return pid.isMeson(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Baryon : public Hadron {
    public:
      Baryon* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return pid.isBaryon(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Charged : public Any {
    public:
      Charged* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return 0 != pid.threeCharge(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Positive : public Charged {
    public:
      Positive* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return 0 < pid.threeCharge(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Negative : public Charged {
    public:
      Negative* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return 0 > pid.threeCharge(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Neutral : public Charged {
    public:
      Neutral* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return 0 == pid.threeCharge(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Nucleus : public Any {
    public:
      Nucleus* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return pid.isNucleus(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API HasQuark : public Any {
    public:
      HasQuark( Gaudi::ParticleID::Quark quark );
      HasQuark* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return pid.hasQuark( m_quark ); }
      std::ostream& fillStream( std::ostream& s ) const override;
 
    private:
      Gaudi::ParticleID::Quark m_quark; // the quark to be tested
    };
 
    class GAUDI_API JSpin : public Any {
    public:
      enum { InvalidSpin = 501 };
 
      JSpin( const int spin );
      JSpin* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return spin() == pid.jSpin(); }
      std::ostream& fillStream( std::ostream& s ) const override;
 
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* /* svc */ ) const override;
 
      int spin() const { return m_spin; }
 
    private:
      int m_spin;
    };
 
    class GAUDI_API SSpin : public JSpin {
    public:
      SSpin( const int spin );
      SSpin* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return spin() == pid.sSpin(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API LSpin : public SSpin {
    public:
      LSpin( const int spin );
      LSpin* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override { return spin() == pid.lSpin(); }
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API CTau : public Decays::iNode {
    public:
      CTau( const double low, const double high, const Gaudi::Interfaces::IParticlePropertySvc* svc = nullptr );
      CTau* clone() const override;
 
      bool operator()( const Gaudi::ParticleID& pid ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
 
      const Gaudi::Interfaces::IParticlePropertySvc* ppSvc() const { return m_ppSvc; }
 
      double low() const { return m_low; }
      double high() const { return m_high; }
 
      StatusCode setService( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const;
 
    protected:
      template <typename F, typename = std::is_invocable_r<bool, F, Gaudi::ParticleID>>
      bool classify( Gaudi::ParticleID pid, F&& f ) const {
        enum struct Classification { Accepted = +1, Rejected = -1, Unknown = 0 };
        auto r = m_pids.with_lock(
            []( const auto& pids, Gaudi::ParticleID pid ) {
              return std::binary_search( pids.accepted.begin(), pids.accepted.end(), pid )   ? Classification::Accepted
                     : std::binary_search( pids.rejected.begin(), pids.rejected.end(), pid ) ? Classification::Rejected
                                                                                             : Classification::Unknown;
            },
            pid );
        switch ( r ) {
        case Classification::Accepted:
          return true;
        case Classification::Rejected:
          return false;
        case Classification::Unknown:
          return add_( pid, std::invoke( std::forward<F>( f ), pid ) );
        }
        __builtin_unreachable();
      }
 
    private:
      bool add_( Gaudi::ParticleID pid, bool acc ) const;
 
    public:
      MsgStream& printAcceptedAsTable( MsgStream& s ) const {
        return m_pids.with_lock(
            [&]( const KnownPids& pids, MsgStream& s, auto const& ppSvc ) -> decltype( auto ) {
              return Gaudi::ParticleProperties::printAsTable( pids.accepted, s, ppSvc );
            },
            s, m_ppSvc );
      }
 
    private:
      typedef SmartIF<Gaudi::Interfaces::IParticlePropertySvc> Service;
      mutable Service m_ppSvc;
 
    public:
      struct KnownPids {
        std::vector<Gaudi::ParticleID> accepted;
        std::vector<Gaudi::ParticleID> rejected;
      };
 
    private:
      mutable Gaudi::cxx::SynchronizedValue<KnownPids> m_pids;
 
      double m_low;
      double m_high;
    };
 
    class GAUDI_API ShortLived_ : public CTau {
    public:
      ShortLived_( const double high, const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      ShortLived_( const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      ShortLived_* clone() const override;
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    struct GAUDI_API LongLived_ : CTau {
      LongLived_( const double high, const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      LongLived_( const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      LongLived_* clone() const override;
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Stable : public LongLived_ {
    public:
      Stable( const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      Stable* clone() const override;
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API StableCharged : public Stable {
    public:
      StableCharged( const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      StableCharged* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Mass : public CTau {
    public:
      Mass( const double low, const double high, const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      Mass* clone() const override;
 
      bool operator()( const Gaudi::ParticleID& pid ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Light : public Mass {
    public:
      Light( const double high, const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      Light* clone() const override;
 
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API Heavy : public Mass {
    public:
      Heavy( const double low, const Gaudi::Interfaces::IParticlePropertySvc* svc = 0 );
      Heavy* clone() const override;
 
      std::ostream& fillStream( std::ostream& s ) const override;
    };
 
    class GAUDI_API PosID : public Decays::iNode {
    public:
      PosID* clone() const override;
      bool operator()( const Gaudi::ParticleID& /* p */ ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
    };
 
    class GAUDI_API NegID : public Decays::iNode {
    public:
      NegID* clone() const override;
      bool operator()( const Gaudi::ParticleID& /* p */ ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
    };
 
    class GAUDI_API Symbol : public Decays::iNode {
    public:
      Symbol( const std::string& sym );
      Symbol* clone() const override;
 
      bool operator()( const Gaudi::ParticleID& pid ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
 
    private:
      Decays::Node m_symbol;
    };
  } // namespace Nodes
} // namespace Gaudi::Decays