Stores event-related information. More...

#include <GenEvent.h>

Public Member Functions
	GenEvent (const GenEvent &)
	Copy constructor.

	GenEvent (std::shared_ptr< GenRunInfo > run, Units::MomentumUnit mu=Units::GEV, Units::LengthUnit lu=Units::MM)
	Constructor with associated run.

	GenEvent (Units::MomentumUnit mu=Units::GEV, Units::LengthUnit lu=Units::MM)
	Event constructor without a run.

	~GenEvent ()
	Destructor.

GenEvent &	operator= (const GenEvent &)
	Copy Assignment operator.

Particle and vertex access
const std::vector< ConstGenParticlePtr > &	particles () const
	Get list of particles (const)

const std::vector< ConstGenVertexPtr > &	vertices () const
	Get list of vertices (const)

const std::vector< GenParticlePtr > &	particles ()
	Get/set list of particles (non-const)

const std::vector< GenVertexPtr > &	vertices ()
	Get/set list of vertices (non-const)

int	particles_size () const
	Particles size, HepMC2 compatibility.

bool	particles_empty () const
	Particles empty, HepMC2 compatibility.

int	vertices_size () const
	Vertices size, HepMC2 compatibility.

bool	vertices_empty () const
	Vertices empty, HepMC2 compatibility.

Event weights
const std::vector< double > &	weights () const
	Get event weight values as a vector.

std::vector< double > &	weights ()
	Get event weights as a vector (non-const)

double	weight (const unsigned long &index=0) const

double	weight (const std::string &name) const

double &	weight (const std::string &name)

const std::vector< std::string > &	weight_names () const

Auxiliary info and event metadata
std::shared_ptr< GenRunInfo >	run_info () const
	Get a pointer to the the GenRunInfo object.

void	set_run_info (std::shared_ptr< GenRunInfo > run)
	Set the GenRunInfo object by smart pointer.

int	event_number () const
	Get event number.

void	set_event_number (const int &num)
	Set event number.

const Units::MomentumUnit &	momentum_unit () const
	Get momentum unit.

const Units::LengthUnit &	length_unit () const
	Get length unit.

void	set_units (Units::MomentumUnit new_momentum_unit, Units::LengthUnit new_length_unit)
	Change event units Converts event from current units to new ones.

GenHeavyIonPtr	heavy_ion ()
	Get heavy ion generator additional information.

ConstGenHeavyIonPtr	heavy_ion () const
	Get heavy ion generator additional information (const version)

void	set_heavy_ion (GenHeavyIonPtr hi)
	Set heavy ion generator additional information.

GenPdfInfoPtr	pdf_info ()
	Get PDF information.

ConstGenPdfInfoPtr	pdf_info () const
	Get PDF information (const version)

void	set_pdf_info (GenPdfInfoPtr pi)
	Set PDF information.

GenCrossSectionPtr	cross_section ()
	Get cross-section information.

ConstGenCrossSectionPtr	cross_section () const
	Get cross-section information (const version)

void	set_cross_section (GenCrossSectionPtr cs)
	Set cross-section information.

Event position
const FourVector &	event_pos () const
	Vertex representing the overall event position.

std::vector< ConstGenParticlePtr >	beams () const
	Vector of beam particles.

std::vector< ConstGenParticlePtr >	beams (const int status) const
	Vector of beam particles.

const std::vector< GenParticlePtr > &	beams ()
	Vector of beam particles.

void	shift_position_by (const FourVector &delta)
	Shift position of all vertices in the event by delta.

void	shift_position_to (const FourVector &newpos)
	Shift position of all vertices in the event to op.

bool	boost (const FourVector &delta)
	Boost event using x,y,z components of delta as velocities.

bool	rotate (const FourVector &delta)
	Rotate event using x,y,z components of delta as rotation angles.

bool	reflect (const int axis)
	Change sign of axis.

Additional attributes
Add event attribute to event This will overwrite existing attribute if an attribute with the same name is present
void	add_attribute (const std::string &name, const std::shared_ptr< Attribute > &att, const int &id=0)

void	add_attributes (const std::vector< std::string > &names, const std::vector< std::shared_ptr< Attribute > > &atts, const std::vector< int > &ids)
	Add multiple attributes to event.

void	add_attributes (const std::string &name, const std::vector< std::shared_ptr< Attribute > > &atts, const std::vector< int > &ids)
	Add multiple attributes to event.

void	add_attributes (const std::string &name, const std::vector< std::pair< int, std::shared_ptr< Attribute > > > &atts)
	Add multiple attributes to event.

void	remove_attribute (const std::string &name, const int &id=0)
	Remove attribute.

template<class T>
std::shared_ptr< T >	attribute (const std::string &name, const int &id=0) const
	Get attribute of type T.

std::string	attribute_as_string (const std::string &name, const int &id=0) const
	Get attribute of any type as string.

std::vector< std::string >	attribute_names (const int &id=0) const
	Get list of attribute names.

std::map< std::string, std::map< int, std::shared_ptr< Attribute > > >	attributes () const
	Get a copy of the list of attributes.

Particle and vertex modification
void	add_particle (GenParticlePtr p)
	Add particle.

void	add_vertex (GenVertexPtr v)
	Add vertex.

void	remove_particle (GenParticlePtr p)
	Remove particle from the event.

void	remove_particles (std::vector< GenParticlePtr > v)
	Remove a set of particles.

void	remove_vertex (GenVertexPtr v)
	Remove vertex from the event.

void	add_tree (const std::vector< GenParticlePtr > &parts)
	Add whole tree in topological order.

void	reserve (const size_t &parts, const size_t &verts=0)
	Reserve memory for particles and vertices.

void	clear ()
	Remove contents of this event.

Deprecated functionality
void	set_beam_particles (GenParticlePtr p1, GenParticlePtr p2)
	Set incoming beam particles.

void	add_beam_particle (GenParticlePtr p1)
	Add particle to root vertex.

Methods to fill GenEventData and to read it back
void	write_data (GenEventData &data) const
	Fill GenEventData object.

void	read_data (const GenEventData &data)
	Fill GenEvent based on GenEventData.

Detailed Description

Stores event-related information.

Manages event-related information. Contains lists of GenParticle and GenVertex objects

Definition at line 47 of file GenEvent.h.

Constructor & Destructor Documentation

◆ GenEvent() [1/3]

HepMC3::GenEvent::GenEvent	(	Units::MomentumUnit	mu = Units::GEV,
		Units::LengthUnit	lu = Units::MM )

Event constructor without a run.

Definition at line 490 of file marley_hepmc3.cc.

492 : m_momentum_unit(mu), m_length_unit(lu), //m_weights(std::vector<double>(1, 1.0)),//Prevent from different number of weights and names

493 m_rootvertex(std::make_shared<GenVertex>()) {}

Referenced by GenEvent(), and operator=().

◆ GenEvent() [2/3]

HepMC3::GenEvent::GenEvent	(	std::shared_ptr< GenRunInfo >	run,
		Units::MomentumUnit	mu = Units::GEV,
		Units::LengthUnit	lu = Units::MM )

Constructor with associated run.

Definition at line 496 of file marley_hepmc3.cc.

    : m_momentum_unit(mu), m_length_unit(lu),  //m_weights(std::vector<double>(1, 1.0)),//Prevent from  different number of weights and names
      m_rootvertex(std::make_shared<GenVertex>()),
      m_run_info(run) {
    if ( run && !run->weight_names().empty() ) {
        m_weights = std::vector<double>(run->weight_names().size(), 1.0);
    }
}

◆ GenEvent() [3/3]

HepMC3::GenEvent::GenEvent ( const GenEvent & e )

Copy constructor.

