DepthProbeComputation.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Sim/Computation/DepthProbeComputation.cpp
//! @brief     Implements class DepthProbeComputation.
//!
//! @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/DepthProbeComputation.h"
#include "Base/Axis/IAxis.h"
#include "Base/Element/DepthProbeElement.h"
#include "Base/Progress/ProgressHandler.h"
#include "Base/Util/Assert.h"
#include "Resample/Flux/ScalarFlux.h"
#include "Resample/Processed/ReSample.h"
 
DepthProbeComputation::DepthProbeComputation(const reSample& re_sample,
                                             const SimulationOptions& options,
                                             ProgressHandler& progress,
                                             DepthProbeElementIter begin_it,
                                             DepthProbeElementIter end_it)
    : IComputation(re_sample, options, progress)
    , m_begin_it(begin_it)
    , m_end_it(end_it)
{
}
 
DepthProbeComputation::~DepthProbeComputation() = default;
 
void DepthProbeComputation::runProtected()
{
    for (auto it = m_begin_it; it != m_end_it; ++it) {
        DepthProbeElement& ele = *it;
        if (!ele.isCalculated())
            continue;
 
        const IAxis& z_positions = *ele.getZPositions();
        const size_t n_z = z_positions.size();
        const size_t n_layers = m_re_sample.numberOfSlices();
        size_t start_z_ind = n_z;
        std::valarray<double> intensities(0.0, n_z);
 
        Fluxes fluxes = m_re_sample.fluxesIn(ele.getKi());
 
        double z_layer_bottom(0.0);
        double z_layer_top(0.0);
        for (size_t i_layer = 0; i_layer < n_layers && start_z_ind != 0; ++i_layer) {
            z_layer_bottom = m_re_sample.sliceBottomZ(i_layer);
            z_layer_top = i_layer ? m_re_sample.sliceTopZ(i_layer) : 0;
 
            // get R & T coefficients for current layer
            const auto* flux = dynamic_cast<const ScalarFlux*>(fluxes[i_layer].get());
            ASSERT(flux);
            const complex_t R = flux->getScalarR();
            const complex_t T = flux->getScalarT();
            const complex_t kz_out = flux->getScalarKz();
            const complex_t kz_in = -kz_out;
 
            // Compute intensity for z's of the layer
            size_t ip1_z = start_z_ind;
            for (; ip1_z > 0; --ip1_z) {
                const size_t i_z = ip1_z - 1;
                if (i_layer + 1 != n_layers && z_positions[i_z] <= z_layer_bottom)
                    break;
                const double z = z_positions[i_z] - z_layer_top;
                intensities[i_z] = std::norm(R * exp_I(kz_out * z) + T * exp_I(kz_in * z));
            }
            start_z_ind = ip1_z;
        }
        ele.setIntensities(std::move(intensities));
 
        stepProgress();
    }
}