SpecularSimulation.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Sim/Simulation/SpecularSimulation.cpp
//! @brief     Implements class OffspecSimulation.
//!
//! @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 "Sim/Simulation/SpecularSimulation.h"
#include "Base/Axis/PointwiseAxis.h"
#include "Base/Util/Assert.h"
#include "Device/Beam/IFootprintFactor.h"
#include "Device/Coord/CoordSystem1D.h"
#include "Device/Data/Datafield.h"
#include "Device/Histo/SimulationResult.h"
#include "Param/Distrib/Distributions.h"
#include "Resample/Element/SpecularElement.h"
#include "Resample/Processed/ReSample.h"
#include "Sim/Background/IBackground.h"
#include "Sim/Computation/SpecularComputation.h"
#include "Sim/Scan/AlphaScan.h"
 
//  ************************************************************************************************
//  class SpecularSimulation
//  ************************************************************************************************
 
SpecularSimulation::SpecularSimulation(const ISpecularScan& scan, const MultiLayer& sample)
    : ISimulation(sample)
    , m_scan(scan.clone())
{
    // TODO: move inside AlphaScan when pointwise resolution is implemented
    if (scan.coordinateAxis()->min() < 0.0)
        throw std::runtime_error("Invalid scan: minimum value on coordinate axis is negative");
}
 
SpecularSimulation::~SpecularSimulation() = default;
 
SpecularSimulation::SpecularSimulation(SpecularSimulation&&) = default;
 
size_t SpecularSimulation::numberOfElements() const
{
    return m_scan->numberOfElements();
}
 
SimulationResult SpecularSimulation::pack_result()
{
    ASSERT(!m_eles.empty());
    Datafield data({m_scan->coordinateAxis()->clone()}, m_scan->createIntensities(m_eles));
    return {data, createCoordSystem()};
}
 
size_t SpecularSimulation::intensityMapSize() const
{
    return m_scan->coordinateAxis()->size();
}
 
#ifndef SWIG
ICoordSystem* SpecularSimulation::createCoordSystem() const
{
    return m_scan->createCoordSystem();
}
#endif
 
void SpecularSimulation::initElementVector()
{
    m_eles = m_scan->generateElements();
 
    if (!m_cache.empty())
        return;
    m_cache.resize(m_eles.size(), 0);
}
 
std::unique_ptr<IComputation> SpecularSimulation::createComputation(const reSample& re_sample,
                                                                    size_t start, size_t n_elements)
{
    ASSERT(start < m_eles.size() && start + n_elements <= m_eles.size());
    const auto& begin = m_eles.begin() + static_cast<long>(start);
    return std::make_unique<SpecularComputation>(re_sample, options(), progress(), begin,
                                                 begin + static_cast<long>(n_elements));
}
 
void SpecularSimulation::checkCache() const
{
    ASSERT(m_eles.size() == m_cache.size());
}
 
void SpecularSimulation::validateParametrization(const ParameterDistribution& par_distr) const
{
    const bool zero_mean = par_distr.getDistribution()->mean() == 0.0;
    if (zero_mean)
        return;
    /* TODO come back to this after refactoring of distribution handling
    if (par_distr.whichParameter() == ParameterDistribution::BeamInclinationAngle)
        throw std::runtime_error("Error in SpecularSimulation: parameter distribution of "
                                 "beam inclination angle should have zero mean.");
    */
}
 
void SpecularSimulation::normalize(size_t start_ind, size_t n_elements)
{
    std::vector<double> footprints = m_scan->footprint(start_ind, n_elements);
 
    for (size_t i = start_ind, k = 0; i < start_ind + n_elements; ++i, ++k) {
        auto& element = m_eles[i];
        element.setIntensity(element.intensity() * footprints[k]);
    }
}
 
void SpecularSimulation::addBackgroundIntensity(size_t start_ind, size_t n_elements)
{
    if (!background())
        return;
    for (size_t i = start_ind, stop_point = start_ind + n_elements; i < stop_point; ++i) {
        auto& element = m_eles[i];
        element.setIntensity(background()->addBackground(element.intensity()));
    }
}
 
void SpecularSimulation::addDataToCache(double weight)
{
    checkCache();
    for (size_t i = 0, size = m_eles.size(); i < size; ++i)
        m_cache[i] += m_eles[i].intensity() * weight;
}
 
void SpecularSimulation::moveDataFromCache()
{
    checkCache();
    for (size_t i = 0, size = m_eles.size(); i < size; ++i)
        m_eles[i].setIntensity(m_cache[i]);
    m_cache.clear();
    m_cache.shrink_to_fit();
}
bool SpecularSimulation::force_polarized() const
{
    return m_scan->polarized();
}