Definition at line 531 of file marley_hepmc3.cc.

                                   {
    if (this != &e)
    {
        std::lock(m_lock_attributes, e.m_lock_attributes);
        std::lock_guard<std::recursive_mutex> lhs_lk(m_lock_attributes, std::adopt_lock);
        std::lock_guard<std::recursive_mutex> rhs_lk(e.m_lock_attributes, std::adopt_lock);
        GenEventData tdata;
        e.write_data(tdata);
        read_data(tdata);
        m_run_info = e.m_run_info;
    }
}

References GenEvent(), read_data(), and write_data().

◆ ~GenEvent()

HepMC3::GenEvent::~GenEvent ( )

Destructor.

Definition at line 544 of file marley_hepmc3.cc.

                    {
    for ( auto attm = m_attributes.begin(); attm != m_attributes.end(); ++attm) {
        for ( auto att = attm->second.begin(); att != attm->second.end(); ++att) { if (att->second) att->second->m_event = nullptr;}
    }
    for  ( auto v = m_vertices.begin(); v != m_vertices.end(); ++v ) if (*v)  if ((*v)->m_event == this) (*v)->m_event = nullptr;
    for  ( auto p = m_particles.begin(); p != m_particles.end(); ++p ) if (*p)  if ((*p)->m_event == this)  (*p)->m_event = nullptr;
}

Member Function Documentation

◆ add_attribute()

void HepMC3::GenEvent::add_attribute	(	const std::string &	name,
		const std::shared_ptr< Attribute > &	att,
		const int &	id = 0 )

Disallow empty strings

Definition at line 1265 of file marley_hepmc3.cc.

                                                                                                       {
    if (name.length() == 0) return;
    if (!att)  return;
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    if (m_attributes.count(name) == 0) m_attributes[name] = std::map<int, std::shared_ptr<Attribute> >();
    m_attributes[name][id] = att;
    att->m_event = this;
    if ( id > 0 && id <= int(particles().size()) ) {
        att->m_particle = particles()[id - 1];
    }
    if ( id < 0 && -id <= int(vertices().size()) ) {
        att->m_vertex = vertices()[-id - 1];
    }
}

References particles(), and vertices().

Referenced by HepMC3::GenParticle::add_attribute(), HepMC3::GenVertex::add_attribute(), marley::Generator::add_state_to_event(), add_tree(), marley::Generator::create_event(), marley::Generator::create_event(), marley::Generator::finish_event_metadata(), set_cross_section(), set_heavy_ion(), and set_pdf_info().

◆ add_attributes() [1/3]

void HepMC3::GenEvent::add_attributes	(	const std::string &	name,
		const std::vector< std::pair< int, std::shared_ptr< Attribute > > > &	atts )

Add multiple attributes to event.

This will overwrite existing attributes if attributes with the same names are present

Disallow empty strings

Definition at line 1339 of file marley_hepmc3.cc.

                                                                                                                    {
    if (name.length() == 0) return;
    if (atts.empty()) return;
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    if (m_attributes.count(name) == 0) m_attributes[name] = std::map<int, std::shared_ptr<Attribute> >();
    auto& tmap = m_attributes[name];
    const int particles_size = int(m_particles.size());
    const int vertices_size = int(m_vertices.size());
    for (const auto& att: atts) {
        if (!att.second)  continue;
        tmap.insert(att);
        att.second->m_event = this;
        if ( att.first > 0 && att.first <= particles_size )
        { att.second->m_particle = m_particles[att.first - 1]; }
        else {
            if ( att.first < 0 && -att.first <= vertices_size ) {
                att.second->m_vertex = m_vertices[-att.first - 1];
            }
        }
    }
}

References particles_size(), and vertices_size().

◆ add_attributes() [2/3]

void HepMC3::GenEvent::add_attributes	(	const std::string &	name,
		const std::vector< std::shared_ptr< Attribute > > &	atts,
		const std::vector< int > &	ids )

Add multiple attributes to event.

This will overwrite existing attributes if attributes with the same names are present

Disallow empty strings

Definition at line 1314 of file marley_hepmc3.cc.

                                                                                                                                {
    if (name.length() == 0) return;
    size_t N = ids.size();
    if(!N) return;
    if ( N != atts.size()) return;
 
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    if (m_attributes.count(name) == 0) m_attributes[name] = std::map<int, std::shared_ptr<Attribute> >();
    auto& tmap = m_attributes[name];
    const int particles_size = int(m_particles.size());
    const int vertices_size = int(m_vertices.size());
    for (size_t i = 0; i < N; i++) {
        if (!atts[i])  continue;
        tmap[ids.at(i)] = atts[i];
        atts[i]->m_event = this;
        if ( ids.at(i) > 0 && ids.at(i) <= particles_size )
        { atts[i]->m_particle = m_particles[ids.at(i) - 1]; }
        else {
            if ( ids.at(i) < 0 && -ids.at(i) <= vertices_size ) {
                atts[i]->m_vertex = m_vertices[-ids.at(i) - 1];
            }
        }
    }
}

References particles_size(), and vertices_size().

◆ add_attributes() [3/3]

void HepMC3::GenEvent::add_attributes	(	const std::vector< std::string > &	names,
		const std::vector< std::shared_ptr< Attribute > > &	atts,
		const std::vector< int > &	ids )

Add multiple attributes to event.

This will overwrite existing attributes if attributes with the same names are present

Disallow empty strings

Definition at line 1282 of file marley_hepmc3.cc.

                                                                                                                                            {
    size_t N = names.size();
    if ( N == 0 ) return;
    if (N != atts.size()) return;
    if (N != ids.size()) return;
 
    std::vector<std::string> unames = names;
    vector<std::string>::iterator ip;
    ip = std::unique(unames.begin(), unames.end());
    unames.resize(std::distance(unames.begin(), ip));
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    for (const auto& name: unames) {
        if (m_attributes.count(name) == 0) m_attributes[name] = std::map<int, std::shared_ptr<Attribute> >();
    }
    const int particles_size = int(m_particles.size());
    const int vertices_size = int(m_vertices.size());
    for (size_t i = 0; i < N; i++) {
        if (names.at(i).length() == 0) continue;
        if (!atts[i])  continue;
        m_attributes[names.at(i)][ids.at(i)] = atts[i];
        atts[i]->m_event = this;
        if ( ids.at(i) > 0 && ids.at(i) <= particles_size )
        { atts[i]->m_particle = m_particles[ids.at(i) - 1]; }
        else {
            if ( ids.at(i) < 0 && -ids.at(i) <= vertices_size ) {
                atts[i]->m_vertex = m_vertices[-ids.at(i) - 1];
            }
        }
    }
}

References particles_size(), and vertices_size().

◆ add_beam_particle()

void HepMC3::GenEvent::add_beam_particle ( GenParticlePtr p1 )

Add particle to root vertex.

Definition at line 1226 of file marley_hepmc3.cc.

                                                  {
    if (!p1)
    {
        HEPMC3_WARNING_LEVEL(700,"Attempting to add an empty particle as beam particle. Ignored.")
        return;
    }
    if (p1->in_event() && p1->parent_event() != this)
    {
        HEPMC3_WARNING_LEVEL(700,"Attempting to add particle from another event. Ignored.")
        return;
    }
    if (p1->production_vertex())  p1->production_vertex()->remove_particle_out(p1);
    //Particle w/o production vertex is added to root vertex.
    add_particle(p1);
    p1->set_status(4);
}

References add_particle().

◆ add_particle()

void HepMC3::GenEvent::add_particle ( GenParticlePtr p )

Add particle.

Definition at line 516 of file marley_hepmc3.cc.

                                            {
    if ( !p || p->in_event() ) return;
 
    m_particles.emplace_back(p);
 
    p->m_event = this;
    p->m_id = particles().size();
 
    // Particles without production vertex are added to the root vertex
    if ( !p->production_vertex() ) {
        m_rootvertex->add_particle_out(p);
    }
}

