CutClasses.h

Go to the documentation of this file.

#ifndef _CUT_CLASSES_H_
#define _CUT_CLASSES_H_
 
//root includes 
#include "TCutG.h"
//c++ includes
#include <vector>
#include <map>
#include <string>
#include <limits>
//don't pollute the global namespace with basic types
namespace NSDCuts
{
enum CutType
{
  LowerBound,
  UpperBound,
  Range,
  PolyBound,
  PolyRange,
  PHVTOF,
  IntListCut,
  GrphCut,
  NA
};
 
//quite nearly a type def to provide shorter but safe access 
//for this type of structure
//should there be a basic template for doing this with JSON config stuff too
class CutTypeNameToEnum : public std::map<std::string , CutType>
{
public:
  CutTypeNameToEnum()
  {
  this->insert({"LowerBoundCut",LowerBound});
  this->insert({"UpperBoundCut",UpperBound});
  this->insert({"RangeCut",Range});
  this->insert({"PolyBoundCut",PolyBound});
  this->insert({"PolyRangeCut",PolyRange});
  this->insert({"PHVTOFCut",PHVTOF});
  this->insert({"IntegerListCut",IntListCut});
  this->insert({"GraphCut",GrphCut});
                                 
  }
  CutType operator[](std::string a_typeName) const;
};
//map used for fetching cut types from string based identifiers
static const CutTypeNameToEnum cutNameToEnum;
 
}//end namespace might update the rest of code to
class CutBase
{
public:
  //default constructor sets the cut names to ""
  CutBase();
  virtual bool passesCut(double                     a_X,
                         const std::vector<double>& a_Ys={})
                         const = 0;
  //this is required for deep copies of derived classes
  virtual CutBase* clone() = 0;
  //getters
  std::string getVarXName() const;
  std::string getVarYName() const;
  //setters
  void setVarXName(std::string a_varXName);
  void setVarYName(std::string a_varYName);
  void setRange(double a_min,double a_max);
 
  TCutG* getTCut(int    a_N = 10,
                 double a_minX=0,
                 double a_maxX=0,
                 std::string a_name = "CUTG"
                 );
  virtual std::vector< std::pair<double,double> > getNPoints(int a_N,
                                                             double a_minX=0,
                                                             double a_maxX=0
                                                             );
  virtual ~CutBase();
protected:
  std::string m_varXName;
  std::string m_varYName;
  double m_rMin;
  double m_rMax;
  bool m_hasRange;
 
};
 
 
class LowerBoundCut : public CutBase
{
public:
  LowerBoundCut();
  double getCutValue();
  void setCut(double a_cutValue);
 
  inline bool passesCut(double                     a_X,
                         const std::vector<double>& a_Ys={}) const;
  std::vector< std::pair<double,double> > getNPoints(int a_N,
                                                     double a_minX,
                                                     double a_maxX
                                                     );
  LowerBoundCut* clone();
private:
  double m_cutValue;
};
 
class UpperBoundCut : public CutBase
{
public:
  UpperBoundCut();
  double getCutValue();
  void setCut(double a_cutValue);
 
  inline bool passesCut(double                     a_X,
                         const std::vector<double>& a_Ys={}) const;
  std::vector< std::pair<double,double> > getNPoints(int a_N,
                                                     double a_minX,
                                                     double a_maxX
                                                     );
  UpperBoundCut* clone();
private:
  double m_cutValue;
};
//used to provide cuts requiring all values to be within a range
class RangeCut : public CutBase
{
public:
  RangeCut();
  double getLowerBound();
  double getUpperBound();
  void setLowerBound(double a_cutValue);
  void setUpperBound(double a_cutValue);
 
  inline bool passesCut(double                     a_X,
                        const std::vector<double>& a_Ys={}) const;
  std::vector< std::pair<double,double> > getNPoints(int a_N,
                                                     double a_minX,
                                                     double a_maxX
                                                     );
  RangeCut* clone();
private:
  double m_lowerBound;
  double m_upperBound;
};
 
class PolyBoundCut : public CutBase
{
public:
  PolyBoundCut();
  //setters
  void setCoeffs(std::vector<double> a_coeffs);
  void setUpper(bool a_log);
  //getters
  std::vector<double> getCoeffs() const;
  bool isUpper() const;
  bool passesCut(double                     a_X,
                        const std::vector<double>& a_Ys={}) const;
  //this will run a loop around the perimineter specified by the bound 
  //and the supplied range
  std::vector< std::pair<double,double> > getNPoints(int a_N,
                                                     double a_minX,
                                                     double a_maxX
                                                     );
  std::vector< std::pair<double,double> > getLine(int a_N,
                                                    double a_minX,
                                                    double a_maxX
                                                    );
  PolyBoundCut* clone();
private:
  std::vector<double> m_coeffs;
  bool m_isUpper;
};
 
class PolyRangeCut : public CutBase
{
public:
  //default constuction creates a null boundary meaning this will return false
  PolyRangeCut();
  void setLowerBoundCoeffs(std::vector<double> a_coeffs);
  void setUpperBoundCoeffs(std::vector<double> a_coeffs);
  std::vector<double> getLowerBoundCoeffs() const;
  std::vector<double> getUpperBoundCoeffs() const;
  bool passesCut(double                     a_X,
                 const std::vector<double>& a_Ys={}) const;
    //this will run a loop around the perimineter specified by the bound 
  //and the supplied range to generate a series of points oulinening the cuts
  std::vector< std::pair<double,double> > getNPoints(int a_N,
                                                     double a_minX,
                                                     double a_maxX
                                                     );
  PolyRangeCut* clone();
private:
  PolyBoundCut m_lowerBound;
  PolyBoundCut m_upperBound;
};
 
class IntegerListCut : public CutBase
{
public:
  IntegerListCut();
  void setIntegerList(std::vector<int> a_integerList);
 
  bool passesCut(double                     a_X,
                const std::vector<double>& a_Ys={}) const;
  IntegerListCut* clone();
private:
  std::vector<int> m_integerList;
};
 
class GraphCut : public CutBase
{
public:
  GraphCut();
  void setPoints(std::vector< std::pair<double,double>> a_points);
  bool passesCut(double                     a_X,
                const std::vector<double>& a_Ys={}) const;
  //this just returns the internal points ignoring the boundaries
  std::vector< std::pair<double,double> > getNPoints(int a_N,
                                                     double a_minX,
                                                     double a_maxX
                                                     );
  GraphCut* clone();
private:
  std::vector< std::pair<double,double> > m_points;
  TCutG* m_rootCut;
};
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//implementations of inline functions
bool LowerBoundCut::passesCut(double a_X,const std::vector<double>&) const
{
  return a_X > m_cutValue;
}
 
bool UpperBoundCut::passesCut(double a_X,const std::vector<double>&) const
{
  return a_X < m_cutValue;
}
 
bool RangeCut::passesCut(double a_X,const std::vector<double>&) const
{
  return a_X < m_upperBound && a_X > m_lowerBound;
}
 
 
#endif