InterferenceItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/InterferenceItems.cpp
//! @brief     Implements InterferenceItems's classes
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2021
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Sample/InterferenceItems.h"
#include "Base/Const/Units.h"
#include "GUI/Model/CatSample/Lattice2DItemCatalog.h"
#include "GUI/Model/CatSample/ProfileItemCatalogs.h"
#include "GUI/Model/Descriptor/UIntDescriptor.h"
#include "GUI/Model/Sample/Lattice2DItems.h"
#include "GUI/Model/Sample/ProfileItems.h"
#include "GUI/Support/XML/Serialize.h"
#include "Sample/Aggregate/Interferences.h"
 
InterferenceItem::InterferenceItem()
{
    m_positionVariance.init("PositionVariance", "Variance of the position in each dimension", 0.0,
                            Unit::nanometer2, "PositionVariance");
}
 
DoubleDescriptor InterferenceItem::positionVariance() const
{
    return m_positionVariance;
}
 
void InterferenceItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_positionVariance);
}
 
// --------------------------------------------------------------------------------------------- //
 
Interference1DLatticeItem::Interference1DLatticeItem()
{
    m_length.init("Length", "Lattice length", 20.0, Unit::nanometer, "Length");
    m_rotationAngle.init(
        "Xi", "Rotation of lattice with respect to x-axis of reference frame (beam direction)", 0.0,
        Unit::degree, "xi");
    m_decayFunction.init<Profile1DItemCatalog>(
        "Decay Function", "One-dimensional decay function (finite size effects)", "decay");
}
 
std::unique_ptr<IInterference> Interference1DLatticeItem::createInterference() const
{
    auto result =
        std::make_unique<Interference1DLattice>(m_length, Units::deg2rad(m_rotationAngle));
    result->setDecayFunction(*m_decayFunction->createProfile());
    result->setPositionVariance(positionVariance());
    return std::unique_ptr<IInterference>(result.release());
}
 
DoubleDescriptor Interference1DLatticeItem::length() const
{
    return m_length;
}
 
DoubleDescriptor Interference1DLatticeItem::rotationAngle() const
{
    return m_rotationAngle;
}
 
void Interference1DLatticeItem::setDecayFunction(Profile1DItem* p)
{
    m_decayFunction.set(p);
}
 
SelectionDescriptor<Profile1DItem*> Interference1DLatticeItem::decayFunction() const
{
    return m_decayFunction;
}
 
void Interference1DLatticeItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_positionVariance);
    Serialize::rwProperty(s, m_length);
    Serialize::rwProperty(s, m_rotationAngle);
    Serialize::rwSelected<Profile1DItemCatalog>(s, m_decayFunction);
}
 
// --------------------------------------------------------------------------------------------- //
 
SelectionDescriptor<Lattice2DItem*> Interference2DAbstractLatticeItem::latticeType() const
{
    return m_latticeType;
}
 
void Interference2DAbstractLatticeItem::setLatticeType(Lattice2DItem* p)
{
    m_latticeType.set(p);
}
 
bool Interference2DAbstractLatticeItem::xiIntegration() const
{
    return m_xiIntegration;
}
 
void Interference2DAbstractLatticeItem::setXiIntegration(bool xiIntegration)
{
    m_xiIntegration = xiIntegration;
}
 
Interference2DAbstractLatticeItem::Interference2DAbstractLatticeItem(bool xiIntegration)
    : m_xiIntegration(xiIntegration)
{
    m_latticeType.init<Lattice2DItemCatalog>("Lattice type", "", "latticeType");
    m_latticeType.set(new HexagonalLattice2DItem());
}
 
// --------------------------------------------------------------------------------------------- //
 
Interference2DLatticeItem::Interference2DLatticeItem()
    : Interference2DAbstractLatticeItem(false)
{
    m_decayFunction.init<Profile2DItemCatalog>(
        "Decay Function", "Two-dimensional decay function (finite size effects)", "decay");
}
 
std::unique_ptr<IInterference> Interference2DLatticeItem::createInterference() const
{
    Lattice2DItem* latticeItem = latticeType().currentItem();
    std::unique_ptr<Interference2DLattice> result(
        new Interference2DLattice(*latticeItem->createLattice()));
 
    result->setDecayFunction(*m_decayFunction->createProfile());
    result->setIntegrationOverXi(xiIntegration());
    result->setPositionVariance(positionVariance());
 
    return std::unique_ptr<IInterference>(result.release());
}
 
void Interference2DLatticeItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_positionVariance);
    Serialize::rwValue(s, "integrate", m_xiIntegration);
    Serialize::rwSelected<Lattice2DItemCatalog>(s, m_latticeType);
    Serialize::rwSelected<Profile2DItemCatalog>(s, m_decayFunction);
}
 
