RotationItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/RotationItems.cpp
//! @brief     Implements class RotationItems
//!
//! @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/RotationItems.h"
#include "Base/Const/Units.h"
#include "Base/Vector/RotMatrix.h"
#include "GUI/Support/XML/Serialize.h"
#include "Sample/Scattering/Rotations.h"
 
using namespace Units;
 
// ----------------------------------------------------------------------------
 
RotationItem::RotationItem() {}
 
RotMatrix RotationItem::rotation() const
{
    auto p = createRotation();
    return (p != nullptr) ? p->rotMatrix() : RotMatrix();
}
 
// ----------------------------------------------------------------------------
 
XRotationItem::XRotationItem()
{
    m_angle.init("Angle", "Rotation angle around x-axis", 0.0, Unit::degree, "angle");
}
 
void XRotationItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_angle);
}
 
unique_ptr<IRotation> XRotationItem::createRotation() const
{
    return std::make_unique<RotationX>(deg2rad(angle()));
}
 
DoubleDescriptor XRotationItem::angle() const
{
    return m_angle;
}
 
// ----------------------------------------------------------------------------
 
YRotationItem::YRotationItem()
{
    m_angle.init("Angle", "Rotation angle around y-axis", 0.0, Unit::degree, "angle");
}
 
void YRotationItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_angle);
}
 
unique_ptr<IRotation> YRotationItem::createRotation() const
{
    return std::make_unique<RotationY>(deg2rad(angle()));
}
 
DoubleDescriptor YRotationItem::angle() const
{
    return m_angle;
}
 
// ----------------------------------------------------------------------------
 
ZRotationItem::ZRotationItem()
{
    m_angle.init("Angle", "Rotation angle around z-axis", 0.0, Unit::degree, "angle");
}
 
void ZRotationItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_angle);
}
 
unique_ptr<IRotation> ZRotationItem::createRotation() const
{
    return std::make_unique<RotationZ>(deg2rad(angle()));
}
 
DoubleDescriptor ZRotationItem::angle() const
{
    return m_angle;
}
 
// ----------------------------------------------------------------------------
 
EulerRotationItem::EulerRotationItem()
{
    m_alpha.init("Alpha", "First Euler angle in z-x'-z' sequence", 0.0, Unit::degree, "alpha");
    m_beta.init("Beta", "Second Euler angle in z-x'-z' sequence", 0.0, Unit::degree, "beta");
    m_gamma.init("Gamma", "Third Euler angle in z-x'-z' sequence", 0.0, Unit::degree, "gamma");
}
 
void EulerRotationItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_alpha);
    Serialize::rwProperty(s, m_beta);
    Serialize::rwProperty(s, m_gamma);
}
 
unique_ptr<IRotation> EulerRotationItem::createRotation() const
{
    return std::make_unique<RotationEuler>(deg2rad(alpha()), deg2rad(beta()), deg2rad(gamma()));
}
 
DoubleDescriptor EulerRotationItem::alpha() const
{
    return m_alpha;
}
 
DoubleDescriptor EulerRotationItem::beta() const
{
    return m_beta;
}
 
DoubleDescriptor EulerRotationItem::gamma() const
{
    return m_gamma;
}