Event.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_Event_h
#define CepGen_Event_Event_h
 
#include "CepGen/Event/Particle.h"
 
namespace cepgen {
  class Event {
  public:
    explicit Event(bool compressed = false);  
    Event(const Event&);                      
 
    Event& operator=(const Event&);       
    bool operator==(const Event&) const;  
 
    static Event minimal(size_t num_out_particles = 1);
 
    void clear();             
    void freeze();            
    void restore();           
    bool compressed() const;  
    Event compress() const;   
    void updateRoles();       
 
    friend std::ostream& operator<<(std::ostream&, const Event&);
    void dump() const;
    double cmEnergy() const;
 
    //----- particles adders
 
    ParticleRef addParticle(Particle& particle, bool replace = false);
    ParticleRef addParticle(Particle::Role role, bool replace = false);
 
    //----- particles retrievers
 
    size_t size() const;                                      
    bool empty() const;                                       
    Particles particles() const;                              
    Particles stableParticles() const;                        
    Particles stableParticlesWithRole(Particle::Role) const;  
    ParticlesMap& map() { return particles_; }                
 
    ParticlesRefs operator[](Particle::Role role);
    const Particles& operator()(Particle::Role role) const;
    ParticlesIds ids(Particle::Role role) const;
    inline bool hasRole(Particle::Role role) const { return particles_.count(role) != 0; }
    Particle& oneWithRole(Particle::Role role);
    const Particle& oneWithRole(Particle::Role role) const;
    Particle& operator[](int id);
    const Particle& operator()(int id) const;
    ParticlesRefs operator[](const ParticlesIds& ids);
    Particles operator()(const ParticlesIds& ids) const;
 
    Momentum missingMomentum() const;
 
    //----- general particles information retriever
 
    Particles mothers(const Particle& particle) const;
    ParticlesRefs mothers(const Particle& particle);
    void clearMothers(Particle& particle);
    Particles children(const Particle& particle) const;
    ParticlesRefs children(const Particle& particle);
    Particles stableChildren(const Particle& particle, bool recursive = false) const;
    ParticlesRefs stableChildren(const Particle& particle, bool recursive = false);
    void clearChildren(Particle& particle);
    ParticleRoles roles() const;
 
    struct EventMetadata : std::unordered_map<std::string, float> {
      EventMetadata();
      float operator()(const std::string& key) const { return count(key) > 0 ? at(key) : -1.; }
    };
    struct EventMetadata : std::unordered_map<std::string, float> {…};
    EventMetadata metadata;
 
  private:
    static constexpr double MIN_PRECISION = 1.e-10;
    void checkKinematics() const;  
    ParticlesMap particles_;       
    struct NumParticles {
      size_t cs{0};   
      size_t op1{0};  
      size_t op2{0};  
    } event_content_{};
    bool compressed_{false};  
  };
}  // namespace cepgen
 
#endif
    ParticlesRefs operator[](Particle::Role role); {…}
  class Event {…};