Finite element and operators to apply force/pressures applied to surfaces. More...

#include "users_modules/basic_finite_elements/src/SurfacePressure.hpp"

Collaboration diagram for NeumannForcesSurface:

Classes
struct	bCForce

struct	bCPressure

struct	DataAtIntegrationPts

struct	LinearVaringPresssure

struct	MethodForAnalyticalForce
	Analytical force method. More...

struct	MyTriangleFE

struct	OpCalculateDeformation
	Operator for computing deformation gradients in side volumes. More...

struct	OpGetTangent
	Operator for computing tangent vectors. More...

struct	OpNeumannFlux
	Operator for flux element. More...

struct	OpNeumannForce
	Operator for force element. More...

struct	OpNeumannForceAnalytical
	Operator for force element. More...

struct	OpNeumannPressure
	RHS-operator for pressure element (spatial configuration) More...

struct	OpNeumannPressureLhs_dx_dX
	LHS-operator for pressure element (spatial configuration) More...

struct	OpNeumannPressureMaterialLhs
	Base class for LHS-operators for pressure element (material configuration) More...

struct	OpNeumannPressureMaterialLhs_dX_dX
	LHS-operator for the pressure element (material configuration) More...

struct	OpNeumannPressureMaterialLhs_dX_dx
	LHS-operator for the pressure element (material configuration) More...

struct	OpNeumannPressureMaterialRhs_dX
	RHS-operator for the pressure element (material configuration) More...

struct	OpNeumannPressureMaterialVolOnSideLhs
	Base class for LHS-operators (material) on side volumes. More...

struct	OpNeumannPressureMaterialVolOnSideLhs_dX_dX
	LHS-operator (material configuration) on the side volume. More...

struct	OpNeumannPressureMaterialVolOnSideLhs_dX_dx
	LHS-operator (material configuration) on the side volume. More...

struct	OpNeumannSurfaceForceLhs_dx_dX
	LHS-operator for surface force element (spatial configuration) More...

struct	OpNeumannSurfaceForceMaterialLhs
	Base class for LHS-operators for pressure element (material configuration) More...

struct	OpNeumannSurfaceForceMaterialLhs_dX_dX
	LHS-operator for the surface force element (material configuration) More...

struct	OpNeumannSurfaceForceMaterialLhs_dX_dx
	LHS-operator for the surface force element (material configuration) More...

struct	OpNeumannSurfaceForceMaterialRhs_dX
	RHS-operator for the surface force element (material configuration) More...

struct	OpNeumannSurfaceForceMaterialVolOnSideLhs
	Base class for LHS-operators (material) on side volumes. More...

struct	OpNeumannSurfaceForceMaterialVolOnSideLhs_dX_dX
	LHS-operator (material configuration) on the side volume. More...

struct	OpNeumannSurfaceForceMaterialVolOnSideLhs_dX_dx
	LHS-operator (material configuration) on the side volume. More...

Public Types
using	UserDataOperator

using	VolOnSideUserDataOperator

using	EntData = EntitiesFieldData::EntData

typedef DEPRECATED typedef MethodForAnalyticalForce	MethodForAnaliticalForce

typedef DEPRECATED typedef OpNeumannPressure	OpNeumannPreassure

typedef DEPRECATED typedef bCPressure	bCPreassure

Public Member Functions
MyTriangleFE &	getLoopFe ()

MyTriangleFE &	getLoopFeLhs ()

MyTriangleFE &	getLoopFeMatRhs ()

MyTriangleFE &	getLoopFeMatLhs ()

	NeumannForcesSurface (MoFEM::Interface &m_field)

MoFEMErrorCode	addForce (const std::string field_name, Vec F, int ms_id, bool ho_geometry=false, bool block_set=false)
	Add operator to calculate forces on element.

MoFEMErrorCode	addForceAle (const std::string field_name_1, const std::string field_name_2, boost::shared_ptr< DataAtIntegrationPts > data_at_pts, std::string side_fe_name, Vec F, Mat aij, int ms_id, bool ho_geometry=false, bool block_set=false, bool ignore_material_force=false)
	Add operator to calculate forces on element (in ALE)

MoFEMErrorCode	addPressure (const std::string field_name, Vec F, int ms_id, bool ho_geometry=false, bool block_set=false)
	Add operator to calculate pressure on element.

