gsBiharmonicExprAssembler.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsAssembler/gsExprAssembler.h>
#include <gsAssembler/gsExprEvaluator.h>
 
namespace gismo
{
 
template <class T>
class gsBiharmonicExprAssembler
{
public:
 
gsBiharmonicExprAssembler(  const gsMultiPatch<T> & mp,
                            const gsMultiBasis<T> & mb,
                            const gsFunctionSet<T> & force,
                            const gsBoundaryConditions<T> & bcs
                            );
 
gsBiharmonicExprAssembler() { }
 
gsBiharmonicExprAssembler( const gsBiharmonicExprAssembler& other )
{
    operator=(other);
}
 
gsBiharmonicExprAssembler( gsBiharmonicExprAssembler&& other )
{
    operator=(give(other));
}
 
gsBiharmonicExprAssembler& operator= ( const gsBiharmonicExprAssembler& other );
 
gsBiharmonicExprAssembler& operator= ( gsBiharmonicExprAssembler&& other );
 
protected:
 
    void _defaultOptions();
 
    void _getOptions();
 
    void _initialize();
 
    void _setup(const expr::gsFeSpace<T> & u);
 
public:
 
    void setSpaceBasis(const gsFunctionSet<T> & spaceBasis);
 
    void assembleMass();
 
    void assemble();
 
    void assembleLHS();
 
    void assembleRHS();
 
    const gsSparseMatrix<T> & matrix() const { return m_assembler.matrix();  }
    const gsMatrix<T>       & rhs()    const { return m_assembler.rhs();     }
 
    T penalty() const { return m_penalty; };
    index_t numDofs() const { return m_assembler.numDofs(); };
 
    T l2error(gsMatrix<T> & solVector, const gsFunctionSet<T> & exact);
 
    T h1error(gsMatrix<T> & solVector, const gsFunctionSet<T> & exact);
 
    T h2error(gsMatrix<T> & solVector, const gsFunctionSet<T> & exact);
 
    std::tuple<T,T,T> errors(gsMatrix<T> & solVector, const gsFunctionSet<T> & exact);
 
    T interfaceError(gsMatrix<T> & solVector, const gsFunctionSet<T> & exact);
 
    gsOptionList & options() {return m_options;}
 
    void setOptions(gsOptionList & options);
 
    void constructSolution(gsMatrix<T> & solVector);
 
    typename gsFunctionSet<T>::Ptr getSolution() const;
 
private:
 
    // template <typename basisT>
    void _setMapperForBiharmonic(const gsBoundaryConditions<T> & bc,
                                const gsFunctionSet<T> & bb2,
                                gsDofMapper & mapper);
 
    void _getDirichletNeumannValuesL2Projection(const gsMultiPatch<T> & mp,
                                                const gsMultiBasis<T> & dbasis,
                                                const gsBoundaryConditions<T> & bc,
                                                const gsFunctionSet<T> & bb2,
                                                const expr::gsFeSpace<T> & u);
 
    void _computeStabilityParameter(const gsMultiPatch<T> & mp,
                                    const gsMultiBasis<T> & dbasis,
                                    gsMatrix<T> & mu_interfaces);
 
protected:
 
    typedef typename gsExprAssembler<T>::geometryMap geometryMap;
    typedef typename gsExprAssembler<T>::space       space;
    typedef typename gsExprAssembler<T>::solution    solution;
    typedef typename gsExprAssembler<T>::element     element;
 
    mutable T m_penalty;
    mutable T m_lambda;
    mutable bool m_second;
    mutable index_t m_continuity;
 
    gsExprAssembler<T> m_assembler;
    gsExprEvaluator<T> m_evaluator;
 
    gsMultiPatch<T>           m_patches;
    mutable gsMultiBasis<T>   m_basis;
    const gsFunctionSet<T> *  m_spaceBasis;
    const gsFunctionSet<T> * m_force;
    gsBoundaryConditions<T>   m_bcs;
 
    mutable gsMappedSpline<2,T> m_mspline;
    mutable gsMultiPatch<T> m_sol;
 
    mutable gsOptionList m_options;
 
 
    // gsFunctionExpr<T> m_ms;
 
  }; // class gsBiharmonicExprAssembler
 
#ifdef GISMO_WITH_PYBIND11
 
  void pybind11_init_gsBiharmonicExprAssembler(pybind11::module &m);
 
#endif // GISMO_WITH_PYBIND11
 
} // namespace gismo
 
 
 
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsBiharmonicExprAssembler.hpp)
#endif