HistogramFactory.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <tracking/dqmUtils/DQMHistoModuleBase.h>
 
namespace Belle2::HistogramFactory {
  template <typename AType>
  class Parameter {
  public:
    explicit Parameter(const AType& defaultValue) :
      m_value(defaultValue), m_temporaryValue(defaultValue), m_isSet(false), m_isSetTemporarily(false)
    {}
 
    void Set(const AType& value);
    void Set(const Parameter<AType>& parameter);
    void SetTemporarily(const AType& value);
    void SetTemporarily(const Parameter<AType>& parameter);
 
    AType Get();
 
  private:
    AType m_value;
    AType m_temporaryValue;
    bool m_isSet;
    bool m_isSetTemporarily;
  };
 
  template <class AType>
  void Parameter<AType>::Set(const AType& value)
  {
    m_value = value;
    m_isSet = true;
  }
 
  template <class AType>
  void Parameter<AType>::Set(const Parameter<AType>& parameter)
  {
    if (parameter.m_isSet)
      Set(parameter.m_value);
  }
 
  template <class AType>
  void Parameter<AType>::SetTemporarily(const AType& value)
  {
    m_temporaryValue = value;
    m_isSetTemporarily = true;
  }
 
  template <class AType>
  void Parameter<AType>::SetTemporarily(const Parameter<AType>& parameter)
  {
    if (parameter.m_isSet)
      SetTemporarily(parameter.m_value);
  }
 
  template <class AType>
  AType Parameter<AType>::Get()
  {
    if (m_isSetTemporarily) {
      m_isSetTemporarily = false;
      return m_temporaryValue;
    } else {
      return m_value;
    }
  }
 
  class Axis {
  public:
    Axis() {}
 
    Axis(int nbins, double low, double up, std::string title)
    {
      m_nbins.Set(nbins);
      m_low.Set(low);
      m_up.Set(up);
      m_title.Set(title);
    }
 
    Axis& nbins(int nbins) { m_nbins.Set(nbins); return *this; }
    Axis& low(double low) { m_low.Set(low); return *this; }
    Axis& up(double up) { m_up.Set(up); return *this; }
    Axis& title(std::string title) { m_title.Set(title); return *this; }
 
  private:
    Parameter<int> m_nbins = Parameter(0);
    Parameter<double> m_low = Parameter(.0);
    Parameter<double> m_up = Parameter(.0);
    Parameter<std::string> m_title = Parameter(std::string());
 
    friend class Factory;
  };
 
  class Factory {
  public:
    explicit Factory(DQMHistoModuleBase* histoModule)
    {
      m_histoModule = histoModule;
    }
 
    Factory& xAxis(const Axis& axis)
    {
      m_nbinsx.SetTemporarily(axis.m_nbins);
      m_xlow.SetTemporarily(axis.m_low);
      m_xup.SetTemporarily(axis.m_up);
      m_xTitle.SetTemporarily(axis.m_title);
 
      return *this;
    }
 
    Factory& yAxis(const Axis& axis)
    {
      m_nbinsy.SetTemporarily(axis.m_nbins);
      m_ylow.SetTemporarily(axis.m_low);
      m_yup.SetTemporarily(axis.m_up);
      m_yTitle.SetTemporarily(axis.m_title);
 
      return *this;
    }
 
    Factory& xAxisDefault(const Axis& axis)
    {
      m_nbinsx.Set(axis.m_nbins);
      m_xlow.Set(axis.m_low);
      m_xup.Set(axis.m_up);
      m_xTitle.Set(axis.m_title);
 
      return *this;
    }
 
    Factory& yAxisDefault(const Axis& axis)
    {
      m_nbinsy.Set(axis.m_nbins);
      m_ylow.Set(axis.m_low);
      m_yup.Set(axis.m_up);
      m_yTitle.Set(axis.m_title);
 
      return *this;
    }
 
    TH1F* CreateTH1F(std::string name, std::string title);
    TH2F* CreateTH2F(std::string name, std::string title);
 
    TH1F** CreateLayersTH1F(boost::format nameTemplate, boost::format titleTemplate);
    TH2F** CreateLayersTH2F(boost::format nameTemplate, boost::format titleTemplate);
    TH1F** CreateSensorsTH1F(boost::format nameTemplate, boost::format titleTemplate);
    TH2F** CreateSensorsTH2F(boost::format nameTemplate, boost::format titleTemplate);
 
    Factory& nbinsxDefault(int nbinsx) {    m_nbinsx.Set(nbinsx); return *this; } 
    Factory& xlowDefault(double xlow) {     m_xlow.Set(xlow);     return *this; } 
    Factory& xupDefault(double xup) {       m_xup.Set(xup);       return *this; } 
    Factory& nbinsyDefault(int nbinsy) {    m_nbinsy.Set(nbinsy); return *this; } 
    Factory& ylowDefault(double ylow) {     m_ylow.Set(ylow);     return *this; } 
    Factory& yupDefault(double yup) {       m_yup.Set(yup);       return *this; } 
    Factory& xTitleDefault(std::string xTitle) { m_xTitle.Set(xTitle); return *this; } 
    Factory& yTitleDefault(std::string yTitle) { m_yTitle.Set(yTitle); return *this; } 
    Factory& zTitleDefault(std::string zTitle) { m_zTitle.Set(zTitle); return *this; } 
    Factory& nbinsx(int nbinsx) {    m_nbinsx.SetTemporarily(nbinsx); return *this; } 
    Factory& xlow(double xlow) {     m_xlow.SetTemporarily(xlow);     return *this; } 
    Factory& xup(double xup) {       m_xup.SetTemporarily(xup);       return *this; } 
    Factory& nbinsy(int nbinsy) {    m_nbinsy.SetTemporarily(nbinsy); return *this; } 
    Factory& ylow(double ylow) {     m_ylow.SetTemporarily(ylow);     return *this; } 
    Factory& yup(double yup) {       m_yup.SetTemporarily(yup);       return *this; } 
    Factory& xTitle(std::string xTitle) { m_xTitle.SetTemporarily(xTitle); return *this; } 
    Factory& yTitle(std::string yTitle) { m_yTitle.SetTemporarily(yTitle); return *this; } 
    Factory& zTitle(std::string zTitle) { m_zTitle.SetTemporarily(zTitle); return *this; } 
  private:
    DQMHistoModuleBase* m_histoModule;
 
    Parameter<int> m_nbinsx = Parameter(0); 
    Parameter<double> m_xlow = Parameter(.0); 
    Parameter<double> m_xup = Parameter(.0); 
    Parameter<std::string> m_xTitle = Parameter(std::string()); 
    Parameter<std::string> m_yTitle = Parameter(std::string()); 
    Parameter<int> m_nbinsy = Parameter(0); 
    Parameter<double> m_ylow = Parameter(.0); 
    Parameter<double> m_yup = Parameter(.0); 
    Parameter<std::string> m_zTitle = Parameter(std::string()); 
  };
}