MoFEMErrorCode	addPressureAle (const std::string field_name_1, const std::string field_name_2, boost::shared_ptr< DataAtIntegrationPts > data_at_pts, std::string side_fe_name, Vec F, Mat aij, int ms_id, bool ho_geometry=false, bool block_set=false)
	Add operator to calculate pressure on element (in ALE)

MoFEMErrorCode	addLinearPressure (const std::string field_name, Vec F, int ms_id, bool ho_geometry=false)
	Add operator to calculate pressure on element.

MoFEMErrorCode	addFlux (const std::string field_name, Vec F, int ms_id, bool ho_geometry=false)
	Add flux element operator (integration on face)

DEPRECATED MoFEMErrorCode	addPreassure (const std::string field_name, Vec F, int ms_id, bool ho_geometry=false, bool block_set=false)

Public Attributes
MoFEM::Interface &	mField

MyTriangleFE	fe

MyTriangleFE	feLhs

MyTriangleFE	feMatRhs

MyTriangleFE	feMatLhs

std::map< int, bCForce >	mapForce

std::map< int, bCPressure >	mapPressure

boost::ptr_vector< MethodForForceScaling >	methodsOp

boost::ptr_vector< MethodForAnalyticalForce >	analyticalForceOp

Detailed Description

Finite element and operators to apply force/pressures applied to surfaces.

Examples: nonlinear_dynamics.cpp.

Definition at line 14 of file SurfacePressure.hpp.

Member Typedef Documentation

◆ bCPreassure

DEPRECATED typedef bCPressure NeumannForcesSurface::bCPreassure

Deprecated: Do not use spelling mistake

Definition at line 1249 of file SurfacePressure.hpp.

◆ EntData

using NeumannForcesSurface::EntData = EntitiesFieldData::EntData

Definition at line 104 of file SurfacePressure.hpp.

◆ MethodForAnaliticalForce

DEPRECATED typedef MethodForAnalyticalForce NeumannForcesSurface::MethodForAnaliticalForce

Deprecated: fixed spelling mistake

Definition at line 1244 of file SurfacePressure.hpp.

◆ OpNeumannPreassure

DEPRECATED typedef OpNeumannPressure NeumannForcesSurface::OpNeumannPreassure

Definition at line 1246 of file SurfacePressure.hpp.

◆ UserDataOperator

using NeumannForcesSurface::UserDataOperator

Initial value:

MoFEM::FaceElementForcesAndSourcesCore::UserDataOperator

default operator for TRI element

Definition FaceElementForcesAndSourcesCore.hpp:95

Definition at line 100 of file SurfacePressure.hpp.

◆ VolOnSideUserDataOperator

using NeumannForcesSurface::VolOnSideUserDataOperator

Initial value:

MoFEM::VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator

default operator for TET element

Definition VolumeElementForcesAndSourcesCoreOnSide.hpp:108

Definition at line 102 of file SurfacePressure.hpp.

Constructor & Destructor Documentation

◆ NeumannForcesSurface()

NeumannForcesSurface::NeumannForcesSurface ( MoFEM::Interface & m_field )

inline

Definition at line 81 of file SurfacePressure.hpp.

82 : mField(m_field), fe(m_field), feLhs(m_field), feMatRhs(m_field),

83 feMatLhs(m_field) {}

NeumannForcesSurface::fe

MyTriangleFE fe

Definition SurfacePressure.hpp:66

NeumannForcesSurface::feMatLhs

MyTriangleFE feMatLhs

Definition SurfacePressure.hpp:78

NeumannForcesSurface::feLhs

MyTriangleFE feLhs

Definition SurfacePressure.hpp:70

NeumannForcesSurface::feMatRhs

MyTriangleFE feMatRhs

Definition SurfacePressure.hpp:74

NeumannForcesSurface::mField

MoFEM::Interface & mField

Definition SurfacePressure.hpp:16

Member Function Documentation

◆ addFlux()

MoFEMErrorCode NeumannForcesSurface::addFlux	(	const std::string	field_name,
		Vec	F,
		int	ms_id,
		bool	ho_geometry = false )

Add flux element operator (integration on face)