References particles().

Referenced by add_beam_particle(), and add_vertex().

◆ add_tree()

void HepMC3::GenEvent::add_tree ( const std::vector< GenParticlePtr > & parts )

Add whole tree in topological order.

This function will find the beam particles (particles that have no production vertices or their production vertices have no particles) and will add the whole decay tree starting from these particles.

Note: Any particles on this list that do not belong to the tree will be ignored.

Definition at line 736 of file marley_hepmc3.cc.

                                                              {
    m_particles.reserve(m_particles.size() + parts.size());
    m_vertices.reserve(m_vertices.size() + parts.size());
    std::shared_ptr<IntAttribute> existing_hc = attribute<IntAttribute>("cycles");
    bool has_cycles = false;
    std::map<GenVertexPtr, int>  sortingv;
    std::vector<GenVertexPtr> noinv;
    if (existing_hc)     if (existing_hc->value() != 0) has_cycles = true;
    if (!existing_hc)
    {
        for (const GenParticlePtr& p: parts) {
            GenVertexPtr v = p->production_vertex();
            if (v) sortingv[v]=0;
            if ( !v || v->particles_in().empty()) {
                GenVertexPtr v2 = p->end_vertex();
                if (v2) {noinv.emplace_back(v2); sortingv[v2] = 0;}
            }
        }
        for (const GenVertexPtr& v: noinv) {
            std::map<ConstGenVertexPtr, int>  sorting_temp(sortingv.begin(), sortingv.end());
            has_cycles = (has_cycles || visit_children(sorting_temp, v));
        }
    }
    if (has_cycles) {
        add_attribute("cycles", std::make_shared<IntAttribute>(1));
        /* Commented out  as improvemnts allow us to do sorting in other way.
         for ( std::map<GenVertexPtr,int>::iterator vi=sortingv.begin();vi!=sortingv.end();++vi) if ( !vi->first->in_event() ) add_vertex(vi->first);
         return;
         */
    }
 
    std::deque<GenVertexPtr> sorting;
 
    // Find all starting vertices (end vertex of particles that have no production vertex)
    for (const auto& p: parts) {
        const GenVertexPtr &v = p->production_vertex();
        if ( !v || v->particles_in().empty() ) {
            const GenVertexPtr &v2 = p->end_vertex();
            if (v2) sorting.emplace_back(v2);
        }
    }
 
    HEPMC3_DEBUG_CODE_BLOCK(
        unsigned int sorting_loop_count = 0;
        unsigned int max_deque_size     = 0;
    )
 
    // Add vertices to the event in topological order
    while ( !sorting.empty() ) {
        HEPMC3_DEBUG_CODE_BLOCK(
            if ( sorting.size() > max_deque_size ) max_deque_size = sorting.size();
            ++sorting_loop_count;
        )
 
            GenVertexPtr &v = sorting.front();
 
        bool added = false;
 
        // Add all mothers to the front of the list
        for (const auto& p: v->particles_in() ) {
            GenVertexPtr v2 = p->production_vertex();
            if ( v2 && !v2->in_event() && find(sorting.begin(), sorting.end(), v2) == sorting.end() ) {
                sorting.push_front(v2);
                added = true;
            }
        }
 
        // If we have added at least one production vertex,
        // our vertex is not the first one on the list
        if ( added ) continue;
 
        // If vertex not yet added
        if ( !v->in_event() ) {
            add_vertex(v);
 
            // Add all end vertices to the end of the list
            for (const auto& p: v->particles_out()) {
                GenVertexPtr v2 = p->end_vertex();
                if ( v2 && !v2->in_event()&& find(sorting.begin(), sorting.end(), v2) == sorting.end() ) {
                    sorting.emplace_back(v2);
                }
            }
        }
 
        sorting.pop_front();
    }
 
    // LL: Make sure root vertex has index zero and is not written out
    if ( m_rootvertex->id() != 0 ) {
        const int vx = -1 - m_rootvertex->id();
        const int rootid = m_rootvertex->id();
        if ( vx >= 0 && vx < (int) m_vertices.size() && m_vertices[vx] == m_rootvertex ) {
            auto next = m_vertices.erase(m_vertices.begin() + vx);
            std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
            for (auto & vt1: m_attributes) {
                std::vector< std::pair< int, std::shared_ptr<Attribute> > > changed_attributes;
                for ( const auto& vt2 : vt1.second ) {
                    if ( vt2.first <= rootid ) {
                        changed_attributes.emplace_back(vt2);
                    }
                }
                for ( const auto& val : changed_attributes ) {
                    vt1.second.erase(val.first);
                    vt1.second[val.first == rootid? 0: val.first + 1] = val.second;
                }
            }
            m_rootvertex->m_id = 0;
            while ( next != m_vertices.end() ) {
                ++((*next++)->m_id);
            }
        } else {
            HEPMC3_WARNING_LEVEL(700,"GenEvent::add_tree Suspicious looking rootvertex found. Will try to cope.")
        }
    }
 
    HEPMC3_DEBUG_CODE_BLOCK(
        HEPMC3_DEBUG(6, "GenEvent - particles sorted: "
                     << this->particles().size() << ", max deque size: "
                     << max_deque_size << ", iterations: " << sorting_loop_count)
    )
}

References add_attribute(), add_vertex(), attribute(), and particles().

◆ add_vertex()

void HepMC3::GenEvent::add_vertex ( GenVertexPtr v )

Add vertex.

Definition at line 567 of file marley_hepmc3.cc.

                                        {
    if ( !v|| v->in_event() ) return;
    m_vertices.emplace_back(v);
 
    v->m_event = this;
    v->m_id = -(int)vertices().size();
 
    // Add all incoming and outgoing particles and restore their production/end vertices
    for (const auto& p: v->particles_in()) {
        if (!p->in_event()) add_particle(p);
        p->m_end_vertex = v->shared_from_this();
    }
 
    for (const auto& p: v->particles_out()) {
        if (!p->in_event()) add_particle(p);
        p->m_production_vertex = v;
    }
}

References add_particle(), and vertices().

Referenced by add_tree().

◆ attribute()

template<class T>

std::shared_ptr< T > HepMC3::GenEvent::attribute	(	const std::string &	name,
		const int &	id = 0 ) const

Get attribute of type T.

Definition at line 418 of file GenEvent.h.

                                                                                {
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    std::map< std::string, std::map<int, std::shared_ptr<Attribute> > >::iterator i1 = m_attributes.find(name);
    if ( i1 == m_attributes.end() ) {
        if ( id == 0 && run_info() ) {
            return run_info()->attribute<T>(name);
        }
        return std::shared_ptr<T>();
    }
 
    std::map<int, std::shared_ptr<Attribute> >::iterator i2 = i1->second.find(id);
    if (i2 == i1->second.end() ) return std::shared_ptr<T>();
 
    if (!i2->second->is_parsed() ) {
 
        std::shared_ptr<T> att = std::make_shared<T>();
        att->m_event = this;
 
        if ( id > 0 && id <= int(particles().size()) ) {
            att->m_particle = m_particles[id - 1];
        }
        if ( id < 0 && -id <= int(vertices().size()) ) {
            att->m_vertex = m_vertices[-id - 1];
        }
        if ( att->from_string(i2->second->unparsed_string()) &&
                att->init() ) {
            // update map with new pointer
            i2->second = att;
            return att;
        } else {
            return std::shared_ptr<T>();
        }
    }
    else return std::dynamic_pointer_cast<T>(i2->second);
}

References particles(), run_info(), and vertices().

Referenced by add_tree(), HepMC3::GenParticle::attribute(), HepMC3::GenVertex::attribute(), cross_section(), cross_section(), heavy_ion(), heavy_ion(), pdf_info(), pdf_info(), and HepMC3::GenVertex::position().

