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