Definition at line 1958 of file SurfacePressure.cpp.

                                                               {
  const CubitMeshSets *cubit_meshset_ptr;
  MeshsetsManager *mmanager_ptr;
  MoFEMFunctionBegin;
  CHKERR mField.getInterface(mmanager_ptr);
  CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, SIDESET, &cubit_meshset_ptr);
  CHKERR cubit_meshset_ptr->getBcDataStructure(mapPressure[ms_id].data);
  CHKERR mField.get_moab().get_entities_by_dimension(
      cubit_meshset_ptr->meshset, 2, mapPressure[ms_id].tRis, true);
  fe.getOpPtrVector().push_back(new OpNeumannFlux(
      field_name, F, mapPressure[ms_id], methodsOp, ho_geometry));
  MoFEMFunctionReturn(0);
}

◆ addForce()

MoFEMErrorCode NeumannForcesSurface::addForce	(	const std::string	field_name,
		Vec	F,
		int	ms_id,
		bool	ho_geometry = false,
		bool	block_set = false )

Add operator to calculate forces on element.

Parameters

field_name	Field name (f.e. TEMPERATURE)
F	Right hand side vector
ms_id	Set id (SideSet or BlockSet if block_set = true)
ho_geometry	Use higher order shape functions to define curved geometry
block_set	If tru get data from block set

Returns: ErrorCode

Definition at line 1571 of file SurfacePressure.cpp.

                                                              {
  const CubitMeshSets *cubit_meshset_ptr;
  MeshsetsManager *mmanager_ptr;
  MoFEMFunctionBegin;
  CHKERR mField.getInterface(mmanager_ptr);
  if (block_set) {
    // Add data from block set.
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, BLOCKSET,
                                            &cubit_meshset_ptr);
    std::vector<double> mydata;
    CHKERR cubit_meshset_ptr->getAttributes(mydata);
    VectorDouble force(mydata.size());
    for (unsigned int ii = 0; ii != mydata.size(); ++ii) {
      force[ii] = mydata[ii];
    }
    // Read forces from BLOCKSET Force (if exists)
    if (force.empty()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Force not given");
    }
    // Assign values from BLOCKSET FORCE to RHS vector. Info about native Cubit
    // BC data structure can be found in BCData.hpp
    const string name = "Force";
    strncpy(mapForce[ms_id].data.data.name, name.c_str(),
            name.size() > 5 ? 5 : name.size());
    double magnitude = std::sqrt(force[0] * force[0] + force[1] * force[1] +
                                 force[2] * force[2]);
    mapForce[ms_id].data.data.value1 = -magnitude; //< Force magnitude
    mapForce[ms_id].data.data.value2 = 0;
    mapForce[ms_id].data.data.value3 =
        force[0] / magnitude; //< X-component of force vector
    mapForce[ms_id].data.data.value4 =
        force[1] / magnitude; //< Y-component of force vector
    mapForce[ms_id].data.data.value5 =
        force[2] / magnitude; //< Z-component of force vector
    mapForce[ms_id].data.data.value6 = 0;
    mapForce[ms_id].data.data.value7 = 0;
    mapForce[ms_id].data.data.value8 = 0;
    mapForce[ms_id].data.data.zero[0] = 0;
    mapForce[ms_id].data.data.zero[1] = 0;
    mapForce[ms_id].data.data.zero[2] = 0;
    mapForce[ms_id].data.data.zero2 = 0;
 
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapForce[ms_id].tRis, true);
    fe.getOpPtrVector().push_back(new OpNeumannForce(
        field_name, F, mapForce[ms_id], methodsOp, ho_geometry));
 
    // SETERRQ(PETSC_COMM_SELF,MOFEM_NOT_IMPLEMENTED,"Not implemented");
  } else {
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, NODESET, &cubit_meshset_ptr);
    CHKERR cubit_meshset_ptr->getBcDataStructure(mapForce[ms_id].data);
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapForce[ms_id].tRis, true);
    fe.getOpPtrVector().push_back(new OpNeumannForce(
        field_name, F, mapForce[ms_id], methodsOp, ho_geometry));
  }
  MoFEMFunctionReturn(0);
}

◆ addForceAle()

MoFEMErrorCode NeumannForcesSurface::addForceAle	(	const std::string	field_name_1,
		const std::string	field_name_2,
		boost::shared_ptr< DataAtIntegrationPts >	data_at_pts,
		std::string	side_fe_name,
		Vec	F,
		Mat	aij,
		int	ms_id,
		bool	ho_geometry = false,
		bool	block_set = false,
		bool	ignore_material_force = false )

