Particle.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2024  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/Constants.h"
#include "CepGen/Physics/Momentum.h"
#include "CepGen/Physics/ParticleProperties.h"
#include "CepGen/Utils/Hasher.h"
 
namespace cepgen {
  typedef std::set<int> ParticlesIds;  
 
  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          
    };
    friend std::ostream& operator<<(std::ostream& os, const Status&);  
    enum Role {
      UnknownRole = -1,   
      IncomingBeam1 = 1,  
      IncomingBeam2 = 2,  
      OutgoingBeam1 = 3,  
      OutgoingBeam2 = 5,  
      CentralSystem = 6,  
      Intermediate = 4,   
      Parton1 = 41,       
      Parton2 = 42        
    };
    friend std::ostream& operator<<(std::ostream& os, const Role&);  
 
    //----- static getters
 
    explicit Particle(Role role = Role::UnknownRole, pdgid_t id = 0, Status st = 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;
    }
    float charge() const;  
    inline Particle& setAntiparticle(bool anti) {
      antiparticle_ = anti;
      return *this;
    }
    inline Role role() const { return role_; }  
    inline Particle& setRole(const Role& role) {
      role_ = role;
      return *this;
    }
    inline Status status() const { return (Status)status_; }  
    inline Particle& setStatus(Status status) {
      status_ = (int)status;
      return *this;
    }
    inline Particle& setStatus(int status) {
      status_ = status;
      return *this;
    }
 
    Particle& setPdgId(pdgid_t pdg, short ch = 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 Momentum& momentum() { return momentum_; }  
    inline const Momentum& momentum() const { return momentum_; }
    Particle& setMomentum(const Momentum&, bool offshell = false);
    Particle& setMomentum(double px, double py, double pz, double e = -1.);
    inline Particle& setMomentum(double p[4]) { return setMomentum(p[0], p[1], p[2], p[3]); }
    bool valid();  
 
    // --- particle relations
 
    inline bool primary() const { return mothers_.empty(); }      
    Particle& addMother(Particle& part);                          
    inline ParticlesIds mothers() const { return mothers_; }      
    inline ParticlesIds& mothers() { return mothers_; }           
    Particle& addDaughter(Particle& part);                        
    inline ParticlesIds daughters() const { return daughters_; }  
    inline ParticlesIds& daughters() { return daughters_; }       
 
    // --- 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_{UnknownRole};              
    int status_{(int)Status::Undefined};  
    ParticlesIds mothers_;                
    ParticlesIds daughters_;              
    pdgid_t pdg_id_{(pdgid_t)0};          
  };
 
  // --- particle containers
 
  typedef std::reference_wrapper<Particle> ParticleRef;  
  typedef std::vector<Particle> Particles;               
  typedef std::vector<ParticleRef> ParticlesRefs;        
  typedef std::vector<Particle::Role> ParticleRoles;     
 
  class ParticlesMap : public std::unordered_map<Particle::Role, Particles, utils::EnumHash<Particle::Role> > {
  public:
    ParticlesMap() = default;
    ParticlesMap(const ParticlesMap&);             
    ParticlesMap& operator=(const ParticlesMap&);  
  };
}  // namespace cepgen
 
#endif