PointUtils.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2023 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_PointUtils_h
#define YODA_PointUtils_h
 
#include <type_traits>
 
namespace YODA {
 
 
  template <class Derived>
  struct XDirectionMixin {
 
 
    double x() const {
      return static_cast<const Derived*>(this)->vals()[0];
    }
 
    void setX(double x) {
      static_cast<Derived*>(this)->setVal(0, x);
    }
 
 
 
    std::pair<double,double> xErrs() const {
      return static_cast<const Derived*>(this)->errs(0);
    }
 
    double xErrMinus() const {
      return static_cast<const Derived*>(this)->errMinus(0);
    }
 
    double xErrPlus() const {
      return static_cast<const Derived*>(this)->errPlus(0);
    }
 
    // Get the average x error
    double xErrAvg() const {
      return static_cast<const Derived*>(this)->errAvg(0);
    }
 
    void setXErrMinus(double err) {
      static_cast<Derived*>(this)->setErrMinus(0, err);
    }
 
    void setXErrPlus(double err) {
      static_cast<Derived*>(this)->setErrPlus(0, err);
    }
 
    void setXErr(double ex) {
      setXErrMinus(ex);
      setXErrPlus(ex);
    }
 
    void setXErrs(double ex) {
      setXErr(ex);
    }
 
    void setXErrs(double errminus, double errplus) {
      static_cast<Derived*>(this)->setErrs(0, {errminus, errplus});
    }
 
    void setXErrs(std::pair<double,double> errs) {
      static_cast<Derived*>(this)->setErrs(0, errs);
    }
 
    double xMin() const {
      return x() - xErrMinus();
      return static_cast<const Derived*>(this)->min(0);
    }
 
    double xMax() const {
      return static_cast<const Derived*>(this)->max(0);
    }
 
 
 
    void setX(double x, double ex) {
      setX(x);
      setXErr(ex);
    }
 
    void setX(double x, double exminus, double explus) {
      setX(x);
      setXErrs(exminus, explus);
    }
 
    void setX(double x, std::pair<double,double>& ex) {
      setX(x);
      setXErrs(ex);
    }
 
 
    // @name Manipulations
 
    void scaleX(double scalex) {
      setX(x()*scalex);
      setXErrs(xErrMinus()*scalex, xErrPlus()*scalex);
    }
 
 
 
  };
 
 
  template <class Derived>
  struct YDirectionMixin {
 
 
    double y() const {
      return static_cast<const Derived*>(this)->vals()[1];
    }
 
    void setY(double y) {
      static_cast<Derived*>(this)->setVal(1, y);
    }
 
    std::pair<double,double> xy() const {
      const auto& vals = static_cast<const Derived*>(this)->vals();
      return {vals[0], vals[1]};
    }
 
    void setXY(double x, double y) {
      static_cast<Derived*>(this)->setVal(0, x);
      static_cast<Derived*>(this)->setVal(1, y);
    }
 
    void setXY(const std::pair<double,double>& xy) {
      setXY(xy.first, xy.second);
    }
 
 
 
    std::pair<double,double> yErrs() const {
      return static_cast<const Derived*>(this)->errs(1);
    }
 
    double yErrMinus() const {
      return static_cast<const Derived*>(this)->errMinus(1);
    }
 
    double yErrPlus() const {
      return static_cast<const Derived*>(this)->errPlus(1);
    }
 
    // Get the average y error
    double yErrAvg() const {
      return static_cast<const Derived*>(this)->errAvg(1);
    }
 
    void setYErrMinus(double err) {
      static_cast<Derived*>(this)->setErrMinus(1, err);
    }
 
    void setYErrPlus(double err) {
      static_cast<Derived*>(this)->setErrPlus(1, err);
    }
 
    void setYErr(double ey) {
      setYErrMinus(ey);
      setYErrPlus(ey);
    }
 
    void setYErrs(double ey) {
      setYErr(ey);
    }
 
    void setYErrs(double errminus, double errplus) {
      static_cast<Derived*>(this)->setErrs(1, {errminus, errplus});
    }
 
    void setYErrs(std::pair<double,double> errs) {
      static_cast<Derived*>(this)->setErrs(1, errs);
    }
 
    double yMin() const {
      return static_cast<const Derived*>(this)->min(1);
    }
 
    double yMax() const {
      return static_cast<const Derived*>(this)->max(1);
    }
 
 
 
    void setY(double y, double ey) {
      setY(y);
      setYErr(ey);
    }
 
    void setY(double y, double eyminus, double eyplus) {
      setY(y);
      setYErrs(eyminus, eyplus);
    }
 
    void setY(double y, std::pair<double,double>& ey) {
      setY(y);
      setYErrs(ey);
    }
 
 
    // @name Manipulations
 
    void scaleY(double scaley) {
      setY(y()*scaley);
      setYErrs(yErrMinus()*scaley, yErrPlus()*scaley);
    }
 
 
 
  };
 
 
  template <class Derived>
  struct ZDirectionMixin {
 
 
    double z() const {
      return static_cast<const Derived*>(this)->vals()[2];
    }
 
    void setZ(double z) {
      static_cast<Derived*>(this)->setVal(2, z);
    }
 
    void setXYZ(double x, double y, double z) {
      static_cast<Derived*>(this)->setVal(0, x);
      static_cast<Derived*>(this)->setVal(1, y);
      static_cast<Derived*>(this)->setVal(2, z);
    }
 
 
 
    std::pair<double,double> zErrs() const {
      return static_cast<const Derived*>(this)->errs(2);
    }
 
    double zErrMinus() const {
      return static_cast<const Derived*>(this)->errMinus(2);
    }
 
    double zErrPlus() const {
      return static_cast<const Derived*>(this)->errPlus(2);
    }
 
    // Get the average z error
    double zErrAvg() const {
      return static_cast<const Derived*>(this)->errAvg(2);
    }
 
    void setZErrMinus(double err) {
      static_cast<Derived*>(this)->setErrMinus(2, err);
    }
 
    void setZErrPlus(double err) {
      static_cast<Derived*>(this)->setErrPlus(2, err);
    }
 
    void setZErr(double ez) {
      setZErrMinus(ez);
      setZErrPlus(ez);
    }
 
    void setZErrs(double ez) {
      setZErr(ez);
    }
 
    void setZErrs(double errminus, double errplus) {
      static_cast<Derived*>(this)->setErrs(2, {errminus, errplus});
    }
 
    void setZErrs(std::pair<double,double> errs) {
      static_cast<Derived*>(this)->setErrs(2, errs);
    }
 
    double zMin() const {
      return static_cast<const Derived*>(this)->min(2);
    }
 
    double zMax() const {
      return static_cast<const Derived*>(this)->max(2);
    }
 
 
 
    void setZ(double z, double ez) {
      setZ(z);
      setZErr(ez);
    }
 
    void setZ(double z, double ezminus, double ezplus) {
      setZ(z);
      setZErrs(ezminus, ezplus);
    }
 
    void setZ(double z, std::pair<double,double>& ez) {
      setZ(z);
      setZErrs(ez);
    }
 
 
    // @name Manipulations
 
    void scaleZ(double scalez) {
      setZ(z()*scalez);
      setZErrs(zErrMinus()*scalez, zErrPlus()*scalez);
    }
 
 
 
  };
 
 
}
 
#endif