Add operator to calculate forces on element (in ALE)

Parameters

field_name_1	Field name for spatial positions
field_name_2	Field name for material positions
data_at_pts	Common data at integration points
side_fe_name	Name of the element in the side volume
F	Right hand side vector
aij	Tangent matrix
ms_id	Set id (SideSet or BlockSet if block_set = true)
ho_geometry	Use higher order shape functions to define curved geometry
block_set	If true get data from block set
ignore_material_force	If true then material force is not added

Returns: ErrorCode

Definition at line 1633 of file SurfacePressure.cpp.

                                                {
  const CubitMeshSets *cubit_meshset_ptr;
  MeshsetsManager *mmanager_ptr;
  MoFEMFunctionBegin;
  CHKERR mField.getInterface(mmanager_ptr);
  if (block_set) {
    // Add data from block set.
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, BLOCKSET,
                                            &cubit_meshset_ptr);
    std::vector<double> mydata;
    CHKERR cubit_meshset_ptr->getAttributes(mydata);
    VectorDouble force(mydata.size());
    for (unsigned int ii = 0; ii != mydata.size(); ++ii) {
      force[ii] = mydata[ii];
    }
    // Read forces from BLOCKSET Force (if exists)
    if (force.empty()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Force not given");
    }
    // Assign values from BLOCKSET FORCE to RHS vector. Info about native Cubit
    // BC data structure can be found in BCData.hpp
    const string name = "Force";
    strncpy(mapForce[ms_id].data.data.name, name.c_str(),
            name.size() > 5 ? 5 : name.size());
    double magnitude = std::sqrt(force[0] * force[0] + force[1] * force[1] +
                                 force[2] * force[2]);
    mapForce[ms_id].data.data.value1 = -magnitude; //< Force magnitude
    mapForce[ms_id].data.data.value2 = 0;
    mapForce[ms_id].data.data.value3 =
        force[0] / magnitude; //< X-component of force vector
    mapForce[ms_id].data.data.value4 =
        force[1] / magnitude; //< Y-component of force vector
    mapForce[ms_id].data.data.value5 =
        force[2] / magnitude; //< Z-component of force vector
    mapForce[ms_id].data.data.value6 = 0;
    mapForce[ms_id].data.data.value7 = 0;
    mapForce[ms_id].data.data.value8 = 0;
    mapForce[ms_id].data.data.zero[0] = 0;
    mapForce[ms_id].data.data.zero[1] = 0;
    mapForce[ms_id].data.data.zero[2] = 0;
    mapForce[ms_id].data.data.zero2 = 0;
 
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapForce[ms_id].tRis, true);
    // SETERRQ(PETSC_COMM_SELF,MOFEM_NOT_IMPLEMENTED,"Not implemented");
  } else {
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, NODESET, &cubit_meshset_ptr);
    CHKERR cubit_meshset_ptr->getBcDataStructure(mapForce[ms_id].data);
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapForce[ms_id].tRis, true);
  }
 
  /*  LEFT-HAND SIDE (SPATIAL) */
  feLhs.getOpPtrVector().push_back(new OpGetTangent(X_field, data_at_pts));
 
  feLhs.getOpPtrVector().push_back(new OpNeumannSurfaceForceLhs_dx_dX(
      x_field, X_field, data_at_pts, aij, mapForce[ms_id], ho_geometry));
 
  /* RIGHT-HAND SIDE (MATERIAL) */
  if (!ignore_material_force) {
    // Side volume element computes the deformation gradient F=hH^-1
    boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnSide> feMatSideRhs =
        boost::make_shared<VolumeElementForcesAndSourcesCoreOnSide>(mField);
 
    feMatSideRhs->getOpPtrVector().push_back(
        new OpCalculateVectorFieldGradient<3, 3>(X_field,
                                                 data_at_pts->getHMatPtr()));
    feMatSideRhs->getOpPtrVector().push_back(
        new OpCalculateVectorFieldGradient<3, 3>(
            x_field, data_at_pts->getSmallhMatPtr()));
 
    feMatSideRhs->getOpPtrVector().push_back(
        new OpCalculateDeformation(X_field, data_at_pts, ho_geometry));
 
    feMatRhs.getOpPtrVector().push_back(new OpNeumannSurfaceForceMaterialRhs_dX(
        X_field, data_at_pts, feMatSideRhs, side_fe_name, F, mapForce[ms_id],
        ho_geometry));
 
    /* LEFT-HAND SIDE (MATERIAL) */
 
    // Side volume element computes linearisation with spatial coordinates
    boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnSide> feMatSideLhs_dx =
        boost::make_shared<VolumeElementForcesAndSourcesCoreOnSide>(mField);
    // Side volume element computes linearisation with material coordinates
    boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnSide> feMatSideLhs_dX =
        boost::make_shared<VolumeElementForcesAndSourcesCoreOnSide>(mField);
 
    feMatSideLhs_dx->getOpPtrVector().push_back(
        new OpCalculateVectorFieldGradient<3, 3>(X_field,
                                                 data_at_pts->getHMatPtr()));
    feMatSideLhs_dx->getOpPtrVector().push_back(
        new OpCalculateVectorFieldGradient<3, 3>(
            x_field, data_at_pts->getSmallhMatPtr()));
 
    feMatSideLhs_dx->getOpPtrVector().push_back(
        new OpCalculateDeformation(X_field, data_at_pts, ho_geometry));
    feMatSideLhs_dx->getOpPtrVector().push_back(
        new OpNeumannSurfaceForceMaterialVolOnSideLhs_dX_dx(
            X_field, x_field, data_at_pts, aij, mapForce[ms_id], ho_geometry));
 
    feMatLhs.getOpPtrVector().push_back(
        new OpNeumannSurfaceForceMaterialLhs_dX_dx(
            X_field, x_field, data_at_pts, feMatSideLhs_dx, side_fe_name, aij,
            mapForce[ms_id], ho_geometry));
 
    feMatSideLhs_dX->getOpPtrVector().push_back(
        new OpCalculateVectorFieldGradient<3, 3>(X_field,
                                                 data_at_pts->getHMatPtr()));
    feMatSideLhs_dX->getOpPtrVector().push_back(
        new OpCalculateVectorFieldGradient<3, 3>(
            x_field, data_at_pts->getSmallhMatPtr()));
    feMatSideLhs_dX->getOpPtrVector().push_back(
        new OpCalculateDeformation(X_field, data_at_pts, ho_geometry));
    feMatSideLhs_dX->getOpPtrVector().push_back(
        new OpNeumannSurfaceForceMaterialVolOnSideLhs_dX_dX(
            X_field, X_field, data_at_pts, aij, mapForce[ms_id], ho_geometry));
 
    feMatLhs.getOpPtrVector().push_back(new OpGetTangent(X_field, data_at_pts));
    feMatLhs.getOpPtrVector().push_back(
        new OpNeumannSurfaceForceMaterialLhs_dX_dX(
            X_field, X_field, data_at_pts, feMatSideLhs_dX, side_fe_name, aij,
            mapForce[ms_id], ho_geometry));
  }
 
  MoFEMFunctionReturn(0);
}

