CElement.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 <mrpt/opengl/CSetOfObjects.h>
#include <openbeam/types.h>
 
#include <memory>
 
namespace openbeam
{
class CFiniteElementProblem;
struct MeshParams;
struct MeshOutputInfo;
class CStructureProblem;
 
struct TStiffnessSubmatrix
{
    size_t   edge_in, edge_out;
    Matrix66 matrix;
};
 
using used_DoFs_t = std::array<bool, 6>;
 
class CElement
{
   public:
    using Ptr      = std::shared_ptr<CElement>;
    using ConstPtr = std::shared_ptr<const CElement>;
 
    static Ptr createElementByName(const std::string& sName);
 
    std::vector<size_t> conected_nodes_ids;
 
    unsigned char getNumberEdges() const { return m_nEdges; }
 
    virtual std::string asString() const { return ""; }
 
    virtual void getLocalStiffnessMatrices(
        std::vector<TStiffnessSubmatrix>& outSubMats) const = 0;
 
    virtual void getLocalDoFs(std::vector<used_DoFs_t>& dofs) const = 0;
 
    void getGlobalDoFs(std::vector<used_DoFs_t>& dofs) const;
 
    virtual void getGlobalStiffnessMatrices(
        std::vector<TStiffnessSubmatrix>& outSubMats) const;
 
    void setGlobalOrientation(const TRotation3D& new_orientation)
    {
        m_global_orientation = new_orientation;
    }
    const TRotation3D& getGlobalOrientation() const
    {
        return m_global_orientation;
    }
 
    virtual void updateOrientationFromNodePositions();
 
    void setDesignRotationAroundLinearAxis(num_t ang)
    {
        m_design_rotation_around_linear_axis = ang;
    }
 
    void setParent(CFiniteElementProblem* parent) { m_parent = parent; }
 
    virtual void loadParamsFromSet(
        const mrpt::containers::yaml& p, const EvaluationContext& ctx) = 0;
 
    void loadParamsFromSet(const mrpt::containers::yaml& p)
    {
        EvaluationContext def;
        loadParamsFromSet(p, def);
    }
 
    CFiniteElementProblem* getParent() const { return m_parent; }
 
    virtual void drawSVG(
        void* _cairo_context, const DrawStructureOptions& options,
        const RenderInitData& ri, const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo* meshing_info) const = 0;
 
    virtual mrpt::opengl::CSetOfObjects::Ptr getVisualization(
        const DrawStructureOptions&   options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const = 0;
 
    virtual void do_mesh(
        const size_t my_idx, CStructureProblem& out_fem,
        MeshOutputInfo& out_info, const MeshParams& params) = 0;
 
   protected:
    CElement(unsigned char nEdges);
    CElement(
        unsigned char nEdges, const size_t from_node_id,
        const size_t to_node_id);  
 
    const unsigned char    m_nEdges;
    CFiniteElementProblem* m_parent;
 
    num_t m_design_rotation_around_linear_axis;
 
    TRotation3D m_global_orientation;
};
}  // namespace openbeam