ParticleBase.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 * External Contributor: Wouter Hulsbergen                                *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <analysis/VertexFitting/TreeFitter/Constraint.h>
#include <analysis/VertexFitting/TreeFitter/Projection.h>
#include <analysis/VertexFitting/TreeFitter/ErrCode.h>
#include <analysis/VertexFitting/TreeFitter/ConstraintConfiguration.h>
#include <Eigen/Core>
 
#include <analysis/dataobjects/Particle.h>
 
namespace TreeFitter {
 
  class FitParams;
  class ConstraintConfiguration;
 
  class ParticleBase {
 
  public:
 
    enum TFParticleType {kInteractionPoint,
                         kOrigin,
                         kRecoComposite,
                         kRecoResonance,
                         kInternalParticle,
                         kRecoTrack,
                         kResonance,
                         kRecoPhoton,
                         kRecoKlong,
                         kMissingParticle
                        };
 
    ParticleBase(Belle2::Particle* particle, const ParticleBase* mother, const ConstraintConfiguration* config) ;
 
    ParticleBase(Belle2::Particle* particle, const ParticleBase* mother) ;
 
 
    ParticleBase(const std::string& name);
 
    virtual ~ParticleBase();
 
    typedef std::vector<Constraint> constraintlist;
 
    typedef std::vector< std::pair<const ParticleBase*, int> > indexmap;
 
    static ParticleBase* createParticle(Belle2::Particle* particle,
                                        const ParticleBase* mother,
                                        const ConstraintConfiguration& config,
                                        bool forceFitAll = false
                                       );
 
    static ParticleBase* createOrigin(Belle2::Particle* daughter,
                                      const ConstraintConfiguration& config,
                                      bool forceFitAll
                                     );
 
    virtual ErrCode initMotherlessParticle(FitParams&) = 0;
 
    virtual ErrCode initParticleWithMother(FitParams&) = 0;
 
    virtual ErrCode initCovariance(FitParams&) const;
 
    virtual int dim() const = 0 ;
 
    virtual void updateIndex(int& offset);
 
    virtual std::string parname(int index) const ;
 
    const ParticleBase* locate(Belle2::Particle* particle) const ;
 
    Belle2::Particle* particle() const { return m_particle ; }
 
    int index() const { return m_index ; }
 
    const ParticleBase* mother() const;
 
    const std::string& name() const { return m_name ; }
 
    virtual ErrCode projectGeoConstraint(const FitParams&, Projection&) const ;
 
    virtual ErrCode projectMassConstraintParticle(const FitParams&, Projection&) const ;
 
    virtual ErrCode projectMassConstraintDaughters(const FitParams&, Projection&) const ;
 
    virtual ErrCode projectMassConstraint(const FitParams&, Projection&) const ;
 
    virtual ErrCode projectConstraint(Constraint::Type, const FitParams&, Projection&) const;
 
    virtual void forceP4Sum(FitParams&) const {} ;
 
    virtual int type() const = 0 ;
 
    virtual int posIndex() const { return -1 ; }
 
    virtual int tauIndex() const { return -1 ; }
 
    virtual int momIndex() const { return -1 ; }
 
    // does the particle have a 3-momentum or a 4-momentum ?
    virtual bool hasEnergy() const { return false ; }
 
    virtual bool hasPosition() const { return false ; }
 
    int eneIndex() const { return hasEnergy() ? momIndex() + 3 : -1 ; }
 
    virtual double chiSquare(const FitParams&) const;
 
    double pdgMass() const { return m_pdgMass ; }
 
    double pdgWidth() const { return m_pdgWidth ; }
 
    double pdgLifeTime() const { return m_pdgLifeTime ; }
 
    double pdgTime() const { return m_pdgMass > 0 ? m_pdgLifeTime : 0; }
 
    int charge() const { return m_charge ; }
 
    virtual ParticleBase* addDaughter(Belle2::Particle*, const ConstraintConfiguration& config, bool forceFitAll = false);
 
    virtual void removeDaughter(const ParticleBase* pb);
 
    virtual void retrieveIndexMap(indexmap& anindexmap) const ;
 
    void setMother(const ParticleBase* m) { m_mother = m ; }
 
    virtual void addToConstraintList(constraintlist& alist, int depth) const = 0 ;
 
    void collectVertexDaughters(std::vector<ParticleBase*>& particles, int posindex) ;
 
    virtual int nFinalChargedCandidates() const;
 
    void setParticle(Belle2::Particle* particle) { m_particle = particle ; }
 
  protected:
 
    typedef std::vector<ParticleBase*> ParticleContainer;
 
    static double pdgLifeTime(Belle2::Particle* particle)  ;
 
    static bool isAResonance(Belle2::Particle* particle) ;
 
    static double bFieldOverC();
 
    ErrCode initTau(FitParams& par) const ;
 
    void setIndex(int i) { m_index = i ; }
 
    Belle2::Particle* m_particle;
 
    const ParticleBase* m_mother;
 
    std::vector<ParticleBase*> m_daughters;
 
    bool m_isStronglyDecayingResonance;
 
    const ConstraintConfiguration* m_config;
 
  private:
    int m_index;
 
    const double m_pdgMass;
 
    double m_pdgWidth;
 
    const double m_pdgLifeTime;
 
    int m_charge;
 
    std::string m_name;
 
  }; // end class ParticleBase
} // end namespace TreeFitter