DecayDescriptor.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/DecayDescriptor/DecayString.h>
#include <analysis/DecayDescriptor/DecayDescriptorParticle.h>
#include <analysis/dataobjects/Particle.h>
 
#include <vector>
#include <string>
 
namespace Belle2 {
  class MCParticle;

  class DecayDescriptor {
  private:
    DecayDescriptorParticle m_mother;
    int m_iDaughter_p;
    std::vector<DecayDescriptor> m_daughters;
    int m_properties;
    bool m_isNULL;
    template <class T>
    int match(const T* p, int iDaughter_p);
    std::vector<std::vector<std::pair<int, std::string>>> m_hierarchy;

    bool m_isInitOK;
 
  public:

    operator DecayDescriptor* ()
    {
      return m_isNULL ? nullptr : this;
    }
    operator DecayDescriptor* () {…}

    DecayDescriptor();

    DecayDescriptor(const DecayDescriptor&) = default;

    DecayDescriptor& operator=(const DecayDescriptor&) = default;

    std::vector<std::vector<std::pair<int, std::string>>>  getHierarchyOfSelected();

    std::vector<std::vector<std::pair<int, std::string>>>  getHierarchyOfSelected(const std::vector<std::pair<int, std::string>>&
        currentPath);

    bool init(const std::string& str);

    bool init(const DecayString& s);

    int match(const Particle* p) {return match<Particle>(p, -1);}

    int match(const MCParticle* p) {return match<MCParticle>(p, -1);}

    int getMatchedDaughter() {return m_iDaughter_p;}

    void resetMatch();

    std::vector<const Particle*> getSelectionParticles(const Particle* particle);
    std::vector<std::string> getSelectionNames();
    std::vector<int> getSelectionPDGCodes();
    const DecayDescriptorParticle* getMother() const
    {
      return &m_mother;
    }
    const DecayDescriptorParticle* getMother() const {…}

    int getNDaughters() const
    {
      return m_daughters.size();
    }
    int getNDaughters() const {…}

    const DecayDescriptor* getDaughter(int i) const
    {
      return (i < getNDaughters()) ? &(m_daughters[i]) : nullptr;
    }
    const DecayDescriptor* getDaughter(int i) const {…}

    int getProperty() const
    {
      return m_properties;
    }
    int getProperty() const {…}

    bool isIgnoreRadiatedPhotons() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreRadiatedPhotons) > 0;
    }
    bool isIgnoreRadiatedPhotons() const {…}

    bool isIgnoreIntermediate() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreIntermediate) > 0;
    }
    bool isIgnoreIntermediate() const {…}

    bool isIgnoreMassive() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreMassive) > 0;
    }
    bool isIgnoreMassive() const {…}

    bool isIgnoreNeutrino() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreNeutrino) > 0;
    }
    bool isIgnoreNeutrino() const {…}

    bool isIgnoreGamma() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreGamma) > 0;
    }
    bool isIgnoreGamma() const {…}

    bool isIgnoreBrems() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreBrems) > 0;
    }
    bool isIgnoreBrems() const {…}

    bool isSelfConjugated() const;

    bool isInitOK() const
    {
      return m_isInitOK;
    }
    bool isInitOK() const {…}

    bool getSelectionParticlesAndNames(const Particle* particle,
                                       std::vector<const Particle*>& selparticles,
                                       std::vector<std::string>& selnames);
  };
  class DecayDescriptor {…};

}