Detailed Description

template<typename ShapeFunction, typename IntegrationMethod, int GlobalDim>
class ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >

Definition at line 39 of file SurfaceFluxLocalAssembler.h.

#include <SurfaceFluxLocalAssembler.h>

Inheritance diagram for ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >:

Collaboration diagram for ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >:

Public Member Functions
	SurfaceFluxLocalAssembler (MeshLib::Element const &surface_element, std::size_t, bool const is_axially_symmetric, unsigned const integration_order, MeshLib::PropertyVector< std::size_t > const &bulk_element_ids, MeshLib::PropertyVector< std::size_t > const &bulk_face_ids)

void	integrate (std::size_t const element_id, std::vector< GlobalVector * > const &x, MeshLib::PropertyVector< double > &specific_flux, double const t, MeshLib::Mesh const &bulk_mesh, std::function< Eigen::Vector3d(std::size_t const, MathLib::Point3d const &, double const, std::vector< GlobalVector * > const &)> getFlux) override

Public Member Functions inherited from ProcessLib::SurfaceFluxLocalAssemblerInterface
virtual	~SurfaceFluxLocalAssemblerInterface ()=default

Protected Types
using	ShapeMatricesType = ShapeMatrixPolicyType< ShapeFunction, GlobalDim >

using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

using	NodalVectorType = typename ShapeMatricesType::NodalVectorType

Private Attributes
MeshLib::Element const &	_surface_element

std::vector< double >	_detJ_times_integralMeasure

IntegrationMethod const	_integration_method

std::size_t const	_bulk_element_id

std::size_t const	_bulk_face_id

Member Typedef Documentation

◆ NodalMatrixType

template<typename ShapeFunction , typename IntegrationMethod , int GlobalDim>

using ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

protected

Definition at line 44 of file SurfaceFluxLocalAssembler.h.

◆ NodalVectorType

template<typename ShapeFunction , typename IntegrationMethod , int GlobalDim>

using ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

protected

Definition at line 45 of file SurfaceFluxLocalAssembler.h.

◆ ShapeMatricesType

template<typename ShapeFunction , typename IntegrationMethod , int GlobalDim>

using ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>

protected

Definition at line 43 of file SurfaceFluxLocalAssembler.h.

Constructor & Destructor Documentation

◆ SurfaceFluxLocalAssembler()

template<typename ShapeFunction , typename IntegrationMethod , int GlobalDim>

ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::SurfaceFluxLocalAssembler	(	MeshLib::Element const &	surface_element,
		std::size_t	,
		bool const	is_axially_symmetric,
		unsigned const	integration_order,
		MeshLib::PropertyVector< std::size_t > const &	bulk_element_ids,
		MeshLib::PropertyVector< std::size_t > const &	bulk_face_ids
	)

inline

Precomputes the shape matrices for a given surface element.

Parameters

surface_element	The surface element used for precomputing the shape matrices used later on for the integration.
is_axially_symmetric	corrects integration measure for cylinder coordinates.
bulk_element_ids	The id of the corresponding element in the bulk mesh.
bulk_face_ids	The id of the corresponding face in the bulk element.
integration_order	the order of the integration

Definition at line 58 of file SurfaceFluxLocalAssembler.h.

         : _surface_element(surface_element),
           _integration_method(integration_order),
           _bulk_element_id(bulk_element_ids[surface_element.getID()]),
           _bulk_face_id(bulk_face_ids[surface_element.getID()])
     {
         auto const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         auto const shape_matrices =
             NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                       GlobalDim, NumLib::ShapeMatrixType::N_J>(
                 _surface_element, is_axially_symmetric, _integration_method);
         for (std::size_t ip = 0; ip < n_integration_points; ++ip)
         {
             _detJ_times_integralMeasure.push_back(
                 shape_matrices[ip].detJ * shape_matrices[ip].integralMeasure);
         }
     }

References ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::_detJ_times_integralMeasure, ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::_integration_method, ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::_surface_element, NumLib::initShapeMatrices(), and NumLib::N_J.

Member Function Documentation