◆ attribute_as_string()

std::string HepMC3::GenEvent::attribute_as_string	(	const std::string &	name,
		const int &	id = 0 ) const

Get attribute of any type as string.

Definition at line 1244 of file marley_hepmc3.cc.

                                                                                  {
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    auto i1 = m_attributes.find(name);
    if ( i1 == m_attributes.end() ) {
        if ( id == 0 && run_info() ) {
            return run_info()->attribute_as_string(name);
        }
        return {};
    }
 
    auto i2 = i1->second.find(id);
    if (i2 == i1->second.end() ) return {};
 
    if ( !i2->second ) return {};
 
    std::string ret;
    i2->second->to_string(ret);
 
    return ret;
}

References run_info().

Referenced by HepMC3::GenParticle::attribute_as_string(), and HepMC3::GenVertex::attribute_as_string().

◆ attribute_names()

std::vector< std::string > HepMC3::GenEvent::attribute_names ( const int & id = 0 ) const

Get list of attribute names.

Definition at line 1081 of file marley_hepmc3.cc.

                                                                  {
    std::vector<std::string> results;
 
    for (const att_key_t& vt1: m_attributes) {
        if ( vt1.second.count(id) == 1 ) {
            results.emplace_back(vt1.first);
        }
    }
 
    return results;
}

Referenced by HepMC3::GenParticle::attribute_names(), HepMC3::GenVertex::attribute_names(), and HepMC3::Print::line().

◆ attributes()

std::map< std::string, std::map< int, std::shared_ptr< Attribute > > > HepMC3::GenEvent::attributes ( ) const

inline

Get a copy of the list of attributes.

Note: To avoid thread issues, this is returns a copy. Better solution may be needed.

Definition at line 268 of file GenEvent.h.

                                                                                   {
        std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
        return m_attributes;
    }

Referenced by HepMC3::Print::content(), write_data(), and HepMC3::WriterAscii::write_event().

◆ beams() [1/3]

const std::vector< GenParticlePtr > & HepMC3::GenEvent::beams ( )

Vector of beam particles.

Definition at line 902 of file marley_hepmc3.cc.

                                                  {
    return m_rootvertex->particles_out();
}

◆ beams() [2/3]

std::vector< ConstGenParticlePtr > HepMC3::GenEvent::beams ( ) const

Vector of beam particles.

Definition at line 897 of file marley_hepmc3.cc.

                                                     {
    return std::const_pointer_cast<const GenVertex>(m_rootvertex)->particles_out();
}

◆ beams() [3/3]

std::vector< ConstGenParticlePtr > HepMC3::GenEvent::beams ( const int status ) const

Vector of beam particles.

Definition at line 890 of file marley_hepmc3.cc.

                                                                     {
    if (!status) return std::const_pointer_cast<const GenVertex>(m_rootvertex)->particles_out();
    std::vector<ConstGenParticlePtr> ret;
    for (auto& p: m_rootvertex->particles_out()) if (p->status() == status) ret.emplace_back(p);
    return ret;
}

◆ boost()

bool HepMC3::GenEvent::boost ( const FourVector & delta )

Boost event using x,y,z components of delta as velocities.

Definition at line 1015 of file marley_hepmc3.cc.

{
    double deltalength2 = delta.length2();
    if (deltalength2 > 1.0)
    {
        HEPMC3_WARNING_LEVEL(400,"GenEvent::boost: wrong large boost vector. Will leave event as is.")
        return false;
    }
    if (std::abs(deltalength2-1.0) < std::numeric_limits<double>::epsilon())
    {
        HEPMC3_WARNING_LEVEL(400,"GenEvent::boost: too large gamma. Will leave event as is.")
        return false;
    }
    if (std::abs(deltalength2) < std::numeric_limits<double>::epsilon())
    {
        HEPMC3_WARNING_LEVEL(400,"GenEvent::boost: wrong small boost vector. Will leave event as is.")
        return true;
    }
    long double deltaX = delta.x();
    long double deltaY = delta.y();
    long double deltaZ = delta.z();
    long double deltalength = std::sqrt(deltalength2);
    long double gamma = 1.0/std::sqrt(1.0-deltalength2);
 
    for ( auto& p: m_particles)
    {
        const FourVector& mom = p->momentum();
 
        long double tempX = mom.x();
        long double tempY = mom.y();
        long double tempZ = mom.z();
        long double tempE = mom.e();
        long double nr = (deltaX*tempX+deltaY*tempY+deltaZ*tempZ)/deltalength;
        long double gfac = (gamma-1)*nr/deltalength-tempE*gamma;
        tempX+=(deltaX*gfac);
        tempY+=(deltaY*gfac);
        tempZ+=(deltaZ*gfac);
        tempE = gamma*(tempE-deltalength*nr);
        FourVector temp(tempX, tempY, tempZ, tempE);
        p->set_momentum(temp);
    }
 
    return true;
}

References HepMC3::FourVector::e(), HepMC3::FourVector::length2(), HepMC3::FourVector::x(), HepMC3::FourVector::y(), and HepMC3::FourVector::z().

◆ clear()

void HepMC3::GenEvent::clear ( )

Remove contents of this event.

Definition at line 1060 of file marley_hepmc3.cc.

                     {
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    m_event_number = 0;
    m_rootvertex = std::make_shared<GenVertex>();
    m_weights.clear();
    m_attributes.clear();
    m_particles.clear();
    m_vertices.clear();
}

Referenced by read_data(), and HepMC3::ReaderAscii::read_event().

◆ cross_section() [1/2]

GenCrossSectionPtr HepMC3::GenEvent::cross_section ( )

inline

Get cross-section information.

Definition at line 182 of file GenEvent.h.

182{ return attribute<GenCrossSection>("GenCrossSection"); }

References attribute().

◆ cross_section() [2/2]

ConstGenCrossSectionPtr HepMC3::GenEvent::cross_section ( ) const

inline

Get cross-section information (const version)

Definition at line 184 of file GenEvent.h.

184{ return attribute<GenCrossSection>("GenCrossSection"); }

References attribute().

◆ event_number()

int HepMC3::GenEvent::event_number ( ) const

inline

Get event number.

Definition at line 155 of file GenEvent.h.

155{ return m_event_number; }

Referenced by write_data(), and HepMC3::WriterAscii::write_event().

◆ event_pos()

const FourVector & HepMC3::GenEvent::event_pos ( ) const

Vertex representing the overall event position.

Definition at line 886 of file marley_hepmc3.cc.

                                            {
    return m_rootvertex->data().position;
}

Referenced by HepMC3::GenVertex::position(), shift_position_by(), shift_position_to(), write_data(), and HepMC3::WriterAscii::write_event().

◆ heavy_ion() [1/2]

GenHeavyIonPtr HepMC3::GenEvent::heavy_ion ( )

inline

Get heavy ion generator additional information.

Definition at line 168 of file GenEvent.h.

168{ return attribute<GenHeavyIon>("GenHeavyIon"); }

References attribute().

◆ heavy_ion() [2/2]

ConstGenHeavyIonPtr HepMC3::GenEvent::heavy_ion ( ) const

inline

Get heavy ion generator additional information (const version)

Definition at line 170 of file GenEvent.h.

170{ return attribute<GenHeavyIon>("GenHeavyIon"); }

References attribute().

◆ length_unit()

const Units::LengthUnit & HepMC3::GenEvent::length_unit ( ) const

inline

Get length unit.

Definition at line 162 of file GenEvent.h.

162{ return m_length_unit; }

Referenced by HepMC3::Print::listing(), write_data(), and HepMC3::WriterAscii::write_event().

◆ momentum_unit()

const Units::MomentumUnit & HepMC3::GenEvent::momentum_unit ( ) const

inline

Get momentum unit.

Definition at line 160 of file GenEvent.h.