◆ addLinearPressure()

MoFEMErrorCode NeumannForcesSurface::addLinearPressure	(	const std::string	field_name,
		Vec	F,
		int	ms_id,
		bool	ho_geometry = false )

Add operator to calculate pressure on element.

Parameters

field_name	Field name (f.e. TEMPERATURE)
F	Right hand side vector
ms_id	Set id (SideSet or BlockSet if block_set = true)
ho_geometry	Use higher order shape functions to define curved geometry
block_set	If tru get data from block set

Returns: ErrorCode

Definition at line 1920 of file SurfacePressure.cpp.

                                                                     {
 
  const CubitMeshSets *cubit_meshset_ptr;
  MeshsetsManager *mmanager_ptr;
  MoFEMFunctionBegin;
  CHKERR mField.getInterface(mmanager_ptr);
  CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, BLOCKSET, &cubit_meshset_ptr);
  std::vector<double> mydata;
  CHKERR cubit_meshset_ptr->getAttributes(mydata);
  if (mydata.size() < 4)
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Should be four block attributes but is %ld", mydata.size());
  VectorDouble3 pressure_coeffs(3);
  for (unsigned int ii = 0; ii != 3; ++ii) {
    pressure_coeffs[ii] = mydata[ii];
  }
  const double pressure_shift = mydata[3];
 
  Range tris;
  CHKERR mField.get_moab().get_entities_by_dimension(cubit_meshset_ptr->meshset,
                                                     2, tris, true);
  boost::shared_ptr<MethodForAnalyticalForce> analytical_force_op(
      new LinearVaringPresssure(pressure_coeffs, pressure_shift));
  fe.getOpPtrVector().push_back(new OpNeumannForceAnalytical(
      field_name, F, tris, methodsOp, analytical_force_op, ho_geometry));
 
  MoFEMFunctionReturn(0);
}

