def create_square_element(mesh: Mesh, finite_element_field: Field,
node_coordinate_set):
"""
Create a single square 2-D finite element using the supplied
finite element field and sequence of 4 n-D node coordinates.
:param mesh: The Zinc Mesh to create elements in.
:param finite_element_field: Zinc FieldFiniteElement to interpolate on element.
:param node_coordinate_set: Sequence of 4 coordinates each with as many components as finite element field.
:return: None
"""
assert mesh.getDimension() == 2
assert finite_element_field.castFiniteElement().isValid()
assert len(node_coordinate_set) == 4
fieldmodule = finite_element_field.getFieldmodule()
nodeset = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
node_template = nodeset.createNodetemplate()
node_template.defineField(finite_element_field)
element_template = mesh.createElementtemplate()
element_template.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
linear_basis = fieldmodule.createElementbasis(
2, Elementbasis.FUNCTION_TYPE_LINEAR_LAGRANGE)
eft = mesh.createElementfieldtemplate(linear_basis)
element_template.defineField(finite_element_field, -1, eft)
field_cache = fieldmodule.createFieldcache()
with ChangeManager(fieldmodule):
node_identifiers = []
for node_coordinate in node_coordinate_set:
node = nodeset.createNode(-1, node_template)
node_identifiers.append(node.getIdentifier())
field_cache.setNode(node)
finite_element_field.assignReal(field_cache, node_coordinate)
element = mesh.createElement(-1, element_template)
element.setNodesByIdentifier(eft, node_identifiers)
fieldmodule.defineAllFaces()
def create_fields_displacement_gradients(coordinates: Field,
reference_coordinates: Field,
mesh: Mesh):
"""
:return: 1st and 2nd displacement gradients of (coordinates - referenceCoordinates) w.r.t. referenceCoordinates.
"""
assert (coordinates.getNumberOfComponents()
== 3) and (reference_coordinates.getNumberOfComponents() == 3)
fieldmodule = mesh.getFieldmodule()
dimension = mesh.getDimension()
with ChangeManager(fieldmodule):
if dimension == 3:
u = coordinates - reference_coordinates
displacement_gradient = fieldmodule.createFieldGradient(
u, reference_coordinates)
displacement_gradient2 = fieldmodule.createFieldGradient(
displacement_gradient, reference_coordinates)
elif dimension == 2:
# Note this needs improvement as missing cross terms
# assume xi directions are approximately normal;
# effect is to penalise elements where this is not so, which is also desired
dX_dxi1 = fieldmodule.createFieldDerivative(
reference_coordinates, 1)
dX_dxi2 = fieldmodule.createFieldDerivative(
reference_coordinates, 2)
dx_dxi1 = fieldmodule.createFieldDerivative(coordinates, 1)
dx_dxi2 = fieldmodule.createFieldDerivative(coordinates, 2)
dS1_dxi1 = fieldmodule.createFieldMagnitude(dX_dxi1)
dS2_dxi2 = fieldmodule.createFieldMagnitude(dX_dxi2)
du_dS1 = (dx_dxi1 - dX_dxi1) / dS1_dxi1
du_dS2 = (dx_dxi2 - dX_dxi2) / dS2_dxi2
displacement_gradient = fieldmodule.createFieldConcatenate(
[du_dS1, du_dS2])
# curvature:
d2u_dSdxi1 = fieldmodule.createFieldDerivative(
displacement_gradient, 1)
d2u_dSdxi2 = fieldmodule.createFieldDerivative(
displacement_gradient, 2)
displacement_gradient2 = fieldmodule.createFieldConcatenate(
[d2u_dSdxi1 / dS1_dxi1, d2u_dSdxi2 / dS2_dxi2])
else: # dimension == 1
dX_dxi1 = fieldmodule.createFieldDerivative(
reference_coordinates, 1)
dx_dxi1 = fieldmodule.createFieldDerivative(coordinates, 1)
dS1_dxi1 = fieldmodule.createFieldMagnitude(dX_dxi1)
displacement_gradient = (dx_dxi1 - dX_dxi1) / dS1_dxi1
# curvature:
displacement_gradient2 = fieldmodule.createFieldDerivative(
displacement_gradient, 1) / dS1_dxi1
return displacement_gradient, displacement_gradient2
def find_or_create_field_stored_mesh_location(fieldmodule: Fieldmodule, mesh: Mesh, name=None, managed=True)\
-> FieldStoredMeshLocation:
"""
Get or create a stored mesh location field for storing locations in the
supplied mesh, used for storing data projections.
Note can't currently verify existing field stores locations in the supplied mesh.
New field is managed by default.
:param fieldmodule: Zinc fieldmodule to find or create field in.
:param mesh: Mesh to store locations in, from same fieldmodule.
:param name: Name of new field. If not defined, defaults to "location_" + mesh.getName().
:param managed: Managed state of field if created here.
"""
if not name:
name = "location_" + mesh.getName()
field = fieldmodule.findFieldByName(name)
# StoredMeshLocation field can only have 1 component; its value is an element + xi coordinates
if field_exists(fieldmodule, name, 'StoredMeshLocation', 1):
mesh_location_field = field.castStoredMeshLocation()
return mesh_location_field
return create_field_stored_mesh_location(fieldmodule,
mesh,
name=name,
managed=managed)
def get_maximum_element_identifier(mesh: Mesh) -> int:
"""
:return: Maximum element identifier in mesh or -1 if none.
"""
maximum_element_id = -1
element_iterator = mesh.createElementiterator()
element = element_iterator.next()
while element.isValid():
element_id = element.getIdentifier()
if element_id > maximum_element_id:
maximum_element_id = element_id
element = element_iterator.next()
return maximum_element_id
def create_triangle_elements(mesh: Mesh, finite_element_field: Field,
element_node_set):
"""
Create a linear triangular element for every set of 3 local nodes in element_node_set.
:param mesh: The Zinc Mesh to create elements in.
:param finite_element_field: Zinc FieldFiniteElement to interpolate from nodes.
:param element_node_set: Sequence of 3 node identifiers for each element.
:return: None
"""
assert mesh.getDimension() == 2
assert finite_element_field.castFiniteElement().isValid()
fieldmodule = finite_element_field.getFieldmodule()
element_template = mesh.createElementtemplate()
element_template.setElementShapeType(Element.SHAPE_TYPE_TRIANGLE)
linear_basis = fieldmodule.createElementbasis(
2, Elementbasis.FUNCTION_TYPE_LINEAR_SIMPLEX)
eft = mesh.createElementfieldtemplate(linear_basis)
element_template.defineField(finite_element_field, -1, eft)
with ChangeManager(fieldmodule):
for element_nodes in element_node_set:
element = mesh.createElement(-1, element_template)
element.setNodesByIdentifier(eft, element_nodes)
fieldmodule.defineAllFaces()
def create_field_stored_mesh_location(fieldmodule: Fieldmodule, mesh: Mesh, name=None, managed=False)\
-> FieldStoredMeshLocation:
"""
Create a stored mesh location field for storing locations in the
supplied mesh, used for storing data projections.
New field is not managed by default.
:param fieldmodule: Zinc fieldmodule to find or create field in.
:param mesh: Mesh to store locations in, from same fieldmodule.
:param name: Name of new field. If not defined, defaults to "location_" + mesh.getName().
:param managed: Managed state of field.
:return: Zinc FieldStoredMeshLocation
"""
if not name:
name = "location_" + mesh.getName()
with ChangeManager(fieldmodule):
mesh_location_field = fieldmodule.createFieldStoredMeshLocation(mesh)
mesh_location_field.setName(name)
mesh_location_field.setManaged(managed)
return mesh_location_field
def evaluate_field_mesh_integral(field: Field, coordinates: Field, mesh: Mesh, number_of_points=4):
"""
Integrate value of a field over mesh using Gaussian Quadrature.
:param field: Field to integrate over mesh.
:param coordinates: Field giving spatial coordinates to integrate over.
:param mesh: The mesh or mesh group to integrate over.
:param number_of_points: Number of integration points in each dimension.
:return: Integral value.
"""
fieldmodule = mesh.getFieldmodule()
components_count = field.getNumberOfComponents()
with ChangeManager(fieldmodule):
integral = fieldmodule.createFieldMeshIntegral(field, coordinates, mesh)
integral.setNumbersOfPoints(number_of_points)
fieldcache = fieldmodule.createFieldcache()
result, value = integral.evaluateReal(fieldcache, components_count)
del integral
del fieldcache
assert result == RESULT_OK
return value