FormFactorItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/FormFactorItems.cpp
//! @brief     Implements FormFactorItems 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/FormFactorItems.h"
#include "Base/Const/Units.h"
#include "Sample/HardParticle/HardParticles.h"
 
/* ------------------------------------------------ */
 
Pyramid2Item::Pyramid2Item()
{
    m_length.init("Length", "Length of the rectangular base", 20.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the rectangular base", 16.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of pyramid", 13.0, Unit::nanometer, "height");
    m_alpha.init("Alpha", "Dihedral angle between base and facet", 60.0, Unit::degree, "alpha");
}
 
std::unique_ptr<IFormFactor> Pyramid2Item::createFormFactor() const
{
    return std::make_unique<Pyramid2>(length(), width(), height(), alpha() * Units::deg);
}
 
/* ------------------------------------------------ */
 
BarGaussItem::BarGaussItem()
{
    m_length.init("Length", "Length of the base", 20.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the base", 16.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the box", 13.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> BarGaussItem::createFormFactor() const
{
    return std::make_unique<BarGauss>(length(), width(), height());
}
 
/* ------------------------------------------------ */
 
BarLorentzItem::BarLorentzItem()
{
    m_length.init("Length", "Length of the base", 20.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the base", 16.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the box", 13.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> BarLorentzItem::createFormFactor() const
{
    return std::make_unique<BarLorentz>(length(), width(), height());
}
 
/* ------------------------------------------------ */
 
BoxItem::BoxItem()
{
    m_length.init("Length", "Length of the base", 20.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the base", 16.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the box", 13.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> BoxItem::createFormFactor() const
{
    return std::make_unique<Box>(length(), width(), height());
}
 
/* ------------------------------------------------ */
 
ConeItem::ConeItem()
{
    m_radius.init("Radius", "Radius of the base", 10.0, Unit::nanometer, "radius");
    m_height.init("Height", "Height of the cone", 13.0, Unit::nanometer, "height");
    m_alpha.init("Alpha", "Angle between the base and the side surface", 60.0, Unit::degree,
                 "alpha");
}
 
std::unique_ptr<IFormFactor> ConeItem::createFormFactor() const
{
    return std::make_unique<Cone>(radius(), height(), alpha() * Units::deg);
}
 
/* ------------------------------------------------ */
 
Pyramid6Item::Pyramid6Item()
{
    m_baseEdge.init("Base edge", "Edge of the regular hexagonal base", 10.0, Unit::nanometer,
                    "baseEdge");
    m_height.init("Height", "Height of a truncated pyramid", 13.0, Unit::nanometer, "height");
    m_alpha.init("Alpha", "Dihedral angle between base and facet", 60.0, Unit::degree, "alpha");
}
 
std::unique_ptr<IFormFactor> Pyramid6Item::createFormFactor() const
{
    return std::make_unique<Pyramid6>(baseEdge(), height(), alpha() * Units::deg);
}
 
/* ------------------------------------------------ */
 
Bipyramid4Item::Bipyramid4Item()
{
    m_length.init("Length", "Side length of the common square base", 20.0, Unit::nanometer,
                  "length");
 
    m_height.init("Height", "Height of the lower pyramid", 13.0, Unit::nanometer, "height");
 
    m_heightRatio.init("Height ratio", "Ratio of heights of top to bottom pyramids", 0.7,
                       Unit::unitless, 3, RealLimits::lowerLimited(0.0), "heightRatio");
 
    m_alpha.init("Alpha", "Dihedral angle between base and facets", 60.0, Unit::degree, "alpha");
}
 
std::unique_ptr<IFormFactor> Bipyramid4Item::createFormFactor() const
{
    return std::make_unique<Bipyramid4>(length(), height(), heightRatio(), alpha() * Units::deg);
}
 
/* ------------------------------------------------ */
 
CylinderItem::CylinderItem()
{
    m_radius.init("Radius", "Radius of the circular base", 8.0, Unit::nanometer, "radius");
    m_height.init("Height", "Height of the cylinder", 16.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> CylinderItem::createFormFactor() const
{
    return std::make_unique<Cylinder>(radius(), height());
}
 
/* ------------------------------------------------ */
 
DodecahedronItem::DodecahedronItem()
{
    m_edge.init("Edge", "Length of the edge", 10.0, Unit::nanometer, "edge");
}
 
std::unique_ptr<IFormFactor> DodecahedronItem::createFormFactor() const
{
    return std::make_unique<Dodecahedron>(edge());
}
 
/* ------------------------------------------------ */
 
EllipsoidalCylinderItem::EllipsoidalCylinderItem()
{
    m_radiusX.init("Radius x", "Radius of the ellipse base in the x-direction", 8.0,
                   Unit::nanometer, "radiusX");
    m_radiusY.init("Radius y", "Radius of the ellipse base in the y-direction", 13.0,
                   Unit::nanometer, "radiusY");
    m_height.init("Height", "Height of the ellipsoidal cylinder", 16.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> EllipsoidalCylinderItem::createFormFactor() const
{
    return std::make_unique<EllipsoidalCylinder>(radiusX(), radiusY(), height());
}
 
/* ------------------------------------------------ */
 
SphereItem::SphereItem()
{
    m_radius.init("Radius", "Radius of the sphere", 8.0, Unit::nanometer, "radius");
}
 
std::unique_ptr<IFormFactor> SphereItem::createFormFactor() const
{
    return std::make_unique<Sphere>(radius());
}
 
/* ------------------------------------------------ */
 
SpheroidItem::SpheroidItem()
{
    m_radius.init("Radius", "Radius of the circular cross section", 10.0, Unit::nanometer,
                  "radius");
    m_height.init("Height", "Height of the full spheroid", 13.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> SpheroidItem::createFormFactor() const
{
    return std::make_unique<Spheroid>(radius(), height());
}
 
/* ------------------------------------------------ */
 
HemiEllipsoidItem::HemiEllipsoidItem()
{
    m_radiusX.init("Radius x", "Radius of the ellipse base in the x-direction", 10.0,
                   Unit::nanometer, "radiusX");
    m_radiusY.init("Radius y", "Radius of the ellipse base in the y-direction", 6.0,
                   Unit::nanometer, "radiusY");
    m_height.init("Height", "Height of the hemi ellipsoid", 8.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> HemiEllipsoidItem::createFormFactor() const
{
    return std::make_unique<HemiEllipsoid>(radiusX(), radiusY(), height());
}
 
/* ------------------------------------------------ */
 
IcosahedronItem::IcosahedronItem()
{
    m_edge.init("Edge", "Length of the edge", 10.0, Unit::nanometer, "edge");
}
 
std::unique_ptr<IFormFactor> IcosahedronItem::createFormFactor() const
{
    return std::make_unique<Icosahedron>(edge());
}
 
/* ------------------------------------------------ */
 
Prism3Item::Prism3Item()
{
    m_baseEdge.init("Base edge", "Length of the base edge", 10.0, Unit::nanometer, "baseEdge");
    m_height.init("Height", "Height", 13.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> Prism3Item::createFormFactor() const
{
    return std::make_unique<Prism3>(baseEdge(), height());
}
 
/* ------------------------------------------------ */
 
Prism6Item::Prism6Item()
{
    m_baseEdge.init("Base edge", "Length of the hexagonal base", 5.0, Unit::nanometer, "baseEdge");
    m_height.init("Height", "Height", 11.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> Prism6Item::createFormFactor() const
{
    return std::make_unique<Prism6>(baseEdge(), height());
}
 
/* ------------------------------------------------ */
 
Pyramid4Item::Pyramid4Item()
{
    m_baseEdge.init("Base edge", "Length of the square base", 18.0, Unit::nanometer, "baseEdge");
    m_height.init("Height", "Height of the pyramid", 13.0, Unit::nanometer, "height");
    m_alpha.init("Alpha", "Dihedral angle between the base and a side face", 60.0, Unit::degree,
                 "alpha");
}
 
std::unique_ptr<IFormFactor> Pyramid4Item::createFormFactor() const
{
    return std::make_unique<Pyramid4>(baseEdge(), height(), alpha() * Units::deg);
}
 
/* ------------------------------------------------ */
 
CosineRippleBoxItem::CosineRippleBoxItem()
{
    m_length.init("Length", "Length of the rectangular base", 27.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the rectangular base", 20.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the ripple", 14.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> CosineRippleBoxItem::createFormFactor() const
{
    return std::make_unique<CosineRippleBox>(length(), width(), height());
}
 
/* ------------------------------------------------ */
 
CosineRippleGaussItem::CosineRippleGaussItem()
{
    m_length.init("Length", "Length of the rectangular base", 27.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the rectangular base", 20.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the ripple", 14.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> CosineRippleGaussItem::createFormFactor() const
{
    return std::make_unique<CosineRippleGauss>(length(), width(), height());
}
 
/* ------------------------------------------------ */
 
CosineRippleLorentzItem::CosineRippleLorentzItem()
{
    m_length.init("Length", "Length of the rectangular base", 27.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the rectangular base", 20.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the ripple", 14.0, Unit::nanometer, "height");
}
 
std::unique_ptr<IFormFactor> CosineRippleLorentzItem::createFormFactor() const
{
    return std::make_unique<CosineRippleLorentz>(length(), width(), height());
}
 
/* ------------------------------------------------ */
 
SawtoothRippleBoxItem::SawtoothRippleBoxItem()
{
    m_length.init("Length", "Length of the rectangular base", 36.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the rectangular base", 25.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the ripple", 14.0, Unit::nanometer, "height");
    m_asymmetry.init("Asymmetry", "Asymmetry length of the triangular profile", 3.0,
                     Unit::nanometer, "asymmetry");
}
 
std::unique_ptr<IFormFactor> SawtoothRippleBoxItem::createFormFactor() const
{
    return std::make_unique<SawtoothRippleBox>(length(), width(), height(), asymmetry());
}
 
/* ------------------------------------------------ */
 
SawtoothRippleGaussItem::SawtoothRippleGaussItem()
{
    m_length.init("Length", "Length of the rectangular base", 36.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the rectangular base", 25.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the ripple", 14.0, Unit::nanometer, "height");
    m_asymmetry.init("Asymmetry", "Asymmetry length of the triangular profile", 3.0,
                     Unit::nanometer, "asymmetry");
}
 
std::unique_ptr<IFormFactor> SawtoothRippleGaussItem::createFormFactor() const
{
    return std::make_unique<SawtoothRippleGauss>(length(), width(), height(), asymmetry());
}
 
/* ------------------------------------------------ */
 
SawtoothRippleLorentzItem::SawtoothRippleLorentzItem()
{
    m_length.init("Length", "Length of the rectangular base", 36.0, Unit::nanometer, "length");
    m_width.init("Width", "Width of the rectangular base", 25.0, Unit::nanometer, "width");
    m_height.init("Height", "Height of the ripple", 14.0, Unit::nanometer, "height");
    m_asymmetry.init("Asymmetry", "Asymmetry length of the triangular profile", 3.0,
                     Unit::nanometer, "asymmetry");
}
 
std::unique_ptr<IFormFactor> SawtoothRippleLorentzItem::createFormFactor() const
{
    return std::make_unique<SawtoothRippleLorentz>(length(), width(), height(), asymmetry());
}
 
/* ------------------------------------------------ */
 
Pyramid3Item::Pyramid3Item()
{
    m_baseEdge.init("Base edge", "Length of one edge of the equilateral triangular base", 15.0,
                    Unit::nanometer, "baseEdge");
    m_height.init("Height", "Height of the tetrahedron", 6.0, Unit::nanometer, "height");
    m_alpha.init("Alpha", "Dihedral angle between base and facet", 60.0, Unit::degree, "alpha");
}
 
std::unique_ptr<IFormFactor> Pyramid3Item::createFormFactor() const
{
    return std::make_unique<Pyramid3>(baseEdge(), height(), alpha() * Units::deg);
}
 
/* ------------------------------------------------ */
 
TruncatedCubeItem::TruncatedCubeItem()
{
    m_length.init("Length", "Length of the full cube's edge", 15.0, Unit::nanometer, "length");
    m_removedLength.init("Removed length", "Removed length from each corner of the cube", 6.0,
                         Unit::nanometer, "removedLength");
}
 
std::unique_ptr<IFormFactor> TruncatedCubeItem::createFormFactor() const
{
    return std::make_unique<TruncatedCube>(length(), removedLength());
}
 
/* ------------------------------------------------ */
 
TruncatedSphereItem::TruncatedSphereItem()
{
    m_radius.init("Radius", "Radius of the truncated sphere", 5.0, Unit::nanometer, "radius");
    m_height.init("Height", "Height of the truncated sphere", 7.0, Unit::nanometer, "height");
    m_removedTop.init("Delta height", "Height of the removed top cap", 0.0, Unit::nanometer,
                      "removedTop");
}
 
std::unique_ptr<IFormFactor> TruncatedSphereItem::createFormFactor() const
{
    return std::make_unique<TruncatedSphere>(radius(), height(), removedTop());
}
 
/* ------------------------------------------------ */
 
TruncatedSpheroidItem::TruncatedSpheroidItem()
{
    m_radius.init("Radius", "Radius of the truncated spheroid", 7.5, Unit::nanometer, "radius");
    m_height.init("Height", "Height of the truncated spheroid", 9.0, Unit::nanometer, "height");
    m_heightFlattening.init(
        "Height flattening",
        "Ratio of the height of the corresponding full spheroid to its diameter", 1.2,
        Unit::unitless, "heightFlattening");
 
    m_removedTop.init("Delta height", "Height of the removed top cap", 0.0, Unit::nanometer,
                      "removedTop");
}
 
std::unique_ptr<IFormFactor> TruncatedSpheroidItem::createFormFactor() const
{
    return std::make_unique<TruncatedSpheroid>(radius(), height(), heightFlattening(),
                                               removedTop());
}
 
/* ------------------------------------------------ */
 
CantellatedCubeItem::CantellatedCubeItem()
{
    m_length.init("Length", "Length of the full cube's edge", 15.0, Unit::nanometer, "length");
    m_removedLength.init("Removed length", "Removed length from each edge and vertice of the cube",
                         6.0, Unit::nanometer, "removedLength");
}
 
std::unique_ptr<IFormFactor> CantellatedCubeItem::createFormFactor() const
{
    return std::make_unique<CantellatedCube>(length(), removedLength());
}
 
/* ------------------------------------------------ */
 
HorizontalCylinderItem::HorizontalCylinderItem()
{
    m_radius.init("Radius", "Radius of the horizontal cylinder", 7.5, Unit::nanometer, "radius");
    m_length.init("Length", "Length of the horizontal cylinder", 9.0, Unit::nanometer, "length");
    m_sliceBottom.init("Bottom boundary", "Position of the lower boundary relative to the center",
                       -4.1, Unit::nanometer, "sliceBottom");
    m_sliceTop.init("Top boundary", "Position of the upper boundary relative to the center", +5.2,
                    Unit::nanometer, "sliceTop");
}
 
std::unique_ptr<IFormFactor> HorizontalCylinderItem::createFormFactor() const
{
    return std::make_unique<HorizontalCylinder>(radius(), length(), sliceBottom(), sliceTop());
}
 
/* ------------------------------------------------ */
 
PlatonicOctahedronItem::PlatonicOctahedronItem()
{
    m_edge.init("Edge", "Length of the edge", 10.0, Unit::nanometer, "edge");
}
 
std::unique_ptr<IFormFactor> PlatonicOctahedronItem::createFormFactor() const
{
    return std::make_unique<PlatonicOctahedron>(edge());
}
 
/* ------------------------------------------------ */
 
PlatonicTetrahedronItem::PlatonicTetrahedronItem()
{
    m_edge.init("Edge", "Length of the edge", 10.0, Unit::nanometer, "edge");
}
 
std::unique_ptr<IFormFactor> PlatonicTetrahedronItem::createFormFactor() const
{
    return std::make_unique<PlatonicTetrahedron>(edge());
}
 
 
void FormFactorItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    for (auto* p : serializationProperties())
        Serialize::rwProperty(s, *p);
}