gsMaterialMatrixTFT.h

Go to the documentation of this file.

 
#pragma once
 
#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:
 
    // /**
    //  * @brief      Constructs a TFT material matrix using a reference to another material matrix
    //  *
    //  * @param      materialMatrix  The original material matrix
    //  */
    // gsMaterialMatrixTFT(typename gsMaterialMatrixBase<T>::uPtr materialMatrix)
    // :
    // gsMaterialMatrixTFT(memory::make_shared(materialMatrix->clone().release()))
    // {}
 
    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;
    using Base::eval3D_matrix;
 
    gsMatrix<T> eval3D_vector(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;
    using Base::eval3D_vector;
 
    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;
    using Base::eval3D_strain;
 
    gsMatrix<T> eval3D_stress(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T> & z, enum MaterialOutput out) const override;
    using Base::eval3D_stress;
 
    gsMatrix<T> eval3D_CauchyStress(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T> & z, enum MaterialOutput out) const override;
    using Base::eval3D_CauchyStress;
 
    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;
    using Base::eval3D_tensionfield;
 
    gsMatrix<T> eval3D_theta(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;
    using Base::eval3D_theta;
 
    gsMatrix<T> eval3D_gamma(const index_t patch, const gsMatrix<T> & u, const gsMatrix<T>& z, enum MaterialOutput out = MaterialOutput::Generic) const override;
    using Base::eval3D_gamma;
 
    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); }
    using Base::setParameters;
 
    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