gsVisitorGradGrad.h

Go to the documentation of this file.

#pragma once


#include <gsAssembler/gsVisitorMass.h>
namespace gismo
{

template <class T>
class gsVisitorGradGrad : public gsVisitorMass<T> // inherit to reuse functionality
{
public:
    typedef gsVisitorMass<T> Base;

public:

    gsVisitorGradGrad(const gsPde<T> & pde)
    { GISMO_UNUSED(pde); }

    void initialize(const gsBasis<T> & basis,
                    const index_t /*patchIndex*/,
                    const gsOptionList & options,
                    gsQuadRule<T>    & rule)
    {
        // Setup Quadrature
        rule = gsQuadrature::get(basis, options); // harmless slicing occurs here

        // Set Geometry evaluation flags
        md.flags = NEED_MEASURE|NEED_GRAD_TRANSFORM;
    }

    inline void evaluate(const gsBasis<T>       & basis,
                         const gsGeometry<T>    & geo,
                         // todo: add element here for efficiency
                         gsMatrix<T>            & quNodes)
    {
        md.points = quNodes;
        // Compute the active basis functions
        // Assumes actives are the same for all quadrature points on the current element
        basis.active_into(md.points.col(0), actives);
        const index_t numActive = actives.rows();

        // Evaluate basis functions on element
        basis.deriv_into(md.points, basisData);

        // Compute geometry related values
        geo.computeMap(md);

        // Initialize local matrix
        localMat.setZero(numActive, numActive);
    }

    inline void assemble(gsDomainIterator<T>    & /*element*/,
                         gsVector<T> const      & quWeights)
    {
        for (index_t k = 0; k < quWeights.rows(); ++k) // loop over quadrature nodes
        {
            // Multiply quadrature weight by the geometry measure
            const T weight = quWeights[k] * md.measure(k);

            // Compute physical gradients at k as a Dim x NumActive matrix
            transformGradients(md, k, basisData, basisPhGrads);

            localMat.noalias() += weight * ( basisPhGrads.transpose() * basisPhGrads );
        }
    }

    //Inherited from gsVisitorMass
    //void localToGlobal( ... )

private:

    // Gradient values
    gsMatrix<T>  basisPhGrads;
    using Base:: basisData;
    using Base::actives;

    // Local matrix
    using Base::localMat;

    using Base::md;
};


} // namespace gismo