ParticleList.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 <analysis/dataobjects/Particle.h>
#include <framework/utilities/ArrayIterator.h>
 
#include <TObject.h>
#include <vector>
 
 
namespace Belle2 {
  template <class T> class StoreObjPtr;
 
  class ParticleList : public TObject {
  public:
 
    typedef ArrayIterator<ParticleList, Particle> iterator;
    typedef ArrayIterator<ParticleList, const Particle> const_iterator;
 
    enum EParticleType {
      c_FlavorSpecificParticle = 0,
      c_SelfConjugatedParticle
    };
 
    ParticleList():
      m_pdg(0),
      m_pdgbar(0),
      m_particleStore("Particles"),
      m_thisListName(),
      m_antiListName(),
      m_antiList(nullptr),
      m_isReserved(false)
    {
    }
 
    ~ParticleList();
 
    void initialize(int pdg, const std::string& name, const std::string& particleStoreName = "Particles");
 
    void bindAntiParticleList(ParticleList& antiList, bool includingAntiList = true);
 
    void setParticleCollectionName(const std::string& name, bool forAntiParticle = true);
 
    void addParticle(const Particle* particle);
 
    void addParticle(unsigned iparticle, int pdg, Particle::EFlavorType flavorType, bool includingAntiList = true);
 
    void removeParticles(const std::vector<unsigned int>& toRemove, bool removeFromAntiList = true);
 
    void clear(bool includingAntiList = true);
 
    std::string getParticleCollectionName() const {return m_particleStore;}
 
    int getPDGCode() const {return m_pdg; }
 
    int getAntiParticlePDGCode() const { return m_pdgbar; }
 
    const std::vector<int>& getList(EParticleType K, bool forAntiParticle = false) const;
 
    std::string getAntiParticleListName() const { return m_antiListName; }
 
    std::string getParticleListName() const { return m_thisListName; }
 
    unsigned getListSize(bool includingAntiList = true) const;
 
    Particle* getParticle(unsigned i, bool includingAntiList = true) const;
 
    Particle* getParticleWithMdstIdx(unsigned int mdstIdx, bool includingAntiList = true) const;
 
    unsigned getNParticlesOfType(EParticleType K, bool forAntiParticle = false) const
    {
      return getList(K, forAntiParticle).size();
    }
 
    bool contains(const Particle* p, bool includingAntiList = true) const;
 
    int getIndex(const Particle* p, bool includingAntiList = true) const;
 
    void print() const;
 
    void setEditable(bool editable, bool includingAntiList = true)
    {
      m_isReserved = !editable;
      if (includingAntiList and !m_antiListName.empty())
        getAntiParticleList().setEditable(editable, false);
    };
 
    bool getIsReserved() const { return m_isReserved; };
 
 
    std::string getInfoHTML() const;
 
    iterator begin() { return iterator(this, 0); }
    iterator end() { return iterator(this, getListSize()); }
 
    const_iterator begin() const { return const_iterator(this, 0); }
    const_iterator end() const { return const_iterator(this, getListSize()); }
 
    Particle* operator[](int index) const {return getParticle(index);}
 
  private:
    ParticleList& getAntiParticleList() const;
 
    int m_pdg;                   
    int m_pdgbar;                
    std::vector<int> m_fsList;   
    std::vector<int>
    m_scList;   
    std::string m_particleStore; 
    std::string m_thisListName;  
    std::string m_antiListName;  
    mutable StoreObjPtr<ParticleList>* m_antiList; 
 
    bool m_isReserved = false;  
    ClassDef(ParticleList, 4); 
    friend class ParticleSubset;
  };
 
} // end namespace Belle2