160{ return m_momentum_unit; }

Referenced by HepMC3::Print::listing(), write_data(), and HepMC3::WriterAscii::write_event().

◆ operator=()

GenEvent & HepMC3::GenEvent::operator= ( const GenEvent & e )

Copy Assignment operator.

Definition at line 552 of file marley_hepmc3.cc.

                                               {
    if (this != &e)
    {
        std::lock(m_lock_attributes, e.m_lock_attributes);
        std::lock_guard<std::recursive_mutex> lhs_lk(m_lock_attributes, std::adopt_lock);
        std::lock_guard<std::recursive_mutex> rhs_lk(e.m_lock_attributes, std::adopt_lock);
        GenEventData tdata;
        e.write_data(tdata);
        read_data(tdata);
        m_run_info = e.m_run_info;
    }
    return *this;
}

References GenEvent(), read_data(), and write_data().

◆ particles() [1/2]

const std::vector< GenParticlePtr > & HepMC3::GenEvent::particles ( )

inline

Get/set list of particles (non-const)

Definition at line 80 of file GenEvent.h.

80{ return m_particles; }

◆ particles() [2/2]

const std::vector< ConstGenParticlePtr > & HepMC3::GenEvent::particles ( ) const

Get list of particles (const)

Definition at line 507 of file marley_hepmc3.cc.

                                                                {
    return *(reinterpret_cast<const std::vector<ConstGenParticlePtr>*>(&m_particles));
}

Referenced by add_attribute(), add_particle(), add_tree(), attribute(), HepMC3::Print::content(), HepMC3::ReaderAscii::read_event(), marley::ProjectileDirectionRotator::rotate_event(), write_data(), and HepMC3::WriterAscii::write_event().

◆ particles_empty()

bool HepMC3::GenEvent::particles_empty ( ) const

inline

Particles empty, HepMC2 compatibility.

Definition at line 93 of file GenEvent.h.

93{ return m_particles.empty(); }

◆ particles_size()

int HepMC3::GenEvent::particles_size ( ) const

inline

Particles size, HepMC2 compatibility.

Definition at line 91 of file GenEvent.h.

91{ return m_particles.size(); }

Referenced by add_attributes(), add_attributes(), and add_attributes().

◆ pdf_info() [1/2]

GenPdfInfoPtr HepMC3::GenEvent::pdf_info ( )

inline

Get PDF information.

Definition at line 175 of file GenEvent.h.

175{ return attribute<GenPdfInfo>("GenPdfInfo"); }

References attribute().

◆ pdf_info() [2/2]

ConstGenPdfInfoPtr HepMC3::GenEvent::pdf_info ( ) const

inline

Get PDF information (const version)

Definition at line 177 of file GenEvent.h.

177{ return attribute<GenPdfInfo>("GenPdfInfo"); }

References attribute().

◆ read_data()

void HepMC3::GenEvent::read_data ( const GenEventData & data )

Fill GenEvent based on GenEventData.

Disallow empty strings

Definition at line 1150 of file marley_hepmc3.cc.

                                                 {
    this->clear();
    this->set_event_number(data.event_number);
    //Note: set_units checks the current unit of event, i.e. applicable only for fully constructed event.
    m_momentum_unit = data.momentum_unit;
    m_length_unit = data.length_unit;
    this->shift_position_to(data.event_pos);
 
    // Fill weights
    this->weights() = data.weights;
    m_particles.reserve(data.particles.size());
    m_vertices.reserve(data.vertices.size());
 
    // Fill particle information
    for ( const GenParticleData &pd: data.particles ) {
        m_particles.emplace_back(std::make_shared<GenParticle>(pd));
        m_particles.back()->m_event = this;
        m_particles.back()->m_id    = m_particles.size();
    }
 
    // Fill vertex information
    for ( const GenVertexData &vd: data.vertices ) {
        m_vertices.emplace_back(std::make_shared<GenVertex>(vd));
        m_vertices.back()->m_event = this;
        m_vertices.back()->m_id    = -(int)m_vertices.size();
    }
 
    // Restore links
    for (unsigned int i = 0; i < data.links1.size(); ++i) {
        const int id1 = data.links1[i];
        const int id2 = data.links2[i];
        /* @note:
        The  meaningfull combinations for (id1,id2) are:
        (+-)  --  particle has end vertex
        (-+)  --  particle  has production vertex
        */
        if ((id1 < 0 && id2 <0) || (id1 > 0 && id2 > 0))   {
            HEPMC3_WARNING_LEVEL(600,"GenEvent::read_data: wrong link: " << id1 << " " << id2);
            continue;
        }
 
        if ( id1 > 0 ) { m_vertices[ (-id2)-1 ]->add_particle_in ( m_particles[ id1-1 ] ); continue; }
        if ( id1 < 0 ) { m_vertices[ (-id1)-1 ]->add_particle_out( m_particles[ id2-1 ] );   continue; }
    }
    for (auto& p:  m_particles) if (!p->production_vertex()) m_rootvertex->add_particle_out(p);
 
    // Read attributes
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    for (unsigned int i = 0; i < data.attribute_id.size(); ++i) {
        const std::string name = data.attribute_name[i];
        if (name.length() == 0) continue;
        const int id = data.attribute_id[i];
        if (m_attributes.count(name) == 0) m_attributes[name] = std::map<int, std::shared_ptr<Attribute> >();
        auto att = std::make_shared<StringAttribute>(data.attribute_string[i]);
        att->m_event = this;
        if ( id > 0 && id <= int(m_particles.size()) ) {
            att->m_particle = m_particles[id - 1];
        }
        if ( id < 0 && -id <= int(m_vertices.size()) ) {
            att->m_vertex = m_vertices[-id - 1];
        }
        m_attributes[name][id] = att;
    }
}

References HepMC3::GenEventData::attribute_id, HepMC3::GenEventData::attribute_name, HepMC3::GenEventData::attribute_string, clear(), HepMC3::GenEventData::event_number, HepMC3::GenEventData::event_pos, HepMC3::GenEventData::length_unit, HepMC3::GenEventData::links1, HepMC3::GenEventData::links2, HepMC3::GenEventData::momentum_unit, HepMC3::GenEventData::particles, set_event_number(), shift_position_to(), HepMC3::GenEventData::vertices, weights(), and HepMC3::GenEventData::weights.

Referenced by GenEvent(), marley::EventFileReader::next_event(), operator=(), and HepMC3::ReaderAscii::read_event().

◆ reflect()

bool HepMC3::GenEvent::reflect ( const int axis )

Change sign of axis.

Definition at line 983 of file marley_hepmc3.cc.

{
    if ( axis > 3 || axis < 0 )
    {
        HEPMC3_WARNING_LEVEL(400,"GenEvent::reflect: wrong axis")
        return false;
    }
    switch (axis)
    {
    case 0:
        for ( auto& p: m_particles) { FourVector temp = p->momentum(); temp.setX(-p->momentum().x()); p->set_momentum(temp);}
        for ( auto& v: m_vertices)  { FourVector temp = v->position(); temp.setX(-v->position().x()); v->set_position(temp);}
        break;
    case 1:
        for ( auto& p: m_particles) { FourVector temp = p->momentum(); temp.setY(-p->momentum().y()); p->set_momentum(temp);}
        for ( auto& v: m_vertices)  { FourVector temp = v->position(); temp.setY(-v->position().y()); v->set_position(temp);}
        break;
    case 2:
        for ( auto& p: m_particles) { FourVector temp = p->momentum(); temp.setZ(-p->momentum().z()); p->set_momentum(temp);}
        for ( auto& v: m_vertices)  { FourVector temp = v->position(); temp.setZ(-v->position().z()); v->set_position(temp);}
        break;
    case 3:
        for ( auto& p: m_particles) { FourVector temp = p->momentum(); temp.setT(-p->momentum().e()); p->set_momentum(temp);}
        for ( auto& v: m_vertices)  { FourVector temp = v->position(); temp.setT(-v->position().t()); v->set_position(temp);}
        break;
    default:
        return false;
    }
 
    return true;
}