◆ addPreassure()

MoFEMErrorCode NeumannForcesSurface::addPreassure	(	const std::string	field_name,
		Vec	F,
		int	ms_id,
		bool	ho_geometry = false,
		bool	block_set = false )

Deprecated: function is deprecated because spelling mistake, use addPressure instead

Definition at line 1950 of file SurfacePressure.cpp.

                                                                  {
  return NeumannForcesSurface::addPressure(field_name, F, ms_id, ho_geometry,
                                           block_set);
}

◆ addPressure()

MoFEMErrorCode NeumannForcesSurface::addPressure	(	const std::string	field_name,
		Vec	F,
		int	ms_id,
		bool	ho_geometry = false,
		bool	block_set = false )

Add operator to calculate pressure on element.

Parameters

field_name	Field name (f.e. TEMPERATURE)
F	Right hand side vector
ms_id	Set id (SideSet or BlockSet if block_set = true)
ho_geometry	Use higher order shape functions to define curved geometry
block_set	If true get data from block set

Returns: ErrorCode

Definition at line 1764 of file SurfacePressure.cpp.

                                                                 {
 
  const CubitMeshSets *cubit_meshset_ptr;
  MeshsetsManager *mmanager_ptr;
  MoFEMFunctionBegin;
  CHKERR mField.getInterface(mmanager_ptr);
  if (block_set) {
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, BLOCKSET,
                                            &cubit_meshset_ptr);
    std::vector<double> mydata;
    CHKERR cubit_meshset_ptr->getAttributes(mydata);
    VectorDouble pressure(mydata.size());
    for (unsigned int ii = 0; ii != mydata.size(); ++ii) {
      pressure[ii] = mydata[ii];
    }
    if (pressure.empty()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Pressure not given");
    }
    const string name = "Pressure";
    strncpy(mapPressure[ms_id].data.data.name, name.c_str(),
            name.size() > 8 ? 8 : name.size());
    mapPressure[ms_id].data.data.flag1 = 0;
    mapPressure[ms_id].data.data.flag2 = 1;
    mapPressure[ms_id].data.data.value1 = pressure[0];
    mapPressure[ms_id].data.data.zero = 0;
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapPressure[ms_id].tRis, true);
    fe.getOpPtrVector().push_back(new OpNeumannPressure(
        field_name, F, mapPressure[ms_id], methodsOp, ho_geometry));
  } else {
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, SIDESET, &cubit_meshset_ptr);
    CHKERR cubit_meshset_ptr->getBcDataStructure(mapPressure[ms_id].data);
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapPressure[ms_id].tRis, true);
    fe.getOpPtrVector().push_back(new OpNeumannPressure(
        field_name, F, mapPressure[ms_id], methodsOp, ho_geometry));
  }
  MoFEMFunctionReturn(0);
}

◆ addPressureAle()

MoFEMErrorCode NeumannForcesSurface::addPressureAle	(	const std::string	field_name_1,
		const std::string	field_name_2,
		boost::shared_ptr< DataAtIntegrationPts >	data_at_pts,
		std::string	side_fe_name,
		Vec	F,
		Mat	aij,
		int	ms_id,
		bool	ho_geometry = false,
		bool	block_set = false )

Add operator to calculate pressure on element (in ALE)

Parameters

field_name_1	Field name for spatial positions
field_name_2	Field name for material positions
data_at_pts	Common data at integration points
side_fe_name	Name of the element in the side volume
F	Right hand side vector
aij	Tangent matrix
ms_id	Set id (SideSet or BlockSet if block_set = true)
ho_geometry	Use higher order shape functions to define curved geometry
block_set	If true get data from block set

Returns: ErrorCode

