MCParticleGraph::ParticleSorter Class Reference

Class to go over all the particles in the Graph an sort them in a sensible way. More...

Collaboration diagram for MCParticleGraph::ParticleSorter:

Public Member Functions
	ParticleSorter (MemoryPool< MCParticleGraph::GraphParticle > &particles, TClonesArray *plist, bool setVertex, bool setTime)
	ParticleSorter constructor.
void	setStartIndex (int index)
	Set the starting index for the particle graph.
template<class Graph>
void	sort (Graph &g)
	Sort the particles and generate MCParticle list.
template<class Vertex, class Graph>
void	finish_vertex (Vertex v, Graph &g)
	Go through the daughters of the vertex.
template<class Vertex, class Graph>
void	find_daughters (Vertex v, Graph &g, MCParticleGraph::GraphParticle &mother)
	Find the daughters of the given vertex.
void	setVertexTime (MCParticleGraph::GraphParticle &m, const MCParticleGraph::GraphParticle &d)
	Set the vertex and time information of the mother particle.

Protected Attributes
int	m_index
	The latest index given to a particle.
MemoryPool< MCParticleGraph::GraphParticle > &	m_particles
	Reference to the list of particles which should be sorted.
TClonesArray *	m_plist
	The final array of sorted particles which is stored in the DataStore.
bool	m_setVertex
	True if the vertex information should be saved.
bool	m_setTime
	True if the production time information should be saved.
vector< bool >	m_seen
	Vector of the particles that were already seen while sorting the graph.
std::queue< unsigned int >	m_vqueue
	The list of the vertices that will be visited.

Detailed Description

Class to go over all the particles in the Graph an sort them in a sensible way.

All particles will be assigned an index, starting at 1. If an particle has its ignore flag set, then it will get assigned the index of its last, unignored parent. The particles will be sorted by depth: First all primary particles, then all direct daughters of the first primary particle, all direct daughters of the second primary particle and so forth.

Definition at line 48 of file MCParticleGraph.cc.

Constructor & Destructor Documentation

ParticleSorter()

ParticleSorter ( MemoryPool< MCParticleGraph::GraphParticle > & particles, TClonesArray * plist, bool setVertex, bool setTime )

inline

ParticleSorter constructor.

Parameters

particles	Reference to the list of particles which should be sorted.
plist	The final array of sorted particles which is stored in the DataStore.
setVertex	Set to true if the vertex information should be saved.
setTime	Set to true if the production time information should be saved.

Definition at line 59 of file MCParticleGraph.cc.

                                                                                                                        :
    m_index(0), m_particles(particles), m_plist(plist), m_setVertex(setVertex), m_setTime(setTime) {}

Member Function Documentation

find_daughters()

template<class Vertex, class Graph>

void find_daughters ( Vertex v, Graph & g, MCParticleGraph::GraphParticle & mother )

inline

Find the daughters of the given vertex.

Parameters

v	The vertex whose daughters are investigated.
g	The graph in which the vertex lives.
mother	Reference to the mother particle.

Definition at line 128 of file MCParticleGraph.cc.

  {
    //References to the daughter information of the mother for easier access
    int& d1 = mother.m_firstDaughter;
    // writes through this reference modify mother.m_lastDaughter, which cppcheck does not track
    // cppcheck-suppress unreadVariable
    int& d2 = mother.m_lastDaughter;
 
    typename boost::graph_traits<Graph>::out_edge_iterator j, j_end;
    for (tie(j, j_end) = out_edges(v, g); j != j_end; ++j) {
      //Get daughter particle from list
      Vertex nv = target(*j, g);
      MCParticleGraph::GraphParticle& daughter = *m_particles[nv - 1];
 
      if (daughter.m_ignore) {
        //daughter ignored, search its children and treat them as direct children of mother
        //if we haven't seen this particle yet, set its index to that of its last unignored parent
        if (!m_seen[nv]) daughter.setIndex(mother.getIndex());
        find_daughters(nv, g, mother);
      } else {
        //If we didn't see this particle already, set its index and add it to the queue for writing out
        if (!m_seen[nv]) {
          daughter.setIndex(++m_index);
          m_vqueue.push(nv);
        }
        //Set daughter information of mother. If 0, no daughters yet so just take current daughter as only
        //daughter. Otherwise allow extension of daughter information in both directions.
        if (d1 == 0) {
          d1 = daughter.getIndex();
          d2 = d1;
        } else if ((d2 + 1) == daughter.getIndex()) {
          ++d2;
        } else if ((d1 - 1) == daughter.getIndex()) {
          --d1;
        } else {
          //Daughter indices are not continuous, cannot continue
          throw MCParticleGraph::NonContinousDaughtersError();
        }
        //Set Vertex and time information if requested
        setVertexTime(mother, daughter);
        daughter.m_mother = mother.getIndex();
      }
      //Mark particle as seen
      m_seen[nv] = true;
    }
  }

