CDCDedxCosineCor.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 <framework/logging/Logger.h>
 
#include <TObject.h>
#include <cmath>
 
namespace Belle2 {

 
  class CDCDedxCosineCor: public TObject {
 
  public:

    CDCDedxCosineCor(): m_cosgains(), m_groupCosgains(), m_layerToGroup() {};

    explicit CDCDedxCosineCor(const std::vector<double>& cosgains): m_cosgains(cosgains), m_groupCosgains(),
      m_layerToGroup() {};

 
    CDCDedxCosineCor(const std::vector<std::vector<double>>& groupCosgains,
                     const std::vector<unsigned int>& layerToGroup);

    ~CDCDedxCosineCor() {};

    CDCDedxCosineCor& operator*=(const CDCDedxCosineCor& rhs);

    bool isGrouped() const
    {
      return !m_groupCosgains.empty();
    }

    unsigned int getNGroups() const
    {
      if (isGrouped()) return m_groupCosgains.size();
      return (m_cosgains.empty() ? 0 : 1);
    }

    unsigned int getNLayers() const
    {
      if (!m_layerToGroup.empty()) return m_layerToGroup.size();
 
      return 0;
    };

    unsigned int getGroup(unsigned int layer) const
    {
      if (layer >= getNLayers()) {
        B2ERROR("Layer out of range");
        return std::numeric_limits<unsigned int>::max();
      }
 
      if (!m_layerToGroup.empty()) {
        return m_layerToGroup[layer];
      }
 
      B2INFO("Invalid cosine correction payload state");
      return std::numeric_limits<unsigned int>::max();
    };

    unsigned int getSize(unsigned int layer) const
    {
      if (isGrouped()) {
        const unsigned int group = getGroup(layer);
        return m_groupCosgains[group].size();
      }
 
      return m_cosgains.size();
    }

    const std::vector<double>& getCosCor() const
    {
      return m_cosgains;
    }

    const std::vector<std::vector<double>>& getGroupCosCor() const
    {
      return m_groupCosgains;
    }

    const std::vector<unsigned int>& getLayerMap() const
    {
      return m_layerToGroup;
    }

    void setCosCor(unsigned int bin, double value);

    void setCosCor(unsigned int group, unsigned int bin, double value);

    double getMean(unsigned int bin) const;

    double getMean(double costh) const;

    double getMean(unsigned int layer, unsigned int bin) const;

    double getMean(unsigned int layer, double costh) const;
 
  private:

    double getMeanFromVector(const std::vector<double>& gains, double costh) const;

    bool isValidGroupedPayload() const;

    bool multiplyGains(std::vector<double>& lhs, const std::vector<double>& rhs) const;
 
    std::vector<double> m_cosgains; 
    std::vector<std::vector<double>> m_groupCosgains; 
    std::vector<unsigned int> m_layerToGroup; 
 
    ClassDef(CDCDedxCosineCor, 9); 
  };

} // end namespace Belle2