Definition at line 1807 of file SurfacePressure.cpp.

                    {
 
  const CubitMeshSets *cubit_meshset_ptr;
  MeshsetsManager *mmanager_ptr;
  MoFEMFunctionBegin;
  CHKERR mField.getInterface(mmanager_ptr);
  if (block_set) {
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, BLOCKSET,
                                            &cubit_meshset_ptr);
    std::vector<double> mydata;
    CHKERR cubit_meshset_ptr->getAttributes(mydata);
    VectorDouble pressure(mydata.size());
    for (unsigned int ii = 0; ii != mydata.size(); ++ii) {
      pressure[ii] = mydata[ii];
    }
    if (pressure.empty()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Pressure not given");
    }
    const string name = "Pressure";
    strncpy(mapPressure[ms_id].data.data.name, name.c_str(),
            name.size() > 8 ? 8 : name.size());
    mapPressure[ms_id].data.data.flag1 = 0;
    mapPressure[ms_id].data.data.flag2 = 1;
    mapPressure[ms_id].data.data.value1 = pressure[0];
    mapPressure[ms_id].data.data.zero = 0;
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapPressure[ms_id].tRis, true);
 
  } else {
    CHKERR mmanager_ptr->getCubitMeshsetPtr(ms_id, SIDESET, &cubit_meshset_ptr);
    CHKERR cubit_meshset_ptr->getBcDataStructure(mapPressure[ms_id].data);
    CHKERR mField.get_moab().get_entities_by_dimension(
        cubit_meshset_ptr->meshset, 2, mapPressure[ms_id].tRis, true);
  }
 
  /*  LEFT-HAND SIDE (SPATIAL) */
 
  feLhs.getOpPtrVector().push_back(new OpGetTangent(X_field, data_at_pts));
 
  feLhs.getOpPtrVector().push_back(new OpNeumannPressureLhs_dx_dX(
      x_field, X_field, data_at_pts, aij, mapPressure[ms_id], ho_geometry));
 
  /* RIGHT-HAND SIDE (MATERIAL) */
 
  // Side volume element computes the deformation gradient F=hH^-1
  boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnSide> feMatSideRhs =
      boost::make_shared<VolumeElementForcesAndSourcesCoreOnSide>(mField);
 
  feMatSideRhs->getOpPtrVector().push_back(
      new OpCalculateVectorFieldGradient<3, 3>(X_field,
                                               data_at_pts->getHMatPtr()));
  feMatSideRhs->getOpPtrVector().push_back(
      new OpCalculateVectorFieldGradient<3, 3>(x_field,
                                               data_at_pts->getSmallhMatPtr()));
 
  feMatSideRhs->getOpPtrVector().push_back(
      new OpCalculateDeformation(X_field, data_at_pts, ho_geometry));
 
  feMatRhs.getOpPtrVector().push_back(new OpNeumannPressureMaterialRhs_dX(
      X_field, data_at_pts, feMatSideRhs, side_fe_name, F, mapPressure[ms_id],
      ho_geometry));
 
  /* LEFT-HAND SIDE (MATERIAL) */
 
  // Side volume element computes linearisation with spatial coordinates
  boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnSide> feMatSideLhs_dx =
      boost::make_shared<VolumeElementForcesAndSourcesCoreOnSide>(mField);
  // Side volume element computes linearisation with material coordinates
  boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnSide> feMatSideLhs_dX =
      boost::make_shared<VolumeElementForcesAndSourcesCoreOnSide>(mField);
 
  feMatSideLhs_dx->getOpPtrVector().push_back(
      new OpCalculateVectorFieldGradient<3, 3>(X_field,
                                               data_at_pts->getHMatPtr()));
  feMatSideLhs_dx->getOpPtrVector().push_back(
      new OpCalculateVectorFieldGradient<3, 3>(x_field,
                                               data_at_pts->getSmallhMatPtr()));
 
  feMatSideLhs_dx->getOpPtrVector().push_back(
      new OpCalculateDeformation(X_field, data_at_pts, ho_geometry));
  feMatSideLhs_dx->getOpPtrVector().push_back(
      new OpNeumannPressureMaterialVolOnSideLhs_dX_dx(
          X_field, x_field, data_at_pts, aij, mapPressure[ms_id], ho_geometry));
 
  feMatLhs.getOpPtrVector().push_back(new OpNeumannPressureMaterialLhs_dX_dx(
      X_field, x_field, data_at_pts, feMatSideLhs_dx, side_fe_name, aij,
      mapPressure[ms_id], ho_geometry));
 
  feMatSideLhs_dX->getOpPtrVector().push_back(
      new OpCalculateVectorFieldGradient<3, 3>(X_field,
                                               data_at_pts->getHMatPtr()));
  feMatSideLhs_dX->getOpPtrVector().push_back(
      new OpCalculateVectorFieldGradient<3, 3>(x_field,
                                               data_at_pts->getSmallhMatPtr()));
  feMatSideLhs_dX->getOpPtrVector().push_back(
      new OpCalculateDeformation(X_field, data_at_pts, ho_geometry));
  feMatSideLhs_dX->getOpPtrVector().push_back(
      new OpNeumannPressureMaterialVolOnSideLhs_dX_dX(
          X_field, X_field, data_at_pts, aij, mapPressure[ms_id], ho_geometry));
 
  feMatLhs.getOpPtrVector().push_back(new OpGetTangent(X_field, data_at_pts));
  feMatLhs.getOpPtrVector().push_back(new OpNeumannPressureMaterialLhs_dX_dX(
      X_field, X_field, data_at_pts, feMatSideLhs_dX, side_fe_name, aij,
      mapPressure[ms_id], ho_geometry));
 
  MoFEMFunctionReturn(0);
}