finish_vertex()

template<class Vertex, class Graph>

void finish_vertex ( Vertex v, Graph & g )

inline

Go through the daughters of the vertex.

Add the found particles to the final particle list.

Parameters

v	The vertex whose daughters are investigated.
g	The graph in which the vertex lives.

Definition at line 101 of file MCParticleGraph.cc.

  {
    MCParticleGraph::GraphParticle& p = *m_particles[v - 1];
 
    //Reset daughter information, will be filled by find_daughters
    p.setFirstDaughter(0);
    p.setLastDaughter(0);
    //Find all direct daughters
    find_daughters(v, g, p);
 
    //If stable particle, set decaytime to infinity
    if (out_degree(v, g) == 0 && m_setTime) {
      p.setDecayTime(numeric_limits<double>::infinity());
    }
    //If given a pointer to a TClonesArray, create MCParticle at the appropriate index position
    if (m_plist) {
      new (m_plist->AddrAt(p.getIndex() - 1)) MCParticle(m_plist, p);
    }
  }

setStartIndex()

void setStartIndex ( int index )

inline

Set the starting index for the particle graph.

Normally this is 0 so the first real particle has an id of 1 but this can be used if there are already particles present so the first particle will have id N+1

Parameters

index

number of particles already present

Definition at line 67 of file MCParticleGraph.cc.

{ m_index = index; }

setVertexTime()

void setVertexTime ( MCParticleGraph::GraphParticle & m, const MCParticleGraph::GraphParticle & d )

inline

Set the vertex and time information of the mother particle.

Parameters

m	Reference to the mother particle whose vertex and time information should be set.
d	Reference to the daughter particle.

Definition at line 181 of file MCParticleGraph.cc.

  {
    //Only set vertex information if both particles have a valid vertex set
    m.setValidVertex(m.hasValidVertex() &&  d.hasValidVertex());
    if (m.hasValidVertex() && d.getProductionTime() >= m.getDecayTime()) {
      if (m_setVertex) {
        m.setDecayVertex(d.getProductionVertex());
      }
      if (m_setTime) {
        m.setDecayTime(d.getProductionTime());
      }
    }
  }

sort()

template<class Graph>

void sort ( Graph & g )

inline

Sort the particles and generate MCParticle list.

Parameters

g	The graph which should be sorted and transformed to a list of particles.

Definition at line 73 of file MCParticleGraph.cc.

  {
    //Set seen flag for all vertices to false
    m_seen.clear();
    m_seen.resize(num_vertices(g), false);
 
    //Create a dummy GraphParticle, needed only to find all primary particles
    MCParticleGraph::GraphParticle dummy(0, 0);
 
    //Add all direct children of the 0th vertex to the queue.
    //This are the primary particles
    find_daughters(0, g, dummy);
 
    //Go through the queue and write out each particle.
    //Daughters of particles will be added to the queue by find_daughters
    while (!m_vqueue.empty()) {
      unsigned int cur = m_vqueue.front();
      m_vqueue.pop();
      finish_vertex(cur, g);
    }
  }

Member Data Documentation

m_index

int m_index

protected

The latest index given to a particle.

Definition at line 198 of file MCParticleGraph.cc.

m_particles

MemoryPool<MCParticleGraph::GraphParticle>& m_particles

protected

Reference to the list of particles which should be sorted.

Definition at line 199 of file MCParticleGraph.cc.

m_plist

TClonesArray* m_plist

protected

The final array of sorted particles which is stored in the DataStore.

Definition at line 201 of file MCParticleGraph.cc.

m_seen

vector<bool> m_seen

protected

Vector of the particles that were already seen while sorting the graph.

Definition at line 205 of file MCParticleGraph.cc.

m_setTime

bool m_setTime

protected

True if the production time information should be saved.

Definition at line 203 of file MCParticleGraph.cc.

m_setVertex

bool m_setVertex

protected

True if the vertex information should be saved.

Definition at line 202 of file MCParticleGraph.cc.

m_vqueue

std::queue<unsigned int> m_vqueue

protected

The list of the vertices that will be visited.

Definition at line 206 of file MCParticleGraph.cc.

---

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

• mdst/dataobjects/src/MCParticleGraph.cc