gsIetiMapper.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsMultiBasis.h>
#include <gsAssembler/gsExprAssembler.h>

namespace gismo
{

template< typename T >
class gsIetiMapper
{
    typedef gsMatrix<T>                Matrix;        
    typedef gsSparseVector<T>          SparseVector;  
    typedef gsSparseMatrix<T,RowMajor> JumpMatrix;    

public:
    gsIetiMapper() : m_multiBasis(NULL), m_nPrimalDofs(0), m_status(0) {}

    gsIetiMapper(
        const gsMultiBasis<T>& multiBasis,
        gsDofMapper dofMapperGlobal,
        const Matrix& fixedPart
    )
    { init(multiBasis, give(dofMapperGlobal), fixedPart); }

    void init(
        const gsMultiBasis<T>& multiBasis,
        gsDofMapper dofMapperGlobal,
        const Matrix& fixedPart
    );

    void cornersAsPrimals();

    void interfaceAveragesAsPrimals( const gsMultiPatch<T>& geo, short_t d );

    void customPrimalConstraints( std::vector< std::pair<index_t,SparseVector> > data );

    void computeJumpMatrices( bool fullyRedundant, bool excludeCorners );

    std::vector<index_t> skeletonDofs( index_t patch ) const;

    void initFeSpace( typename gsExprAssembler<T>::space u, index_t k )
    {
        GISMO_ASSERT( m_status&1,
            "gsIetiMapper: The class has not been initialized." );
        GISMO_ASSERT( u.mapper().size() ==  m_dofMapperLocal[k].size(),
            "gsIetiMapper::initFeSpace: The sizes do not agree." );
        const_cast<expr::gsFeSpace<T>&>(u).mapper() = m_dofMapperLocal[k];
        const_cast<expr::gsFeSpace<T>&>(u).fixedPart() = m_fixedPart[k];
    }

    Matrix constructGlobalSolutionFromLocalSolutions( const std::vector<Matrix>& localContribs );

public:

    index_t nLagrangeMultipliers()
    {
        GISMO_ASSERT(! m_jumpMatrices.empty(),
            "gsIetiMapper: Number of Lagrange multipliers not yet known.");
        return m_jumpMatrices[0].rows();
    }

    index_t nPrimalDofs() const                                            { return m_nPrimalDofs;                }

    const std::vector<SparseVector> & primalConstraints(index_t k) const   { return m_primalConstraints[k];       }

    const std::vector<index_t> & primalDofIndices(index_t k) const         { return m_primalDofIndices[k];        }

    const JumpMatrix& jumpMatrix(index_t k) const                          { return m_jumpMatrices[k];            }

    const gsDofMapper& dofMapperGlobal() const                             { return m_dofMapperGlobal;            }

    const gsDofMapper& dofMapperLocal(index_t k) const                     { return m_dofMapperLocal[k];          }

    const Matrix& fixedPart(index_t k) const                               { return m_fixedPart[k];               }

    Matrix incorporateFixedPart(index_t k, const gsMatrix<T>& localSolution) const;

    const gsMultiBasis<T>& multiBasis() const                              { return *m_multiBasis;                }

private:

    static gsSparseVector<T> assembleAverage( const gsGeometry<T>& geo,
        const gsBasis<T>& basis, const gsDofMapper& dm,
        boxComponent bc );   

private:
    const gsMultiBasis<T>*                        m_multiBasis;          
    gsDofMapper                                   m_dofMapperGlobal;     
    std::vector<gsDofMapper>                      m_dofMapperLocal;      
    std::vector<Matrix>                           m_fixedPart;           
    std::vector<JumpMatrix>                       m_jumpMatrices;        
    index_t                                       m_nPrimalDofs;         
    std::vector< std::vector<SparseVector> >      m_primalConstraints;   
    std::vector< std::vector<index_t> >           m_primalDofIndices;    
    unsigned                                      m_status;              
};

} // namespace gismo

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