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