types.h

/* +---------------------------------------------------------------------------+
   |              OpenBeam - C++ Finite Element Analysis library               |
   |                                                                           |
   |   Copyright (C) 2010-2021  Jose Luis Blanco Claraco                       |
   |                              University of Malaga                         |
   |                                                                           |
   | OpenBeam is free software: you can redistribute it and/or modify          |
   |     it under the terms of the GNU General Public License as published by  |
   |     the Free Software Foundation, either version 3 of the License, or     |
   |     (at your option) any later version.                                   |
   |                                                                           |
   | OpenBeam is distributed in the hope that it will be useful,               |
   |     but WITHOUT ANY WARRANTY; without even the implied warranty of        |
   |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         |
   |     GNU General Public License for more details.                          |
   |                                                                           |
   |     You should have received a copy of the GNU General Public License     |
   |     along with OpenBeam.  If not, see <http://www.gnu.org/licenses/>.     |
   |                                                                           |
   +---------------------------------------------------------------------------+
 */
 
#pragma once
 
#include <openbeam/config.h>
//
#include <mrpt/containers/yaml.h>
#include <mrpt/core/exceptions.h>  // ASSERT_(), etc.
#include <mrpt/core/format.h>  // mrpt::format()
#include <mrpt/math/TPoint3D.h>
#include <mrpt/system/CTimeLogger.h>
 
#include <Eigen/Dense>
#include <Eigen/StdVector>
#include <array>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <string>
 
#define OB_MESSAGE(VERBOSE_LEVEL)                       \
    if (openbeam::getVerbosityLevel() >= VERBOSE_LEVEL) \
    std::cout << "[" << __func__ << "] "
 
#define OB_TODO(x__) MRPT_TODO(x__)
 
namespace openbeam
{
inline num_t DEG2RAD(const num_t x) { return x * M_PI / num_t(180.0); }
inline num_t RAD2DEG(const num_t x) { return x * num_t(180.0) / M_PI; }
 
constexpr num_t UNINITIALIZED_VALUE = (std::numeric_limits<num_t>::max());
 
template <typename T>
inline T square(T x)
{
    return x * x;
}
 
extern mrpt::system::CTimeLogger timelog;  
 
using DynMatrix = Eigen::Matrix<num_t, Eigen::Dynamic, Eigen::Dynamic>;
using Matrix66  = Eigen::Matrix<num_t, 6, 6>;
using Matrix33  = Eigen::Matrix<num_t, 3, 3>;
using Vector6   = Eigen::Matrix<num_t, 6, 1>;
using Vector3   = Eigen::Matrix<num_t, 3, 1>;
 
using vector_string_t = std::vector<std::string>;
 
struct FaceStress
{
    FaceStress()  = default;
    ~FaceStress() = default;
 
    num_t N  = 0;  
    num_t Vy = 0;  
    num_t Vz = 0;  
    num_t Mx = 0;  
    num_t My = 0;  
    num_t Mz = 0;  
 
    num_t operator[](const int idx) const
    {
        switch (idx)
        {
            case 0:
                return N;
            case 1:
                return Vy;
            case 2:
                return Mz;
            case 3:
                return Vz;
            case 4:
                return My;
            case 5:
                return Mx;
            default:
                THROW_EXCEPTION("out of range");
        };
    }
    num_t& operator[](const int idx)
    {
        switch (idx)
        {
            case 0:
                return N;
            case 1:
                return Vy;
            case 2:
                return Mz;
            case 3:
                return Vz;
            case 4:
                return My;
            case 5:
                return Mx;
            default:
                THROW_EXCEPTION("out of range");
        };
    }
 
    FaceStress& operator+=(const FaceStress& o)
    {
        N += o.N;
        Vy += o.Vy;
        Vz += o.Vz;
        Mx += o.Mx;
        My += o.My;
        Mz += o.Mz;
        return *this;
    }
 
    template <class MAT>
    FaceStress& operator+=(const Eigen::MatrixBase<MAT>& o)
    {
        ASSERT_(o.size() == 6);
        N += o[0];
        Vy += o[1];
        Vz += o[2];
        Mx += o[3];
        My += o[4];
        Mz += o[5];
        return *this;
    }
};
 
using ElementStress = std::vector<FaceStress>;
 
// TODO: Move to its own header and put a forward decl here.
struct EvaluationContext
{
    EvaluationContext() = default;
 
    num_t evaluate(const std::string& sVarVal) const;
 
    num_t evaluate(const mrpt::containers::yaml& proxy) const
    {
        return evaluate(proxy.node().as<std::string>());
    }
 
    std::map<std::string, double> parameters;
 
    std::map<std::string, mrpt::containers::yaml> beamSectionParameters;
 
    vector_string_t* err_msgs  = nullptr;
    vector_string_t* warn_msgs = nullptr;
    unsigned int     lin_num   = 0;
 
    // Warning switches:
    const bool warn_unused_constraints = true;
};
 
struct TRotation3D
{
    inline TRotation3D() : rot(Matrix33::Identity()), m_is_pure_identity(true)
    {
    }
    TRotation3D(const num_t ang_x, const num_t ang_y, const num_t ang_z);
 
    inline const Matrix33& getRot() const { return rot; }
    inline void            setRot(const Matrix33& r)
    {
        rot                = r;
        m_is_pure_identity = false;
    }
 
    static void matrix2angles(
        const Matrix33& R, num_t& ang_x, num_t& ang_y, num_t& ang_z);
 
    bool isIdentity()
        const;  
 
   private:
    Matrix33 rot;
    bool     m_is_pure_identity;
};
 
using TPoint3D = mrpt::math::TPoint3D_<num_t>;
 
struct TRotationTrans3D
{
    TRotationTrans3D() = default;
 
    TRotationTrans3D(
        num_t x, num_t y, num_t z, num_t ang_x, num_t ang_y, num_t ang_z)
        : t(x, y, z), r(ang_x, ang_y, ang_z)
    {
    }
 
    TPoint3D    t;  
    TRotation3D r;  
 
    num_t distanceTo(const TRotationTrans3D& o) const
    {
        return t.distanceTo(o.t);
    }
};
 
void setVerbosityLevel(int verbose_level);
 
int getVerbosityLevel();
 
bool strCmpI(const std::string& s1, const std::string& s2);
 
num_t str2num(const std::string& s);
 
using mrpt::format;
using array6 = std::array<num_t, 6>;
 
using element_index_t = std::size_t;
using node_index_t    = std::size_t;
 
struct DrawStructureOptions;
struct RenderInitData;
struct DrawElementExtraParams;
struct StaticSolveProblemInfo;
 
}  // namespace openbeam