loads.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/CElement.h>
#include <openbeam/types.h>
 
#include <memory>
 
namespace openbeam
{
struct CLoadOnBeam
{
    CLoadOnBeam()          = default;
    virtual ~CLoadOnBeam() = default;
 
    using Ptr      = std::shared_ptr<CLoadOnBeam>;
    using ConstPtr = std::shared_ptr<const CLoadOnBeam>;
 
    virtual void computeStressAndEquivalentLoads(
        const CElement* el, ElementStress& stress,
        std::vector<array6>& loads) = 0;
 
    static CLoadOnBeam::Ptr createLoadByName(const std::string& sName);
 
    virtual void loadParamsFromSet(
        const mrpt::containers::yaml& p, const EvaluationContext& ctx) = 0;
 
    virtual void meshLoad(
        CStructureProblem&         meshed_fem,
        const std::vector<size_t>& meshed_element_idxs,
        const size_t               original_bar_idx,
        const CStructureProblem&   original_fem) const = 0;
 
    virtual mrpt::opengl::CSetOfObjects::Ptr getVisualization(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const = 0;
 
    virtual void getVisualization_init(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const
    {
    }
    virtual void getVisualization_pre(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const
    {
    }
};
 
struct CLoadConstTemperature : public CLoadOnBeam
{
    CLoadConstTemperature(const num_t inc_temp) : m_incr_temp(inc_temp) {}
 
    CLoadConstTemperature() = default;
 
    void computeStressAndEquivalentLoads(
        const CElement* el, ElementStress& stress,
        std::vector<array6>& loads) override;
    void loadParamsFromSet(
        const mrpt::containers::yaml& p, const EvaluationContext& ctx) override;
 
    void meshLoad(
        CStructureProblem&         meshed_fem,
        const std::vector<size_t>& meshed_element_idxs,
        const size_t               original_bar_idx,
        const CStructureProblem&   original_fem) const override;
 
    mrpt::opengl::CSetOfObjects::Ptr getVisualization(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const override;
 
    num_t m_incr_temp = UNINITIALIZED_VALUE;
};
 
struct CLoadDistributedUniform : public CLoadOnBeam
{
    CLoadDistributedUniform(num_t q_, num_t vx, num_t vy, num_t vz) : q(q_)
    {
        dir[0] = vx;
        dir[1] = vy;
        dir[2] = vz;
    }
 
    CLoadDistributedUniform() : q(UNINITIALIZED_VALUE)
    {
        dir[0] = dir[1] = dir[2] = UNINITIALIZED_VALUE;
    }
 
    void computeStressAndEquivalentLoads(
        const CElement* el, ElementStress& stress,
        std::vector<array6>& loads) override;
    void loadParamsFromSet(
        const mrpt::containers::yaml& p, const EvaluationContext& ctx) override;
 
    void meshLoad(
        CStructureProblem&         meshed_fem,
        const std::vector<size_t>& meshed_element_idxs,
        const size_t               original_bar_idx,
        const CStructureProblem&   original_fem) const override;
 
    mrpt::opengl::CSetOfObjects::Ptr getVisualization(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const override;
 
    void getVisualization_init(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const override;
 
    void getVisualization_pre(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const override;
 
    num_t q;  
    num_t dir[3];  
};
 
struct CLoadDistributedTriangular : public CLoadOnBeam
{
    CLoadDistributedTriangular(
        num_t q_ini_, num_t q_end_, num_t vx, num_t vy, num_t vz)
        : q_ini(q_ini_), q_end(q_end_)
    {
        dir[0] = vx;
        dir[1] = vy;
        dir[2] = vz;
    }
 
    CLoadDistributedTriangular()
        : q_ini(UNINITIALIZED_VALUE), q_end(UNINITIALIZED_VALUE)
    {
        dir[0] = dir[1] = dir[2] = UNINITIALIZED_VALUE;
    }
 
    void computeStressAndEquivalentLoads(
        const CElement* el, ElementStress& stress,
        std::vector<array6>& loads) override;
    void loadParamsFromSet(
        const mrpt::containers::yaml& p, const EvaluationContext& ctx) override;
 
    void meshLoad(
        CStructureProblem&         meshed_fem,
        const std::vector<size_t>& meshed_element_idxs,
        const size_t               original_bar_idx,
        const CStructureProblem&   original_fem) const override;
 
    mrpt::opengl::CSetOfObjects::Ptr getVisualization(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const override;
 
    num_t q_ini, q_end;
    num_t dir[3] = {0, 0, 0};  
};
 
struct CLoadConcentratedForce : public CLoadOnBeam
{
    CLoadConcentratedForce(num_t P_, num_t dist_, num_t vx, num_t vy, num_t vz)
        : P(P_), dist(dist_)
    {
        dir[0] = vx;
        dir[1] = vy;
        dir[2] = vz;
    }
 
    CLoadConcentratedForce() : P(UNINITIALIZED_VALUE), dist(UNINITIALIZED_VALUE)
    {
        dir[0] = dir[1] = dir[2] = UNINITIALIZED_VALUE;
    }
 
    void computeStressAndEquivalentLoads(
        const CElement* el, ElementStress& stress,
        std::vector<array6>& loads) override;
    void loadParamsFromSet(
        const mrpt::containers::yaml& p, const EvaluationContext& ctx) override;
 
    void meshLoad(
        CStructureProblem&         meshed_fem,
        const std::vector<size_t>& meshed_element_idxs,
        const size_t               original_bar_idx,
        const CStructureProblem&   original_fem) const override;
 
    mrpt::opengl::CSetOfObjects::Ptr getVisualization(
        const CFiniteElementProblem& fem, const DrawStructureOptions& options,
        const DrawElementExtraParams& draw_el_params,
        const MeshOutputInfo*         meshing_info) const override;
 
    num_t P;  
    num_t dist;  
    num_t dir[3];  
};
 
}  // namespace openbeam