DistributionItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Descriptor/DistributionItems.cpp
//! @brief     Implements class DistributionItem and several subclasses
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2022
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Descriptor/DistributionItems.h"
#include "GUI/Model/Descriptor/DoubleDescriptor.h"
#include "GUI/Support/Type/GroupInfo.h"
#include "GUI/Support/XML/Serialize.h"
#include "Param/Distrib/Distributions.h"
#include "Param/Distrib/RangedDistributions.h"
#include <cmath>
 
DistributionItem::DistributionItem()
{
    m_numberOfSamples.init("Number of samples", "", 5, "", RealLimits::lowerLimited(1.0),
                           "nSamples");
}
 
void DistributionItem::setLimits(const RealLimits& limits)
{
    m_limits = limits;
}
 
void DistributionItem::initSigmaFactor()
{
    m_sigmaFactor.init("Sigma factor", "", 2.0, Unit::unitless, "sigmaFactor");
    addToSerialization(&m_sigmaFactor);
}
 
void DistributionItem::addToSerialization(DoubleProperty* d)
{
    m_serializationProperties << d;
}
 
bool DistributionItem::hasSigmaFactor() const
{
    return m_sigmaFactor.isInitialized();
}
 
void DistributionItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_numberOfSamples);
 
    for (auto* p : m_serializationProperties)
        Serialize::rwProperty(s, *p);
 
    // m_limits and a changed unit (with setUnit) will not be serialized here. They have to be set
    // again by the owner of DistributionItem after reading it
}
 
RealLimits DistributionItem::limits() const
{
    return m_limits;
}
 
// --------------------------------------------------------------------------------------------- //
 
SymmetricResolutionItem::SymmetricResolutionItem(double mean, int decimals,
                                                 const QString& meanLabel)
{
    m_mean.init(meanLabel, "", mean, Unit::unitless, decimals, RealLimits::limitless(), "mean");
    addToSerialization(&m_mean);
}
 
void SymmetricResolutionItem::setUnit(const variant<QString, Unit>& unit)
{
    m_mean.setUnit(unit);
}
 
void SymmetricResolutionItem::setLimits(const RealLimits& limits)
{
    DistributionItem::setLimits(limits);
    m_mean.setLimits(limits);
}
 
void SymmetricResolutionItem::setMeanDecimals(uint d)
{
    m_mean.setDecimals(d);
}
 
// --------------------------------------------------------------------------------------------- //
 
DistributionNoneItem::DistributionNoneItem()
    : SymmetricResolutionItem(0.1, 3, "Value")
{
}
 
std::unique_ptr<IDistribution1D> DistributionNoneItem::createDistribution(double) const
{
    return nullptr;
}
 
std::unique_ptr<IRangedDistribution> DistributionNoneItem::createIRangedDistribution(double) const
{
    return nullptr;
}
 
double DistributionNoneItem::deviation(double) const
{
    return 0.0;
}
 
void DistributionNoneItem::initDistribution(double value)
{
    setMean(value);
}
 
DoubleDescriptors DistributionNoneItem::distributionValues(bool withMean) const
{
    return withMean ? DoubleDescriptors{mean()} : DoubleDescriptors{};
}
 
// --------------------------------------------------------------------------------------------- //
 
DistributionGateItem::DistributionGateItem()
{
    m_minimum.init("Min", "", 0.0, Unit::unitless, 3, RealLimits::limitless(), "min");
    m_maximum.init("Max", "", 1.0, Unit::unitless, 3, RealLimits::limitless(), "max");
 
    addToSerialization(&m_minimum);
    addToSerialization(&m_maximum);
}
 
void DistributionGateItem::setUnit(const variant<QString, Unit>& unit)
{
    m_minimum.setUnit(unit);
    m_maximum.setUnit(unit);
}
 
std::unique_ptr<IDistribution1D> DistributionGateItem::createDistribution(double scale) const
{
    return std::make_unique<DistributionGate>(scale * m_minimum, scale * m_maximum);
}
 
void DistributionGateItem::initDistribution(double value)
{
    double sigma(0.1 * std::abs(value));
    if (sigma == 0.0)
        sigma = 0.1;
    m_minimum.set(value - sigma);
    m_maximum.set(value + sigma);
}
 
