Lattice2DItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/Lattice2DItems.cpp
//! @brief     Implements classes Lattice2DItems
//!
//! @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/Lattice2DItems.h"
#include "Base/Const/Units.h"
#include "Base/Util/Assert.h"
#include "GUI/Support/XML/Serialize.h"
#include "Sample/Lattice/Lattice2D.h"
 
Lattice2DItem::Lattice2DItem()
{
    m_latticeRotationAngle.init(
        "Xi", "Rotation of lattice with respect to x-axis of reference frame (beam direction)", 0.0,
        Unit::degree, "xi");
}
 
double Lattice2DItem::unitCellArea() const
{
    return createLattice()->unitCellArea();
}
 
DoubleDescriptor Lattice2DItem::latticeRotationAngle() const
{
    return m_latticeRotationAngle;
}
 
void Lattice2DItem::setLatticeRotationAngle(const double angle)
{
    m_latticeRotationAngle.set(angle);
}
 
// --------------------------------------------------------------------------------------------- //
 
BasicLattice2DItem::BasicLattice2DItem()
{
    m_length1.init("LatticeLength1", "Length of first lattice vector", 20.0, Unit::nanometer,
                   "len1");
    m_length2.init("LatticeLength2", "Length of second lattice vector", 20.0, Unit::nanometer,
                   "len2");
    m_angle.init("Angle", "Angle between lattice vectors", 90.0, Unit::degree, "angle");
}
 
std::unique_ptr<Lattice2D> BasicLattice2DItem::createLattice() const
{
    return std::make_unique<BasicLattice2D>(m_length1, m_length2, Units::deg2rad(m_angle),
                                            Units::deg2rad(latticeRotationAngle()));
}
 
void BasicLattice2DItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_latticeRotationAngle);
    Serialize::rwProperty(s, m_length1);
    Serialize::rwProperty(s, m_length2);
    Serialize::rwProperty(s, m_angle);
}
 
DoubleDescriptor BasicLattice2DItem::latticeLength1() const
{
    return m_length1;
}
 
void BasicLattice2DItem::setLatticeLength1(const double length1)
{
    m_length1.set(length1);
}
 
DoubleDescriptor BasicLattice2DItem::latticeLength2() const
{
    return m_length2;
}
 
void BasicLattice2DItem::setLatticeLength2(const double length2)
{
    m_length2.set(length2);
}
 
DoubleDescriptor BasicLattice2DItem::latticeAngle() const
{
    return m_angle;
}
 
void BasicLattice2DItem::setLatticeAngle(const double angle)
{
    m_angle.set(angle);
}
 
// --------------------------------------------------------------------------------------------- //
 
SquareLattice2DItem::SquareLattice2DItem()
{
    m_length.init("LatticeLength", "Length of first and second lattice vectors", 20.0,
                  Unit::nanometer, "len");
}
 
std::unique_ptr<Lattice2D> SquareLattice2DItem::createLattice() const
{
    return std::make_unique<SquareLattice2D>(m_length, Units::deg2rad(latticeRotationAngle()));
}
 
void SquareLattice2DItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_latticeRotationAngle);
    Serialize::rwProperty(s, m_length);
}
 
DoubleDescriptor SquareLattice2DItem::latticeLength() const
{
    return m_length;
}
 
void SquareLattice2DItem::setLatticeLength(const double length)
{
    m_length.set(length);
}
 
// --------------------------------------------------------------------------------------------- //
 
HexagonalLattice2DItem::HexagonalLattice2DItem()
{
    m_length.init("LatticeLength", "Length of first and second lattice vectors", 20.0,
                  Unit::nanometer, "len");
}
 
std::unique_ptr<Lattice2D> HexagonalLattice2DItem::createLattice() const
{
    return std::make_unique<HexagonalLattice2D>(m_length, Units::deg2rad(latticeRotationAngle()));
}
 
void HexagonalLattice2DItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_latticeRotationAngle);
    Serialize::rwProperty(s, m_length);
}
 
DoubleDescriptor HexagonalLattice2DItem::latticeLength() const
{
    return m_length;
}
 
void HexagonalLattice2DItem::setLatticeLength(const double length)
{
    m_length.set(length);
}