gsMaterialMatrixTFT.h

Go to the documentation of this file.

#pragma once

#include <gsKLShell/src/gsMaterialMatrixBase.h>
#include <gsKLShell/src/gsMaterialMatrixBaseDim.h>
#include <gsKLShell/src/gsMaterialMatrixUtils.h>

namespace gismo
{


template <  short_t dim,
            class T,
            bool linear=false
         >
class gsMaterialMatrixTFT : public gsMaterialMatrixBaseDim<dim,T>
{
public:
    typedef memory::shared_ptr< gsMaterialMatrixTFT > Ptr;

    typedef memory::unique_ptr< gsMaterialMatrixTFT > uPtr;

    typedef typename gsMaterialMatrixBase<T>::Ptr material_ptr;

    using Base = gsMaterialMatrixBaseDim<dim,T>;

    typedef typename gsFunctionSet<T>::Ptr function_ptr;

    // Define clone functions
    GISMO_OVERRIDE_CLONE_FUNCTION(gsMaterialMatrixTFT)

public:

    gsMaterialMatrixTFT(gsMaterialMatrixBase<T> * materialMatrix)
    :
    gsMaterialMatrixTFT(memory::make_shared_not_owned(materialMatrix))
    {}

    gsMaterialMatrixTFT(gsMaterialMatrixBase<T> & materialMatrix)
    :
    gsMaterialMatrixTFT(memory::make_shared(materialMatrix.clone().release()))
    {}

    gsMaterialMatrixTFT(const material_ptr & materialMatrix)
    :
    m_materialMat(give(materialMatrix))
    {
        if (materialMatrix.get()->hasUndeformed())
            this->setUndeformed(materialMatrix.get()->getUndeformed());
        if (materialMatrix.get()->hasDeformed())
            this->setDeformed(materialMatrix.get()->getDeformed());

        this->setThickness(materialMatrix.get()->getThickness());

        m_options.addReal("SlackMultiplier","Multiplies the original value of the matrix for the slack state",0);
        m_options.addSwitch("Explicit","Explicit iterations; use tension field from a fixed deformed geometry that does not change when calling setDeformed",false);
    }

    inline enum MatIntegration isMatIntegrated() const override
    // {return m_materialMat->isMatIntegrated(); gsWarn<<"Change this to a constant one, like for linear. So that no things out of the mid-plane are needed"; }
    {return MatIntegration::Linear;} // Multiplies with z t or its moment

    inline enum MatIntegration isVecIntegrated() const override
    // {return m_materialMat->isVecIntegrated(); gsWarn<<"Change this to a constant one, like for linear. So that no things out of the mid-plane are needed"; }
    {return MatIntegration::Linear;} // Multiplies with z t or its moment

    // bool isLinear() { return isLinear_impl(); }
    // typename util::enable_if<U::Linear,bool>::type
    // eval_impl(const U & u, const index_t k)
    // { return m_materialMat; }

    void density_into(const index_t patch, const gsMatrix<T>& u, gsMatrix<T>& result) const override
    { m_materialMat->density_into( patch,u,result ); }

    void thickness_into(const index_t patch, const gsMatrix<T> & u, gsMatrix<T>& result) const override
    { m_materialMat->thickness_into( patch,u,result ); }

