Dbn2D.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2021 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_Dbn2D_h
#define YODA_Dbn2D_h

#include "YODA/Exceptions.h"
#include "YODA/Dbn1D.h"

namespace YODA {


  class Dbn2D {
  public:


    Dbn2D() {
      reset();
    }


    Dbn2D(double numEntries, double sumW, double sumW2,
          double sumWX, double sumWX2, double sumWY, double sumWY2, double sumWXY)
      : _dbnX(numEntries, sumW, sumW2, sumWX, sumWX2),
        _dbnY(numEntries, sumW, sumW2, sumWY, sumWY2),
        _sumWXY(sumWXY)
    { }


    Dbn2D(const Dbn2D& toCopy) {
      _dbnX = toCopy._dbnX;
      _dbnY = toCopy._dbnY;
      _sumWXY = toCopy._sumWXY;
    }


    Dbn2D& operator=(const Dbn2D& toCopy) {
      _dbnX = toCopy._dbnX;
      _dbnY = toCopy._dbnY;
      _sumWXY = toCopy._sumWXY;
      return *this;
    }




    void fill(double valX, double valY, double weight=1.0, double fraction=1.0) {
      _dbnX.fill(valX, weight, fraction);
      _dbnY.fill(valY, weight, fraction);
      _sumWXY += fraction*weight*valX*valY;
    }


    void fill(std::pair<double,double> val, double weight=1.0, double fraction=1.0) {
      fill(val.first, val.second, weight, fraction);
    }


    void reset() {
      _dbnX.reset();
      _dbnY.reset();
      _sumWXY = 0;
    }


    void scaleW(double scalefactor) {
      _dbnX.scaleW(scalefactor);
      _dbnY.scaleW(scalefactor);
      _sumWXY *= scalefactor;
    }


    void scaleX(double xscale) {
      _dbnX.scaleX(xscale);
      _sumWXY *= xscale;
    }


    void scaleY(double yscale) {
      _dbnY.scaleX(yscale);
      _sumWXY *= yscale;
    }


    void scaleXY(double xscale, double yscale) {
      scaleX(xscale);
      scaleY(yscale);
    }


  public:



    double errW() const { return _dbnX.errW(); }

    double relErrW() const { return _dbnX.relErrW(); }

    double xMean() const { return _dbnX.xMean();}

    double yMean() const { return _dbnY.xMean(); }

    double xVariance() const { return _dbnX.xVariance(); }

    double yVariance() const { return _dbnY.xVariance(); }

    double xStdDev() const { return _dbnX.xStdDev(); }

    double yStdDev() const { return _dbnY.xStdDev(); }

    double xStdErr() const { return _dbnX.xStdErr(); }

    double yStdErr() const { return _dbnY.xStdErr(); }

    double xRMS() const { return _dbnX.xRMS(); }

    double yRMS() const { return _dbnY.xRMS(); }




    double numEntries() const {
      return _dbnX.numEntries();
    }

    double effNumEntries() const {
      return _dbnX.effNumEntries();
    }

    double sumW() const {
      return _dbnX.sumW();
    }

    double sumW2() const {
      return _dbnX.sumW2();
    }

    double sumWX() const {
      return _dbnX.sumWX();
    }

    double sumWX2() const {
      return _dbnX.sumWX2();
    }

    double sumWY() const {
      return _dbnY.sumWX();
    }

    double sumWY2() const {
      return _dbnY.sumWX2();
    }

    double sumWXY() const {
      return _sumWXY;
    }




    Dbn2D& operator += (const Dbn2D& d) {
      return add(d);
    }

    Dbn2D& operator -= (const Dbn2D& d) {
      return subtract(d);
    }

    void flipXY() {
      Dbn1D temp(_dbnX);
      _dbnX = _dbnY;
      _dbnY = temp;
    }

    Dbn1D transformX() {
      Dbn1D ret(_dbnX);
      return ret;
    }

    Dbn1D transformY() {
      Dbn1D ret(_dbnY);
      return ret;
    }


  protected:

    Dbn2D& add(const Dbn2D& d) {
      _dbnX += d._dbnX;
      _dbnY += d._dbnY;
      _sumWXY += d._sumWXY;
      return *this;
    }

    Dbn2D& subtract(const Dbn2D& d) {
      _dbnX -= d._dbnX;
      _dbnY -= d._dbnY;
      _sumWXY -= d._sumWXY;
      return *this;
    }


  private:


    Dbn1D _dbnX;

    Dbn1D _dbnY;

    double _sumWXY;


  };


  inline Dbn2D operator + (const Dbn2D& a, const Dbn2D& b) {
    Dbn2D rtn = a;
    rtn += b;
    return rtn;
  }

  inline Dbn2D operator - (const Dbn2D& a, const Dbn2D& b) {
    Dbn2D rtn = a;
    rtn -= b;
    return rtn;
  }


}

#endif