ConstKBinAxis.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Base/Axis/ConstKBinAxis.cpp
//! @brief     Implement class ConstKBinAxis.
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "Base/Axis/ConstKBinAxis.h"
#include "Base/Axis/Bin.h"
#include "Base/Util/Algorithms.h"
#include <cmath>
#include <iomanip>
 
ConstKBinAxis::ConstKBinAxis(const std::string& name, size_t nbins)
    : VariableBinAxis(name, nbins)
    , m_start(0)
    , m_end(0)
{
}
 
ConstKBinAxis::ConstKBinAxis(const std::string& name, size_t nbins, double start, double end)
    : VariableBinAxis(name, nbins)
    , m_start(start)
    , m_end(end)
{
    if (m_start >= m_end)
        throw std::runtime_error(
            "ConstKBinAxis::ConstKBinAxis() -> Error. start >= end is not allowed.");
 
    double start_sin = std::sin(m_start);
    double end_sin = std::sin(m_end);
    double step = (end_sin - start_sin) / (m_nbins);
 
    std::vector<double> bin_boundaries;
    bin_boundaries.resize(m_nbins + 1, 0.0);
    for (size_t i = 0; i < bin_boundaries.size(); ++i)
        bin_boundaries[i] = std::asin(start_sin + step * i);
    setBinBoundaries(bin_boundaries);
}
 
ConstKBinAxis* ConstKBinAxis::clone() const
{
    return new ConstKBinAxis(axisName(), m_nbins, m_start, m_end);
}
 
void ConstKBinAxis::clip(double lower, double upper)
{
    if (lower >= upper)
        throw std::runtime_error(
            "ConstKBinAxis::clip() -> Error. 'lower' should be smaller than 'upper'");
 
    if (lower < min())
        lower = bin(0).center();
    if (upper >= max())
        upper = bin(size() - 1).center();
 
    size_t nbin1 = findClosestIndex(lower);
    size_t nbin2 = findClosestIndex(upper);
 
    size_t new_nbins = nbin2 - nbin1 + 1;
    std::vector<double> new_boundaries;
    std::vector<double> old_boundaries = binBoundaries();
    for (size_t i = 0; i < new_nbins + 1; ++i)
        new_boundaries.push_back(old_boundaries[nbin1 + i]);
 
    m_nbins = new_nbins;
    m_start = new_boundaries.front();
    m_end = new_boundaries.back();
    setBinBoundaries(new_boundaries);
}
 
bool ConstKBinAxis::equals(const IAxis& other) const
{
    if (!IAxis::equals(other))
        return false;
    if (const auto* otherAxis = dynamic_cast<const ConstKBinAxis*>(&other)) {
        if (size() != otherAxis->size())
            return false;
        if (!BaseUtils::algo::almostEqual(m_start, otherAxis->m_start))
            return false;
        if (!BaseUtils::algo::almostEqual(m_end, otherAxis->m_end))
            return false;
        return true;
    }
    return false;
}
 
void ConstKBinAxis::print(std::ostream& ostr) const
{
    ostr << "ConstKBinAxis(\"" << axisName() << "\", " << size() << ", "
         << std::setprecision(std::numeric_limits<double>::digits10 + 2) << m_start << ", " << m_end
         << ")";
}