SimulationResult.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Device/Histo/SimulationResult.cpp
//! @brief     Implements class SimulationResult.
//!
//! @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 "Device/Histo/SimulationResult.h"
#include "Base/Axis/IAxis.h"
#include "Base/Util/Assert.h"
#include "Device/Data/Datafield.h"
 
#include <stdexcept>
 
SimulationResult::SimulationResult(const Datafield& data, const ICoordSystem& coords)
    : m_data(data.clone())
    , m_coordsys(coords.clone())
{
    checkRank();
}
 
SimulationResult::SimulationResult(const Datafield& data, const ICoordSystem*&& coords)
    : m_data(data.clone())
    , m_coordsys(coords)
{
    checkRank();
}
 
SimulationResult::~SimulationResult() = default;
 
SimulationResult::SimulationResult(const SimulationResult& other)
{
    m_data.reset(other.m_data->clone());
    m_coordsys.reset(other.m_coordsys->clone());
}
 
SimulationResult::SimulationResult(SimulationResult&& other)
    : m_data(std::move(other.m_data))
    , m_coordsys(std::move(other.m_coordsys))
{
}
 
SimulationResult& SimulationResult::operator=(const SimulationResult& other)
{
    if (&other == this)
        return *this;
    m_data.reset(other.m_data->clone());
    m_coordsys.reset(other.m_coordsys->clone());
    return *this;
}
 
SimulationResult& SimulationResult::operator=(SimulationResult&& other)
{
    m_data = std::move(other.m_data);
    m_coordsys = std::move(other.m_coordsys);
    return *this;
}
 
size_t SimulationResult::rank() const
{
    return m_data->rank();
}
 
size_t SimulationResult::size() const
{
    return m_data ? m_data->size() : 0;
}
 
std::vector<double> SimulationResult::flatVector(Coords units) const
{
    std::unique_ptr<Datafield> f(datafield(units));
    return f->flatVector();
}
 
Datafield* SimulationResult::datafield(Coords units) const
{
    return m_coordsys->createConvertedData(*m_data, units);
}
 
std::pair<double, double> SimulationResult::axisMinMax(size_t i, Coords units) const
{
    return {m_coordsys->calculateMin(i, units), m_coordsys->calculateMax(i, units)};
}
 
std::string SimulationResult::axisName(size_t i, Coords units) const
{
    return m_coordsys->axisName(i, units);
}
 
const ICoordSystem& SimulationResult::converter() const
{
    return *m_coordsys;
}
 
double& SimulationResult::operator[](size_t i)
{
    return (*m_data)[i];
}
 
const double& SimulationResult::operator[](size_t i) const
{
    return (*m_data)[i];
}
 
SimulationResult SimulationResult::relativeToMaximum() const
{
    std::unique_ptr<Datafield> data2(m_data->normalizedToMaximum());
    return {*data2, m_coordsys->clone()};
}
 
#ifdef BORNAGAIN_PYTHON
PyObject* SimulationResult::array(Coords units) const
{
    std::unique_ptr<Datafield> data(m_coordsys->createConvertedData(*m_data, units));
    return data->npArray();
}
#endif
 
std::vector<double> SimulationResult::convertedBinCenters(Coords units) const
{
    return convertedBinCenters(0, units);
}
 
std::vector<double> SimulationResult::convertedBinCenters(size_t i_axis, Coords units) const
{
    if (i_axis >= m_coordsys->rank())
        throw std::runtime_error(
            "Error in SimulationResult::axis: no axis corresponds to passed index.");
    auto axis = m_coordsys->createConvertedAxis(i_axis, units);
    return axis->binCenters();
}
 
void SimulationResult::checkRank() const
{
    ASSERT(m_data);
    ASSERT(m_coordsys);
    ASSERT(m_data->rank() == m_coordsys->rank());
}