References HepMC3::FourVector::setT(), HepMC3::FourVector::setX(), HepMC3::FourVector::setY(), and HepMC3::FourVector::setZ().

◆ remove_attribute()

void HepMC3::GenEvent::remove_attribute	(	const std::string &	name,
		const int &	id = 0 )

Remove attribute.

Definition at line 1070 of file marley_hepmc3.cc.

                                                                     {
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    auto i1 = m_attributes.find(name);
    if ( i1 == m_attributes.end() ) return;
 
    auto i2 = i1->second.find(id);
    if ( i2 == i1->second.end() ) return;
 
    i1->second.erase(i2);
}

Referenced by HepMC3::GenParticle::remove_attribute(), and HepMC3::GenVertex::remove_attribute().

◆ remove_particle()

void HepMC3::GenEvent::remove_particle ( GenParticlePtr p )

Remove particle from the event.

This function will remove whole sub-tree starting from this particle if it is the only incoming particle of this vertex. It will also production vertex of this particle if this vertex has no more outgoing particles

Definition at line 587 of file marley_hepmc3.cc.

                                               {
    if ( !p || p->parent_event() != this ) return;
 
    HEPMC3_DEBUG(30, "GenEvent::remove_particle - called with particle: " << p->id());
    GenVertexPtr end_vtx = p->end_vertex();
    if ( end_vtx ) {
        end_vtx->remove_particle_in(p);
 
        // If that was the only incoming particle, remove vertex from the event
        if ( end_vtx->particles_in().empty() )  remove_vertex(end_vtx);
    }
 
    GenVertexPtr prod_vtx = p->production_vertex();
    if ( prod_vtx ) {
        prod_vtx->remove_particle_out(p);
 
        // If that was the only outgoing particle, remove vertex from the event
        if ( prod_vtx->particles_out().empty() ) remove_vertex(prod_vtx);
    }
 
    HEPMC3_DEBUG(30, "GenEvent::remove_particle - erasing particle: " << p->id())
 
    int idx = p->id();
    auto it = m_particles.erase(m_particles.begin() + idx-1);
 
    // Remove attributes of this particle
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    for (att_key_t& vt1: m_attributes) {
        auto vt2 = vt1.second.find(idx);
        if (vt2 == vt1.second.end()) continue;
        vt1.second.erase(vt2);
    }
 
    //
    // Reassign id of attributes with id above this one
    //
    std::vector< std::pair< int, std::shared_ptr<Attribute> > > changed_attributes;
 
    for (att_key_t& vt1: m_attributes) {
        changed_attributes.clear();
 
        for (auto vt2 = vt1.second.begin(); vt2 != vt1.second.end(); ++vt2) {
            if ( (*vt2).first > p->id() ) {
                changed_attributes.emplace_back(*vt2);
            }
        }
 
        std::sort(changed_attributes.begin(),changed_attributes.end(), [](const std::pair< int, std::shared_ptr<Attribute> > &a, const std::pair< int, std::shared_ptr<Attribute> > &b) { return a.first < b.first; });
        for ( const auto& val: changed_attributes ) {
            vt1.second.erase(val.first);
            vt1.second[val.first-1] = val.second;
        }
    }
    // Reassign id of particles with id above this one
    for (; it != m_particles.end(); ++it) {
        --((*it)->m_id);
    }
 
    // Finally - set parent event and id of this particle to 0
    p->m_event = nullptr;
    p->m_id    = 0;
}

References remove_vertex().

Referenced by remove_particles(), and remove_vertex().

◆ remove_particles()

void HepMC3::GenEvent::remove_particles ( std::vector< GenParticlePtr > v )

Remove a set of particles.

This function follows rules of GenEvent::remove_particle to remove a list of particles from the event.

Definition at line 650 of file marley_hepmc3.cc.

                                                           {
    std::sort(v.begin(), v.end(), [](const GenParticlePtr& p1, const GenParticlePtr& p2) { return p1->id() > p2->id();});
 
    for (auto p = v.begin(); p != v.end(); ++p) {
        remove_particle(*p);
    }
}

References remove_particle().

◆ remove_vertex()

void HepMC3::GenEvent::remove_vertex ( GenVertexPtr v )

Remove vertex from the event.

This will remove all sub-trees of all outgoing particles of this vertex

Definition at line 658 of file marley_hepmc3.cc.

                                           {
    if ( !v || v->parent_event() != this ) return;
 
    HEPMC3_DEBUG(30, "GenEvent::remove_vertex   - called with vertex:  " << v->id());
    std::shared_ptr<GenVertex> null_vtx;
 
    for (const auto& p: v->particles_in()) {
        p->m_end_vertex = std::weak_ptr<GenVertex>();
    }
 
    for (const auto& p: v->particles_out()) {
        p->m_production_vertex = std::weak_ptr<GenVertex>();
 
        // recursive delete rest of the tree
        remove_particle(p);
    }
 
    // Erase this vertex from vertices list
    HEPMC3_DEBUG(30, "GenEvent::remove_vertex   - erasing vertex: " << v->id())
 
    int idx = -v->id();
    auto it = m_vertices.erase(m_vertices.begin() + idx-1);
    // Remove attributes of this vertex
    std::lock_guard<std::recursive_mutex> lock(m_lock_attributes);
    for (att_key_t& vt1: m_attributes) {
        auto vt2 = vt1.second.find(-idx);
        if (vt2 == vt1.second.end()) continue;
        vt1.second.erase(vt2);
    }
 
    //
    // Reassign id of attributes with id below this one
    //
 
    std::vector< std::pair< int, std::shared_ptr<Attribute> > > changed_attributes;
 
    for ( att_key_t& vt1: m_attributes ) {
        changed_attributes.clear();
 
        for (auto vt2 = vt1.second.begin(); vt2 != vt1.second.end(); ++vt2) {
            if ( (*vt2).first < v->id() ) {
                changed_attributes.emplace_back(*vt2);
            }
        }
 
        std::reverse(changed_attributes.begin(),changed_attributes.end());
        std::sort(changed_attributes.begin(),changed_attributes.end(),[](const std::pair< int, std::shared_ptr<Attribute> > &a, const std::pair< int, std::shared_ptr<Attribute> > &b) { return a.first > b.first; });
        for ( const auto& val: changed_attributes ) {
            vt1.second.erase(val.first);
            vt1.second[val.first+1] = val.second;
        }
    }
 
    // Reassign id of particles with id above this one
    for (; it != m_vertices.end(); ++it) {
        ++((*it)->m_id);
    }
 
    // Finally - set parent event and id of this vertex to 0
    v->m_event = nullptr;
    v->m_id    = 0;
}

References remove_particle().

Referenced by remove_particle().

◆ reserve()

void HepMC3::GenEvent::reserve	(	const size_t &	parts,
		const size_t &	verts = 0 )

Reserve memory for particles and vertices.

Helps optimize event creation when size of the event is known beforehand

Definition at line 859 of file marley_hepmc3.cc.

                                                               {
    m_particles.reserve(parts);
    m_vertices.reserve(verts);
}

◆ rotate()

bool HepMC3::GenEvent::rotate ( const FourVector & delta )

Rotate event using x,y,z components of delta as rotation angles.

Definition at line 917 of file marley_hepmc3.cc.

