Constraint_Intermed.h

Go to the documentation of this file.

//
//
// File: hitfit/private/Constraint_Intermed.h
// Purpose: Represent one side of a mass constraint equation.
// Created: Jul, 2000, sss, based on run 1 mass analysis code.
//
// Mass constraints come in two varieties, either saying that the sum
// of a set of labels should equal a constant:
//
//     (1 + 2) = 80
//
// or that two such sums should equal each other:
//
//     (1 + 2) = (3 + 4)
//
// These classes represent one side of such an equation.
// There is an abstract base class Constraint_Intermed, and then concrete
// implementations for the two cases, Constraint_Intermed_Constant
// and Constraint_Intermed_Labels.  There is also a free function
// make_constraint_intermed() to parse a string representing one
// side of a constraint and return the appropriate Constraint_Intermed
// instance.
//
// CMSSW File      : interface/Constraint_Intermed.h
// Original Author : Scott Stuart Snyder <snyder@bnl.gov> for D0
// Imported to CMSSW by Haryo Sumowidagdo <Suharyo.Sumowidagdo@cern.ch>
//
 
#ifndef HITFIT_CONSTRAINT_INTERMED_H
#define HITFIT_CONSTRAINT_INTERMED_H
 
#include <iosfwd>
#include <vector>
#include <string>
#include <memory>
 
namespace hitfit {
 
  class Fourvec_Event;
 
  //************************************************************************
 
  class Constraint_Intermed
  //
  // Purpose: Abstract base class for describing one side of a mass constraint.
  //
  {
  public:
    // Constructor, destructor.
 
    Constraint_Intermed() {}
 
    virtual ~Constraint_Intermed() {}
 
    // Return true if this guy references both labels ILABEL and JLABEL.
    virtual bool has_labels(int ilabel, int jlabel) const = 0;
 
    // Evaluate this half of the mass constraint, using the data in EV.
    // Return m^2/2.
    virtual double sum_mass_terms(const Fourvec_Event& ev) const = 0;
 
    // Print out this object.
    virtual void print(std::ostream& s) const = 0;
 
    // Copy this object.
    virtual std::unique_ptr<Constraint_Intermed> clone() const = 0;
  };
 
  //************************************************************************
 
  class Constraint_Intermed_Constant : public Constraint_Intermed
  //
  // Purpose: Concrete base class for a constant mass constraint half.
  //
  {
  public:
    // Constructor, destructor.
    Constraint_Intermed_Constant(double constant);
 
    ~Constraint_Intermed_Constant() override{};
 
    // Copy constructor.
    Constraint_Intermed_Constant(const Constraint_Intermed_Constant& c);
 
    // Return true if this guy references both labels ILABEL and JLABEL.
    bool has_labels(int ilabel, int jlabel) const override;
 
    // Evaluate this half of the mass constraint, using the data in EV.
    // Return m^2/2.
    double sum_mass_terms(const Fourvec_Event& ev) const override;
 
    // Print out this object.
    void print(std::ostream& s) const override;
 
    // Copy this object.
    std::unique_ptr<Constraint_Intermed> clone() const override;
 
  private:
    // Store c^2 / 2.
    double _c2;
  };
 
  //************************************************************************
 
  class Constraint_Intermed_Labels : public Constraint_Intermed {
  public:
    Constraint_Intermed_Labels(const std::vector<int>& labels);
 
    Constraint_Intermed_Labels(const Constraint_Intermed_Labels& c);
    ~Constraint_Intermed_Labels() override{};
 
    // Return true if this guy references both labels ILABEL and JLABEL.
    bool has_labels(int ilabel, int jlabel) const override;
 
    // Evaluate this half of the mass constraint, using the data in EV.
    // Return m^2/2.
    double sum_mass_terms(const Fourvec_Event& ev) const override;
 
    // Print out this object.
    void print(std::ostream& s) const override;
 
    // Copy this object.
    std::unique_ptr<Constraint_Intermed> clone() const override;
 
  private:
    // Test to see if LABEL is used by this constraint half.
    bool has_label(int label) const;
 
    // List of the labels for this constraint half, kept in sorted order.
    std::vector<int> _labels;
 
    // Disallow assignment
    Constraint_Intermed& operator=(const Constraint_Intermed&);
  };
 
  //************************************************************************
 
  // Print out a Constraint_Intermed object.
  std::ostream& operator<<(std::ostream& s, const Constraint_Intermed& ci);
 
  // Parse the string S and construct the appropriate Constraint_Intermed
  // instance.
  std::unique_ptr<Constraint_Intermed> make_constraint_intermed(std::string s);
 
}  // namespace hitfit
 
#endif  // not HITFIT_CONSTRAINT_INTERMED_H