RotMatrix.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Base/Vector/RotMatrix.cpp
//! @brief     Implements class RotMatrix.
//!
//! @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 "Base/Vector/RotMatrix.h"
 
RotMatrix::RotMatrix(double x_, double y_, double z_, double s_)
    : x(x_)
    , y(y_)
    , z(z_)
    , s(s_)
{
}
 
RotMatrix::RotMatrix()
    : RotMatrix(0, 0, 0, 1)
{
}
 
RotMatrix RotMatrix::AroundX(double phi)
{
    return {sin(phi / 2), 0, 0, cos(phi / 2)};
}
 
RotMatrix RotMatrix::AroundY(double phi)
{
    return {0, sin(phi / 2), 0, cos(phi / 2)};
}
 
RotMatrix RotMatrix::AroundZ(double phi)
{
    return {0, 0, sin(phi / 2), cos(phi / 2)};
}
 
RotMatrix RotMatrix::EulerZXZ(double alpha, double beta, double gamma)
{
    RotMatrix zrot = AroundZ(alpha);
    RotMatrix xrot = AroundX(beta);
    RotMatrix zrot2 = AroundZ(gamma);
    return zrot * xrot * zrot2;
}
 
std::array<double, 3> RotMatrix::zxzEulerAngles() const
{
    double m00 = (-1 + 2 * x * x + 2 * s * s);
    double m02 = 2 * (x * z + y * s);
    double m10 = 2 * (y * x + z * s);
    double m12 = 2 * (y * z - x * s);
    double m20 = 2 * (z * x - y * s);
    double m21 = 2 * (z * y + x * s);
    double m22 = (-1 + 2 * z * z + 2 * s * s);
 
    const double beta = std::acos(m22);
 
    if (std::abs(m22) == 1.0) // second z angle is zero or pi
        return {std::atan2(m10, m00), beta, 0.};
    return {std::atan2(m02, -m12), beta, std::atan2(m20, m21)};
}
 
RotMatrix RotMatrix::Inverse() const
{
    return {-x, -y, -z, s};
}
 
template <class T>
T RotMatrix::transformed(const T& v) const
{
    auto xf = (-1 + 2 * x * x + 2 * s * s) * v.x() + 2 * (x * y - z * s) * v.y()
              + 2 * (x * z + y * s) * v.z();
    auto yf = (-1 + 2 * y * y + 2 * s * s) * v.y() + 2 * (y * z - x * s) * v.z()
              + 2 * (y * x + z * s) * v.x();
    auto zf = (-1 + 2 * z * z + 2 * s * s) * v.z() + 2 * (z * x - y * s) * v.x()
              + 2 * (z * y + x * s) * v.y();
 
    return T(xf, yf, zf);
}
 
template R3 RotMatrix::transformed<R3>(const R3& v) const;
template C3 RotMatrix::transformed<C3>(const C3& v) const;
 
template <class T>
T RotMatrix::counterTransformed(const T& v) const
{
    return Inverse().transformed(v);
}
 
template R3 RotMatrix::counterTransformed<R3>(const R3& v) const;
template C3 RotMatrix::counterTransformed<C3>(const C3& v) const;
 
RotMatrix RotMatrix::operator*(const RotMatrix& o) const
{
    return {s * o.x + x * o.s + y * o.z - z * o.y, s * o.y + y * o.s + z * o.x - x * o.z,
            s * o.z + z * o.s + x * o.y - y * o.x, s * o.s - x * o.x - y * o.y - z * o.z};
}
 
bool RotMatrix::operator==(const RotMatrix& o) const
{
    return x == o.x && y == o.y && z == o.z && s == o.s;
}
 
bool RotMatrix::isIdentity() const
{
    return x == 0 && y == 0 && z == 0;
}
 
bool RotMatrix::isXRotation() const
{
    return y == 0 && z == 0;
}
 
bool RotMatrix::isYRotation() const
{
    return z == 0 && x == 0;
}
 
bool RotMatrix::isZRotation() const
{
    return x == 0 && y == 0;
}
 
std::optional<double> RotMatrix::angleAroundCoordAxis(int iAxis) const
{
    if (iAxis == 0 && isXRotation())
        return 2 * atan2(x, s);
    if (iAxis == 1 && isYRotation())
        return 2 * atan2(y, s);
    if (iAxis == 2 && isZRotation())
        return 2 * atan2(z, s);
    return {};
}