◆ getLoopFe()

MyTriangleFE & NeumannForcesSurface::getLoopFe ( )

inline

Definition at line 67 of file SurfacePressure.hpp.

67{ return fe; }

◆ getLoopFeLhs()

MyTriangleFE & NeumannForcesSurface::getLoopFeLhs ( )

inline

Definition at line 71 of file SurfacePressure.hpp.

71{ return feLhs; }

◆ getLoopFeMatLhs()

MyTriangleFE & NeumannForcesSurface::getLoopFeMatLhs ( )

inline

Definition at line 79 of file SurfacePressure.hpp.

79{ return feMatLhs; }

◆ getLoopFeMatRhs()

MyTriangleFE & NeumannForcesSurface::getLoopFeMatRhs ( )

inline

Definition at line 75 of file SurfacePressure.hpp.

75{ return feMatRhs; }

Member Data Documentation

◆ analyticalForceOp

boost::ptr_vector<MethodForAnalyticalForce> NeumannForcesSurface::analyticalForceOp

Definition at line 98 of file SurfacePressure.hpp.

◆ fe

MyTriangleFE NeumannForcesSurface::fe

Definition at line 66 of file SurfacePressure.hpp.

◆ feLhs

MyTriangleFE NeumannForcesSurface::feLhs

Definition at line 70 of file SurfacePressure.hpp.

◆ feMatLhs

MyTriangleFE NeumannForcesSurface::feMatLhs

Definition at line 78 of file SurfacePressure.hpp.

◆ feMatRhs

MyTriangleFE NeumannForcesSurface::feMatRhs

Definition at line 74 of file SurfacePressure.hpp.

◆ mapForce

std::map<int, bCForce> NeumannForcesSurface::mapForce

Definition at line 89 of file SurfacePressure.hpp.

◆ mapPressure

std::map<int, bCPressure> NeumannForcesSurface::mapPressure

Definition at line 95 of file SurfacePressure.hpp.

◆ methodsOp

boost::ptr_vector<MethodForForceScaling> NeumannForcesSurface::methodsOp

Definition at line 97 of file SurfacePressure.hpp.

◆ mField

MoFEM::Interface& NeumannForcesSurface::mField

Definition at line 16 of file SurfacePressure.hpp.

The documentation for this struct was generated from the following files:

users_modules/basic_finite_elements/src/SurfacePressure.hpp
users_modules/basic_finite_elements/src/impl/SurfacePressure.cpp

Classes

Public Types

Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ bCPreassure

◆ EntData

◆ MethodForAnaliticalForce

◆ OpNeumannPreassure

◆ UserDataOperator

◆ VolOnSideUserDataOperator

Constructor & Destructor Documentation

◆ NeumannForcesSurface()

Member Function Documentation

◆ addFlux()

◆ addForce()

◆ addForceAle()

◆ addLinearPressure()

◆ addPreassure()

◆ addPressure()

◆ addPressureAle()

◆ getLoopFe()

◆ getLoopFeLhs()

◆ getLoopFeMatLhs()

◆ getLoopFeMatRhs()

Member Data Documentation

◆ analyticalForceOp

◆ fe

◆ feLhs

◆ feMatLhs

◆ feMatRhs

◆ mapForce

◆ mapPressure

◆ methodsOp

◆ mField