◆ integrate()

template<typename ShapeFunction , typename IntegrationMethod , int GlobalDim>

void ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::integrate	(	std::size_t const	element_id,
		std::vector< GlobalVector * > const &	x,
		MeshLib::PropertyVector< double > &	specific_flux,
		double const	t,
		MeshLib::Mesh const &	bulk_mesh,
		std::function< Eigen::Vector3d(std::size_t const, MathLib::Point3d const &, double const, std::vector< GlobalVector * > const &)>	getFlux
	)

inlineoverridevirtual

Integration for the element with the id element_id.

Parameters

element_id	id of the element
x	The global vector containing the values for numerical integration.
specific_flux	PropertyVector the integration result will be stored into, where specific_flux has the same number of entries like mesh elements exists.
t	The integration is performed at the time t.
bulk_mesh	Stores a reference to the bulk mesh that is needed to fetch the information for the integration over the surface mesh.
getFlux	function that calculates the flux in the integration points of the face elements of the bulk element that belongs to the surface.

Implements ProcessLib::SurfaceFluxLocalAssemblerInterface.

Definition at line 97 of file SurfaceFluxLocalAssembler.h.

     {
         auto get_surface_normal =
             [this, &bulk_mesh](
                 MeshLib::Element const& surface_element) -> Eigen::Vector3d {
             Eigen::Vector3d surface_element_normal;
             if (surface_element.getGeomType() == MeshLib::MeshElemType::LINE)
             {
                 auto const bulk_normal = MeshLib::FaceRule::getSurfaceNormal(
                     *bulk_mesh.getElements()[_bulk_element_id]);
                 auto const l0 = Eigen::Map<Eigen::Vector3d const>(
                     _surface_element.getNode(0)->getCoords());
                 auto const l1 = Eigen::Map<Eigen::Vector3d const>(
                     _surface_element.getNode(1)->getCoords());
                 Eigen::Vector3d const line = l1 - l0;
                 surface_element_normal = line.cross(bulk_normal);
             }
             else
             {
                 surface_element_normal =
                     MeshLib::FaceRule::getSurfaceNormal(surface_element);
             }
             surface_element_normal.normalize();
             // At the moment (2016-09-28) the surface normal is not oriented
             // according to the right hand rule. Thus for an intuitive flux
             // output, i.e., inflow has positive sign, outflow has negative
             // sign, the normal must not be multiplied by -1.
             return surface_element_normal;
         };
         auto const surface_element_normal =
             get_surface_normal(_surface_element);
  
         double element_area = 0.0;
         std::size_t const n_integration_points =
             _integration_method.getNumberOfPoints();
         // specific_flux[id_of_element] +=
         //   int_{\Gamma_e} \alpha \cdot flux \cdot normal \d \Gamma /
         //   element_area
         for (std::size_t ip(0); ip < n_integration_points; ip++)
         {
             auto const& wp = _integration_method.getWeightedPoint(ip);
  
             auto const bulk_element_point = MeshLib::getBulkElementPoint(
                 bulk_mesh, _bulk_element_id, _bulk_face_id, wp);
             auto const bulk_flux =
                 getFlux(_bulk_element_id, bulk_element_point, t, x);
             for (int component_id(0);
                  component_id < specific_flux.getNumberOfGlobalComponents();
                  ++component_id)
             {
                 // TODO find solution for 2d case
                 double const bulk_grad_times_normal(
                     Eigen::Map<Eigen::RowVectorXd const>(bulk_flux.data(),
                                                          bulk_flux.size())
                         .dot(surface_element_normal));
  
                 specific_flux.getComponent(element_id, component_id) +=
                     bulk_grad_times_normal * _detJ_times_integralMeasure[ip] *
                     wp.getWeight();
             }
             element_area += _detJ_times_integralMeasure[ip] * wp.getWeight();
         }
         for (int component_id(0);
              component_id < specific_flux.getNumberOfGlobalComponents();
              ++component_id)
         {
             specific_flux.getComponent(element_id, component_id) /=
                 element_area;
         }
     }