Constraint.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2013 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributor: Wouter Hulsbergen, Francesco Tenchini, Jo-Frederik Krohn  *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <string>
#include <analysis/VertexFitting/TreeFitter/ErrCode.h>
 
namespace TreeFitter {
  class ParticleBase ;
  class Projection ;
  class FitParams ;
 
  class Constraint {
  public:
    enum Type { unknown = 0,
                beamenergy,
                beamspot,
                origin,
                lifetime,
                resonance,
                composite,
                track,
                photon,
                klong,
                conversion,
                kinematic,
                geometric,
                mass,
                massEnergy,
                merged,
                ntypes,
                helix
              };
 
    bool operator<(const Constraint& rhs) const;
 
    bool operator==(const Constraint& rhs) const
    {
      return m_type == rhs.m_type;
    }
 
    Type type() const { return m_type; }
 
    unsigned int dim() const { return m_dim; }
 
    bool isLinear() const { return m_maxNIter <= 1; }
 
    unsigned int nIter() const { return m_maxNIter; }
 
    Constraint() :
      m_node(0),
      m_depth(0),
      m_type(unknown),
      m_dim(0),
      m_weight(0),
      m_maxNIter(0) {}
 
    Constraint(const ParticleBase* node,
               Type type,
               int depth,
               unsigned int dim,
               int maxniter = 1) :
      m_node(node),
      m_depth(depth),
      m_type(type),
      m_dim(dim),
      m_weight(1),
      m_maxNIter(maxniter) {}
 
    virtual ~Constraint() {}
 
    virtual ErrCode project(const FitParams& fitpar, Projection& p) const;
 
    virtual ErrCode filter(FitParams& fitpar);
 
    virtual ErrCode filterWithReference(FitParams& fitpar, const FitParams& oldState);
 
    std::string name() const;
 
    [[gnu::unused]] void setWeight(int w) { m_weight = w < 0 ? -1 : 1; }
 
  protected:
 
    explicit Constraint(Constraint::Type type) :
      m_node(0),
      m_depth(0),
      m_type(type),
      m_dim(0),
      m_weight(0),
      m_maxNIter(0) {}
 
    void setDim(unsigned int d) { m_dim = d; }
 
    void setNIter(unsigned int d) { m_maxNIter = d; }
 
  private:
 
    const ParticleBase* m_node;
 
    int m_depth;
 
    Type m_type;
 
    unsigned int m_dim;
 
    int m_weight;
 
    int m_maxNIter;
  };
 
}