gsElasticityFunctions.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsCore/gsMultiPatch.h>
#include <gsElasticity/gsBaseUtils.h>
#include <gsIO/gsOptionList.h>
 
namespace gismo
{
 
template <class T>
class gsCauchyStressFunction : public gsFunction<T>
{
public:
 
    gsCauchyStressFunction(index_t patch, stress_components::components comp,
                           const gsOptionList & options,
                           const gsMultiPatch<T> * geometry,
                           const gsMultiPatch<T> * displacement,
                           const gsMultiPatch<T> * pressure = nullptr,
                           const gsMultiPatch<T> * velocity = nullptr)
        : m_geometry(geometry),
          m_displacement(displacement),
          m_pressure(pressure),
          m_velocity(velocity),
          m_patch(patch),
          m_dim(m_geometry->patch(m_patch).parDim()),
          m_options(options),
          m_type(comp)
    {}
 
 
 
    virtual short_t domainDim() const
    {
        return m_geometry->patch(m_patch).parDim();
    }
 
    virtual short_t targetDim() const
    {
        switch(m_type)
        {
        case stress_components::von_mises: return 1;
        case stress_components::all_2D_vector: return 3;
        case stress_components::all_2D_matrix: return 2;
        case stress_components::normal_3D_vector: return 3;
        case stress_components::shear_3D_vector: return 3;
        case stress_components::all_3D_matrix: return 3;
        default: return 0;
        };
    }
 
    virtual void eval_into(const gsMatrix<T> & u, gsMatrix<T> & result) const
    {
        switch (material_law::law(m_options.getInt("MaterialLaw")))
        {
        case material_law::hooke : linearElastic(u,result); return;
        case material_law::saint_venant_kirchhoff : nonLinearElastic(u,result); return;
        case material_law::neo_hooke_ln : nonLinearElastic(u,result); return;
        case material_law::neo_hooke_quad : nonLinearElastic(u,result); return;
        case material_law::mixed_hooke : mixedLinearElastic(u,result); return;
        case material_law::mixed_neo_hooke_ln : mixedNonLinearElastic(u,result); return;
        case material_law::muscle : mixedNonLinearElastic(u,result); return;
        default: return;
        }
    }
 
protected:
 
    index_t outputCols(index_t inputCols) const
    {
        switch (m_type)
        {
        case stress_components::von_mises: return inputCols;
        case stress_components::all_2D_vector: return inputCols;
        case stress_components::all_2D_matrix: return 2*inputCols;
        case stress_components::normal_3D_vector: return inputCols;
        case stress_components::shear_3D_vector: return inputCols;
        case stress_components::all_3D_matrix: return 3*inputCols;
        default: return 0;
        }
    }
    void saveStress(const gsMatrix<T> & S, gsMatrix<T> & result, index_t q) const;
 
    void linearElastic(const gsMatrix<T> & u, gsMatrix<T> & result) const;
    void nonLinearElastic(const gsMatrix<T> & u, gsMatrix<T> & result) const;
    void mixedLinearElastic(const gsMatrix<T> & u, gsMatrix<T> & result) const;
    void mixedNonLinearElastic(const gsMatrix<T> & u, gsMatrix<T> & result) const;
 
protected:
    const gsMultiPatch<T> * m_geometry;
    const gsMultiPatch<T> * m_displacement;
    const gsMultiPatch<T> * m_pressure;
    const gsMultiPatch<T> * m_velocity;
    index_t m_patch;
    short_t m_dim;
    const gsOptionList & m_options;
    stress_components::components m_type;
 
}; // class definition ends
 
 
 
template <class T>
class gsDetFunction : public gsFunction<T>
{
public:
 
    gsDetFunction(const gsMultiPatch<T> & geo, index_t patch)
        : m_geo(geo),
          m_patch(patch)
    {}
 
    virtual short_t domainDim() const { return m_geo.domainDim(); }
 
    virtual short_t targetDim() const { return 1; }
 
    virtual void eval_into(const gsMatrix<T> & u, gsMatrix<T> & result) const;
 
protected:
 
    gsMultiPatch<T> const & m_geo;
    index_t m_patch;
 
}; // class definition ends
 
template <class T>
class gsFsiLoad : public gsFunction<T>
{
public:
 
    gsFsiLoad(const gsMultiPatch<T> & geoRef, const gsMultiPatch<T> & ALEdisplacement,
              index_t patchGeo, boxSide sideGeo,
              const gsMultiPatch<T> & velocity, const gsMultiPatch<T> & pressure,
              index_t patchVelPres, T viscosity, T density)
        : m_geo(geoRef),
          m_ale(ALEdisplacement),
          m_patchGeo(patchGeo),
          m_sideGeo(sideGeo),
          m_vel(velocity),
          m_pres(pressure),
          m_patchVP(patchVelPres),
          m_viscosity(viscosity),
          m_density(density)
    {}
 
    virtual short_t domainDim() const { return m_geo.domainDim(); }
 
    virtual short_t targetDim() const { return m_geo.domainDim(); }
 
    virtual void eval_into(const gsMatrix<T> & u, gsMatrix<T> & result) const;
 
protected:
 
    gsMultiPatch<T> const & m_geo;
    gsMultiPatch<T> const & m_ale;
    index_t m_patchGeo;
    boxSide m_sideGeo;
    gsMultiPatch<T> const & m_vel;
    gsMultiPatch<T> const & m_pres;
    index_t m_patchVP;
    T m_viscosity;
    T m_density;
 
}; // class definition ends
 
} // namespace ends
 
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsElasticityFunctions.hpp)
#endif