gsMaterialMatrixComposite.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>
#include <gsIO/gsOptionList.h>
#include <gsCore/gsFuncData.h>
 
namespace gismo
{
 
template <  short_t dim,
            class T
         >
class gsMaterialMatrixComposite : public gsMaterialMatrixBaseDim<dim,T>
{
public:
 
    GISMO_OVERRIDE_CLONE_FUNCTION(gsMaterialMatrixComposite)
 
    using Base = gsMaterialMatrixBaseDim<dim,T>;
 
    typedef typename Base::function_ptr function_ptr;
 
    gsMaterialMatrixComposite() { }
 
    gsMaterialMatrixComposite(
                            const gsFunctionSet<T>                              & mp,
                            const std::vector< gsFunctionSet<T> *>              & thickness,
                            const std::vector< gsFunctionSet<T> *>              & G,
                            const std::vector< gsFunctionSet<T> *>              & alpha,
                            const std::vector< gsFunctionSet<T> *>              & rho           );
 
    gsMaterialMatrixComposite(
                            const gsFunctionSet<T>                              & mp,
                            const std::vector< gsFunctionSet<T> *>              & thickness,
                            const std::vector< gsFunctionSet<T> *>              & G,
                            const std::vector< gsFunctionSet<T> *>              & alpha         );
 
    enum MatIntegration isMatIntegrated() const override {return MatIntegration::Integrated; }
    enum MatIntegration isVecIntegrated() const override {return MatIntegration::Integrated; }
 
    gsOptionList & options() override {return m_options;}
    void setOptions(gsOptionList opt) override {m_options.update(opt,gsOptionList::addIfUnknown); }
 
    // template COM
    void density_into(const index_t patch, const gsMatrix<T>& u, gsMatrix<T>& result) const override;
    // template COM
    void pstretch_into(const index_t /*patch*/, const gsMatrix<T>& /*u*/, gsMatrix<T>& /*result*/) const override
    {GISMO_NO_IMPLEMENTATION;}
    void pstretchDir_into(const index_t /*patch*/, const gsMatrix<T>& /*u*/, gsMatrix<T>& /*result*/) const override
    {GISMO_NO_IMPLEMENTATION;}
    void pstress_into(const index_t /*patch*/, const gsMatrix<T>& /*u*/, gsMatrix<T>& /*result*/) const override
    {GISMO_NO_IMPLEMENTATION;}
    void pstressDir_into(const index_t /*patch*/, const gsMatrix<T>& /*u*/, gsMatrix<T>& /*result*/) const override
    {GISMO_NO_IMPLEMENTATION;}
 
    void thickness_into(const index_t patch, const gsMatrix<T> & u, gsMatrix<T>& result) const override;
 
    void parameters_into(const index_t /*patch*/, const gsMatrix<T> & /*u*/, gsMatrix<T>& /*result*/) const override
    {GISMO_NO_IMPLEMENTATION;}
 
    void transform_into(const index_t /*patch*/, const gsMatrix<T> & /*u*/, gsMatrix<T>& /*result*/) const override
    {GISMO_NO_IMPLEMENTATION;}
 
    void covtransform_into(const index_t /*patch*/, const gsMatrix<T> & /*u*/, gsMatrix<T>& /*result*/) const
    {GISMO_NO_IMPLEMENTATION;}
 
    void pstressTransform_into(const index_t /*patch*/, const gsMatrix<T> & /*u*/, gsMatrix<T>& /*result*/) const
    {GISMO_NO_IMPLEMENTATION;}
 
    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;
 
    std::ostream &print(std::ostream &os) const override;
 
    bool initialized() const override
    {
        return m_patches!=nullptr;
    }
 
public:
    typedef memory::shared_ptr< gsMaterialMatrixComposite > Ptr;
 
    typedef memory::unique_ptr< gsMaterialMatrixComposite > uPtr;
 
protected:
    void _initialize(const index_t nLayers);
    void _defaultOptions();
 
    gsMatrix<T> _transformationMatrix(const gsMatrix<T> & phi, const gsMatrix<T> & u) const;
    // NOTE: it could be that these matrices should be transposed!!
    gsMatrix<T> _cart2cov(const gsVector<T> & a1, const gsVector<T> & a2, const gsVector<T> & e1, const gsVector<T> & e2) const;
    gsMatrix<T> _con2cart(const gsVector<T> & ac1, const gsVector<T> & ac2, const gsVector<T> & e1, const gsVector<T> & e2) const;
 
protected:
 
    // template MAT
    void _computePoints(const index_t patch, const gsMatrix<T> & u, bool basis = true) const;
 
protected:
 
    // constructor
    using Base::m_patches;
    using Base::m_defpatches;
 
    // Composite
    index_t m_nLayers;
 
    // Geometric data
    using Base::m_data;
 
 
    gsOptionList m_options;
 
    std::vector< function_ptr > m_Ts;
    std::vector< function_ptr > m_Gs;
    std::vector< function_ptr > m_As;
    std::vector< function_ptr > m_Rs;
    mutable util::gsThreaded<std::vector< gsMatrix<T> >> m_Gcontainer, m_Tcontainer, m_Acontainer, m_Rcontainer;
};
 
} // namespace
 
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsMaterialMatrixComposite.hpp)
#endif