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:
    const static DecayDescriptor& s_NULL;
 
    operator DecayDescriptor* ()
    {
      return m_isNULL ? nullptr : this;
    }
    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;
    }
    int getNDaughters() const
    {
      return m_daughters.size();
    }
    const DecayDescriptor* getDaughter(int i) const
    {
      return (i < getNDaughters()) ? &(m_daughters[i]) : nullptr;
    }
    int getProperty() const
    {
      return m_properties;
    }
    bool isIgnoreRadiatedPhotons() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreRadiatedPhotons) > 0;
    }
    bool isIgnoreIntermediate() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreIntermediate) > 0;
    }
    bool isIgnoreMassive() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreMassive) > 0;
    }
    bool isIgnoreNeutrino() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreNeutrino) > 0;
    }
    bool isIgnoreGamma() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreGamma) > 0;
    }
    bool isIgnoreBrems() const
    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreBrems) > 0;
    }
 
    bool isSelfConjugated() const;
 
    bool isInitOK() const
    {
      return m_isInitOK;
    }
 
    bool getSelectionParticlesAndNames(const Particle* particle,
                                       std::vector<const Particle*>& selparticles,
                                       std::vector<std::string>& selnames);
  };
 
}