void DistributionGateItem::setRange(double min, double max)
{
    m_minimum.set(min);
    m_maximum.set(max);
}
 
DoubleDescriptors DistributionGateItem::distributionValues(bool /*withMean*/) const
{
    return {minimum(), maximum()};
}
 
// --------------------------------------------------------------------------------------------- //
 
DistributionLorentzItem::DistributionLorentzItem()
    : SymmetricResolutionItem(1.0)
{
    initSigmaFactor();
 
    m_hwhm.init("HWHM", "", 1.0, Unit::unitless, "hwhm");
    addToSerialization(&m_hwhm);
}
 
void DistributionLorentzItem::setUnit(const variant<QString, Unit>& unit)
{
    SymmetricResolutionItem::setUnit(unit);
    m_hwhm.setUnit(unit);
}
 
std::unique_ptr<IDistribution1D> DistributionLorentzItem::createDistribution(double scale) const
{
    return std::make_unique<DistributionLorentz>(scale * m_mean, scale * m_hwhm);
}
 
std::unique_ptr<IRangedDistribution>
DistributionLorentzItem::createIRangedDistribution(double scale) const
{
    return std::make_unique<RangedDistributionLorentz>(numberOfSamples(), sigmaFactor(),
                                                       m_limits.scaledLimits(scale));
}
 
double DistributionLorentzItem::deviation(double scale) const
{
    return m_hwhm * scale;
}
 
void DistributionLorentzItem::initDistribution(double value)
{
    double hw(0.1 * std::abs(value));
    if (hw == 0.0)
        hw = 0.1;
 
    setMean(value);
    setHwhm(hw);
    m_hwhm.setLimits(RealLimits::lowerLimited(0.0));
}
 
DoubleDescriptors DistributionLorentzItem::distributionValues(bool withMean) const
{
    return withMean ? DoubleDescriptors{mean(), hwhm(), sigmaFactor()}
                    : DoubleDescriptors{hwhm(), sigmaFactor()};
}
 
// --------------------------------------------------------------------------------------------- //
 
DistributionGaussianItem::DistributionGaussianItem()
    : SymmetricResolutionItem(1.0)
{
    initSigmaFactor();
 
    m_standardDeviation.init("StdDev", "", 1.0, Unit::unitless, 3, RealLimits::lowerLimited(0.0),
                             "stdDev");
    addToSerialization(&m_standardDeviation);
}
 
void DistributionGaussianItem::setUnit(const variant<QString, Unit>& unit)
{
    SymmetricResolutionItem::setUnit(unit);
    m_standardDeviation.setUnit(unit);
}
 
std::unique_ptr<IDistribution1D> DistributionGaussianItem::createDistribution(double scale) const
{
    return std::make_unique<DistributionGaussian>(scale * m_mean, scale * m_standardDeviation);
}
 
std::unique_ptr<IRangedDistribution>
DistributionGaussianItem::createIRangedDistribution(double scale) const
{
    return std::make_unique<RangedDistributionGaussian>(numberOfSamples(), sigmaFactor(),
                                                        m_limits.scaledLimits(scale));
}
 
double DistributionGaussianItem::deviation(double scale) const
{
    return standardDeviation() * scale;
}
 
void DistributionGaussianItem::initDistribution(double value)
{
    double stddev(0.1 * std::abs(value));
    if (stddev == 0.0)
        stddev = 0.1;
 
    setMean(value);
    setStandardDeviation(stddev);
}
 
DoubleDescriptors DistributionGaussianItem::distributionValues(bool withMean) const
{
    return withMean ? DoubleDescriptors{mean(), standardDeviation(), sigmaFactor()}
                    : DoubleDescriptors{standardDeviation(), sigmaFactor()};
}
 
// --------------------------------------------------------------------------------------------- //
 
DistributionLogNormalItem::DistributionLogNormalItem()
{
    initSigmaFactor();
 
    m_median.init("Median", "", 1.0, Unit::unitless, "median");
    m_scaleParameter.init("ScaleParameter", "", 1.0, Unit::unitless, 3,
                          RealLimits::lowerLimited(0.0), "scalePar");
 
    addToSerialization(&m_median);
    addToSerialization(&m_scaleParameter);
}
 