void Interference2DLatticeItem::setDecayFunctionType(Profile2DItem* p)
{
    m_decayFunction.set(p);
}
 
SelectionDescriptor<Profile2DItem*> Interference2DLatticeItem::decayFunction() const
{
    return m_decayFunction;
}
 
// --------------------------------------------------------------------------------------------- //
 
Interference2DParaCrystalItem::Interference2DParaCrystalItem()
    : Interference2DAbstractLatticeItem(true)
{
    m_dampingLength.init("Damping length", "The damping (coherence) length of the paracrystal", 0.0,
                         Unit::nanometer, "dampingLen");
    m_domainSize1.init("Domain size 1", "Size of the coherent domain along the first basis vector",
                       20000.0, Unit::nanometer, "size1");
    m_domainSize2.init("Domain size 2", "Size of the coherent domain along the second basis vector",
                       20000.0, Unit::nanometer, "size2");
    m_pdf1.init<Profile2DItemCatalog>(
        "PDF 1", "Probability distribution in first lattice direction", "pdf1");
    m_pdf2.init<Profile2DItemCatalog>(
        "PDF 2", "Probability distribution in second lattice direction", "pdf2");
}
 
std::unique_ptr<IInterference> Interference2DParaCrystalItem::createInterference() const
{
    Lattice2DItem* latticeItem = latticeType().currentItem();
 
    std::unique_ptr<Interference2DParaCrystal> result(
        new Interference2DParaCrystal(*latticeItem->createLattice(), 0, 0, 0));
 
    result->setDampingLength(m_dampingLength);
    result->setDomainSizes(m_domainSize1, m_domainSize2);
    result->setIntegrationOverXi(xiIntegration());
    result->setProbabilityDistributions(*m_pdf1->createProfile(), *m_pdf2->createProfile());
    result->setPositionVariance(positionVariance());
    return std::unique_ptr<IInterference>(result.release());
}
 
void Interference2DParaCrystalItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_positionVariance);
    Serialize::rwValue(s, "integrate", m_xiIntegration);
    Serialize::rwSelected<Lattice2DItemCatalog>(s, m_latticeType);
    Serialize::rwProperty(s, m_dampingLength);
    Serialize::rwProperty(s, m_domainSize1);
    Serialize::rwProperty(s, m_domainSize2);
    Serialize::rwSelected<Profile2DItemCatalog>(s, m_pdf1);
    Serialize::rwSelected<Profile2DItemCatalog>(s, m_pdf2);
}
 
DoubleDescriptor Interference2DParaCrystalItem::dampingLength() const
{
    return m_dampingLength;
}
 
void Interference2DParaCrystalItem::setDampingLength(double dampingLength)
{
    m_dampingLength.set(dampingLength);
}
 
DoubleDescriptor Interference2DParaCrystalItem::domainSize1() const
{
    return m_domainSize1;
}
 
void Interference2DParaCrystalItem::setDomainSize1(const double size)
{
    m_domainSize1.set(size);
}
 
DoubleDescriptor Interference2DParaCrystalItem::domainSize2() const
{
    return m_domainSize2;
}
 
void Interference2DParaCrystalItem::setDomainSize2(const double size)
{
    m_domainSize2.set(size);
}
 
SelectionDescriptor<Profile2DItem*> Interference2DParaCrystalItem::probabilityDistribution1() const
{
    return m_pdf1;
}
 
void Interference2DParaCrystalItem::setPDF1Type(Profile2DItem* p)
{
    m_pdf1.set(p);
}
 
SelectionDescriptor<Profile2DItem*> Interference2DParaCrystalItem::probabilityDistribution2() const
{
    return m_pdf2;
}
 
void Interference2DParaCrystalItem::setPDF2Type(Profile2DItem* p)
{
    m_pdf2.set(p);
}
 
// --------------------------------------------------------------------------------------------- //
 
InterferenceFinite2DLatticeItem::InterferenceFinite2DLatticeItem()
    : Interference2DAbstractLatticeItem(false)
{
    m_domainSize1.init("Domain size 1", "Domain size 1 in number of unit cells", 100,
                       Unit::unitless, "size1");
    m_domainSize2.init("Domain size 2", "Domain size 2 in number of unit cells", 100,
                       Unit::unitless, "size2");
}
 
std::unique_ptr<IInterference> InterferenceFinite2DLatticeItem::createInterference() const
{
    Lattice2DItem* latticeItem = latticeType().currentItem();
    auto result = std::make_unique<InterferenceFinite2DLattice>(*latticeItem->createLattice(),
                                                                m_domainSize1, m_domainSize2);
 
    result->setIntegrationOverXi(xiIntegration());
    result->setPositionVariance(positionVariance());
 
    return result;
}
 
