MC::Loops< Evt, Prt, Vtx > Class Template Reference

#include <Loops.h>

Collaboration diagram for MC::Loops< Evt, Prt, Vtx >:

Public Member Functions
	Loops ()
	Loops (const Evt *evt)
bool	isLoop (const Prt &p) const
bool	isLoop (const Vtx &v) const
const std::vector< Prt > &	loop_particles () const
const std::vector< Vtx > &	loop_vertices () const
int	findLoops (const Evt *evt, bool force)

Private Attributes
const Evt *	m_evt = nullptr
std::vector< Prt >	m_loop_particles
std::vector< Vtx >	m_loop_vertices

Detailed Description

template<class Evt, class Prt, class Vtx>
class MC::Loops< Evt, Prt, Vtx >

Definition at line 13 of file Loops.h.

Constructor & Destructor Documentation

Loops() [1/2]

template<class Evt , class Prt , class Vtx >

MC::Loops< Evt, Prt, Vtx >::Loops ( )

inline

Definition at line 15 of file Loops.h.

{}

Loops() [2/2]

template<class Evt , class Prt , class Vtx >

MC::Loops< Evt, Prt, Vtx >::Loops ( const Evt *  evt )

inline

Definition at line 16 of file Loops.h.

                          {
        findLoops(evt,true);
    }

Member Function Documentation

findLoops()

template<class Evt , class Prt , class Vtx >

int MC::Loops< Evt, Prt, Vtx >::findLoops ( const Evt *  evt, bool  force  )

inline

Definition at line 31 of file Loops.h.

                                              {
        if (!evt) return -1;
        if (evt == m_evt &&  !force) return 0;
        m_evt = evt;
        m_loop_particles.clear();
        m_loop_vertices.clear();
        std::map<Prt, int> incycle;
        for (const auto & p: *m_evt) if (!p->end_vertex()||!p->production_vertex()) incycle[p] = -1;
            else incycle[p] = 0;
        size_t minincycle = m_evt->particles_size();
        for (;;) {
            size_t unknown = 0;
            for (const auto & p: *m_evt) {
                if (incycle[p] != 0) continue;
                unknown++;
                auto ev = p->end_vertex();
                if (ev) {
                    bool goodo = true;
                    for (auto& po: *ev) goodo = goodo && (incycle[po] == -1);
                    if (goodo) incycle[p] = -1;
                }
                auto pv = p->production_vertex();
                if (pv) {
                    bool goodi = true;
#ifdef HEPMC3
                    for (auto& pi: ev->particles_in()) goodi = goodi && (incycle[pi] == -1);
#else
                    for (auto ip = ev->particles_in_const_begin();
                         ip != ev->particles_in_const_end();
                         ++ip)
                    {
                      goodi = goodi && (incycle[*ip] == -1);
                    }
#endif
                    if (goodi) incycle[p] = -1;
                }
            }
            if (minincycle == unknown) break;
            minincycle = std::min(minincycle, unknown);
        }
        for (const auto & p: *m_evt) if (incycle[p] == 0) incycle[p] = 1;
 
        for (const auto & p: *m_evt) if (incycle[p] == 1) m_loop_particles.push_back(p);
#ifdef HEPMC3
        for (auto & v: m_evt->vertices()) {
#else
        for (auto iv = m_evt->vertices_begin(); iv != m_evt->vertices_end(); ++iv) {
            auto v = *iv;
#endif
            bool push = false;
#ifdef HEPMC3
            for ( auto& pin: v->particles_in()) if (incycle[pin] == 1) {
#else
            for ( auto ipin = v->particles_in_const_begin();
                  ipin != v->particles_in_const_end();
                  ++ipin)
              if (incycle[*ipin] == 1) {
#endif
                    push = true;
                    break;
                }
            if(!push) {
                for ( const auto& pou: *v) {
                    if (incycle[pou] == 1) {
                        push = true;
                        break;
                    }
                }
            }
            if (push)  m_loop_vertices.push_back(v);
        }
        return 0;
    }

isLoop() [1/2]

template<class Evt , class Prt , class Vtx >

bool MC::Loops< Evt, Prt, Vtx >::isLoop ( const Prt &  p ) const

inline

Definition at line 19 of file Loops.h.

                                    {
        return std::find(m_loop_particles.begin(), m_loop_particles.end(), p) != m_loop_particles.end();
    }

isLoop() [2/2]

template<class Evt , class Prt , class Vtx >

bool MC::Loops< Evt, Prt, Vtx >::isLoop ( const Vtx &  v ) const

inline

Definition at line 22 of file Loops.h.

                                    {
        return std::find(m_loop_vertices.begin(), m_loop_vertices.end(), v) != m_loop_vertices.end();
    }

loop_particles()

template<class Evt , class Prt , class Vtx >

const std::vector<Prt>& MC::Loops< Evt, Prt, Vtx >::loop_particles ( ) const

inline

Definition at line 25 of file Loops.h.

                                                 {
        return m_loop_particles;
    }

loop_vertices()

template<class Evt , class Prt , class Vtx >

const std::vector<Vtx>& MC::Loops< Evt, Prt, Vtx >::loop_vertices ( ) const

inline

Definition at line 28 of file Loops.h.

                                                {
        return m_loop_vertices;
    }

Member Data Documentation

m_evt

template<class Evt , class Prt , class Vtx >

const Evt* MC::Loops< Evt, Prt, Vtx >::m_evt = nullptr

private

Definition at line 106 of file Loops.h.

m_loop_particles

template<class Evt , class Prt , class Vtx >

std::vector<Prt> MC::Loops< Evt, Prt, Vtx >::m_loop_particles

private

Definition at line 107 of file Loops.h.

m_loop_vertices

template<class Evt , class Prt , class Vtx >

std::vector<Vtx> MC::Loops< Evt, Prt, Vtx >::m_loop_vertices

private

Definition at line 108 of file Loops.h.

---

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

• Loops.h