MultiLayer.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Sample/Multilayer/MultiLayer.cpp
//! @brief     Implements class MultiLayer.
//!
//! @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 "Sample/Multilayer/MultiLayer.h"
 
#include "Base/Util/Assert.h"
#include "Fit/Param/RealLimits.h"
#include "Sample/Aggregate/ParticleLayout.h"
#include "Sample/Interface/LayerInterface.h"
#include "Sample/Interface/LayerRoughness.h"
#include "Sample/Material/MaterialUtils.h"
#include "Sample/Multilayer/Layer.h"
#include "Sample/Multilayer/MultilayerUtils.h"
#include <utility>
 
MultiLayer::MultiLayer(std::string name)
    : m_crossCorrLength(0)
    , m_sample_name(std::move(name))
{
    RealLimits::nonnegative().check("CrossCorrelationLength", m_crossCorrLength);
}
 
MultiLayer::~MultiLayer() = default;
 
MultiLayer* MultiLayer::clone() const
{
    auto* result = new MultiLayer;
    result->setCrossCorrLength(crossCorrLength());
    result->setExternalField(externalField());
    result->setRoughnessModel(roughnessModel());
    for (size_t i = 0; i < numberOfLayers(); ++i) {
        const LayerInterface* interface = i > 0 ? m_interfaces[i - 1] : nullptr;
        if (i > 0 && interface->roughness())
            result->addLayerWithTopRoughness(std::as_const(*m_layers[i]), *interface->roughness());
        else
            result->addLayer(std::as_const(*m_layers[i]));
    }
    return result;
}
 
//! Adds layer with default (zero) roughness
void MultiLayer::addLayer(const Layer& layer)
{
    LayerRoughness zero_roughness;
    addLayerWithTopRoughness(layer, zero_roughness);
}
 
//! Adds layer with top roughness
void MultiLayer::addLayerWithTopRoughness(const Layer& layer, const LayerRoughness& roughness)
{
    Layer* new_layer = layer.clone();
    if (numberOfLayers()) {
        // not the top layer
        const Layer* last_layer = m_layers.back();
        LayerInterface* interface(nullptr);
        if (roughness.sigma() != 0.0)
            interface = LayerInterface::createRoughInterface(last_layer, new_layer, roughness);
        else
            interface = LayerInterface::createSmoothInterface(last_layer, new_layer);
        addInterface(interface);
    } else {
        // the top layer
        if (new_layer->thickness() != 0.0) {
            delete new_layer;
            throw std::runtime_error(
                "Invalid call to MultiLayer::addLayer(): the semi-infinite top layer "
                "must have a pro forma thickness of 0");
        }
 
        if (roughness.sigma() != 0.0) {
            delete new_layer;
            throw std::runtime_error(
                "Invalid call to MultiLayer::addLayer(): the semi-infinite top layer "
                "cannot have roughness.");
        }
    }
    addLayer(new_layer);
}
 
const Layer* MultiLayer::layer(size_t i_layer) const
{
    return m_layers.at(i_layer);
}
 
const LayerInterface* MultiLayer::layerInterface(size_t i_interface) const
{
    return m_interfaces.at(i_interface);
}
 
void MultiLayer::setCrossCorrLength(double crossCorrLength)
{
    if (crossCorrLength < 0.0)
        throw std::runtime_error("Attempt to set crossCorrLength to negative value");
    m_crossCorrLength = crossCorrLength;
}
 
void MultiLayer::setExternalField(R3 ext_field)
{
    m_ext_field = ext_field;
}
 
void MultiLayer::setRoughnessModel(RoughnessModel roughnessModel)
{
    m_roughness_model = roughnessModel;
}
 
std::vector<const INode*> MultiLayer::nodeChildren() const
{
    std::vector<const INode*> result;
    const size_t N = m_layers.size();
    result.reserve(N + m_interfaces.size());
 
    for (size_t i = 0; i < N; ++i) {
        result.push_back(layer(i));
        if (i == N - 1)
            break;
        result.push_back(layerInterface(i));
    }
    return result;
}
 
void MultiLayer::addLayer(Layer* child)
{
    m_layers.emplace_back(child);
}
 
void MultiLayer::addInterface(LayerInterface* child)
{
    m_interfaces.emplace_back(child);
}