    gsMatrix<T> eval3D_matrix(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;

    gsMatrix<T> eval3D_vector(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;

    gsMatrix<T> eval3D_pstress(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;

    gsMatrix<T> eval3D_pstrain(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z) const override;

    gsMatrix<T> eval3D_strain(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T> & z) const override;

    gsMatrix<T> eval3D_stress(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T> & z, enum MaterialOutput out) const override;

    gsMatrix<T> eval3D_CauchyStress(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T> & z, enum MaterialOutput out) const override;

    gsMatrix<T> eval3D_CauchyPStress(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T> & z, enum MaterialOutput out) const override
    {return m_materialMat->eval3D_CauchyPStress(patch,u,z,out);}

    gsMatrix<T> eval3D_tensionfield(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;

    gsMatrix<T> eval3D_theta(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;

    gsMatrix<T> eval3D_gamma(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;

    gsMatrix<T> eval3D_pstretch(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z) const override
    { return m_materialMat->eval3D_pstretch( patch,u,z ); }

    gsMatrix<T> eval3D_pstretchDir(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z) const override
    { return m_materialMat->eval3D_pstretchDir( patch,u,z ); }

    void setParameters(const std::vector<gsFunctionSet<T>*> &pars) override
    { m_materialMat->setParameters(pars); }

    void info() const override
    { m_materialMat->info(); }

    void setUndeformed(function_ptr undeformed) override
    {
        Base::setUndeformed(undeformed);
        m_materialMat->setUndeformed(m_patches);
    }

    void setDeformed(function_ptr deformed) override
    {
        Base::setDeformed(deformed);
        m_materialMat->setDeformed(m_defpatches);
    }

    void setUndeformed(const gsFunctionSet<T> * undeformed) override
    {
        Base::setUndeformed(undeformed);
        m_materialMat->setUndeformed(m_patches);
    }

    void setDeformed(const gsFunctionSet<T> * deformed) override
    {
        Base::setDeformed(deformed);
        m_materialMat->setDeformed(m_defpatches);
    }

    void updateDeformed(const gsFunctionSet<T> * deformed)
    {
        function_ptr fun = memory::make_shared_not_owned(deformed);
        m_defpatches0 = fun;
    }

    void updateDeformed(const function_ptr & deformed)
    {
        m_defpatches0 = deformed;
    }

    gsMatrix<T> eval_theta(const gsMatrix<T> & Cs, const gsMatrix<T> & Ns, const gsMatrix<T> & Es) const;

    std::ostream &print(std::ostream &os) const override;

    const gsMaterialMatrixBase<T> * material() const override { return m_materialMat.get(); }

    gsMaterialMatrixBase<T> * material() override { return m_materialMat.get(); }

protected:
    template <bool _linear>
    typename std::enable_if< _linear, gsMatrix<T> >::type _eval3D_matrix_impl(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const;

    template <bool _linear>
    typename std::enable_if<!_linear, gsMatrix<T> >::type _eval3D_matrix_impl(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const;

    gsMatrix<T> _compute_TF(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T> & z) const;
    gsMatrix<T> _compute_TF(const index_t patch, const gsVector<T> & u, const T & z)           const;

    gsMatrix<T> _compute_E(const T theta, const gsMatrix<T> & C, const gsMatrix<T> & S, const gsMatrix<T> & E) const;

    gsMatrix<T> _compute_S(const T theta, const gsMatrix<T> & C, const gsMatrix<T> & S) const;

    gsMatrix<T> _compute_C(const T theta, const gsMatrix<T> & C, const gsMatrix<T> & S) const;

    gsMatrix<T> _compute_C(const T theta, const gsMatrix<T> & C, const gsMatrix<T> & S, const gsMatrix<T> & dC) const;


    T _compute_gamma(const T & theta, const gsMatrix<T> & C, const gsVector<T> & N, const gsVector<T> & E) const;
    gsVector<T> _theta_interval(const gsMatrix<T> & C, const gsVector<T> & N, const gsVector<T> & E) const;
    bool _check_theta_full(const T & theta, const gsMatrix<T> & C, const gsVector<T> & N, const gsVector<T> & E) const;
    bool _check_theta_gamma(const T & theta, const gsMatrix<T> & C, const gsVector<T> & N, const gsVector<T> & E) const;

protected:

    mutable material_ptr m_materialMat;
    using Base::m_patches;
    using Base::m_defpatches;
    function_ptr m_defpatches0;
    using Base::m_options;

    using Base::m_data;

};

} // namespace


#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsMaterialMatrixTFT.hpp)
#endif