cl_EF_EdgeFunction.hpp

Go to the documentation of this file.

//
// Created by christian on 12/1/21.
//
 
#ifndef BELFEM_CL_EF_EDGEFUNCTION_HPP
#define BELFEM_CL_EF_EDGEFUNCTION_HPP
 
#include "typedefs.hpp"
#include "Mesh_Enums.hpp"
#include "cl_Vector.hpp"
#include "cl_Matrix.hpp"
#include "assert.hpp"
 
namespace belfem
{
    namespace mesh
    {
        class Element ;
    }
 
    namespace fem
    {
        class Element ;

        class EdgeFunction
        {
//------------------------------------------------------------------------------
        protected:
//------------------------------------------------------------------------------

            Matrix< real > mJ;

            Matrix< real > mInvJ;

            real mDetJ = BELFEM_QUIET_NAN ;

            real mAbsDetJ = BELFEM_QUIET_NAN ;
 
            // values for the shape function
            Matrix< real > mE ;

            Matrix< real > mC ;

            Matrix< real > mGrad ;

            real mSumW ;
            uint mNumDofs ;
 
//------------------------------------------------------------------------------
        public:
//------------------------------------------------------------------------------

            EdgeFunction() = default;
 
//------------------------------------------------------------------------------

            virtual ~EdgeFunction() = default;
 
//------------------------------------------------------------------------------

             virtual void
             link( Element * aElement ) = 0 ;
 
//------------------------------------------------------------------------------

             virtual void
             precompute( const Matrix< real > & aXi ) = 0 ;
 
//------------------------------------------------------------------------------
 
            // compute the edge function
            virtual const Matrix< real > &
            E( const uint aIndex ) ;
 
//------------------------------------------------------------------------------
 
            // compute the curl function
            virtual const Matrix< real > &
            C( const uint aIndex = 0 ) = 0 ;
 
//------------------------------------------------------------------------------
 
            // compute the gradient operator of the edge function
            // ( layout contract: see the mGrad member documentation )
            virtual const Matrix< real > &
            G( const uint aIndex = 0 ) = 0 ;
 
//------------------------------------------------------------------------------

            real
            det_J() const ;
 
//------------------------------------------------------------------------------

            real
            abs_det_J() const ;
 
//------------------------------------------------------------------------------

            real
            sum_w() const ;
 
//------------------------------------------------------------------------------

            uint
            ndofs() const ;
 
//------------------------------------------------------------------------------
 
            virtual void
            update_nabla( const uint aIndex );
 
//------------------------------------------------------------------------------
        };
//------------------------------------------------------------------------------
 
        inline uint
        EdgeFunction::ndofs() const
        {
            return mNumDofs ;
        }
 
//------------------------------------------------------------------------------
 
        inline real
        EdgeFunction::sum_w() const
        {
            return mSumW ;
        }
 
//------------------------------------------------------------------------------
 
        inline real
        EdgeFunction::det_J() const
        {
            return mDetJ;
        }
 
//------------------------------------------------------------------------------
 
        inline real
        EdgeFunction::abs_det_J() const
        {
            return mAbsDetJ ;
        }
 
//------------------------------------------------------------------------------
 
        inline const Matrix <real> &
        EdgeFunction::E( const uint aIndex )
        {
            BELFEM_ERROR( false, "Invalid call to edge function");
            return mE;
        }
 
//------------------------------------------------------------------------------
 
        inline const Matrix <real> &
        EdgeFunction::C( const uint aIndex )
        {
            BELFEM_ERROR( false, "Invalid call to curl function");
            return mC;
        }
 
//------------------------------------------------------------------------------
 
        inline void
        EdgeFunction::update_nabla( const uint aIndex )
        {
            BELFEM_ERROR( false, "Invalid call to update_nabla()");
        }
 
//------------------------------------------------------------------------------
 
    } /* end namespace fem */
}  /* end namespace belfem */
 
 
#endif //BELFEM_CL_EF_EDGEFUNCTION_HPP