DWBAComputation.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Sim/Computation/DWBAComputation.cpp
//! @brief     Implements class DWBAComputation.
//!
//! @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/Computation/DWBAComputation.h"
#include "Base/Progress/DelayedProgressCounter.h"
#include "Base/Progress/ProgressHandler.h"
#include "Resample/Element/DiffuseElement.h"
#include "Resample/Flux/IFlux.h"
#include "Resample/Options/SimulationOptions.h"
#include "Resample/Processed/ReLayout.h"
#include "Resample/Processed/ReSample.h"
#include "Sim/Contrib/GISASSpecularContribution.h"
#include "Sim/Contrib/ParticleLayoutContribution.h"
#include "Sim/Contrib/RoughMultiLayerContribution.h"
 
namespace {
 
std::vector<std::unique_ptr<const ParticleLayoutContribution>>
makeLayoutComputation(const std::vector<reLayout>& layouts, const SimulationOptions& options,
                      bool polarized)
{
    std::vector<std::unique_ptr<const ParticleLayoutContribution>> result;
 
    for (const reLayout& layout : layouts)
        result.emplace_back(new ParticleLayoutContribution(layout, options, polarized));
 
    return result;
}
 
} // namespace
 
 
DWBAComputation::DWBAComputation(const reSample& re_sample, const SimulationOptions& options,
                                 ProgressHandler& progress,
                                 std::vector<std::unique_ptr<DiffuseElement>>::iterator begin_it,
                                 std::vector<std::unique_ptr<DiffuseElement>>::iterator end_it)
    : IComputation(re_sample, options, progress)
    , m_begin_it(begin_it)
    , m_end_it(end_it)
    , m_specular_contrib(options.includeSpecular() ? new GISASSpecularContribution() : nullptr)
    , m_roughness_contrib(m_re_sample.hasRoughness() ? new RoughMultiLayerContribution(m_re_sample)
                                                     : nullptr)
    , m_layout_contribs(makeLayoutComputation(m_re_sample.layouts(), options,
                                              m_re_sample.containsMagneticMaterial()))
{
}
 
DWBAComputation::~DWBAComputation() = default;
 
// The normalization of the calculated scattering intensities is:
// For nanoparticles: rho * (scattering cross-section/scattering particle)
// For roughness: (scattering cross-section of area S)/S
// For specular peak: |R|^2 * sin(alpha_i) / solid_angle
// This allows them to be added and normalized together to the beam afterwards
void DWBAComputation::runProtected()
{
    for (auto it = m_begin_it; it != m_end_it; ++it) {
        if (!m_progress->alive())
            break;
        std::unique_ptr<DiffuseElement>& ele = *it;
 
        const Fluxes fluxes_in = m_re_sample.fluxesIn(ele->getKi());
        const Fluxes fluxes_out = m_re_sample.fluxesOut(ele->meanKf());
        ele->setFluxes(&fluxes_in, &fluxes_out);
 
        for (const auto& contrib : m_layout_contribs)
            contrib->compute(*ele);
 
        if (m_roughness_contrib)
            m_roughness_contrib->compute(*ele);
 
        if (m_specular_contrib)
            m_specular_contrib->compute(*ele);
 
        stepProgress();
    }
}