Particle.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2025  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_Event_Particle_h
#define CepGen_Event_Particle_h
 
#include <set>
 
#include "CepGen/Physics/Momentum.h"
#include "CepGen/Physics/ParticleProperties.h"
#include "CepGen/Utils/Hasher.h"
 
namespace cepgen {
  using ParticlesIds = std::set<int>;  
 
  class Particle {
  public:
    enum class Status {
      PrimordialIncoming = -9,  
      DebugResonance = -5,      
      Resonance = -4,           
      Fragmented = -3,          
      Propagator = -2,          
      Incoming = -1,            
      Undefined = 0,            
      FinalState = 1,           
      Undecayed = 2,            
      Unfragmented = 3          
    };
    enum class Status {…};
    friend std::ostream& operator<<(std::ostream& os, const Status&);  
    enum class Role {
      UnknownRole = -1,   
      IncomingBeam1 = 1,  
      IncomingBeam2 = 2,  
      OutgoingBeam1 = 3,  
      OutgoingBeam2 = 5,  
      CentralSystem = 6,  
      Intermediate = 4,   
      Parton1 = 41,       
      Parton2 = 42        
    };
    enum class Role {…};
    friend std::ostream& operator<<(std::ostream& os, const Role&);  
 
    //----- static getters
 
    explicit Particle(Role role = Role::UnknownRole, pdgid_t id = 0, Status status = Status::Undefined);
 
    bool operator<(const Particle&) const;   
    bool operator==(const Particle&) const;  
 
    // --- general particle properties
 
    inline int id() const { return id_; }  
    inline Particle& setId(int id) {
      id_ = id;
      return *this;
    }
    inline Particle& setId(int id) {…}
    float charge() const;  
    inline Particle& setAntiparticle(bool anti) {
      antiparticle_ = anti;
      return *this;
    }
    inline Particle& setAntiparticle(bool anti) {…}
    inline Role role() const { return role_; }  
    inline Particle& setRole(const Role& role) {
      role_ = role;
      return *this;
    }
    inline Particle& setRole(const Role& role) {…}
    inline Status status() const { return static_cast<Status>(status_); }  
    inline Particle& setStatus(Status status) {
      status_ = static_cast<int>(status);
      return *this;
    }
    inline Particle& setStatus(Status status) {…}
    inline Particle& setStatus(int status) {
      status_ = status;
      return *this;
    }
    inline Particle& setStatus(int status) {…}
 
    Particle& setPdgId(pdgid_t pdg, short charge_factor = 0);
    pdgid_t pdgId() const;  
    Particle& setIntegerPdgId(long pdg_id);
    long integerPdgId() const;  
 
    inline float helicity() const { return helicity_; }  
    inline Particle& setHelicity(float heli) {
      helicity_ = heli;
      return *this;
    }
    inline Particle& setHelicity(float heli) {…}
 
    inline Momentum& momentum() { return momentum_; }  
    inline const Momentum& momentum() const { return momentum_; }
    Particle& setMomentum(const Momentum&, bool off_shell = false);
    Particle& setMomentum(double px, double py, double pz, double energy = -1.);
    inline Particle& setMomentum(double p[4]) { return setMomentum(p[0], p[1], p[2], p[3]); }
    bool valid() const;  
 
    // --- particle relations
 
    inline bool primary() const { return mothers_.empty(); }    
    Particle& addMother(Particle& mother_particle);             
    inline ParticlesIds mothers() const { return mothers_; }    
    inline ParticlesIds& mothers() { return mothers_; }         
    Particle& addChild(Particle& child_particle);               
    inline ParticlesIds children() const { return children_; }  
    inline ParticlesIds& children() { return children_; }       
 
    // --- global particle information extraction
 
    friend std::ostream& operator<<(std::ostream&, const Particle&);  
 
  protected:
    int id_{-1};                                       
    bool antiparticle_{false};                         
    Momentum momentum_;                                
    float helicity_{0.};                               
    Role role_{Role::UnknownRole};                     
    int status_{static_cast<int>(Status::Undefined)};  
    ParticlesIds mothers_{};                           
    ParticlesIds children_{};                          
    pdgid_t pdg_id_{0};                                
  };
 
  // --- particle containers
 
  using ParticleRef = std::reference_wrapper<Particle>;  
  using Particles = std::vector<Particle>;               
  using ParticlesRefs = std::vector<ParticleRef>;        
  using ParticleRoles = std::vector<Particle::Role>;     
 
  class ParticlesMap : public std::unordered_map<Particle::Role, Particles, utils::EnumHash<Particle::Role> > {
  public:
    ParticlesMap() = default;
    ParticlesMap(const ParticlesMap&);             
    ParticlesMap& operator=(const ParticlesMap&);  
    ~ParticlesMap() = default;
  };
  class ParticlesMap : public std::unordered_map<Particle::Role, Particles, utils::EnumHash<Particle::Role> > {…};
}  // namespace cepgen
 
#endif
    friend std::ostream& operator<<(std::ostream&, const Particle&);   {…};
    inline ParticlesIds& children() { return children_; }        {…}
    Particle& addChild(Particle& child_particle);                {…}
    inline ParticlesIds& mothers() { return mothers_; }          {…}
    Particle& addMother(Particle& mother_particle);              {…}
  class Particle {…};