void DistributionLogNormalItem::setUnit(const variant<QString, Unit>& unit)
{
    m_median.setUnit(unit);
}
 
std::unique_ptr<IDistribution1D> DistributionLogNormalItem::createDistribution(double scale) const
{
    return std::make_unique<DistributionLogNormal>(scale * median(), scaleParameter());
}
 
void DistributionLogNormalItem::initDistribution(double value)
{
    double scale(0.1 * std::abs(value));
    if (scale == 0.0)
        scale = 0.1;
 
    setMedian(value);
    setScaleParameter(scale);
}
 
DoubleDescriptors DistributionLogNormalItem::distributionValues(bool /*withMean*/) const
{
    return {median(), scaleParameter(), sigmaFactor()};
}
 
// --------------------------------------------------------------------------------------------- //
 
DistributionCosineItem::DistributionCosineItem()
    : SymmetricResolutionItem(1.0)
{
    initSigmaFactor();
    m_sigma.init("Sigma", "", 1.0, Unit::unitless, 3, RealLimits::lowerLimited(0.0), "sigma");
    addToSerialization(&m_sigma);
}
 
void DistributionCosineItem::setUnit(const variant<QString, Unit>& unit)
{
    SymmetricResolutionItem::setUnit(unit);
    m_sigma.setUnit(unit);
}
 
std::unique_ptr<IDistribution1D> DistributionCosineItem::createDistribution(double scale) const
{
    return std::make_unique<DistributionCosine>(scale * m_mean, scale * sigma());
}
 
std::unique_ptr<IRangedDistribution>
DistributionCosineItem::createIRangedDistribution(double scale) const
{
    return std::make_unique<RangedDistributionCosine>(numberOfSamples(), sigmaFactor(),
                                                      m_limits.scaledLimits(scale));
}
 
double DistributionCosineItem::deviation(double scale) const
{
    return sigma() * scale;
}
 
void DistributionCosineItem::initDistribution(double value)
{
    double sigma(0.1 * std::abs(value));
    if (sigma == 0.0)
        sigma = 0.1;
 
    setMean(value);
    setSigma(sigma);
}
 
DoubleDescriptors DistributionCosineItem::distributionValues(bool withMean) const
{
    return withMean ? DoubleDescriptors{mean(), sigma(), sigmaFactor()}
                    : DoubleDescriptors{sigma(), sigmaFactor()};
    ;
}
 
// --------------------------------------------------------------------------------------------- //
 
DistributionTrapezoidItem::DistributionTrapezoidItem()
{
    m_center.init("Center", "", 1.0, Unit::unitless, 3, RealLimits::limitless(), "center");
    m_leftWidth.init("LeftWidth", "", 1.0, Unit::unitless, "left");
    m_middleWidth.init("MiddleWidth", "", 1.0, Unit::unitless, "middle");
    m_rightWidth.init("RightWidth", "", 1.0, Unit::unitless, "right");
 
    addToSerialization(&m_center);
    addToSerialization(&m_leftWidth);
    addToSerialization(&m_middleWidth);
    addToSerialization(&m_rightWidth);
}
 
void DistributionTrapezoidItem::setUnit(const variant<QString, Unit>& unit)
{
    m_center.setUnit(unit);
    m_leftWidth.setUnit(unit);
    m_middleWidth.setUnit(unit);
    m_rightWidth.setUnit(unit);
}
 
std::unique_ptr<IDistribution1D> DistributionTrapezoidItem::createDistribution(double scale) const
{
    return std::make_unique<DistributionTrapezoid>(scale * center(), scale * leftWidth(),
                                                   scale * middleWidth(), scale * rightWidth());
}
 
void DistributionTrapezoidItem::initDistribution(double value)
{
    double width(0.1 * std::abs(value));
    if (width == 0.0)
        width = 0.1;
    setCenter(value);
    setLeftWidth(width);
    setMiddleWidth(width);
    setRightWidth(width);
}
 
DoubleDescriptors DistributionTrapezoidItem::distributionValues(bool withMean) const
{
    return withMean ? DoubleDescriptors{center(), leftWidth(), middleWidth(), rightWidth()}
                    : DoubleDescriptors{leftWidth(), middleWidth(), rightWidth()};
}