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)
if field_exists(fieldmodule, name, 'StoredMeshLocation', mesh.getDimension()):
mesh_location_field = field.castStoredMeshLocation()
return mesh_location_field
return create_field_stored_mesh_location(fieldmodule, mesh, name=name, managed=managed)
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()