{
    long double cosa = std::cos(delta.x());
    long double sina = std::sin(delta.x());
    long double cosb = std::cos(delta.y());
    long double sinb = std::sin(delta.y());
    long double cosg = std::cos(delta.z());
    long double sing = std::sin(delta.z());
 
    for ( auto& p: m_particles)
    {
        const FourVector& mom = p->momentum();
        long double tempX = mom.x();
        long double tempY = mom.y();
        long double tempZ = mom.z();
 
        long double tempY_ = cosa*tempY+sina*tempZ;
        long double tempZ_ = -sina*tempY+cosa*tempZ;
        tempY = tempY_;
        tempZ = tempZ_;
 
        long double tempX_ = cosb*tempX-sinb*tempZ;
        tempZ_ = sinb*tempX+cosb*tempZ;
        tempX = tempX_;
        tempZ = tempZ_;
 
        tempX_ = cosg*tempX+sing*tempY;
        tempY_ = -sing*tempX+cosg*tempY;
        tempX = tempX_;
        tempY = tempY_;
 
        FourVector temp(tempX, tempY, tempZ, mom.e());
        p->set_momentum(temp);
    }
    for (auto& v: m_vertices)
    {
        const FourVector& pos = v->position();
        if (pos.is_zero()) continue;
 
        long double tempX = pos.x();
        long double tempY = pos.y();
        long double tempZ = pos.z();
 
        long double tempY_ = cosa*tempY+sina*tempZ;
        long double tempZ_ = -sina*tempY+cosa*tempZ;
        tempY = tempY_;
        tempZ = tempZ_;
 
        long double tempX_ = cosb*tempX-sinb*tempZ;
        tempZ_ = sinb*tempX+cosb*tempZ;
        tempX = tempX_;
        tempZ = tempZ_;
 
        tempX_ = cosg*tempX+sing*tempY;
        tempY_ = -sing*tempX+cosg*tempY;
        tempX = tempX_;
        tempY = tempY_;
 
        FourVector temp(tempX, tempY, tempZ, pos.t());
        v->set_position(temp);
    }
 
 
    return true;
}

References HepMC3::FourVector::e(), HepMC3::FourVector::is_zero(), HepMC3::FourVector::t(), HepMC3::FourVector::x(), HepMC3::FourVector::y(), and HepMC3::FourVector::z().

◆ run_info()

std::shared_ptr< GenRunInfo > HepMC3::GenEvent::run_info ( ) const

inline

Get a pointer to the the GenRunInfo object.

Definition at line 144 of file GenEvent.h.

                                               {
        return m_run_info;
    }

Referenced by attribute(), attribute_as_string(), marley::CommandHandler::cmd_reweight(), marley::EventFileReader::deduce_file_format(), weight(), weight(), weight_names(), and HepMC3::WriterAscii::write_event().

◆ set_beam_particles()

void HepMC3::GenEvent::set_beam_particles	(	GenParticlePtr	p1,
		GenParticlePtr	p2 )

Set incoming beam particles.

Deprecated: Backward compatibility

Definition at line 1221 of file marley_hepmc3.cc.

                                                                      {
    m_rootvertex->add_particle_out(p1);
    m_rootvertex->add_particle_out(p2);
}

◆ set_cross_section()

void HepMC3::GenEvent::set_cross_section ( GenCrossSectionPtr cs )

inline

Set cross-section information.

Definition at line 186 of file GenEvent.h.

186{ add_attribute("GenCrossSection",cs); }

References add_attribute().

◆ set_event_number()

void HepMC3::GenEvent::set_event_number ( const int & num )

inline

Set event number.

Definition at line 157 of file GenEvent.h.

157{ m_event_number = num; }

Referenced by read_data().

◆ set_heavy_ion()

void HepMC3::GenEvent::set_heavy_ion ( GenHeavyIonPtr hi )

inline

Set heavy ion generator additional information.

Definition at line 172 of file GenEvent.h.

172{ add_attribute("GenHeavyIon",hi); }

References add_attribute().

◆ set_pdf_info()

void HepMC3::GenEvent::set_pdf_info ( GenPdfInfoPtr pi )

inline

Set PDF information.

Definition at line 179 of file GenEvent.h.

179{ add_attribute("GenPdfInfo",pi); }

References add_attribute().

◆ set_run_info()

void HepMC3::GenEvent::set_run_info ( std::shared_ptr< GenRunInfo > run )

inline

Set the GenRunInfo object by smart pointer.

Definition at line 148 of file GenEvent.h.

                                                     {
        m_run_info = run;
        if ( run && !run->weight_names().empty() )
            m_weights.resize(run->weight_names().size(), 1.0);
    }

Referenced by marley::CommandHandler::cmd_convert(), marley::CommandHandler::cmd_reweight(), marley::EventFileReader::next_event(), and HepMC3::ReaderAscii::read_event().

◆ set_units()

void HepMC3::GenEvent::set_units	(	Units::MomentumUnit	new_momentum_unit,
		Units::LengthUnit	new_length_unit )

Change event units Converts event from current units to new ones.

Definition at line 865 of file marley_hepmc3.cc.

                                                                                             {
    if ( new_momentum_unit != m_momentum_unit ) {
        for ( GenParticlePtr& p: m_particles ) {
            Units::convert(p->m_data.momentum, m_momentum_unit, new_momentum_unit);
            Units::convert(p->m_data.mass, m_momentum_unit, new_momentum_unit);
        }
 
        m_momentum_unit = new_momentum_unit;
    }
 
    if ( new_length_unit != m_length_unit ) {
        for (GenVertexPtr& v: m_vertices) {
            FourVector &fv = v->m_data.position;
            if ( !fv.is_zero() ) Units::convert( fv, m_length_unit, new_length_unit );
        }
 
        m_length_unit = new_length_unit;
    }
}

References HepMC3::Units::convert(), and HepMC3::FourVector::is_zero().

◆ shift_position_by()

void HepMC3::GenEvent::shift_position_by ( const FourVector & delta )

Shift position of all vertices in the event by delta.

Definition at line 906 of file marley_hepmc3.cc.

                                                         {
    m_rootvertex->set_position(event_pos() + delta);
 
    // Offset all vertices
    for ( GenVertexPtr& v: m_vertices ) {
        if ( v->has_set_position() ) {
            v->set_position(v->position() + delta);
        }
    }
}

References event_pos().

Referenced by shift_position_to().

◆ shift_position_to()

void HepMC3::GenEvent::shift_position_to ( const FourVector & newpos )

inline

Shift position of all vertices in the event to op.

Definition at line 211 of file GenEvent.h.

                                                        {
        const FourVector delta = newpos - event_pos();
        shift_position_by(delta);
    }

References event_pos(), and shift_position_by().

Referenced by read_data().

◆ vertices() [1/2]

const std::vector< GenVertexPtr > & HepMC3::GenEvent::vertices ( )

inline

Get/set list of vertices (non-const)

Definition at line 82 of file GenEvent.h.

82{ return m_vertices; }

◆ vertices() [2/2]

const std::vector< ConstGenVertexPtr > & HepMC3::GenEvent::vertices ( ) const

Get list of vertices (const)

Definition at line 511 of file marley_hepmc3.cc.

                                                             {
    return *(reinterpret_cast<const std::vector<ConstGenVertexPtr>*>(&m_vertices));
}

Referenced by add_attribute(), add_vertex(), attribute(), HepMC3::Print::content(), HepMC3::Print::listing(), HepMC3::ReaderAscii::read_event(), write_data(), and HepMC3::WriterAscii::write_event().

◆ vertices_empty()

bool HepMC3::GenEvent::vertices_empty ( ) const

inline

Vertices empty, HepMC2 compatibility.

Definition at line 97 of file GenEvent.h.

97{ return m_vertices.empty(); }

◆ vertices_size()

int HepMC3::GenEvent::vertices_size ( ) const

inline

Vertices size, HepMC2 compatibility.

Definition at line 95 of file GenEvent.h.

95{ return m_vertices.size(); }

