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/dataobjects/Particle.h>
 
namespace TreeFitter {
 
  class FitParams;
  class ConstraintConfiguration;
  class Projection;

  class ParticleBase {
 
  public:

    enum TFParticleType {kInteractionPoint,
                         kOrigin,
                         kComposite,
                         kRecoResonance,
                         kInternalParticle,
                         kRecoTrack,
                         kResonance,
                         kRecoNeutral,
                         kMissingParticle
                        };

    ParticleBase(Belle2::Particle* particle, const ParticleBase* mother, const ConstraintConfiguration* config = nullptr) ;

    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 { return m_mother; };

    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;

    int charge() const
    {
      if (m_particle->getPDGCode()) {
        double fltcharge = m_particle->getCharge();
        return fltcharge < 0 ? int(fltcharge - 0.5) : int(fltcharge + 0.5);
      } else {
        return m_particle->getCharge() > 0 ? 1 : (m_particle->getCharge() < 0 ? -1 : 0);
      }
    }

    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;
 
  protected:

    typedef std::vector<ParticleBase*> ParticleContainer;

    static bool isAResonance(Belle2::Particle* particle) ;

    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;

    std::string m_name;
 
  }; // end class ParticleBase
} // end namespace TreeFitter