ProfileItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/ProfileItems.cpp
//! @brief     Implements Profile1DItem's classes
//!
//! @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 "GUI/Model/Sample/ProfileItems.h"
#include "Base/Const/Units.h"
#include "GUI/Support/XML/Serialize.h"
 
Profile1DItem::Profile1DItem()
{
    m_omega.init("Omega", "Half-width of the distribution", 1.0, Unit::nanometer, "omega");
}
 
void Profile1DItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_omega);
}
 
DoubleDescriptor Profile1DItem::omega() const
{
    return m_omega;
}
 
DoubleDescriptors Profile1DItem::valueDescriptors() const
{
    return {omega()};
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile1D> Profile1DCauchyItem::createProfile() const
{
    return std::make_unique<Profile1DCauchy>(omega());
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile1D> Profile1DGaussItem::createProfile() const
{
    return std::make_unique<Profile1DGauss>(omega());
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile1D> Profile1DGateItem::createProfile() const
{
    return std::make_unique<Profile1DGate>(omega());
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile1D> Profile1DTriangleItem::createProfile() const
{
    return std::make_unique<Profile1DTriangle>(omega());
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile1D> Profile1DCosineItem::createProfile() const
{
    return std::make_unique<Profile1DCosine>(omega());
}
 
// --------------------------------------------------------------------------------------------- //
 
Profile1DVoigtItem::Profile1DVoigtItem()
{
    m_eta.init("Eta", "Parameter [0,1] to balance between Cauchy (eta=0.0) and Gauss (eta=1.0)",
               0.5, Unit::unitless, 3, RealLimits::limited(0.0, 1.0), "eta");
}
 
std::unique_ptr<IProfile1D> Profile1DVoigtItem::createProfile() const
{
    return std::make_unique<Profile1DVoigt>(omega(), m_eta);
}
 
void Profile1DVoigtItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_omega);
    Serialize::rwProperty(s, m_eta);
}
 
DoubleDescriptor Profile1DVoigtItem::eta() const
{
    return m_eta;
}
 
DoubleDescriptors Profile1DVoigtItem::valueDescriptors() const
{
    return Profile1DItem::valueDescriptors() + DoubleDescriptors{eta()};
}
 
// --------------------------------------------------------------------------------------------- //
 
Profile2DItem::Profile2DItem()
{
    m_omegaX.init("OmegaX", "Half-width of the distribution along its x-axis", 1.0, Unit::nanometer,
                  "omegaX");
    m_omegaY.init("OmegaY", "Half-width of the distribution along its y-axis", 1.0, Unit::nanometer,
                  "omegaY");
    m_gamma.init(
        "Gamma",
        "Angle in direct space between first lattice vector and x-axis of the distribution", 0.0,
        Unit::degree, "gamma");
}
 
void Profile2DItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_omegaX);
    Serialize::rwProperty(s, m_omegaY);
    Serialize::rwProperty(s, m_gamma);
}
 
DoubleDescriptor Profile2DItem::omegaX() const
{
    return m_omegaX;
}
 
void Profile2DItem::setOmegaX(const double omega_x)
{
    m_omegaX.set(omega_x);
}
 
DoubleDescriptor Profile2DItem::omegaY() const
{
    return m_omegaY;
}
 
void Profile2DItem::setOmegaY(const double omega_y)
{
    m_omegaY.set(omega_y);
}
 
DoubleDescriptor Profile2DItem::gamma() const
{
    return m_gamma;
}
 
void Profile2DItem::setGamma(const double gamma)
{
    m_gamma.set(gamma);
}
 
DoubleDescriptors Profile2DItem::valueDescriptors() const
{
    return {omegaX(), omegaY(), gamma()};
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile2D> Profile2DCauchyItem::createProfile() const
{
    return std::make_unique<Profile2DCauchy>(omegaX(), omegaY(), Units::deg2rad(gamma()));
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile2D> Profile2DGaussItem::createProfile() const
{
    return std::make_unique<Profile2DGauss>(omegaX(), omegaY(), Units::deg2rad(gamma()));
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile2D> Profile2DGateItem::createProfile() const
{
    return std::make_unique<Profile2DGate>(omegaX(), omegaY(), Units::deg2rad(gamma()));
}
 
// --------------------------------------------------------------------------------------------- //
 
std::unique_ptr<IProfile2D> Profile2DConeItem::createProfile() const
{
    return std::make_unique<Profile2DCone>(omegaX(), omegaY(), Units::deg2rad(gamma()));
}
 
// --------------------------------------------------------------------------------------------- //
 
Profile2DVoigtItem::Profile2DVoigtItem()
{
    m_eta.init("Eta", "Parameter [0,1] to balance between Cauchy (eta=0.0) and Gauss (eta=1.0)",
               0.5, Unit::unitless, 3, RealLimits::limited(0.0, 1.0), "eta");
}
 
std::unique_ptr<IProfile2D> Profile2DVoigtItem::createProfile() const
{
    return std::make_unique<Profile2DVoigt>(omegaX(), omegaY(), Units::deg2rad(gamma()), m_eta);
}
 
void Profile2DVoigtItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_omegaX);
    Serialize::rwProperty(s, m_omegaY);
    Serialize::rwProperty(s, m_gamma);
    Serialize::rwProperty(s, m_eta);
}
 
DoubleDescriptor Profile2DVoigtItem::eta() const
{
    return m_eta;
}
 
void Profile2DVoigtItem::setEta(double eta)
{
    m_eta.set(eta);
}
 
DoubleDescriptors Profile2DVoigtItem::valueDescriptors() const
{
    return {omegaX(), omegaY(), eta(), gamma()};
}