Referenced by add_attributes(), add_attributes(), and add_attributes().

◆ weight() [1/3]

double & HepMC3::GenEvent::weight ( const std::string & name )

inline

Get event weight accessed by weight name

Note: Requires there to be an attached GenRunInfo, otherwise will throw an exception; It's the user's responsibility to ensure that the given name exists!

Definition at line 121 of file GenEvent.h.

                                          {
        if (!run_info()) throw std::runtime_error("GenEvent::weight(const std::string&): named access to event weights requires the event to have a GenRunInfo");
        int pos = run_info()->weight_index(name);
        if ( pos < 0 ) throw std::runtime_error("GenEvent::weight(const std::string&): no weight with given name in this run");
        if ( pos >= int(m_weights.size())) throw std::runtime_error("GenEvent::weight(const std::string&): weight index outside of range");
        return m_weights[pos];
    }

References run_info().

◆ weight() [2/3]

double HepMC3::GenEvent::weight ( const std::string & name ) const

inline

Get event weight accessed by weight name

Note: Requires there to be an attached GenRunInfo, otherwise will throw an exception; It's the user's responsibility to ensure that the given name exists!

Definition at line 114 of file GenEvent.h.

                                               {
        if (!run_info()) throw std::runtime_error("GenEvent::weight(const std::string&): named access to event weights requires the event to have a GenRunInfo");
        return weight(run_info()->weight_index(name));
    }

References run_info(), and weight().

◆ weight() [3/3]

double HepMC3::GenEvent::weight ( const unsigned long & index = 0 ) const

inline

Get event weight accessed by index (or the canonical/first one if there is no argument)

Note: It's the user's responsibility to ensure that the given index exists!

Definition at line 110 of file GenEvent.h.

110{ if ( index < weights().size() ) return weights().at(index); else throw std::runtime_error("GenEvent::weight(const unsigned long&): weight index outside of range"); return 0.0; }

References weights().

Referenced by weight().

◆ weight_names()

const std::vector< std::string > & HepMC3::GenEvent::weight_names ( ) const

inline

Get event weight names, if there are some

Note: Requires there to be an attached GenRunInfo with registered weight names, otherwise will throw an exception

Definition at line 130 of file GenEvent.h.

                                                     {
        if (!run_info()) throw std::runtime_error("GenEvent::weight_names(): access to event weight names requires the event to have a GenRunInfo");
        const std::vector<std::string>& weightnames = run_info()->weight_names();
        if (weightnames.empty()) throw std::runtime_error("GenEvent::weight_names(): no event weight names are registered for this run");
        return weightnames;
    }

References run_info().

◆ weights() [1/2]

std::vector< double > & HepMC3::GenEvent::weights ( )

inline

Get event weights as a vector (non-const)

Definition at line 107 of file GenEvent.h.

107{ return m_weights; }

◆ weights() [2/2]

const std::vector< double > & HepMC3::GenEvent::weights ( ) const

inline

Get event weight values as a vector.

Definition at line 105 of file GenEvent.h.

105{ return m_weights; }

Referenced by marley::CommandHandler::cmd_reweight(), HepMC3::Print::content(), read_data(), weight(), write_data(), and HepMC3::WriterAscii::write_event().

◆ write_data()

void HepMC3::GenEvent::write_data ( GenEventData & data ) const

Fill GenEventData object.

Definition at line 1093 of file marley_hepmc3.cc.

                                                  {
    // Reserve memory for containers
    data.particles.reserve(this->particles().size());
    data.vertices.reserve(this->vertices().size());
    data.links1.reserve(this->particles().size()*2);
    data.links2.reserve(this->particles().size()*2);
    data.attribute_id.reserve(m_attributes.size());
    data.attribute_name.reserve(m_attributes.size());
    data.attribute_string.reserve(m_attributes.size());
 
    // Fill event data
    data.event_number  = this->event_number();
    data.momentum_unit = this->momentum_unit();
    data.length_unit   = this->length_unit();
    data.event_pos     = this->event_pos();
 
    // Fill containers
    data.weights = this->weights();
 
    for (const ConstGenParticlePtr& p: this->particles()) {
        data.particles.emplace_back(p->data());
    }
 
    for (const ConstGenVertexPtr& v: this->vertices()) {
        data.vertices.emplace_back(v->data());
        int v_id = v->id();
 
        for (const ConstGenParticlePtr& p: v->particles_in()) {
            data.links1.emplace_back(p->id());
            data.links2.emplace_back(v_id);
        }
 
        for (const ConstGenParticlePtr& p: v->particles_out()) {
            data.links1.emplace_back(v_id);
            data.links2.emplace_back(p->id());
        }
    }
 
    for (const att_key_t& vt1: this->attributes()) {
        for (const att_val_t& vt2: vt1.second) {
            std::string st;
 
            bool status = vt2.second->to_string(st);
 
            if ( !status ) {
                HEPMC3_WARNING_LEVEL(300,"GenEvent::write_data: problem serializing attribute: " << vt1.first)
            }
            else {
                data.attribute_id.emplace_back(vt2.first);
                data.attribute_name.emplace_back(vt1.first);
                data.attribute_string.emplace_back(st);
            }
        }
    }
}

References HepMC3::GenEventData::attribute_id, HepMC3::GenEventData::attribute_name, HepMC3::GenEventData::attribute_string, attributes(), event_number(), HepMC3::GenEventData::event_number, event_pos(), HepMC3::GenEventData::event_pos, length_unit(), HepMC3::GenEventData::length_unit, HepMC3::GenEventData::links1, HepMC3::GenEventData::links2, momentum_unit(), HepMC3::GenEventData::momentum_unit, particles(), HepMC3::GenEventData::particles, vertices(), HepMC3::GenEventData::vertices, weights(), and HepMC3::GenEventData::weights.

Referenced by GenEvent(), and operator=().

The documentation for this class was generated from the following files:

/home/sjg/Desktop/marley/include/builtin/HepMC3/GenEvent.h
/home/sjg/Desktop/marley/src/marley_hepmc3.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ GenEvent() [1/3]

◆ GenEvent() [2/3]

◆ GenEvent() [3/3]

◆ ~GenEvent()

Member Function Documentation

◆ add_attribute()

◆ add_attributes() [1/3]

◆ add_attributes() [2/3]

◆ add_attributes() [3/3]

◆ add_beam_particle()

◆ add_particle()

◆ add_tree()

◆ add_vertex()

◆ attribute()

◆ attribute_as_string()

◆ attribute_names()

◆ attributes()

◆ beams() [1/3]

◆ beams() [2/3]

◆ beams() [3/3]

◆ boost()

◆ clear()

◆ cross_section() [1/2]

◆ cross_section() [2/2]

◆ event_number()

◆ event_pos()

◆ heavy_ion() [1/2]

◆ heavy_ion() [2/2]

◆ length_unit()

◆ momentum_unit()

◆ operator=()

◆ particles() [1/2]

◆ particles() [2/2]

◆ particles_empty()

◆ particles_size()

◆ pdf_info() [1/2]

◆ pdf_info() [2/2]

◆ read_data()

◆ reflect()

◆ remove_attribute()

◆ remove_particle()

◆ remove_particles()

◆ remove_vertex()

◆ reserve()

◆ rotate()

◆ run_info()

◆ set_beam_particles()

◆ set_cross_section()

◆ set_event_number()

◆ set_heavy_ion()

◆ set_pdf_info()

◆ set_run_info()

◆ set_units()

◆ shift_position_by()

◆ shift_position_to()

◆ vertices() [1/2]

◆ vertices() [2/2]

◆ vertices_empty()

◆ vertices_size()

◆ weight() [1/3]

◆ weight() [2/3]

◆ weight() [3/3]

◆ weight_names()

◆ weights() [1/2]

◆ weights() [2/2]

◆ write_data()