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