void InterferenceFinite2DLatticeItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_positionVariance);
    Serialize::rwValue(s, "integrate", m_xiIntegration);
    Serialize::rwSelected<Lattice2DItemCatalog>(s, m_latticeType);
    Serialize::rwProperty(s, m_domainSize1);
    Serialize::rwProperty(s, m_domainSize2);
}
 
UIntDescriptor InterferenceFinite2DLatticeItem::domainSize1() const
{
    return m_domainSize1;
}
 
void InterferenceFinite2DLatticeItem::setDomainSize1(const unsigned int size)
{
    m_domainSize1.set(size);
}
 
UIntDescriptor InterferenceFinite2DLatticeItem::domainSize2() const
{
    return m_domainSize2;
}
 
void InterferenceFinite2DLatticeItem::setDomainSize2(const unsigned int size)
{
    m_domainSize2.set(size);
}
 
// --------------------------------------------------------------------------------------------- //
 
InterferenceHardDiskItem::InterferenceHardDiskItem()
{
    m_radius.init("Radius", "Hard disk radius", 5.0, Unit::nanometer, "radius");
    m_density.init("Total particle density", "Particle density in particles per area", 0.002,
                   Unit::nanometerMinus2, "density");
}
 
std::unique_ptr<IInterference> InterferenceHardDiskItem::createInterference() const
{
    auto result = std::make_unique<InterferenceHardDisk>(m_radius, m_density);
    result->setPositionVariance(positionVariance());
    return std::unique_ptr<IInterference>(result.release());
}
 
void InterferenceHardDiskItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_positionVariance);
    Serialize::rwProperty(s, m_radius);
    Serialize::rwProperty(s, m_density);
}
 
DoubleDescriptor InterferenceHardDiskItem::density() const
{
    return m_density;
}
 
DoubleDescriptor InterferenceHardDiskItem::radius() const
{
    return m_radius;
}
 
// --------------------------------------------------------------------------------------------- //
 
InterferenceRadialParaCrystalItem::InterferenceRadialParaCrystalItem()
{
    m_peakDistance.init("Peak distance", "Average distance to the next neighbor", 20.0,
                        Unit::nanometer, "peak");
    m_dampingLength.init("Damping length", "The damping (coherence) length of the paracrystal",
                         1000.0, Unit::nanometer, "dampingLen");
    m_domainSize.init("Domain size", "Size of coherence domain along the lattice main axis", 0.0,
                      Unit::nanometer, "size");
    m_kappa.init("SizeSpaceCoupling",
                 "Size spacing coupling parameter of the Size Spacing Correlation Approximation",
                 0.0, Unit::unitless, "kappa");
    m_pdf.init<Profile1DItemCatalog>("PDF", "One-dimensional probability distribution", "pdf");
}
 
std::unique_ptr<IInterference> InterferenceRadialParaCrystalItem::createInterference() const
{
    auto result = std::make_unique<InterferenceRadialParaCrystal>(m_peakDistance, m_dampingLength);
    result->setDomainSize(m_domainSize);
    result->setKappa(m_kappa);
    auto pdf = m_pdf->createProfile();
    result->setProbabilityDistribution(*pdf);
    result->setPositionVariance(positionVariance());
    return std::unique_ptr<IInterference>(result.release());
}
 
void InterferenceRadialParaCrystalItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_positionVariance);
    Serialize::rwProperty(s, m_peakDistance);
    Serialize::rwProperty(s, m_dampingLength);
    Serialize::rwProperty(s, m_domainSize);
    Serialize::rwProperty(s, m_kappa);
    Serialize::rwSelected<Profile1DItemCatalog>(s, m_pdf);
}
 
DoubleDescriptor InterferenceRadialParaCrystalItem::peakDistance() const
{
    return m_peakDistance;
}
 
DoubleDescriptor InterferenceRadialParaCrystalItem::dampingLength() const
{
    return m_dampingLength;
}
 
DoubleDescriptor InterferenceRadialParaCrystalItem::domainSize() const
{
    return m_domainSize;
}
 
DoubleDescriptor InterferenceRadialParaCrystalItem::kappa() const
{
    return m_kappa;
}
 
SelectionDescriptor<Profile1DItem*>
InterferenceRadialParaCrystalItem::probabilityDistribution() const
{
    return m_pdf;
}
 
void InterferenceRadialParaCrystalItem::setPDFType(Profile1DItem* p)
{
    m_pdf.set(p);
}