MCParticleGraph.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/FrameworkExceptions.h>
#include <framework/core/MemoryPool.h>
#include <mdst/dataobjects/MCParticle.h>
 
#include <set>
#include <string>
 
 
namespace Belle2 {
  class MCParticleGraph {
 
  public:
 
    //Exception definition
 
    BELLE2_DEFINE_EXCEPTION(CyclicReferenceError, "Cyclic decay, cannot continue");
    BELLE2_DEFINE_EXCEPTION(NotSameGraphError, "Particles not from same graph");
    BELLE2_DEFINE_EXCEPTION(NonContinousDaughtersError, "Can not represent decay graph, non continuous indices for daughters");
    BELLE2_DEFINE_EXCEPTION(DaughterHasMotherError,
                            "A daughter particle was already assigned to a mother. A particle can't have two mothers!");
    BELLE2_DEFINE_EXCEPTION(OutOfRangeError, "Index out of range");
 
    typedef std::pair<unsigned int, unsigned int> DecayLine;
 
    enum GraphOptions {
      c_setNothing      = 0, 
      c_setDecayVertex = 1, 
      c_setDecayTime   = 2, 
      c_setDecayInfo   = c_setDecayVertex | c_setDecayTime, 
      c_checkCyclic     = 4,  
      c_clearParticles = 8 
    };
 
    class GraphParticle: public MCParticle {
 
    public:
      GraphParticle& operator=(const MCParticle& particle)
      {
        MCParticle::operator=(particle);
        //The pointer to the TClonesArray the MCParticle is stored in makes no
        //sense inside the Graph so we set it to some invalid value to avoid
        //the MCParticle::fixParticleList() to complain
        m_plist = (TClonesArray*) - 1;
        return *this;
      }
 
      void decaysInto(GraphParticle& daughter) { m_graph->addDecay(*this, daughter); }
 
      void comesFrom(GraphParticle& mother) { m_graph->addDecay(mother, *this); }
 
      void setFirstDaughter(int daughter) { m_firstDaughter = daughter; }
 
      void setLastDaughter(int daughter) { m_lastDaughter = daughter; }
 
      void setIgnore(bool ignore = true) { m_ignore = ignore; }
 
      bool getIgnore() const { return m_ignore; }
 
      void setTrackID(int trackID) { m_trackID = trackID; }
 
      int getTrackID() const { return m_trackID; }
 
 
    private:
 
      GraphParticle() = delete;
 
      GraphParticle(const GraphParticle&) = delete;
 
      GraphParticle(TClonesArray*, const MCParticle&) {}
 
      GraphParticle(MCParticleGraph* graph, unsigned int vertexId): MCParticle(),
        m_graph(graph), m_vertexId(vertexId)
      {
        //The pointer to the TClonesArray the MCParticle is stored in makes no
        //sense inside the Graph so we set it to some invalid value to avoid
        //the MCParticle::fixParticleList() to complain
        m_plist = (TClonesArray*) - 1;
      }
 
      void setIndex(int index) { m_index = index; }
 
      MCParticleGraph* m_graph{0}; 
      unsigned int m_vertexId{0};  
      bool m_ignore{false};        
      bool m_primary{true};        
      int m_trackID{0};            
      friend class MCParticleGraph;
      friend class ParticleSorter;
    };
 
    MCParticleGraph() {}
 
    virtual ~MCParticleGraph() { clear(); }
 
    GraphParticle& addParticle();
 
    void addDecay(GraphParticle& mother, GraphParticle& daughter);
 
    GraphParticle& operator[](size_t i) { if (i >= m_particles.size()) throw OutOfRangeError(); return *m_particles[i]; }
 
    size_t size() const { return m_particles.size(); }
 
    void generateList(const std::string& name = "", int options = c_setNothing);
 
 
    void loadList(const std::string& name = "");
 
    void clear();
 
 
  protected:
 
    class ParticleSorter;
 
    MemoryPool<GraphParticle> m_particles; 
    std::set<DecayLine> m_decays;          
  };
 
 
  inline void MCParticleGraph::clear()
  {
    m_particles.clear();
    m_decays.clear();
  }
 
 
  inline MCParticleGraph::GraphParticle& MCParticleGraph::addParticle()
  {
    unsigned int index = m_particles.size() + 1;
    MCParticleGraph::GraphParticle* p = new (m_particles.add()) MCParticleGraph::GraphParticle(this, index);
    return *p;
  }
 
 
  inline void MCParticleGraph::addDecay(MCParticleGraph::GraphParticle& mother, MCParticleGraph::GraphParticle& daughter)
  {
    if (this != mother.m_graph || this != daughter.m_graph) throw NotSameGraphError();
    //if (daughter.getMother() != NULL) throw DaughterHasMotherError();
    m_decays.insert(DecayLine(mother.m_vertexId, daughter.m_vertexId));
    daughter.m_primary = false;
  }
 
} // end namespace Belle2