def zinc_find_ix_from_real_coordinates(region, regionName):
fm = region.getFieldmodule()
cache = fm.createFieldcache()
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
datapoints = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
dataNamesField = fm.findFieldByName(regionName)
coordinates = findOrCreateFieldCoordinates(fm, "coordinates")
data_coordinates = findOrCreateFieldCoordinates(fm, "data_coordinates")
mesh = fm.findMeshByDimension(3)
found_mesh_location = fm.createFieldFindMeshLocation(
data_coordinates, coordinates, mesh)
found_mesh_location.setSearchMode(found_mesh_location.SEARCH_MODE_NEAREST)
xi_projected_data = {}
nodeIter = datapoints.createNodeiterator()
node = nodeIter.next()
while node.isValid():
# print('dpoint ', node.getIdentifier())
cache.setNode(node)
element, xi = found_mesh_location.evaluateMeshLocation(cache, 3)
marker_name = dataNamesField.evaluateString(cache).split('_data')[0]
if element.isValid():
addProjection = {
marker_name: {
"elementID": element.getIdentifier(),
"xi": xi
}
}
xi_projected_data.update(addProjection)
node = nodeIter.next()
return xi_projected_data
def generateMesh(region, options):
"""
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: None
"""
coordinateDimensions = options['Coordinate dimensions']
length = options['Length']
elementsCount = options['Number of elements']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm, components_count=coordinateDimensions)
cache = fm.createFieldcache()
#################
# Create nodes
#################
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
nodeIdentifier = 1
x = [ 0.0, 0.0, 0.0 ]
dx_ds1 = [ length/elementsCount, 0.0, 0.0 ]
dx_ds2 = [ 0.0, 1.0, 0.0 ]
d2x_ds1ds2 = [ 0.0, 0.0, 0.0 ]
for n in range(elementsCount + 1):
x[0] = length*n/elementsCount
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, dx_ds1)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, dx_ds2)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, d2x_ds1ds2)
nodeIdentifier = nodeIdentifier + 1
#################
# Create elements
#################
mesh = fm.findMeshByDimension(1)
cubicHermiteBasis = fm.createElementbasis(1, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
eft = mesh.createElementfieldtemplate(cubicHermiteBasis)
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_LINE)
result = elementtemplate.defineField(coordinates, -1, eft)
elementIdentifier = 1
for e in range(elementsCount):
element = mesh.createElement(elementIdentifier, elementtemplate)
element.setNodesByIdentifier(eft, [ e + 1, e + 2 ])
elementIdentifier = elementIdentifier + 1
fm.endChange()
def generateZincModel(self,
region,
nextNodeIdentifier=1,
nextElementIdentifier=1):
'''
Generate Zinc nodes and elements in region to represent tree.
:return: Final nextNodeIdentifier, nextElementIdentifier.
'''
self._fieldmodule = region.getFieldmodule()
self._nodes = self._fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self._mesh1d = self._fieldmodule.findMeshByDimension(1)
self._cubicHermiteBasis = self._fieldmodule.createElementbasis(
1, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
self._linearBasis = self._fieldmodule.createElementbasis(
1, Elementbasis.FUNCTION_TYPE_LINEAR_LAGRANGE)
self._nodetemplates = {
} # indexed by (d1VersionsCount, rVersionsCount)
self._elementtemplates = {} # indexed by start (d1Version, rVersion)
with ChangeManager(self._fieldmodule):
self._coordinates = findOrCreateFieldCoordinates(self._fieldmodule)
self._radius = findOrCreateFieldFiniteElement(self._fieldmodule,
"radius",
components_count=1,
managed=True)
self._fieldcache = self._fieldmodule.createFieldcache()
parentNode = None
self._generateZincModelTree(self._rootNode, parentNode,
nextNodeIdentifier,
nextElementIdentifier)
return nextNodeIdentifier, nextElementIdentifier
def generateBaseMesh(cls, region, options):
"""
Generate the base tricubic Hermite mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: list of AnnotationGroup
"""
# set dependent outer diameter used in atria2
options['LV outlet outer diameter'] = options[
'LV outlet inner diameter'] + 2.0 * options[
'LV outlet wall thickness']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
cache = fm.createFieldcache()
# generate heartventriclesbase2 model and put atria2 on it
ventriclesAnnotationGroups = MeshType_3d_heartventriclesbase2.generateBaseMesh(
region, options)
atriaAnnotationGroups = MeshType_3d_heartatria2.generateBaseMesh(
region, options)
annotationGroups = mergeAnnotationGroups(ventriclesAnnotationGroups,
atriaAnnotationGroups)
fm.endChange()
return annotationGroups
def generate(self):
coordinate_dimensions = 2
elements_count = self.__options['number of elements']
node_coordinates = self.__options['node coordinates']
node_derivatives = self.__options['node derivatives']
fieldmodule = self.__region.getFieldmodule()
with ChangeManager(fieldmodule):
fieldmodule.beginChange()
coordinates = findOrCreateFieldCoordinates(
fieldmodule, components_count=coordinate_dimensions)
cache = fieldmodule.createFieldcache()
#################
# Create nodes
#################
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
node_template = nodes.createNodetemplate()
node_template.defineField(coordinates)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
node_identifier = 1
for n in range(len(node_coordinates)):
node = nodes.createNode(node_identifier, node_template)
cache.setNode(node)
x = node_coordinates[n]
d = node_derivatives[n]
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1, d)
node_identifier = node_identifier + 1
#################
# Create elements
#################
mesh = fieldmodule.findMeshByDimension(1)
cubic_hermite_basis = fieldmodule.createElementbasis(
1, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
eft = mesh.createElementfieldtemplate(cubic_hermite_basis)
element_template = mesh.createElementtemplate()
element_template.setElementShapeType(Element.SHAPE_TYPE_LINE)
result = element_template.defineField(coordinates, -1, eft)
element_identifier = 1
for e in range(elements_count):
element = mesh.createElement(element_identifier,
element_template)
element.setNodesByIdentifier(eft, [e + 1, e + 2])
element_identifier = element_identifier + 1
def zinc_find_ix_from_real_coordinates(modelFile, dataFile):
context = Context("Example")
region = context.getDefaultRegion()
# load model
region.readFile(modelFile)
if not region.readFile(modelFile):
print('File not readable for zinc')
return []
region.readFile(dataFile)
if not region.readFile(dataFile):
print('File not readable for zinc')
return []
fm = region.getFieldmodule()
cache = fm.createFieldcache()
datapoints = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
dataNamesField = fm.findFieldByName("marker_data_name")
coordinates = findOrCreateFieldCoordinates(fm, "coordinates")
data_coordinates = findOrCreateFieldCoordinates(fm,
"marker_data_coordinates")
mesh = fm.findMeshByDimension(3)
found_mesh_location = fm.createFieldFindMeshLocation(
data_coordinates, coordinates, mesh)
found_mesh_location.setSearchMode(found_mesh_location.SEARCH_MODE_NEAREST)
xi_projected_data = {}
nodeIter = datapoints.createNodeiterator()
node = nodeIter.next()
while node.isValid():
cache.setNode(node)
element, xi = found_mesh_location.evaluateMeshLocation(cache, 3)
marker_name = dataNamesField.evaluateString(cache)
if element.isValid():
addProjection = {
marker_name: {
"elementID": element.getIdentifier(),
"xi": xi
}
}
xi_projected_data.update(addProjection)
node = nodeIter.next()
return xi_projected_data
def test_field_coordinates(self):
"""
Test creation of finite element coordinates field.
"""
context = Context("test")
region = context.createRegion()
fieldmodule = region.getFieldmodule()
coordinates = findOrCreateFieldCoordinates(fieldmodule)
self.assertTrue(coordinates.isValid())
self.assertEqual(3, coordinates.getNumberOfComponents())
self.assertTrue(coordinates.isManaged())
self.assertTrue(coordinates.isTypeCoordinate())
def generateBaseMesh(cls, region, options):
"""
Generate the base bicubic-linear Hermite mesh.
Optional extra parameters allow centre and axes to be set.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: list of AnnotationGroup
"""
fieldmodule = region.getFieldmodule()
with ChangeManager(fieldmodule):
coordinates = findOrCreateFieldCoordinates(fieldmodule)
x, d1, d2, d3 = cls.getPoints(options)
nodeId = cls.generateNodes(fieldmodule, coordinates, x, d1, d2,
d3)[1]
cls.generateElements(fieldmodule, coordinates, nodeId)[0]
return [] # annotationGroups
def exnodeStringFromNodeValues(
nodeValueLabels=[Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1],
nodeValues=[[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]],
[[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]]],
groupName='meshEdits'):
'''
Return a string in Zinc EX format defining nodes 1..N with the supplied
coordinate values and their labels. Works in a private zinc context.
'''
# following requires at least one value label and node, assumes consistent values and components counts
nodeValueLabelsCount = len(nodeValueLabels)
nodesCount = len(nodeValues)
componentsCount = len(nodeValues[0][0])
context = Context('exnodeStringFromNodeValues')
region = context.getDefaultRegion()
fieldmodule = region.getFieldmodule()
with ChangeManager(fieldmodule):
cache = fieldmodule.createFieldcache()
coordinates = findOrCreateFieldCoordinates(
fieldmodule, components_count=componentsCount)
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
group = fieldmodule.createFieldGroup()
group.setName(groupName)
nodesetGroup = group.createFieldNodeGroup(nodes).getNodesetGroup()
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
if not Node.VALUE_LABEL_VALUE in nodeValueLabels:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 0)
for nodeValueLabel in nodeValueLabels:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
nodeValueLabel, 1)
# create nodes
for n in range(nodesCount):
node = nodesetGroup.createNode(n + 1, nodetemplate)
cache.setNode(node)
for v in range(nodeValueLabelsCount):
coordinates.setNodeParameters(cache, -1, nodeValueLabels[v], 1,
nodeValues[n][v])
# serialise to string
sir = region.createStreaminformationRegion()
srm = sir.createStreamresourceMemory()
sir.setResourceGroupName(srm, groupName)
region.write(sir)
result, exString = srm.getBuffer()
return exString
def generateBaseMesh(region, options):
"""
Generate the base tricubic Hermite mesh. See also generateMesh().
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: None
"""
centralPath = options['Central path']
full = not options['Lower half']
elementsCountAcrossMajor = options['Number of elements across major']
if not full:
elementsCountAcrossMajor //= 2
elementsCountAcrossMinor = options['Number of elements across minor']
elementsCountAcrossShell = options['Number of elements across shell']
elementsCountAcrossTransition = options[
'Number of elements across transition']
elementsCountAlong = options['Number of elements along']
shellProportion = options['Shell element thickness proportion']
useCrossDerivatives = options['Use cross derivatives']
fm = region.getFieldmodule()
coordinates = findOrCreateFieldCoordinates(fm)
cylinderCentralPath = CylinderCentralPath(region, centralPath,
elementsCountAlong)
cylinderShape = CylinderShape.CYLINDER_SHAPE_FULL if full else CylinderShape.CYLINDER_SHAPE_LOWER_HALF
base = CylinderEnds(elementsCountAcrossMajor, elementsCountAcrossMinor,
elementsCountAcrossShell,
elementsCountAcrossTransition, shellProportion,
[0.0, 0.0, 0.0], cylinderCentralPath.alongAxis[0],
cylinderCentralPath.majorAxis[0],
cylinderCentralPath.minorRadii[0])
cylinder1 = CylinderMesh(fm,
coordinates,
elementsCountAlong,
base,
cylinderShape=cylinderShape,
cylinderCentralPath=cylinderCentralPath,
useCrossDerivatives=False)
annotationGroup = []
return annotationGroup
def zinc_write_element_xi_file(outFile, xyz, allMarkers):
context = Context("Example")
outputRegion = context.getDefaultRegion()
fm = outputRegion.getFieldmodule()
fm.beginChange()
cache = fm.createFieldcache()
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
markerNodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
markerGroup = findOrCreateFieldGroup(fm, "marker")
markerName = findOrCreateFieldStoredString(fm, name="marker_name")
markerPoints = findOrCreateFieldNodeGroup(markerGroup,
markerNodes).getNodesetGroup()
markerTemplate = markerPoints.createNodetemplate()
markerTemplate.defineField(markerName)
markerTemplate.defineField(coordinates)
nodeIdentifier = 1
for ix in xyz:
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, ix)
nodeIdentifier += 1
nodeIdentifier = 1
for key in allMarkers:
addMarker = {"name": key, "xyz": allMarkers[key]}
node = markerPoints.createNode(nodeIdentifier, markerTemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
addMarker['xyz'])
markerName.assignString(cache, addMarker["name"])
nodeIdentifier += 1
fm.endChange()
outputRegion.writeFile(outFile)
def __init__(self, region, description, annotationGroups = None):
'''
:param region: Region containing finite element model to export.
:param description: Single line text description up to 256 characters.
:param annotationGroups: Optional list of AnnotationGroup for model.
'''
self._region = region
self._fieldmodule = self._region.getFieldmodule()
for dimension in range(3, 1, -1):
self._mesh = self._fieldmodule.findMeshByDimension(dimension)
if self._mesh.getSize() > 0:
break
self._nodes = self._fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self._coordinates = findOrCreateFieldCoordinates(self._fieldmodule)
self._description = description
self._annotationGroups = annotationGroups if annotationGroups else []
self._markerNodes = None
markerGroup = self._fieldmodule.findFieldByName("marker")
if markerGroup.isValid():
markerGroup = markerGroup.castGroup()
markerNodeGroup = markerGroup.getFieldNodeGroup(self._nodes)
if markerNodeGroup.isValid():
self._markerNodes = markerNodeGroup.getNodesetGroup()
def generateBaseMesh(cls, region, options):
"""
Generate the base tricubic Hermite mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: [] empty list of AnnotationGroup
"""
options['Diameter'] = 1.0
radiusSphere = options['Diameter'] * 0.5
radiusAnt = options['Anterior radius of curvature']
radiusPos = options['Posterior radius of curvature']
lensThickness = options['Axial thickness']
sphereSphericalRadiusFraction = options[
'Sphere spherical radius fraction']
lensSphericalRadiusFraction = options['Lens spherical radius fraction']
fm = region.getFieldmodule()
fm.beginChange()
cache = fm.createFieldcache()
# generate solidsphere with unit diameter
MeshType_3d_solidsphere1.generateBaseMesh(region, options)
sphereCoordinates = findOrCreateFieldCoordinates(fm)
# Morph sphere surface to lens surface
lensRC = getSphereToLensCoordinates(sphereCoordinates, radiusSphere,
radiusAnt, radiusPos,
lensThickness,
sphereSphericalRadiusFraction,
lensSphericalRadiusFraction)
# Assign Field
fieldassignment = sphereCoordinates.createFieldassignment(lensRC)
result = fieldassignment.assign()
fm.endChange()
return []
reader.SetFileName(path+vf)
reader.Update()
polydata = reader.GetOutput()
points = polydata.GetPoints()
array = points.GetData()
numpy_nodes = vtk_to_numpy(array)
step = 1
numpy_nodes = [numpy_nodes[i] for i in range(0,len(numpy_nodes),step)]
outFile = path+vf+'_step%d.exf' %step if step > 1 else path+vf+'.exf'
context = Context("brainstem")
region = context.getDefaultRegion()
fm = region.getFieldmodule()
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
coordinates = findOrCreateFieldCoordinates(fm, "data_coordinates")
mesh1d = fm.findMeshByDimension(1)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
cache = fm.createFieldcache()
fm.beginChange()
nodeIdentifier = 1
for p in numpy_nodes:
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
result = coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, list([float(pp) for pp in p]))
nodeIdentifier += 1
fm.endChange()
def generateBaseMesh(cls, region, options):
'''
Generate the base bicubic Hermite mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: list of AnnotationGroup
'''
elementsCountUpNeck = options['Number of elements up neck']
elementsCountUpBody = options['Number of elements up body']
elementsCountAround = options['Number of elements around']
height = options['Height']
majorDiameter = options['Major diameter']
minorDiameter = options['Minor diameter']
radius = 0.5 * options['Urethra diameter']
bladderWallThickness = options['Bladder wall thickness']
useCrossDerivatives = options['Use cross derivatives']
elementsCountAroundOstium = options['Number of elements around ostium']
elementsCountAnnulusRadially = options['Number of elements radially on annulus']
ostiumPositionAround = options['Ostium position around']
ostiumPositionUp = options['Ostium position up']
ostiumOptions = options['Ureter']
ostiumDefaultOptions = ostiumOptions.getScaffoldSettings()
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
cache = fm.createFieldcache()
mesh = fm.findMeshByDimension(3)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplateApex = nodes.createNodetemplate()
nodetemplateApex.defineField(coordinates)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
else:
nodetemplate = nodetemplateApex
eftfactory = eftfactory_bicubichermitelinear(mesh, useCrossDerivatives)
eft = eftfactory.createEftBasic()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementtemplate.defineField(coordinates, -1, eft)
neckGroup = AnnotationGroup(region, get_bladder_term("neck of urinary bladder"))
bodyGroup = AnnotationGroup(region, get_bladder_term("dome of the bladder"))
urinaryBladderGroup = AnnotationGroup(region, get_bladder_term("urinary bladder"))
annotationGroups = [neckGroup, bodyGroup, urinaryBladderGroup]
neckMeshGroup = neckGroup.getMeshGroup(mesh)
bodyMeshGroup = bodyGroup.getMeshGroup(mesh)
urinaryBladderMeshGroup = urinaryBladderGroup.getMeshGroup(mesh)
# create nodes
# create neck of the bladder
nodeIdentifier = 1
radiansPerElementAround = 2.0*math.pi/elementsCountAround
radiansPerElementUpNeck = (math.pi/4)/elementsCountUpNeck
# create lower part of the ellipsoidal
neckHeight = height - height * math.cos(math.pi / 4)
ellipsoidal_x = []
ellipsoidal_d1 = []
ellipsoidal_d2 = []
for n2 in range(0, elementsCountUpNeck+1):
radiansUp = n2 * radiansPerElementUpNeck
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
majorRadius = 0.5 * majorDiameter * sinRadiansUp
minorRadius = 0.5 * minorDiameter * sinRadiansUp
if n2 == 0:
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-majorRadius * sinRadiansAround,
minorRadius * cosRadiansAround,
-height - neckHeight
]
dx_ds1 = [
-majorRadius * cosRadiansAround * radiansPerElementAround,
minorRadius * -sinRadiansAround * radiansPerElementAround,
0.0
]
dx_ds2 = [
-0.5 * majorDiameter * sinRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
0.5 * minorDiameter * cosRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
height * sinRadiansUp * radiansPerElementUpNeck
]
ellipsoidal_x.append(x)
ellipsoidal_d1.append(dx_ds1)
ellipsoidal_d2.append(dx_ds2)
else:
for n1 in range(elementsCountAround):
neckHeight = height - height * math.cos(math.pi/4)
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-majorRadius * sinRadiansAround,
minorRadius * cosRadiansAround,
-height - neckHeight + n2 * 2 * neckHeight / elementsCountUpNeck
]
dx_ds1 = [
-majorRadius * cosRadiansAround * radiansPerElementAround,
minorRadius * -sinRadiansAround * radiansPerElementAround,
0.0
]
dx_ds2 = [
-0.5 * majorDiameter * sinRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
0.5 * minorDiameter * cosRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
height * sinRadiansUp * radiansPerElementUpNeck
]
ellipsoidal_x.append(x)
ellipsoidal_d1.append(dx_ds1)
ellipsoidal_d2.append(dx_ds2)
# create tube nodes
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
tube_x = []
tube_d1 = []
tube_d2 = []
for n2 in range(0, elementsCountUpNeck + 1):
radiansUp = n2 * radiansPerElementUpNeck
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
if n2 == 0:
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-radius * sinRadiansAround,
radius * cosRadiansAround,
-height - neckHeight
]
dx_ds1 = [
-radiansPerElementAround * radius * cosRadiansAround,
radiansPerElementAround * radius * -sinRadiansAround,
0.0
]
dx_ds2 = [0, 0, height / (2 * elementsCountUpNeck)]
tube_x.append(x)
tube_d1.append(dx_ds1)
tube_d2.append(dx_ds2)
else:
for n1 in range(elementsCountAround):
neckHeight = height - height* math.cos(math.pi/4)
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-radius * sinRadiansAround,
radius * cosRadiansAround,
-height - neckHeight + n2 * 2 * neckHeight / elementsCountUpNeck
]
dx_ds1 = [
-radiansPerElementAround * radius * cosRadiansAround,
radiansPerElementAround * radius * -sinRadiansAround,
0.0
]
dx_ds2 = [0, 0, height / elementsCountUpNeck]
tube_x.append(x)
tube_d1.append(dx_ds1)
tube_d2.append(dx_ds2)
# interpolation between the lower part of the ellipsoidal and the tube
m1 = 0
z_bottom = ellipsoidal_x[-1][2]
z_top = ellipsoidal_x[0][2]
delta_z = z_top - z_bottom
interpolatedNodes = []
interpolatedNodes_d1 = []
interpolatedNodes_d2 = []
for n2 in range(elementsCountUpNeck+1):
xi = 1.0 - (ellipsoidal_x[m1][2] - z_bottom) / delta_z
for n1 in range(elementsCountAround):
phi_inner, _, phi_outer, _ = getCubicHermiteBasis(xi)
x = [(phi_inner*tube_x[m1][c] + phi_outer*ellipsoidal_x[m1][c]) for c in range(3)]
d1 = [(phi_inner*tube_d1[m1][c] + phi_outer*ellipsoidal_d1[m1][c]) for c in range(3)]
d2 = [(phi_inner*tube_d2[m1][c] + phi_outer*ellipsoidal_d2[m1][c]) for c in range(3)]
interpolatedNodes.append(x)
interpolatedNodes_d1.append(d1)
interpolatedNodes_d2.append(d2)
m1 += 1
# smoothing the derivatives
sd2Raw = []
for n1 in range(elementsCountAround):
lineSmoothingNodes = []
lineSmoothingNodes_d2 = []
for n2 in range(elementsCountUpNeck+1):
lineSmoothingNodes.append(interpolatedNodes[n1 + n2 * elementsCountAround])
lineSmoothingNodes_d2.append(interpolatedNodes_d2[n1 + n2 * elementsCountAround])
sd2 = smoothCubicHermiteDerivativesLine(lineSmoothingNodes, lineSmoothingNodes_d2,
fixAllDirections=False,
fixStartDerivative=True, fixEndDerivative=True,
fixStartDirection=False, fixEndDirection=False)
sd2Raw.append(sd2)
# re-arrange the derivatives order
d2RearrangedList = []
for n2 in range(elementsCountUpNeck+1):
for n1 in range(elementsCountAround):
d2 = sd2Raw[n1][n2]
d2RearrangedList.append(d2)
# create tracksurface at the outer layer of the neck
nodesOnTrackSurface = []
nodesOnTrackSurface_d1 = []
nodesOnTrackSurface_d2 = []
for n2 in range(elementsCountUpNeck+1):
for n1 in range(elementsCountAround):
if (n1 <= elementsCountAround / 2):
nodesOnTrackSurface.append(interpolatedNodes[n2 * elementsCountAround + n1])
nodesOnTrackSurface_d1.append(interpolatedNodes_d1[n2 * elementsCountAround + n1])
nodesOnTrackSurface_d2.append(d2RearrangedList[n2 * elementsCountAround + n1])
# nodes and derivatives of the neck of the bladder
listOuterNeck_x = []
listOuterNeck_d1 = []
listOuterNeck_d2 = []
elementsCount1 = elementsCountAround // 2
elementsCount2 = elementsCountUpNeck
tracksurfaceOstium1 = TrackSurface(elementsCount1, elementsCount2, nodesOnTrackSurface, nodesOnTrackSurface_d1,
nodesOnTrackSurface_d2)
ostium1Position = tracksurfaceOstium1.createPositionProportion(ostiumPositionAround, ostiumPositionUp)
ostium1Position.xi1 = 1.0
ostium1Position.xi2 = 1.0
ostiumElementPositionAround = ostium1Position.e1
ostiumElementPositionUp = ostium1Position.e2
for n2 in range(len(interpolatedNodes)):
listOuterNeck_x.append(interpolatedNodes[n2])
listOuterNeck_d1.append(interpolatedNodes_d1[n2])
listOuterNeck_d2.append(d2RearrangedList[n2])
# create body of the bladder
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
radiansPerElementUpBody = (3 * math.pi / 4) / elementsCountUpBody
# create regular rows
listOuterBody_x = []
listOuterBody_d1 = []
listOuterBody_d2 = []
for n2 in range(1, elementsCountUpBody):
radiansUp = (math.pi / 4) + n2 * radiansPerElementUpBody
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
majorRadius = 0.5 * majorDiameter * sinRadiansUp
minorRadius = 0.5 * minorDiameter * sinRadiansUp
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-majorRadius * sinRadiansAround,
minorRadius * cosRadiansAround,
-height * cosRadiansUp
]
dx_ds1 = [
-majorRadius * cosRadiansAround * radiansPerElementAround,
minorRadius * -sinRadiansAround * radiansPerElementAround,
0.0
]
dx_ds2 = [
-0.5 * majorDiameter * sinRadiansAround * cosRadiansUp * radiansPerElementUpBody,
0.5 * minorDiameter * cosRadiansAround * cosRadiansUp * radiansPerElementUpBody,
height*sinRadiansUp * radiansPerElementUpBody
]
listOuterBody_x.append(x)
listOuterBody_d1.append(dx_ds1)
listOuterBody_d2.append(dx_ds2)
# create outer apex node
outerApexNode_x = []
outerApexNode_d1 = []
outerApexNode_d2 = []
x = [0.0, 0.0, height]
dx_ds1 = [height*radiansPerElementUpBody/2, 0.0, 0.0]
dx_ds2 = [0.0, height*radiansPerElementUpBody/2, 0.0]
outerApexNode_x.append(x)
outerApexNode_d1.append(dx_ds1)
outerApexNode_d2.append(dx_ds2)
# set nodes of outer layer of the bladder
listTotalOuter_x = listOuterNeck_x + listOuterBody_x + outerApexNode_x
listTotalOuter_d1 = listOuterNeck_d1 + listOuterBody_d1 + outerApexNode_d1
listTotalOuter_d2 = listOuterNeck_d2 + listOuterBody_d2 + outerApexNode_d2
outerLayer_x = []
outerLayer_d1 = []
outerLayer_d2 = []
for n2 in range(len(listTotalOuter_x)):
if (n2 != (ostiumElementPositionUp + 1) * elementsCountAround + ostiumElementPositionAround + 1) and\
(n2 != (ostiumElementPositionUp + 1) * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 1):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, listTotalOuter_x[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, listTotalOuter_d1[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, listTotalOuter_d2[n2])
nodeIdentifier += 1
outerLayer_x.append(listTotalOuter_x[n2])
outerLayer_d1.append(listTotalOuter_d1[n2])
outerLayer_d2.append(listTotalOuter_d2[n2])
# create and set nodes of inner layer of the bladder
listTotalInner_x = []
listTotalInner_d1 = []
listTotalInner_d2 = []
for n2 in range(elementsCountUpNeck + elementsCountUpBody):
loop_x = [listTotalOuter_x[n2 * elementsCountAround + n1] for n1 in range(elementsCountAround)]
loop_d1 = [listTotalOuter_d1[n2 * elementsCountAround + n1] for n1 in range(elementsCountAround)]
loop_d2 = [listTotalOuter_d2[n2 * elementsCountAround + n1] for n1 in range(elementsCountAround)]
for n1 in range(elementsCountAround):
x, d1, _, _ = interp.projectHermiteCurvesThroughWall(loop_x, loop_d1, loop_d2, n1,
-bladderWallThickness, loop=True)
listTotalInner_x.append(x)
listTotalInner_d1.append(d1)
listInner_d2 = []
for n2 in range(elementsCountAround):
nx = [listTotalOuter_x[n1 * elementsCountAround + n2] for n1 in range(elementsCountUpNeck + elementsCountUpBody)]
nd1 = [listTotalOuter_d1[n1 * elementsCountAround + n2] for n1 in range(elementsCountUpNeck + elementsCountUpBody)]
nd2 = [listTotalOuter_d2[n1 * elementsCountAround + n2] for n1 in range(elementsCountUpNeck + elementsCountUpBody)]
for n1 in range(elementsCountUpNeck + elementsCountUpBody):
_, d2, _, _ = interp.projectHermiteCurvesThroughWall(nx, nd2, nd1, n1,
bladderWallThickness, loop=False)
listInner_d2.append(d2)
# re-arrange the derivatives order
for n2 in range(elementsCountUpNeck + elementsCountUpBody):
for n1 in range(elementsCountAround):
rearranged_d2 = listInner_d2[n1 * (elementsCountUpNeck + elementsCountUpBody) + n2]
listTotalInner_d2.append(rearranged_d2)
innerLayer_x = []
innerLayer_d1 = []
innerLayer_d2 = []
for n2 in range(len(listTotalInner_x)):
if (n2 != (ostiumElementPositionUp + 1) * elementsCountAround + ostiumElementPositionAround + 1) and \
(n2 != (ostiumElementPositionUp + 1) * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 1):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, listTotalInner_x[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, listTotalInner_d1[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, listTotalInner_d2[n2])
nodeIdentifier += 1
innerLayer_x.append(listTotalInner_x[n2])
innerLayer_d1.append(listTotalInner_d1[n2])
innerLayer_d2.append(listTotalInner_d2[n2])
# create inner apex node
x = [0.0, 0.0, height - bladderWallThickness]
dx_ds1 = [height*radiansPerElementUpBody/2, 0.0, 0.0]
dx_ds2 = [0.0, height*radiansPerElementUpBody/2, 0.0]
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, dx_ds1)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, dx_ds2)
listTotalInner_x.append(x)
listTotalInner_d1.append(dx_ds1)
listTotalInner_d2.append(dx_ds2)
innerLayer_x.append(x)
innerLayer_d1.append(dx_ds1)
innerLayer_d2.append(dx_ds2)
nodeIdentifier += 1
# create ureters on the surface
elementIdentifier = 1
# ureter 1
centerUreter1_x, centerUreter1_d1, centerUreter1_d2 = tracksurfaceOstium1.evaluateCoordinates(ostium1Position, derivatives=True)
td1, td2, td3 = calculate_surface_axes(centerUreter1_d1, centerUreter1_d2, [1.0, 0.0, 0.0])
m1 = ostiumElementPositionUp * elementsCountAround + ostiumElementPositionAround
ureter1StartCornerx = listOuterNeck_x[m1]
v1 = [(ureter1StartCornerx[c] - centerUreter1_x[c]) for c in range(3)]
ostium1Direction = vector.crossproduct3(td3, v1)
nodeIdentifier, elementIdentifier, (o1_x, o1_d1, o1_d2, _, o1_NodeId, o1_Positions) = \
generateOstiumMesh(region, ostiumDefaultOptions, tracksurfaceOstium1, ostium1Position, ostium1Direction,
startNodeIdentifier=nodeIdentifier, startElementIdentifier=elementIdentifier)
# ureter 2
tracksurfaceOstium2 = tracksurfaceOstium1.createMirrorX()
ostium2Position = TrackSurfacePosition(elementsCountAround - ostiumElementPositionAround, ostiumElementPositionUp - 1, 0.0, 1.0)
centerUreter2_x, centerUreter2_d1, centerUreter2_d2 = tracksurfaceOstium2.evaluateCoordinates(ostium2Position, derivatives =True)
ad1, ad2, ad3 = calculate_surface_axes(centerUreter2_d1, centerUreter2_d2, [1.0, 0.0, 0.0])
if elementsCountAroundOstium == 4:
m2 = ostiumElementPositionUp * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 1
else:
m2 = ostiumElementPositionUp * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 2
ureter2StartCornerx = listOuterNeck_x[m2]
v2 = [(ureter2StartCornerx[c] - centerUreter2_x[c]) for c in range(3)]
ostium2Direction = vector.crossproduct3(ad3, v2)
nodeIdentifier, elementIdentifier, (o2_x, o2_d1, o2_d2, _, o2_NodeId, o2_Positions) = \
generateOstiumMesh(region, ostiumDefaultOptions, tracksurfaceOstium2, ostium2Position, ostium2Direction,
startNodeIdentifier=nodeIdentifier, startElementIdentifier=elementIdentifier)
# create annulus mesh around ostium
endPoints1_x = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints1_d1 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints1_d2 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endNode1_Id = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endDerivativesMap = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints2_x = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints2_d1 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints2_d2 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endNode2_Id = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
nodeCountsEachWallLayer = (elementsCountUpNeck + elementsCountUpBody) * elementsCountAround - 1
for n3 in range(2):
n1 = 0
endNode1_Id[n3][n1] = ((1 - n3) * nodeCountsEachWallLayer) + (ostiumElementPositionUp * elementsCountAround) + ostiumElementPositionAround + 1
endNode1_Id[n3][n1 + 1] = endNode1_Id[n3][n1] + elementsCountAround
endNode1_Id[n3][n1 + 2] = endNode1_Id[n3][n1 + 1] + elementsCountAround - 2
endNode1_Id[n3][n1 + 3] = endNode1_Id[n3][n1 + 2] + 1
endNode1_Id[n3][n1 + 4] = endNode1_Id[n3][n1 + 3] + 1
endNode1_Id[n3][n1 + 5] = endNode1_Id[n3][n1 + 1] + 1
endNode1_Id[n3][n1 + 6] = endNode1_Id[n3][n1] + 2
endNode1_Id[n3][n1 + 7] = endNode1_Id[n3][n1] + 1
if ostiumElementPositionAround == 0:
endNode2_Id[n3][n1] = ((1 - n3) * nodeCountsEachWallLayer) + (ostiumElementPositionUp * elementsCountAround)\
+ elementsCountAround - ostiumElementPositionAround - 1
endNode2_Id[n3][n1 + 1] = endNode2_Id[n3][n1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 2] = endNode2_Id[n3][n1 + 1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 3] = endNode2_Id[n3][n1 + 2] + 1
endNode2_Id[n3][n1 + 4] = endNode2_Id[n3][n1 + 3] - elementsCountAround + 1
endNode2_Id[n3][n1 + 5] = endNode2_Id[n3][n1 + 4] - elementsCountAround + 2
endNode2_Id[n3][n1 + 6] = endNode2_Id[n3][n1 + 5] - elementsCountAround
endNode2_Id[n3][n1 + 7] = endNode2_Id[n3][n1] + 1
else:
endNode2_Id[n3][n1] = ((1 - n3) * nodeCountsEachWallLayer) + (ostiumElementPositionUp * elementsCountAround)\
+ elementsCountAround - ostiumElementPositionAround - 1
endNode2_Id[n3][n1 + 1] = endNode2_Id[n3][n1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 2] = endNode2_Id[n3][n1 + 1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 3] = endNode2_Id[n3][n1 + 2] + 1
endNode2_Id[n3][n1 + 4] = endNode2_Id[n3][n1 + 3] + 1
endNode2_Id[n3][n1 + 5] = endNode2_Id[n3][n1 + 1] + 1
endNode2_Id[n3][n1 + 6] = endNode2_Id[n3][n1] + 2
endNode2_Id[n3][n1 + 7] = endNode2_Id[n3][n1] + 1
for n3 in range(2):
for n1 in range(elementsCountAroundOstium):
nc1 = endNode1_Id[n3][n1] - (1 - n3) * nodeCountsEachWallLayer - 1
endPoints1_x[n3][n1] = innerLayer_x[nc1]
endPoints1_d1[n3][n1] = innerLayer_d1[nc1]
endPoints1_d2[n3][n1] = [innerLayer_d2[nc1][c] for c in range(3)]
nc2 = endNode2_Id[n3][n1] - (1 - n3) * nodeCountsEachWallLayer - 1
endPoints2_x[n3][n1] = innerLayer_x[nc2]
endPoints2_d1[n3][n1] = innerLayer_d1[nc2]
endPoints2_d2[n3][n1] = innerLayer_d2[nc2]
for n1 in range(elementsCountAroundOstium):
if n1 == 0:
endDerivativesMap[0][n1] = ((-1, 0, 0), (-1, -1, 0), None, (0, 1, 0))
endDerivativesMap[1][n1] = ((-1, 0, 0), (-1, -1, 0), None, (0, 1, 0))
elif n1 == 1:
endDerivativesMap[0][n1] = ((0, 1, 0), (-1, 0, 0), None)
endDerivativesMap[1][n1] = ((0, 1, 0), (-1, 0, 0), None)
elif n1 == 2:
endDerivativesMap[0][n1] = ((0, 1, 0), (-1, 1, 0), None, (1, 0, 0))
endDerivativesMap[1][n1] = ((0, 1, 0), (-1, 1, 0), None, (1, 0, 0))
elif n1 == 3:
endDerivativesMap[0][n1] = ((1, 0, 0), (0, 1, 0), None)
endDerivativesMap[1][n1] = ((1, 0, 0), (0, 1, 0), None)
elif n1 == 4:
endDerivativesMap[0][n1] = ((1, 0, 0), (1, 1, 0), None, (0, -1, 0))
endDerivativesMap[1][n1] = ((1, 0, 0), (1, 1, 0), None, (0, -1, 0))
elif n1 == 5:
endDerivativesMap[0][n1] = ((0, -1, 0), (1, 0, 0), None)
endDerivativesMap[1][n1] = ((0, -1, 0), (1, 0, 0), None)
elif n1 == 6:
endDerivativesMap[0][n1] = ((0, -1, 0), (1, -1, 0), None, (-1, 0, 0))
endDerivativesMap[1][n1] = ((0, -1, 0), (1, -1, 0), None, (-1, 0, 0))
else:
endDerivativesMap[0][n1] = ((-1, 0, 0), (0, -1, 0), None)
endDerivativesMap[1][n1] = ((-1, 0, 0), (0, -1, 0), None)
nodeIdentifier, elementIdentifier = createAnnulusMesh3d(
nodes, mesh, nodeIdentifier, elementIdentifier,
o1_x, o1_d1, o1_d2, None, o1_NodeId, None,
endPoints1_x, endPoints1_d1, endPoints1_d2, None, endNode1_Id, endDerivativesMap,
elementsCountRadial=elementsCountAnnulusRadially, meshGroups=[neckMeshGroup, urinaryBladderMeshGroup])
nodeIdentifier, elementIdentifier = createAnnulusMesh3d(
nodes, mesh, nodeIdentifier, elementIdentifier,
o2_x, o2_d1, o2_d2, None, o2_NodeId, None,
endPoints2_x, endPoints2_d1, endPoints2_d2, None, endNode2_Id, endDerivativesMap,
elementsCountRadial=elementsCountAnnulusRadially, meshGroups=[neckMeshGroup, urinaryBladderMeshGroup])
# create elements
for e3 in range(1):
newl = (e3 + 1) * ((elementsCountUpNeck + elementsCountUpBody) * elementsCountAround - 1)
# create bladder neck elements
for e2 in range(elementsCountUpNeck):
for e1 in range(elementsCountAround):
if e2 == ostiumElementPositionUp:
if (e1 == ostiumElementPositionAround or e1 == ostiumElementPositionAround + 1):
pass
elif (e1 == elementsCountAround - ostiumElementPositionAround - 2 or e1 == elementsCountAround - 1 - ostiumElementPositionAround):
pass
else:
bni1 = e2 * elementsCountAround + e1 + 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
if e1 < ostiumElementPositionAround:
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
elif (ostiumElementPositionAround + 1 < e1 < elementsCountAround - ostiumElementPositionAround - 2):
bni3 = bni1 + elementsCountAround - 1
bni4 = bni2 + elementsCountAround - 1
elif e1 > elementsCountAround - ostiumElementPositionAround - 1:
bni3 = bni1 + elementsCountAround - 2
if e1 == elementsCountAround - 1:
bni4 = bni2 + elementsCountAround
else:
bni4 = bni2 + elementsCountAround - 2
element = mesh.createElement(elementIdentifier, elementtemplate)
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
elif e2 == ostiumElementPositionUp + 1:
if (e1 == ostiumElementPositionAround or e1 == ostiumElementPositionAround + 1):
pass
elif (e1 == elementsCountAround - ostiumElementPositionAround - 2 or e1 == elementsCountAround - 1 - ostiumElementPositionAround):
pass
else:
if e1 < ostiumElementPositionAround:
bni1 = e2 * elementsCountAround + e1 + 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
bni3 = bni1 + elementsCountAround - 2
bni4 = bni2 + elementsCountAround - 2
elif (ostiumElementPositionAround + 1 < e1 < elementsCountAround - ostiumElementPositionAround - 2):
bni1 = e2 * elementsCountAround + e1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround
bni3 = bni1 + elementsCountAround - 1
bni4 = bni2 + elementsCountAround - 1
elif e1 > elementsCountAround - ostiumElementPositionAround - 1:
bni1 = e2 * elementsCountAround + e1 - 1
bni3 = bni1 + elementsCountAround
if e1 == elementsCountAround - 1:
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
bni4 = bni2 + elementsCountAround - 2
else:
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround - 1
bni4 = bni2 + elementsCountAround
element = mesh.createElement(elementIdentifier, elementtemplate)
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
elif e2 > ostiumElementPositionUp + 1:
element = mesh.createElement(elementIdentifier, elementtemplate)
bni1 = e2 * elementsCountAround + e1 - 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround - 1
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
else:
element = mesh.createElement(elementIdentifier, elementtemplate)
bni1 = e2 * elementsCountAround + e1 + 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
# create bladder body elements
for e2 in range(elementsCountUpNeck, (elementsCountUpNeck + elementsCountUpBody - 1)):
for e1 in range(elementsCountAround):
element = mesh.createElement(elementIdentifier, elementtemplate)
bni1 = e2 * elementsCountAround + e1 - 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround - 1
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
bodyMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
# create apex elements
bni3 = (elementsCountUpNeck + elementsCountUpBody) * elementsCountAround - 1
elementtemplateApex = mesh.createElementtemplate()
elementtemplateApex.setElementShapeType(Element.SHAPE_TYPE_CUBE)
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eftApex = eftfactory.createEftShellPoleTop(va, vb)
elementtemplateApex.defineField(coordinates, -1, eftApex)
# redefine field in template for changes to eftApex:
element = mesh.createElement(elementIdentifier, elementtemplateApex)
bni1 = bni3 - elementsCountAround + e1
bni2 = bni3 - elementsCountAround + (e1 + 1) % elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni1, bni2, bni3]
result = element.setNodesByIdentifier(eftApex, nodeIdentifiers)
bodyMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
fm.endChange()
return annotationGroups
def generateMesh(region, options):
"""
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: None
"""
coordinateDimensions = options['Coordinate dimensions']
elementsCount1 = options['Number of elements 1']
elementsCount2 = options['Number of elements 2']
useCrossDerivatives = options['Use cross derivatives']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(
fm, components_count=coordinateDimensions)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1)
mesh = fm.findMeshByDimension(2)
bicubicHermiteBasis = fm.createElementbasis(
2, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
eft = mesh.createElementfieldtemplate(bicubicHermiteBasis)
if not useCrossDerivatives:
for n in range(4):
eft.setFunctionNumberOfTerms(n * 4 + 4, 0)
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
result = elementtemplate.defineField(coordinates, -1, eft)
cache = fm.createFieldcache()
# create nodes
nodeIdentifier = 1
x = [0.0, 0.0, 0.0]
dx_ds1 = [1.0 / elementsCount1, 0.0, 0.0]
dx_ds2 = [0.0, 1.0 / elementsCount2, 0.0]
zero = [0.0, 0.0, 0.0]
for n2 in range(elementsCount2 + 1):
x[1] = n2 / elementsCount2
for n1 in range(elementsCount1 + 1):
x[0] = n1 / elementsCount1
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
dx_ds1)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
dx_ds2)
if useCrossDerivatives:
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1, zero)
nodeIdentifier = nodeIdentifier + 1
# create elements
elementIdentifier = 1
no2 = (elementsCount1 + 1)
for e2 in range(elementsCount2):
for e1 in range(elementsCount1):
element = mesh.createElement(elementIdentifier,
elementtemplate)
bni = e2 * no2 + e1 + 1
nodeIdentifiers = [bni, bni + 1, bni + no2, bni + no2 + 1]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
fm.endChange()
def generateBaseMesh(cls, region, options):
"""
Generate the base tricubic Hermite mesh. See also generateMesh().
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: None
"""
parameterSetName = options['Base parameter set']
isDefault = 'Default' in parameterSetName
isMouse = 'Mouse' in parameterSetName
isMean = 'mean' in parameterSetName
fm = region.getFieldmodule()
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
coordinates = findOrCreateFieldCoordinates(fm)
mesh = fm.findMeshByDimension(3)
cache = fm.createFieldcache()
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
armCount = 3
elementLengthCentral = options['Element width central']
elementLengths = [
options['Element length along arm'],
options['Element width across arm'], options['Element thickness']
]
elementsCountsAlongArms = options['Numbers of elements along arms']
elementsCount2 = 2
elementsCount3 = 1
useCrossDerivatives = False
# arm group annotations for user
armTerms, _ = getAutomaticArmFaceTerms(armCount)
armGroups = [AnnotationGroup(region, armTerm) for armTerm in armTerms]
stellateTerm = get_stellate_term(
"cervicothoracic ganglion") if isMouse else ("stellate", None)
stellateGroup = AnnotationGroup(region, stellateTerm)
annotationGroups = [stellateGroup] + armGroups
armMeshGroups = [a.getMeshGroup(mesh) for a in armGroups]
stellateMeshGroup = stellateGroup.getMeshGroup(mesh)
# markers with element number and xi position
allMarkers = {}
if isMouse:
xProportion = {}
xProportion['ICN'] = 0.9
xProportion['VA'] = 0.9
xProportion['DA'] = 0.9
xProportion['C8'] = 0.9
xProportion['T1'] = 0.25
xProportion['T2'] = 0.5
xProportion['T3'] = 0.75
xProportion['TST'] = 1
armNumber = {}
armNumber['ICN'] = 2
armNumber['VA'] = 2
armNumber['DA'] = 3
armNumber['C8'] = 3
armNumber['T1'] = 1
armNumber['T2'] = 1
armNumber['T3'] = 1
armNumber['TST'] = 1
nerveAbbrev = list(xProportion.keys())
elementIndex = {}
xi1 = {}
for nerve in nerveAbbrev:
elementIndex[nerve] = int(
xProportion[nerve] *
elementsCountsAlongArms[armNumber[nerve] - 1])
xi1[nerve] = 1 if xProportion[nerve] == 1 else xProportion[
nerve] * elementsCountsAlongArms[armNumber[nerve] -
1] - elementIndex[nerve]
elementIndex[nerve] += 1 if xProportion[nerve] < 1 else 0
allMarkers = {
"Inferior cardiac nerve": {
"elementID":
elementIndex['ICN'] + 2 * elementsCountsAlongArms[0],
"xi": [xi1['ICN'], 0.0, 0.5]
},
"Ventral ansa subclavia": {
"elementID":
elementIndex['VA'] + 2 * elementsCountsAlongArms[0] +
elementsCountsAlongArms[1],
"xi": [xi1['VA'], 1.0, 0.5]
},
"Dorsal ansa subclavia": {
"elementID":
elementIndex['DA'] + 2 *
(elementsCountsAlongArms[0] + elementsCountsAlongArms[1]),
"xi": [xi1['DA'], 0.0, 0.5]
},
"Cervical spinal nerve 8": {
"elementID":
elementIndex['C8'] + 2 *
(elementsCountsAlongArms[0] + elementsCountsAlongArms[1]) +
elementsCountsAlongArms[2],
"xi": [xi1['C8'], 1.0, 0.5]
},
"Thoracic spinal nerve 1": {
"elementID": elementIndex['T1'],
"xi": [xi1['T1'], 0.0, 0.5]
},
"Thoracic spinal nerve 2": {
"elementID": elementIndex['T2'],
"xi": [xi1['T2'], 0.0, 0.5]
},
"Thoracic spinal nerve 3": {
"elementID": elementIndex['T3'],
"xi": [xi1['T3'], 0.0, 0.5]
},
"Thoracic sympathetic nerve trunk": {
"elementID": elementIndex['TST'],
"xi": [xi1['TST'], 1.0, 0.5]
},
}
markerGroup = findOrCreateFieldGroup(fm, "marker")
markerName = findOrCreateFieldStoredString(fm, name="marker_name")
markerLocation = findOrCreateFieldStoredMeshLocation(
fm, mesh, name="marker_location")
markerPoints = findOrCreateFieldNodeGroup(markerGroup,
nodes).getNodesetGroup()
markerTemplateInternal = nodes.createNodetemplate()
markerTemplateInternal.defineField(markerName)
markerTemplateInternal.defineField(markerLocation)
# Create nodes
nodeIdentifier = 1
minArmAngle = 2 * math.pi / armCount
halfArmArcAngleRadians = minArmAngle / 2
if not isMean:
dipMultiplier = 1
for na in range(armCount):
elementsCount_i = [
elementsCountsAlongArms[na], elementsCount2, elementsCount3
]
x, ds1, ds2, nWheelEdge = createArm(halfArmArcAngleRadians,
elementLengths,
elementLengthCentral,
elementsCount_i,
dipMultiplier, armCount,
na)
for ix in range(len(x)):
if na == 0 or ix not in nWheelEdge:
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE,
1, x[ix])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1,
1, ds1[ix])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2,
1, ds2[ix])
nodeIdentifier += 1
else:
x_dx_all = cls.mouseMeanMesh['meshEdits']
xyz_all = [x[0] for x in x_dx_all]
dxyz = [[x[1], x[2]] for x in x_dx_all]
nodeIdentifier = 1
for i, nx in enumerate(xyz_all):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, nx)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
dxyz[i][0])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
dxyz[i][1])
nodeIdentifier += 1
nodesCountsPerArm = [0] + [((elementsCount2 + 1) * e + 1) * 2
for e in elementsCountsAlongArms]
# Create elements
bicubichermitelinear = eftfactory_bicubichermitelinear(
mesh, useCrossDerivatives)
eft = bicubichermitelinear.createEftNoCrossDerivatives(
) #createEftBasic()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementtemplate.defineField(coordinates, -1, eft)
elementtemplateX = mesh.createElementtemplate()
elementtemplateX.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementIdentifier = 1
cumNodesCountsPerArm = [
sum(nodesCountsPerArm[:i + 1])
for i in range(len(nodesCountsPerArm))
]
nCentre = [
elementsCountsAlongArms[0] + 1,
int(nodesCountsPerArm[1] / 2) + elementsCountsAlongArms[0] + 1
]
for na in range(armCount):
for e3 in range(elementsCount3):
for e2 in range(elementsCount2):
for e1 in range(elementsCountsAlongArms[na]):
scalefactors = None
### NODES ###
no2 = (elementsCountsAlongArms[na] + 1)
no3 = (elementsCount2 + 1) * no2 - 2
offset = (cumNodesCountsPerArm[na])
bni = e3 * no3 + e2 * no2 + e1 + 1 + offset
if e2 == 0:
if e1 == 0 and na > 0: # and na < armCount -1: # wheelSouth
nWh = cumNodesCountsPerArm[na - 1] + (
2 * elementsCountsAlongArms[na - 1]) + 2
nplUq = int(
nodesCountsPerArm[na + 1] / 2
) - elementsCountsAlongArms[
na] # unused nodes at centre and shared edge
npl = int(
nodesCountsPerArm[na + 1] /
2) # nodes at centre and shared edge
if na < armCount - 1:
cn = cumNodesCountsPerArm[
na] + elementsCountsAlongArms[na] - 2
no2 = cumNodesCountsPerArm[na]
em = elementsCountsAlongArms[na]
nwPrev = [
nWh,
nWh + int(nodesCountsPerArm[na] / 2)
] # previous arm's edge, depends on armCount.
nodeIdentifiers = [
nwPrev[0], no2 + 1, nCentre[0],
no2 + em, nwPrev[1],
no2 + em - 1 + nplUq, nCentre[1],
bni + (4 * em) - 2
]
else:
nplPrev = int(
nodesCountsPerArm[na] / 2) - 2
no2 = elementsCountsAlongArms[na] - 1
no3 = int(
nodesCountsPerArm[na + 1] / 2) - 3
nwPrev = [
cumNodesCountsPerArm[na - 1] + 2 *
(elementsCountsAlongArms[na - 1]),
cumNodesCountsPerArm[na - 1] + 2 *
(elementsCountsAlongArms[na - 1]) +
nplPrev
]
start = cumNodesCountsPerArm[na] - 3
nodeIdentifiers = [
nwPrev[0], start, nCentre[0],
start + no2, nwPrev[1], start + no3,
nCentre[1], start + no2 + no3
]
elif e1 == elementsCountsAlongArms[
na] - 1: # armEnd, south
if na == 0:
nodeIdentifiers = [
bni, bni + no2 - 1, bni + no2,
bni + no3, bni + no2 + no3 - 1,
bni + no2 + no3
]
else:
no3 = armCount * elementsCountsAlongArms[
na] - 1
no2 = elementsCountsAlongArms[na]
if na > 1:
bni -= 4
no3 -= 1
nodeIdentifiers = [
bni - 1, bni + no2 - 2, bni + no2 - 1,
bni + no3 - 1, bni + no2 - 2 + no3,
bni + no2 + no3 - 1
]
elif na > 0 and e1 > 0: # [na=1+, e1=1+, e2=0] for len=3+
bni -= 1 + ((armCount + 1) * (na - 1))
no2 = elementsCountsAlongArms[na]
no3 = armCount * no2 - (na - 1) - 1
nodeIdentifiers = [
bni, bni + 1, bni + no2 - 1, bni + no2,
bni + no3, bni + no3 + 1,
bni + no2 + no3 - 1, bni + no2 + no3
]
else:
nodeIdentifiers = [
bni, bni + 1, bni + no2 - 1, bni + no2,
bni + no3, bni + no3 + 1,
bni + no2 + no3 - 1, bni + no2 + no3
]
else:
if e1 == 0 and na > 0: # and na < armCount -1: # wheelNorth
if na < armCount - 1:
bni -= armCount
npl = int(
nodesCountsPerArm[na + 1] / 2) - 2
no2 = elementsCountsAlongArms[na]
nodeIdentifiers = [
nCentre[0], bni + 1, bni + no2 + 1,
bni + no2 + 2, nCentre[1],
bni + npl + 1, bni + npl + no2 + 1,
bni + npl + no2 + 2
]
else: # last arm
bni = cumNodesCountsPerArm[na] - 2 - (
armCount - elementsCountsAlongArms[na])
nodeIdentifiers = [
nCentre[0], bni + 1, 1, bni + no2,
nCentre[1], bni + no3 - 2,
int(nodesCountsPerArm[1] / 2) + 1,
bni + no2 + no3 - armCount
]
elif e1 == elementsCountsAlongArms[
na] - 1: # armEnd north
if na > 0:
no2 = elementsCountsAlongArms[na]
nplUq = int(
nodesCountsPerArm[na + 1] / 2) - 2
if na > 1:
adj = na - 1
bni -= armCount * na + (
armCount -
elementsCountsAlongArms[na]) + 1
if elementsCountsAlongArms[na] < 3:
bni += 1
if elementsCountsAlongArms[na] > 3:
bni -= elementsCountsAlongArms[
na] - 3
no2 += 1 - adj
no3 = nplUq - adj
nodeIdentifiers = [
bni, bni + 1, bni + no2, bni + no3,
bni + no3 + 1, bni + no2 + no3
]
else:
bni -= armCount
nodeIdentifiers = [
bni, bni + 1, bni + no2 + 1,
bni + nplUq, bni + nplUq + 1,
bni + no2 + nplUq + 1
]
else:
nodeIdentifiers = [
bni - 1, bni, bni + no2 - 1,
bni + no3 - 1, bni + no3,
bni + no2 + no3 - 1
]
elif na > 0 and e1 > 0: # [na=1+, e1=1+, e2=1] for len=3+
adj = na - 1
bni -= armCount * na + adj
no2 -= adj
k = armCount * elementsCountsAlongArms[na] - na
nodeIdentifiers = [
bni, bni + 1, bni + no2, bni + no2 + 1,
bni + k, bni + k + 1, bni + no2 + k,
bni + no2 + k + 1
]
else:
nodeIdentifiers = [
bni - 1, bni, bni + no2 - 1, bni + no2,
bni + no3 - 1, bni + no3,
bni + no2 + no3 - 1, bni + no2 + no3
]
if e1 == 0: # wheel
eft1 = bicubichermitelinear.createEftNoCrossDerivatives(
)
if armCount == 3:
if e2 == 0:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
scaleEftNodeValueLabels(
eft1, [1, 5], [
Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2
], [1])
ns = [3, 7]
else:
ns = [1, 5]
if na == 0:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS2, [])])
if e2 == 0:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [1])])
elif na == 1:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1])])
if e2 == 0:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS2, [1])])
elif e2 == 1:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS2, [1])])
elif na == 2:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS2, [1])])
if e2 == 0:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS2, [])])
elif e2 == 1:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [])])
elif armCount == 4:
if e2 == 0:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
scaleEftNodeValueLabels(
eft1, [1, 5], [
Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2
], [1])
ns = [3, 7]
else:
ns = [1, 5]
if na == 0:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS2, [])])
if e2 == 0:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [1])])
elif na == 1:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS2, [])])
if e2 == 0:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS2, [1])])
else:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [1])])
elif na == 2:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS2, [1])])
if e2 == 0:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [])])
else:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS2, [1])])
elif na == 3:
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS2, [1])])
if e2 == 0:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS2, [])])
else:
remapEftNodeValueLabel(
eft1, ns, Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [])])
elif e1 < (elementsCountsAlongArms[na] - 1):
eft1 = eft
elementtemplate1 = elementtemplate
else:
# rounded ends of arms. Collapse xi2 at xi1 = 1
eft1 = bicubichermitelinear.createEftNoCrossDerivatives(
)
remapEftNodeValueLabel(eft1, [2, 4, 6, 8],
Node.VALUE_LABEL_D_DS2, [])
if e2 == 0:
remapEftNodeValueLabel(
eft1, [2, 6], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS2, [])])
nodeIdentifiers = [
nodeIdentifiers[0], nodeIdentifiers[2],
nodeIdentifiers[1], nodeIdentifiers[3],
nodeIdentifiers[5], nodeIdentifiers[4]
]
else: # e2 == 1
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(
eft1, [4, 8], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS2, [1])])
ln_map = [1, 2, 3, 2, 4, 5, 6, 5]
remapEftLocalNodes(eft1, 6, ln_map)
if eft1 is not eft:
elementtemplateX.defineField(coordinates, -1, eft1)
elementtemplate1 = elementtemplateX
element = mesh.createElement(elementIdentifier,
elementtemplate1)
result = element.setNodesByIdentifier(
eft1, nodeIdentifiers)
result3 = element.setScaleFactors(
eft1, scalefactors) if scalefactors else None
# add to meshGroup
stellateMeshGroup.addElement(element)
armMeshGroups[na].addElement(element)
elementIdentifier += 1
# annotation fiducial points
if isMouse:
for key in allMarkers:
xi = allMarkers[key]["xi"]
addMarker = {"name": key, "xi": allMarkers[key]["xi"]}
markerPoint = markerPoints.createNode(nodeIdentifier,
markerTemplateInternal)
nodeIdentifier += 1
cache.setNode(markerPoint)
markerName.assignString(cache, addMarker["name"])
elementID = allMarkers[key]["elementID"]
element = mesh.findElementByIdentifier(elementID)
markerLocation.assignMeshLocation(cache, element,
addMarker["xi"])
return annotationGroups
def generateBaseMesh(region, options):
"""
Generate the base tricubic Hermite mesh. See also generateMesh().
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: None
"""
elementsCountAround = options['Number of elements around']
elementsCountAlong = options['Number of elements along']
elementsCountThroughWall = options['Number of elements through wall']
wallThickness = options['Wall thickness']
useCrossDerivatives = options['Use cross derivatives']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS3,
1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS2DS3,
1)
nodetemplate.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1)
mesh = fm.findMeshByDimension(3)
tricubichermite = eftfactory_tricubichermite(mesh, useCrossDerivatives)
eft = tricubichermite.createEftBasic()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = elementtemplate.defineField(coordinates, -1, eft)
cache = fm.createFieldcache()
# create nodes
nodeIdentifier = 1
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
wallThicknessPerElement = wallThickness / elementsCountThroughWall
x = [0.0, 0.0, 0.0]
dx_ds1 = [0.0, 0.0, 0.0]
dx_ds2 = [0.0, 0.0, 1.0 / elementsCountAlong]
dx_ds3 = [0.0, 0.0, 0.0]
zero = [0.0, 0.0, 0.0]
for n3 in range(elementsCountThroughWall + 1):
radius = 0.5 + wallThickness * (n3 / elementsCountThroughWall -
1.0)
for n2 in range(elementsCountAlong + 1):
x[2] = n2 / elementsCountAlong
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x[0] = radius * cosRadiansAround
x[1] = radius * sinRadiansAround
dx_ds1[
0] = radiansPerElementAround * radius * -sinRadiansAround
dx_ds1[
1] = radiansPerElementAround * radius * cosRadiansAround
dx_ds3[0] = wallThicknessPerElement * cosRadiansAround
dx_ds3[1] = wallThicknessPerElement * sinRadiansAround
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
dx_ds1)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
dx_ds2)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS3, 1,
dx_ds3)
if useCrossDerivatives:
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS3, 1, zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS2DS3, 1, zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1, zero)
nodeIdentifier = nodeIdentifier + 1
# create elements
elementIdentifier = 1
now = (elementsCountAlong + 1) * elementsCountAround
for e3 in range(elementsCountThroughWall):
for e2 in range(elementsCountAlong):
for e1 in range(elementsCountAround):
element = mesh.createElement(elementIdentifier,
elementtemplate)
bni11 = e3 * now + e2 * elementsCountAround + e1 + 1
bni12 = e3 * now + e2 * elementsCountAround + (
e1 + 1) % elementsCountAround + 1
bni21 = e3 * now + (e2 + 1) * elementsCountAround + e1 + 1
bni22 = e3 * now + (e2 + 1) * elementsCountAround + (
e1 + 1) % elementsCountAround + 1
nodeIdentifiers = [
bni11, bni12, bni21, bni22, bni11 + now, bni12 + now,
bni21 + now, bni22 + now
]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
fm.endChange()
def generate_mesh(self):
use_cross_derivatives = self._options['Use cross derivatives']
elements_count1 = self._options['Number of elements 1']
elements_count2 = self._options['Number of elements 2']
elements_count3 = self._options['Number of elements 3']
fm = self._region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
node_template = nodes.createNodetemplate()
node_template.defineField(coordinates)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if use_cross_derivatives:
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3, 1)
if use_cross_derivatives:
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS3,
1)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS2DS3,
1)
node_template.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1)
mesh = fm.findMeshByDimension(3)
tricubic_hermite = EftTricubicHermite(mesh, use_cross_derivatives)
eft = tricubic_hermite.create_eft_basic()
element_template = mesh.createElementtemplate()
element_template.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = element_template.defineField(coordinates, -1, eft)
cache = fm.createFieldcache()
# create nodes
node_identifier = 1
number_of_nodes = len(self._x) // 3
for n in range(number_of_nodes):
node = nodes.createNode(node_identifier, node_template)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
self._x[n * 3:(n * 3) + 3])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
self._dx_ds1[n * 3:(n * 3) + 3])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
self._dx_ds2[n * 3:(n * 3) + 3])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1,
self._dx_ds3[n * 3:(n * 3) + 3])
if use_cross_derivatives:
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS1DS2, 1,
self._dx_ds12[n * 3:(n * 3) + 3])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS1DS3, 1,
self._dx_ds13[n * 3:(n * 3) + 3])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS2DS3, 1,
self._dx_ds23[n * 3:(n * 3) + 3])
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1,
self._dx_ds123[n * 3:(n * 3) + 3])
node_identifier = node_identifier + 1
# create elements
element_identifier = 1
no2 = (elements_count1 + 1)
no3 = (elements_count2 + 1) * no2
for e3 in range(elements_count3):
for e2 in range(elements_count2):
for e1 in range(elements_count1):
element = mesh.createElement(element_identifier,
element_template)
bni = e3 * no3 + e2 * no2 + e1 + 1
node_identifiers = [
bni, bni + 1, bni + no2, bni + no2 + 1, bni + no3,
bni + no3 + 1, bni + no2 + no3, bni + no2 + no3 + 1
]
result = element.setNodesByIdentifier(
eft, node_identifiers)
element_identifier = element_identifier + 1
fm.defineAllFaces()
fm.endChange()
return None
def generateBaseMesh(cls, region, options):
"""
Generate the base tricubic Hermite mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: list of AnnotationGroup
"""
# set dependent outer diameter used in atria2
options['Aorta outer plus diameter'] = options[
'LV outlet inner diameter'] + 2.0 * options[
'LV outlet wall thickness']
elementsCountAroundAtrialSeptum = options[
'Number of elements around atrial septum']
elementsCountAroundLeftAtriumFreeWall = options[
'Number of elements around left atrium free wall']
elementsCountAroundLeftAtrium = elementsCountAroundLeftAtriumFreeWall + elementsCountAroundAtrialSeptum
elementsCountAroundRightAtriumFreeWall = options[
'Number of elements around right atrium free wall']
elementsCountAroundRightAtrium = elementsCountAroundRightAtriumFreeWall + elementsCountAroundAtrialSeptum
useCrossDerivatives = False
fm = region.getFieldmodule()
coordinates = findOrCreateFieldCoordinates(fm)
cache = fm.createFieldcache()
mesh = fm.findMeshByDimension(3)
# generate heartventriclesbase1 model and put atria1 on it
ventriclesAnnotationGroups = MeshType_3d_heartventriclesbase1.generateBaseMesh(
region, options)
atriaAnnotationGroups = MeshType_3d_heartatria1.generateBaseMesh(
region, options)
annotationGroups = mergeAnnotationGroups(ventriclesAnnotationGroups,
atriaAnnotationGroups)
lFibrousRingGroup = findOrCreateAnnotationGroupForTerm(
annotationGroups, region, get_heart_term("left fibrous ring"))
rFibrousRingGroup = findOrCreateAnnotationGroupForTerm(
annotationGroups, region, get_heart_term("right fibrous ring"))
# annotation fiducial points
markerGroup = findOrCreateFieldGroup(fm, "marker")
markerName = findOrCreateFieldStoredString(fm, name="marker_name")
markerLocation = findOrCreateFieldStoredMeshLocation(
fm, mesh, name="marker_location")
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
markerPoints = findOrCreateFieldNodeGroup(markerGroup,
nodes).getNodesetGroup()
markerTemplateInternal = nodes.createNodetemplate()
markerTemplateInternal.defineField(markerName)
markerTemplateInternal.defineField(markerLocation)
##############
# Create nodes
##############
nodeIdentifier = max(1, getMaximumNodeIdentifier(nodes) + 1)
# discover left and right fibrous ring nodes from ventricles and atria
# because nodes are iterated in identifier order, the lowest and first are on the lv outlet cfb, right and left on lower outer layers
# left fibrous ring
lavNodeId = [[[], []], [[], []]] # [n3][n2][n1]
iter = lFibrousRingGroup.getNodesetGroup(nodes).createNodeiterator()
# left fibrous ring, bottom row
cfbNodeId = iter.next().getIdentifier()
cfbLeftNodeId = iter.next().getIdentifier()
for n1 in range(elementsCountAroundLeftAtrium):
lavNodeId[0][0].append(iter.next().getIdentifier())
lavNodeId[1][0].append(cfbNodeId)
lavNodeId[1][0].append(cfbLeftNodeId)
for n1 in range(elementsCountAroundLeftAtriumFreeWall - 1):
lavNodeId[1][0].append(iter.next().getIdentifier())
for n1 in range(elementsCountAroundAtrialSeptum - 1):
lavNodeId[1][0].append(None) # no outer node on interatrial septum
# left fibrous ring, top row
for n1 in range(elementsCountAroundLeftAtrium):
lavNodeId[0][1].append(iter.next().getIdentifier())
for n1 in range(elementsCountAroundLeftAtriumFreeWall + 1):
lavNodeId[1][1].append(iter.next().getIdentifier())
for n1 in range(elementsCountAroundAtrialSeptum - 1):
lavNodeId[1][1].append(None) # no outer node on interatrial septum
# right fibrous ring
ravNodeId = [[[], []], [[], []]] # [n3][n2][n1]
iter = rFibrousRingGroup.getNodesetGroup(nodes).createNodeiterator()
cfbNodeId = iter.next().getIdentifier()
cfbRightNodeId = iter.next().getIdentifier()
# right fibrous ring, bottom row
for n1 in range(elementsCountAroundRightAtrium):
ravNodeId[0][0].append(iter.next().getIdentifier())
for n1 in range(elementsCountAroundRightAtriumFreeWall - 1):
ravNodeId[1][0].append(iter.next().getIdentifier())
ravNodeId[1][0].append(cfbRightNodeId)
ravNodeId[1][0].append(cfbNodeId)
for n1 in range(elementsCountAroundAtrialSeptum - 1):
ravNodeId[1][0].append(None) # no outer node on interatrial septum
# right fibrous ring, top row
for n1 in range(elementsCountAroundRightAtrium):
ravNodeId[0][1].append(iter.next().getIdentifier())
cfbUpperNodeId = iter.next().getIdentifier(
) # cfb from left will be first
for n1 in range(elementsCountAroundRightAtriumFreeWall):
ravNodeId[1][1].append(iter.next().getIdentifier())
ravNodeId[1][1].append(cfbUpperNodeId)
for n1 in range(elementsCountAroundAtrialSeptum - 1):
ravNodeId[1][1].append(None) # no outer node on interatrial septum
#for n2 in range(2):
# print('n2', n2)
# print('lavNodeId[0]', lavNodeId[0][n2])
# print('lavNodeId[1]', lavNodeId[1][n2])
# print('ravNodeId[0]', ravNodeId[0][n2])
# print('ravNodeId[1]', ravNodeId[1][n2])
#################
# Create elements
#################
lFibrousRingMeshGroup = lFibrousRingGroup.getMeshGroup(mesh)
rFibrousRingMeshGroup = rFibrousRingGroup.getMeshGroup(mesh)
elementIdentifier = getMaximumElementIdentifier(mesh) + 1
elementtemplate1 = mesh.createElementtemplate()
elementtemplate1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
# create fibrous ring elements
bicubichermitelinear = eftfactory_bicubichermitelinear(
mesh,
useCrossDerivatives,
linearAxis=2,
d_ds1=Node.VALUE_LABEL_D_DS1,
d_ds2=Node.VALUE_LABEL_D_DS3)
eftFibrousRing = bicubichermitelinear.createEftBasic()
# left fibrous ring, starting at crux / collapsed posterior interatrial sulcus
cruxElementId = None
for e in range(-1, elementsCountAroundLeftAtriumFreeWall):
eft1 = eftFibrousRing
n1 = e
nids = [
lavNodeId[0][0][n1], lavNodeId[0][0][n1 + 1],
lavNodeId[0][1][n1], lavNodeId[0][1][n1 + 1],
lavNodeId[1][0][n1], lavNodeId[1][0][n1 + 1],
lavNodeId[1][1][n1], lavNodeId[1][1][n1 + 1]
]
scalefactors = None
meshGroups = [lFibrousRingMeshGroup]
if e == -1:
# interatrial groove straddles left and right atria, collapsed to 6 node wedge
nids[0] = ravNodeId[0][0][
elementsCountAroundRightAtriumFreeWall]
nids[2] = ravNodeId[0][1][
elementsCountAroundRightAtriumFreeWall]
nids.pop(6)
nids.pop(4)
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(eft1, [1, 3], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [2, 4], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [1])])
remapEftNodeValueLabel(eft1, [5, 6, 7, 8],
Node.VALUE_LABEL_D_DS1, [])
# reverse d3 on cfb:
remapEftNodeValueLabel(eft1, [5], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [1])])
remapEftNodeValueLabel(eft1, [6], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [0]),
(Node.VALUE_LABEL_D_DS3, [1])])
remapEftNodeValueLabel(eft1, [7], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [8], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [])])
ln_map = [1, 2, 3, 4, 5, 5, 6, 6]
remapEftLocalNodes(eft1, 6, ln_map)
meshGroups += [rFibrousRingMeshGroup]
elif e == 0:
# general linear map d3 adjacent to collapsed sulcus
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
# reverse d1, d3 on cfb, left cfb:
scaleEftNodeValueLabels(
eft1, [6],
[Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS3], [1])
remapEftNodeValueLabel(eft1, [5], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1])])
remapEftNodeValueLabel(eft1, [5], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [1])])
remapEftNodeValueLabel(eft1, [7], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [])])
elif e == 1:
# reverse d1, d3 on left cfb:
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(eft1, [5], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [5], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS3, [1])])
elif e == (elementsCountAroundLeftAtriumFreeWall - 1):
# general linear map d3 adjacent to collapsed sulcus
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(eft1, [6, 8], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [])])
result = elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier, elementtemplate1)
result2 = element.setNodesByIdentifier(eft1, nids)
result3 = element.setScaleFactors(
eft1, scalefactors) if scalefactors else None
#print('create element fibrous ring left', elementIdentifier, result, result2, result3, nids)
elementIdentifier += 1
for meshGroup in meshGroups:
meshGroup.addElement(element)
# right fibrous ring, starting at crux / collapsed posterior interatrial sulcus
for e in range(-1, elementsCountAroundRightAtriumFreeWall):
eft1 = eftFibrousRing
n1 = e
nids = [
ravNodeId[0][0][n1], ravNodeId[0][0][n1 + 1],
ravNodeId[0][1][n1], ravNodeId[0][1][n1 + 1],
ravNodeId[1][0][n1], ravNodeId[1][0][n1 + 1],
ravNodeId[1][1][n1], ravNodeId[1][1][n1 + 1]
]
scalefactors = None
meshGroups = [rFibrousRingMeshGroup]
if e == -1:
# interatrial groove straddles left and right atria, collapsed to 6 node wedge
nids[0] = lavNodeId[0][0][
elementsCountAroundLeftAtriumFreeWall]
nids[2] = lavNodeId[0][1][
elementsCountAroundLeftAtriumFreeWall]
nids.pop(6)
nids.pop(4)
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(eft1, [1, 3], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [2, 4], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [1])])
remapEftNodeValueLabel(eft1, [5, 6, 7, 8],
Node.VALUE_LABEL_D_DS1, [])
remapEftNodeValueLabel(eft1, [5, 7], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [6, 8], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [])])
ln_map = [1, 2, 3, 4, 5, 5, 6, 6]
remapEftLocalNodes(eft1, 6, ln_map)
meshGroups += [lFibrousRingMeshGroup]
cruxElementId = elementIdentifier
elif e == 0:
# general linear map d3 adjacent to collapsed crux/posterior sulcus
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(eft1, [5, 7], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [])])
elif e == (elementsCountAroundRightAtriumFreeWall - 2):
# reverse d1, d3 on right cfb:
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(eft1, [6], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [1])])
remapEftNodeValueLabel(eft1, [6], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS3, [1])])
elif e == (elementsCountAroundRightAtriumFreeWall - 1):
# general linear map d3 adjacent to collapsed cfb/anterior sulcus
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
# reverse d1, d3 on right cfb, cfb:
scaleEftNodeValueLabels(
eft1, [5],
[Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS3], [1])
remapEftNodeValueLabel(eft1, [6], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1])])
remapEftNodeValueLabel(eft1, [6], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [1])])
remapEftNodeValueLabel(eft1, [8], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [])])
result = elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier, elementtemplate1)
result2 = element.setNodesByIdentifier(eft1, nids)
result3 = element.setScaleFactors(
eft1, scalefactors) if scalefactors else None
#print('create element fibrous ring right', elementIdentifier, result, result2, result3, nids)
elementIdentifier += 1
for meshGroup in meshGroups:
meshGroup.addElement(element)
# fibrous ring septum:
meshGroups = [lFibrousRingMeshGroup, rFibrousRingMeshGroup]
for e in range(elementsCountAroundAtrialSeptum):
eft1 = eftFibrousRing
nlm = e - elementsCountAroundAtrialSeptum
nlp = nlm + 1
nrm = -e
nrp = nrm - 1
nids = [
lavNodeId[0][0][nlm], lavNodeId[0][0][nlp],
lavNodeId[0][1][nlm], lavNodeId[0][1][nlp],
ravNodeId[0][0][nrm], ravNodeId[0][0][nrp],
ravNodeId[0][1][nrm], ravNodeId[0][1][nrp]
]
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
if e == 0:
# general linear map d3 adjacent to collapsed posterior interventricular sulcus
scaleEftNodeValueLabels(eft1, [5, 6, 7, 8],
[Node.VALUE_LABEL_D_DS1], [1])
scaleEftNodeValueLabels(eft1, [6, 8], [Node.VALUE_LABEL_D_DS3],
[1])
remapEftNodeValueLabel(eft1, [1, 3], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [5, 7], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, []),
(Node.VALUE_LABEL_D_DS3, [1])])
elif e == (elementsCountAroundAtrialSeptum - 1):
# general linear map d3 adjacent to cfb
scaleEftNodeValueLabels(eft1, [5, 6, 7, 8],
[Node.VALUE_LABEL_D_DS1], [1])
scaleEftNodeValueLabels(eft1, [5, 7], [Node.VALUE_LABEL_D_DS3],
[1])
remapEftNodeValueLabel(eft1, [2, 4], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [6, 8], Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D_DS1, [1]),
(Node.VALUE_LABEL_D_DS3, [1])])
else:
scaleEftNodeValueLabels(
eft1, [5, 6, 7, 8],
[Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS3], [1])
result = elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier, elementtemplate1)
result2 = element.setNodesByIdentifier(eft1, nids)
result3 = element.setScaleFactors(
eft1, scalefactors) if scalefactors else None
#print('create element fibrous ring septum', elementIdentifier, result, result2, result3, nids)
elementIdentifier += 1
for meshGroup in meshGroups:
meshGroup.addElement(element)
# annotation fiducial points
cruxElement = mesh.findElementByIdentifier(cruxElementId)
cruxXi = [0.5, 0.5, 1.0]
cache.setMeshLocation(cruxElement, cruxXi)
result, cruxCoordinates = coordinates.evaluateReal(cache, 3)
markerPoint = markerPoints.createNode(nodeIdentifier,
markerTemplateInternal)
nodeIdentifier += 1
cache.setNode(markerPoint)
markerName.assignString(cache, "crux of heart")
markerLocation.assignMeshLocation(cache, cruxElement, cruxXi)
return annotationGroups
def main_writerotatefile(data_path):
plot = False
concave_hull = True if 'concave_hull' in data_path else False
# fiducial points are in the new xml file with separate marker field
fids_in_xml = False if concave_hull else True
files = os.listdir(data_path)
files = [f for f in files if f.endswith('.ex')]
max_soma = 5
all_nerves = [
'Inferior cardiac nerve', 'Ventral ansa subclavia',
'Dorsal ansa subclavia', 'Cervical spinal nerve 8',
'Thoracic spinal nerve 1', 'Thoracic spinal nerve 2',
'Thoracic spinal nerve 3', 'Thoracic sympathetic nerve trunk',
'Thoracic ansa'
]
bodyname = ['Cervicalganglion', 'stellate']
fdict = {sample: {} for sample in files}
write_this = False
for sample in files:
print(sample)
lr_groups = True
output_suffix = '_LR.exf'
short_name = sample.split('_')[0] if not concave_hull else sample
fmag = sample.split('_')[1].upper()
full_body = True
xyz_sm = []
txt = []
in_file = data_path + sample
if not os.path.exists(data_path + 'exf_output\\'):
os.mkdir(data_path + 'exf_output\\')
mapclient_workflow_path = 'scaffoldfitter_output\\scaffoldfitter_geofit_folder\\exp_data\\'
with open(in_file, 'r') as f_in:
if '10x' not in sample.lower() and not concave_hull:
full_body = False
out_file = data_path + 'exf_output\\' + short_name + (
'_fragment_%s' % (fmag) * (not full_body)) + output_suffix
possibleGroups = [] if concave_hull else all_nerves + [
'Soma %d' % (i) for i in range(1, 6)
] + ['T3 paravertebral ganglion', 'Cervicothoracic ganglion']
all_node_num, xyz_all, _, xyzGroups, _, xyz_marker, marker_names, marker_nodenum, _ = zinc_read_exf_file(
data_path + sample, 2, 0, 1, [], possibleGroups, 3)
xyz_n = {m: xyz_marker[im] for im, m in enumerate(marker_names)}
xyz_all_dict = {n: xyz_all[n - 1] for n in all_node_num}
if not full_body:
nervename = []
for key in xyzGroups.keys():
if key in all_nerves:
nervename.append(key)
for nn in nervename:
xyz_n_0 = xyzGroups[nn]
xyz_n[nn] = xyz_n_0
try:
xyz_st = xyzGroups['Cervicothoracic ganglion']
except:
xyz_st = [xyz_all_dict[key] for key in xyz_all_dict.keys()]
xyz_t3 = []
xyz_t3Rot = []
try:
xyz_t3 = xyzGroups['T3 paravertebral ganglion']
print('T3 paravertebral ganglion present')
except:
pass
# there may be more than one soma
num_soma = 0
if not concave_hull:
for key in xyzGroups:
if 'soma' in key.lower():
num_soma += 1
for i in range(num_soma):
# print('soma '+str(i+1))
crd = xyzGroups['Soma ' + str(i + 1)]
xyz_sm.extend([[c[0], c[1], c[2], i + 1] for c in crd])
if full_body:
if not concave_hull:
x = [(ix[0]) for ix in xyz_st]
y = [(ix[1]) for ix in xyz_st]
z = [(ix[2]) for ix in xyz_st]
centroid = [np.mean(x), np.mean(y), np.mean(z)]
xsm = [[]] * num_soma
ysm = [[]] * num_soma
zsm = [[]] * num_soma
isoma = [[]] * num_soma
for i in range(num_soma):
xsm[i] = [(ix[0]) for ix in xyz_sm if ix[3] == i + 1]
ysm[i] = [(ix[1]) for ix in xyz_sm if ix[3] == i + 1]
zsm[i] = [(ix[2]) for ix in xyz_sm if ix[3] == i + 1]
isoma[i] = i + 1
try:
xy_ICN = xyz_n['Inferior cardiac nerve']
except:
# print('no iCN. using Ventral ansa for system rotation')
xy_ICN = xyz_n['Ventral ansa subclavia']
xy_nerve_fids = [
xyz_n['Dorsal ansa subclavia'], xy_ICN,
xyz_n['Thoracic sympathetic nerve trunk']
]
[
x, y, z, xsm, ysm, zsm, xyz_st, xyz_sm, xyz_t3, fdict,
xyz_n, xy_nerve_end, _
] = flip_system(x, y, z, xsm, ysm, zsm, xy_nerve_fids,
xyz_t3, centroid, num_soma, fdict, xyz_n,
sample, 0)
centroid = [np.mean(x), np.mean(y), np.mean(z)]
[xyz_stRot, theta] = rotate_points(xyz_st, [], [])
[xyz_smRot, theta] = rotate_points(xyz_sm, theta, [])
if xyz_t3:
[xyz_t3Rot, theta] = rotate_points(xyz_t3, theta, [])
xyz_nRot = xyz_n.copy()
for key in xyz_n:
if xyz_n[key]:
[nrot, theta] = rotate_points([xyz_n[key]], theta, [])
xyz_nRot[key] = nrot[0]
try:
[newcoord,
theta] = rotate_points([fdict[sample][key]],
theta, [])
fdict[sample][key] = newcoord[0]
for i in range(num_soma):
[sout, theta] = rotate_points(
[fdict[sample]['Soma%s' % (str(i + 1))]],
theta, [])
fdict[sample]['Soma%s' %
(str(i + 1))] = sout[0]
except:
pass
x = [(ix[0]) for ix in xyz_stRot]
y = [(ix[1]) for ix in xyz_stRot]
z = [(ix[2]) for ix in xyz_stRot]
centroid = [np.mean(x), np.mean(y), np.mean(z)]
xsm = [[]] * num_soma
ysm = [[]] * num_soma
zsm = [[]] * num_soma
isoma = [[]] * num_soma
for i in range(num_soma):
xsm[i] = [(ix[0]) for ix in xyz_smRot if ix[3] == i + 1]
ysm[i] = [(ix[1]) for ix in xyz_smRot if ix[3] == i + 1]
zsm[i] = [(ix[2]) for ix in xyz_smRot if ix[3] == i + 1]
isoma[i] = i + 1
else:
xyz_smRot_2D = xyz_sm # [[xsm[i], ysm[i], zsm[i]] for i in range(len(xsm))]
xyz_stRot = xyz_st.copy()
xyz_nRot = xyz_n.copy()
x = [(ix[0]) for ix in xyz_stRot]
y = [(ix[1]) for ix in xyz_stRot]
z = [(ix[2]) for ix in xyz_stRot]
xsm = [[]] * num_soma
ysm = [[]] * num_soma
zsm = [[]] * num_soma
isoma = [[]] * num_soma
for i in range(num_soma):
xsm[i] = [(ix[0]) for ix in xyz_smRot_2D if ix[3] == i + 1]
ysm[i] = [(ix[1]) for ix in xyz_smRot_2D if ix[3] == i + 1]
zsm[i] = [(ix[2]) for ix in xyz_smRot_2D if ix[3] == i + 1]
isoma[i] = i + 1
lr_groups = False
# soma cx to nerves - INNERVATIONS
cx_soma = {}
if not concave_hull:
xname = sample.split('.ex')[0]
xml_path = data_path + 'xml\\'
cx_soma = parse_xml_find_soma_ID(xml_path + xname)
if lr_groups:
cx = centroid[0]
cy = centroid[1]
if full_body:
# parse through all stellate nodes between selected fiducials of every contour layer
# LEFT: Dorsal ansa / C8 to Ventral ansa / inferior cardiac nerve
# TOP: iCN/VA to trunk (or rightmost top nodes of rotated stellate)
# BOTTOM: C8/DA to trunk or rightmost bottom nodes
[nleft, ntop,
nbottom] = lefttopbottom_by_fiducials(x, y, z, xyz_nRot,
'by_order', sample,
plot)
if lr_groups or not full_body:
# write with zinc
context = Context('Example')
region = context.getDefaultRegion()
fm = region.getFieldmodule()
fm.beginChange()
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
coordinates = findOrCreateFieldCoordinates(fm, 'data_coordinates')
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
# stellate face groups
armGroup12 = findOrCreateFieldGroup(fm, 'stellate face 1-2')
armGroup23 = findOrCreateFieldGroup(fm, 'stellate face 2-3')
armGroup31 = findOrCreateFieldGroup(fm, 'stellate face 3-1')
armGroup12Name = findOrCreateFieldStoredString(
fm, name='stellate face 1-2')
armGroup23Name = findOrCreateFieldStoredString(
fm, name='stellate face 2-3')
armGroup31Name = findOrCreateFieldStoredString(
fm, name='stellate face 3-1')
armGroup12Nodes = findOrCreateFieldNodeGroup(
armGroup12, nodes).getNodesetGroup()
armGroup23Nodes = findOrCreateFieldNodeGroup(
armGroup23, nodes).getNodesetGroup()
armGroup31Nodes = findOrCreateFieldNodeGroup(
armGroup31, nodes).getNodesetGroup()
markerNodes = fm.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
markerGroup = findOrCreateFieldGroup(fm, 'marker')
markerName = findOrCreateFieldStoredString(fm,
name='marker_data_name')
markerPoints = findOrCreateFieldNodeGroup(
markerGroup, markerNodes).getNodesetGroup()
marker_coordinates = findOrCreateFieldCoordinates(
fm, 'marker_data_coordinates')
markerTemplate = markerPoints.createNodetemplate()
markerTemplate.defineField(marker_coordinates)
markerTemplate.setValueNumberOfVersions(marker_coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
markerTemplate.defineField(markerName)
cache = fm.createFieldcache()
for nID0, xyz in enumerate(xyz_stRot):
nID = nID0 + 1
if nID in nleft:
node = armGroup23Nodes.createNode(nID, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
xyz)
elif nID in ntop:
node = armGroup12Nodes.createNode(nID, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
xyz)
elif nID in nbottom:
node = armGroup31Nodes.createNode(nID, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
xyz)
else: # nothing
node = nodes.createNode(nID, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
xyz)
nID = 1000001
for i, key in enumerate(xyz_n):
if xyz_n[key] and 'junction' not in key.lower():
if full_body:
xyz = find_closest_end(x, y, z, xyz_nRot[key])
else: # use junction point
for nkey in xyz_nRot:
if 'junction' in nkey.lower() and key.lower(
) in nkey.lower():
xyz = xyz_nRot[nkey]
node = markerPoints.createNode(nID, markerTemplate)
cache.setNode(node)
marker_coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_VALUE, 1, xyz)
markerName.assignString(cache, key)
nID += 1
written_soma_connections = []
for j in range(num_soma):
soma_id = 'Soma ' + str(j + 1)
for key in cx_soma[soma_id]:
possible_nerve = cx_soma[soma_id][key]
if possible_nerve:
soma_nerve = possible_nerve[0]
if (soma_nerve not in written_soma_connections):
soma_inn_name = 'Soma_' + soma_nerve
xys = [
np.mean(xsm[j]),
np.mean(ysm[j]),
np.mean(zsm[j])
]
node = markerPoints.createNode(nID, markerTemplate)
cache.setNode(node)
marker_coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_VALUE, 1, xys)
markerName.assignString(cache, soma_inn_name)
written_soma_connections.append(soma_nerve)
nID += 1
fm.endChange()
region.writeFile(out_file)
# write to mapclient workflow
m_out = mapclient_workflow_path + short_name + output_suffix
shutil.copyfile(out_file, m_out)
else: # do not write anything for files without LR groups
pass
return
def generateBaseMesh(cls, region, options):
"""
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: [] empty list of AnnotationGroup
"""
coordinateDimensions = options['Coordinate dimensions']
elementsCount1 = options['Number of elements 1']
elementsCount2 = options['Number of elements 2']
elementsCountThroughWall = options['Number of elements through wall']
elementsCountAround = 2*(elementsCount1 + elementsCount2)
holeRadius = options['Hole diameter']*0.5
useCrossDerivatives = options['Use cross derivatives']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm, components_count=coordinateDimensions)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
mesh = fm.findMeshByDimension(2)
bicubicHermiteBasis = fm.createElementbasis(2, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
eft = mesh.createElementfieldtemplate(bicubicHermiteBasis)
if not useCrossDerivatives:
for n in range(4):
eft.setFunctionNumberOfTerms(n*4 + 4, 0)
# note I'm cheating here by using element-based scale factors
# i.e. not shared by neighbouring elements
eftOuter1 = mesh.createElementfieldtemplate(bicubicHermiteBasis)
eftOuter2 = mesh.createElementfieldtemplate(bicubicHermiteBasis)
i = 0
for eftOuter in [ eftOuter1, eftOuter2 ]:
i += 1
eftOuter.setNumberOfLocalScaleFactors(10)
eft.setScaleFactorType(1, Elementfieldtemplate.SCALE_FACTOR_TYPE_GLOBAL_GENERAL)
# GRC: allow scale factor identifier for global -1.0 to be prescribed
eft.setScaleFactorIdentifier(1, 1)
# Global scale factor 4.0 to subtract lateral derivative term from cross derivative to fix edges
eft.setScaleFactorType(2, Elementfieldtemplate.SCALE_FACTOR_TYPE_GLOBAL_GENERAL)
eft.setScaleFactorIdentifier(2, 2)
nonCrossDerivativesNodes = [0, 1] if useCrossDerivatives else range(4)
for n in nonCrossDerivativesNodes:
eftOuter.setFunctionNumberOfTerms(n*4 + 4, 0)
# nodes 1,2: general map dxi1, dsxi2 from ds1, ds2
for n in [0, 1]:
ln = n + 1
sfo = (n % 2)*4 + 2
eftOuter.setFunctionNumberOfTerms(n*4 + 2, 2)
eftOuter.setTermNodeParameter(n*4 + 2, 1, ln, Node.VALUE_LABEL_D_DS1, 1)
eftOuter.setTermScaling(n*4 + 2, 1, [1 + sfo])
eftOuter.setTermNodeParameter(n*4 + 2, 2, ln, Node.VALUE_LABEL_D_DS2, 1)
eftOuter.setTermScaling(n*4 + 2, 2, [2 + sfo])
eftOuter.setFunctionNumberOfTerms(n*4 + 3, 2)
eftOuter.setTermNodeParameter(n*4 + 3, 1, ln, Node.VALUE_LABEL_D_DS1, 1)
eftOuter.setTermScaling(n*4 + 3, 1, [3 + sfo])
eftOuter.setTermNodeParameter(n*4 + 3, 2, ln, Node.VALUE_LABEL_D_DS2, 1)
eftOuter.setTermScaling(n*4 + 3, 2, [4 + sfo])
# map d2_dxi1dxi2 to subtract corner angle terms to fix edge continuity
eftOuter.setFunctionNumberOfTerms(n*4 + 4, 1)
if i == 1:
eftOuter.setTermNodeParameter(n*4 + 4, 1, ln, Node.VALUE_LABEL_D_DS1, 1)
if (n % 2) == 0:
eftOuter.setTermScaling(n*4 + 4, 1, [1, 2, 3 + sfo])
else:
eftOuter.setTermScaling(n*4 + 4, 1, [2, 3 + sfo])
else:
eftOuter.setTermNodeParameter(n*4 + 4, 1, ln, Node.VALUE_LABEL_D_DS2, 1)
if (n % 2) == 0:
eftOuter.setTermScaling(n*4 + 4, 1, [1, 2, 4 + sfo])
else:
eftOuter.setTermScaling(n*4 + 4, 1, [2, 4 + sfo])
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
result = elementtemplate.defineField(coordinates, -1, eft)
elementtemplateOuter1 = mesh.createElementtemplate()
elementtemplateOuter1.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
result = elementtemplateOuter1.defineField(coordinates, -1, eftOuter1)
elementtemplateOuter2 = mesh.createElementtemplate()
elementtemplateOuter2.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
result = elementtemplateOuter2.defineField(coordinates, -1, eftOuter2)
cache = fm.createFieldcache()
# create nodes
radiansPerElementAround = 2.0*math.pi/elementsCountAround
wallThicknessMin = (0.5 - holeRadius)
wallThicknessMax = math.sqrt(0.5) - holeRadius
wallThicknessPerElement = wallThicknessMin/elementsCountThroughWall
radius = holeRadius
inner_x = []
inner_d1 = []
inner_d2 = []
startRadians = math.pi*(-0.5 - elementsCount1/elementsCountAround)
for n1 in range(elementsCountAround):
radiansAround = startRadians + n1*radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
inner_x.append((radius*cosRadiansAround, radius*sinRadiansAround))
inner_d1.append((radiansPerElementAround*radius*-sinRadiansAround, radiansPerElementAround*radius*cosRadiansAround))
#inner_d2.append((wallThicknessPerElement*cosRadiansAround, wallThicknessPerElement*sinRadiansAround))
inner_d2.append((wallThicknessMin*cosRadiansAround, wallThicknessMin*sinRadiansAround))
outer_x = []
outer_d1 = []
outer_d2 = []
mag = math.sqrt(elementsCount1*elementsCount1 + elementsCount2*elementsCount2)
outer_dx1_ds1 = 1.0 / elementsCount1
outer_dx2_ds2 = 1.0 / elementsCount2
#cornerScale1 = 1.0 / max(elementsCount1 + 1, elementsCount2 + 1)
#cornerScale1 = 1.0 / min(2, max(elementsCount1, elementsCount2))
cornerScale1 = 1.0 / max(elementsCount1 + elementsCountThroughWall, elementsCount2 + elementsCountThroughWall)
sqrt05 = math.sqrt(0.5)
wallThicknessMax = sqrt05 - holeRadius
for n in range(elementsCount1):
x = -0.5 + n/elementsCount1
outer_x.append((x, -0.5))
if n == 0:
rx = x/sqrt05
ry = -0.5/sqrt05
scale2 = wallThicknessMax
outer_d1.append((-ry*cornerScale1, rx*cornerScale1))
outer_d2.append((rx*scale2, ry*scale2))
else:
scale2 = wallThicknessMin
outer_d1.append((outer_dx1_ds1, 0.0))
outer_d2.append((0.0, -scale2))
for n in range(elementsCount2):
y = -0.5 + n/elementsCount2
outer_x.append((0.5, y))
if n == 0:
rx = 0.5/sqrt05
ry = y/sqrt05
scale2 = wallThicknessMax
outer_d1.append((-ry*cornerScale1, rx*cornerScale1))
outer_d2.append((rx*scale2, ry*scale2))
else:
scale2 = wallThicknessMin
outer_d1.append((0.0, outer_dx2_ds2))
outer_d2.append((scale2, 0.0))
for n in range(elementsCount1):
x = 0.5 - n/elementsCount1
outer_x.append((x, 0.5))
if n == 0:
rx = x/sqrt05
ry = 0.5/sqrt05
scale2 = wallThicknessMax
outer_d1.append((-ry*cornerScale1, rx*cornerScale1))
outer_d2.append((rx*scale2, ry*scale2))
else:
scale2 = wallThicknessMin
outer_d1.append((-outer_dx1_ds1, 0.0))
outer_d2.append((0.0, scale2))
for n in range(elementsCount2):
y = 0.5 - n/elementsCount2
outer_x.append((-0.5, y))
if n == 0:
rx = -0.5/sqrt05
ry = y/sqrt05
scale2 = wallThicknessMax
outer_d1.append((-ry*cornerScale1, rx*cornerScale1))
outer_d2.append((rx*scale2, ry*scale2))
else:
scale2 = wallThicknessMin
outer_d1.append((0.0, -outer_dx2_ds2))
outer_d2.append((-scale2, 0.0))
nodeIdentifier = 1
x = [ 0.0, 0.0, 0.0 ]
dx_ds1 = [ 0.0, 0.0, 0.0 ]
dx_ds2 = [ 0.0, 0.0, 0.0 ]
outer_dx_ds1 = [ 1.0 / elementsCount1, 0.0, 0.0 ]
outer_dx_ds2 = [ 0.0, 1.0 / elementsCount2, 0.0 ]
zero = [ 0.0, 0.0, 0.0 ]
# outer nodes
for n1 in range(elementsCountAround):
x[0] = outer_x[n1][0]
x[1] = outer_x[n1][1]
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, outer_dx_ds1)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, outer_dx_ds2)
if useCrossDerivatives:
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
nodeIdentifier = nodeIdentifier + 1
# inner nodes
for n2 in range(elementsCountThroughWall):
xir = (n2 + 1)/elementsCountThroughWall
xi = 1.0 - xir
for n1 in range(elementsCountAround):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
v = interpolateCubicHermite(inner_x[n1], inner_d2[n1], outer_x[n1], outer_d2[n1], xi)
x[0] = v[0]
x[1] = v[1]
dx_ds1[0] = xir*inner_d1[n1][0] + xi*outer_d1[n1][0]
dx_ds1[1] = xir*inner_d1[n1][1] + xi*outer_d1[n1][1]
d2 = interpolateCubicHermiteDerivative(inner_x[n1], inner_d2[n1], outer_x[n1], outer_d2[n1], xi)
dx_ds2[0] = -d2[0]/elementsCountThroughWall
dx_ds2[1] = -d2[1]/elementsCountThroughWall
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, dx_ds1)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, dx_ds2)
if useCrossDerivatives:
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
nodeIdentifier = nodeIdentifier + 1
# create elements
elementIdentifier = 1
# first row general maps ds1, ds2 to dxi1, dxi2
for e1 in range(elementsCountAround):
en = (e1 + 1)%elementsCountAround
onX = (e1 % (elementsCount1 + elementsCount2)) < elementsCount1
elementtemplateOuter = elementtemplateOuter1 if onX else elementtemplateOuter2
eftOuter = eftOuter1 if onX else eftOuter2
element = mesh.createElement(elementIdentifier, elementtemplateOuter)
bni11 = e1 + 1
bni12 = en + 1
bni21 = elementsCountAround + e1 + 1
bni22 = elementsCountAround + en + 1
nodeIdentifiers = [ bni11, bni12, bni21, bni22 ]
result = element.setNodesByIdentifier(eftOuter, nodeIdentifiers)
rev = e1 >= (elementsCount1 + elementsCount2)
one = -1.0 if rev else 1.0
vx = one if onX else 0.0
vy = 0.0 if onX else one
scaleFactors = [
-1.0,
4.0,
vx, vy,
-outer_d2[e1][0]/outer_dx_ds1[0]/elementsCountThroughWall, -outer_d2[e1][1]/outer_dx_ds2[1]/elementsCountThroughWall,
vx, vy,
-outer_d2[en][0]/outer_dx_ds1[0]/elementsCountThroughWall, -outer_d2[en][1]/outer_dx_ds2[1]/elementsCountThroughWall ]
element.setScaleFactors(eftOuter, scaleFactors)
elementIdentifier = elementIdentifier + 1
# remaining rows
for e2 in range(1, elementsCountThroughWall):
for e1 in range(elementsCountAround):
element = mesh.createElement(elementIdentifier, elementtemplate)
bni11 = e2*elementsCountAround + e1 + 1
bni12 = e2*elementsCountAround + (e1 + 1)%elementsCountAround + 1
bni21 = (e2 + 1)*elementsCountAround + e1 + 1
bni22 = (e2 + 1)*elementsCountAround + (e1 + 1)%elementsCountAround + 1
nodeIdentifiers = [ bni11, bni12, bni21, bni22 ]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
fm.endChange()
return []
def generateOstiumMesh(region, options, trackSurface, centrePosition, axis1, startNodeIdentifier = 1, startElementIdentifier = 1,
vesselMeshGroups = None):
'''
:param vesselMeshGroups: List (over number of vessels) of list of mesh groups to add vessel elements to.
:return: nextNodeIdentifier, nextElementIdentifier, Ostium points tuple
(ox[n3][n1][c], od1[n3][n1][c], od2[n3][n1][c], od3[n3][n1][c], oNodeId[n3][n1], oPositions).
'''
vesselsCount = options['Number of vessels']
elementsCountAroundOstium = options['Number of elements around ostium']
elementsCountAcross = options['Number of elements across common']
elementsCountsAroundVessels, elementsCountAroundMid = getOstiumElementsCountsAroundVessels(elementsCountAroundOstium, elementsCountAcross, vesselsCount)
elementsCountAroundEnd = (elementsCountAroundOstium - 2*elementsCountAroundMid)//2
#print('\nvesselsCount', vesselsCount, 'elementsCountsAroundOstium', elementsCountAroundOstium, 'elementsCountAcross', elementsCountAcross)
#print('--> elementsCountsAroundVessels', elementsCountsAroundVessels, 'elementsCountAroundMid', elementsCountAroundMid)
elementsCountAlong = options['Number of elements along']
elementsCountThroughWall = options['Number of elements through wall']
unitScale = options['Unit scale']
isOutlet = options['Outlet']
ostiumRadius = 0.5*unitScale*options['Ostium diameter']
ostiumLength = unitScale*options['Ostium length']
ostiumWallThickness = unitScale*options['Ostium wall thickness']
interVesselHeight = unitScale*options['Ostium inter-vessel height']
interVesselDistance = unitScale*options['Ostium inter-vessel distance'] if (vesselsCount > 1) else 0.0
halfInterVesselDistance = 0.5*interVesselDistance
useCubicHermiteThroughOstiumWall = not(options['Use linear through ostium wall'])
vesselEndDerivative = ostiumLength*options['Vessel end length factor']/elementsCountAlong
vesselInnerRadius = 0.5*unitScale*options['Vessel inner diameter']
vesselWallThickness = unitScale*options['Vessel wall thickness']
vesselOuterRadius = vesselInnerRadius + vesselWallThickness
vesselAngle1Radians = math.radians(options['Vessel angle 1 degrees'])
vesselAngle1SpreadRadians = math.radians(options['Vessel angle 1 spread degrees'])
vesselAngle2Radians = math.radians(options['Vessel angle 2 degrees'])
useCubicHermiteThroughVesselWall = not(options['Use linear through vessel wall'])
useCrossDerivatives = False # options['Use cross derivatives'] # not implemented
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
cache = fm.createFieldcache()
# track points in shape of ostium
# get directions in plane of surface at centre:
cx, cd1, cd2 = trackSurface.evaluateCoordinates(centrePosition, True)
trackDirection1, trackDirection2, centreNormal = calculate_surface_axes(cd1, cd2, axis1)
trackDirection2reverse = [ -d for d in trackDirection2 ]
halfCircumference = math.pi*ostiumRadius
circumference = 2.0*halfCircumference
distance = 0.0
elementLengthAroundOstiumMid = 0.0
vesselsSpanAll = interVesselDistance*(vesselsCount - 1)
vesselsSpanMid = interVesselDistance*(vesselsCount - 2)
if vesselsCount == 1:
elementLengthAroundOstiumEnd = circumference/elementsCountAroundOstium
vesselOstiumPositions = [ centrePosition ]
ocx = [ cx ]
ocd1 = [ trackDirection1 ]
ocd2 = [ trackDirection2 ]
ocd3 = [ centreNormal ]
else:
elementLengthAroundOstiumEnd = (circumference + 2.0*interVesselDistance)/(elementsCountAroundOstium - 2*elementsCountAroundMid)
if elementsCountAroundMid > 0:
elementLengthAroundOstiumMid = interVesselDistance*(vesselsCount - 2)/elementsCountAroundMid
vesselOstiumPositions = []
ocx = []
ocd1 = []
ocd2 = []
ocd3 = []
for v in range(vesselsCount):
vesselOstiumPositions.append(trackSurface.trackVector(centrePosition, trackDirection1, (v/(vesselsCount - 1) - 0.5)*vesselsSpanAll))
x, d1, d2 = trackSurface.evaluateCoordinates(vesselOstiumPositions[-1], -1)
d1, d2, d3 = calculate_surface_axes(d1, d2, trackDirection1)
ocx .append(x)
ocd1.append(d1)
ocd2.append(d2)
ocd3.append(d3)
# coordinates around ostium
ox = [ [], [] ]
od1 = [ [], [] ]
od2 = [ [], [] ]
od3 = [ [], [] ]
oPositions = []
for n1 in range(elementsCountAroundOstium):
elementLength = elementLengthAroundOstiumEnd
if distance <= (vesselsSpanMid + halfInterVesselDistance):
position = trackSurface.trackVector(centrePosition, trackDirection1, 0.5*vesselsSpanMid - distance)
sideDirection = trackDirection2reverse
if n1 < elementsCountAroundMid:
elementLength = elementLengthAroundOstiumMid
elif distance < (vesselsSpanMid + halfInterVesselDistance + halfCircumference):
position = vesselOstiumPositions[0]
angleRadians = (distance - (vesselsSpanMid + halfInterVesselDistance))/ostiumRadius
w1 = -math.sin(angleRadians)
w2 = -math.cos(angleRadians)
sideDirection = [ (w1*trackDirection1[c] + w2*trackDirection2[c]) for c in range(3) ]
elif distance < (2.0*vesselsSpanMid + halfInterVesselDistance + halfCircumference + interVesselDistance):
position = trackSurface.trackVector(centrePosition, trackDirection1, distance - (1.5*vesselsSpanMid + interVesselDistance + halfCircumference))
sideDirection = trackDirection2
if 0 <= (n1 - elementsCountAroundEnd - elementsCountAroundMid) < elementsCountAroundMid:
elementLength = elementLengthAroundOstiumMid
elif distance < (2.0*vesselsSpanMid + halfInterVesselDistance + circumference + interVesselDistance):
position = vesselOstiumPositions[-1]
angleRadians = (distance - (2.0*vesselsSpanMid + halfInterVesselDistance + halfCircumference + interVesselDistance))/ostiumRadius
w1 = math.sin(angleRadians)
w2 = math.cos(angleRadians)
sideDirection = [ (w1*trackDirection1[c] + w2*trackDirection2[c]) for c in range(3) ]
else:
position = trackSurface.trackVector(centrePosition, trackDirection1, 0.5*vesselsSpanMid + (circumference + 2.0*(vesselsSpanMid + interVesselDistance)) - distance)
sideDirection = trackDirection2reverse
position = trackSurface.trackVector(position, sideDirection, ostiumRadius)
oPositions.append(position)
px, d1, d2 = trackSurface.evaluateCoordinates(position, True)
pd2, pd1, pd3 = calculate_surface_axes(d1, d2, sideDirection)
# get outer coordinates
opx = px
opd1 = vector.setMagnitude([ -d for d in pd1 ], elementLengthAroundOstiumEnd)
opd2 = vector.setMagnitude(pd2, elementLengthAroundOstiumEnd) # smoothed later
opd3 = vector.setMagnitude(pd3, ostiumWallThickness)
# set inner and outer coordinates (use copy to avoid references to same list later)
ox [0].append([ (opx[c] - opd3[c]) for c in range(3) ])
od1[0].append(copy.copy(opd1))
od2[0].append(copy.copy(opd2))
ox [1].append(opx)
od1[1].append(opd1)
od2[1].append(opd2)
if useCubicHermiteThroughOstiumWall:
od3[0].append(copy.copy(opd3))
od3[1].append(opd3)
distance += elementLength
for n3 in range(2):
od1[n3] = interp.smoothCubicHermiteDerivativesLoop(ox[n3], od1[n3], fixAllDirections = True)
xx = []
xd1 = []
xd2 = []
xd3 = []
# coordinates across common ostium, between vessels
nodesCountFreeEnd = elementsCountsAroundVessels[0] + 1 - elementsCountAcross
oinc = 0 if (vesselsCount <= 2) else elementsCountAroundMid//(vesselsCount - 2)
for iv in range(vesselsCount - 1):
xx .append([ None, None ])
xd1.append([ None, None ])
xd2.append([ None, None ])
xd3.append([ None, None ])
oa = elementsCountAroundMid - iv*oinc
ob = elementsCountAroundMid + nodesCountFreeEnd - 1 + iv*oinc
nx = [ ox[1][oa], ox[1][ob] ]
nd1 = [ [ -d for d in od1[1][oa] ], od1[1][ob] ]
nd2 = [ [ -d for d in od2[1][oa] ], od2[1][ob] ]
if elementsCountAcross > 1:
# add centre point, displaced by interVesselHeight
if vesselsCount == 2:
position = centrePosition
else:
position = trackSurface.trackVector(centrePosition, trackDirection1, (iv/(vesselsCount - 2) - 0.5)*vesselsSpanMid)
mx, d1, d2 = trackSurface.evaluateCoordinates(position, derivatives = True)
md1, md2, md3 = calculate_surface_axes(d1, d2, trackDirection1)
nx .insert(1, [ (mx[c] + interVesselHeight*md3[c]) for c in range(3) ])
nd1.insert(1, vector.setMagnitude(md1, elementLengthAroundOstiumMid if (0 < iv < (vesselsCount - 2)) else elementLengthAroundOstiumEnd))
nd2.insert(1, vector.setMagnitude(md2, ostiumRadius))
nd2 = interp.smoothCubicHermiteDerivativesLine(nx, nd2, fixAllDirections = True)
px, pd2, pe, pxi = interp.sampleCubicHermiteCurves(nx, nd2, elementsCountAcross)[0:4]
pd1 = interp.interpolateSampleLinear(nd1, pe, pxi)
pd3 = [ vector.setMagnitude(vector.crossproduct3(pd1[n2], pd2[n2]), ostiumWallThickness) for n2 in range(elementsCountAcross + 1) ]
lx = [ ([ (px[n2][c] - pd3[n2][c]) for c in range(3) ]) for n2 in range(elementsCountAcross + 1) ]
ld2 = interp.smoothCubicHermiteDerivativesLine(lx, pd2, fixAllDirections = True)
xx [iv][0] = lx [1:elementsCountAcross]
xd1[iv][0] = copy.deepcopy(pd1[1:elementsCountAcross]) # to be smoothed later
xd2[iv][0] = ld2[1:elementsCountAcross]
xx [iv][1] = px [1:elementsCountAcross]
xd1[iv][1] = pd1[1:elementsCountAcross] # to be smoothed later
xd2[iv][1] = pd2[1:elementsCountAcross]
if useCubicHermiteThroughOstiumWall:
xd3[iv][0] = copy.deepcopy(pd3[1:elementsCountAcross])
xd3[iv][1] = pd3[1:elementsCountAcross]
# set smoothed d2 on ostium circumference
od2[0][oa] = [ -d for d in ld2[0] ]
od2[1][oa] = [ -d for d in pd2[0] ]
od2[0][ob] = ld2[-1]
od2[1][ob] = pd2[-1]
# get positions of vessel end centres and rings
vcx = []
vcd1 = []
vcd2 = []
vcd3 = []
vox = []
vod1 = []
vod2 = []
vod3 = []
for v in range(vesselsCount):
elementsCountAroundVessel = elementsCountsAroundVessels[v]
radiansPerElementVessel = 2.0*math.pi/elementsCountAroundVessel
useVesselAngleRadians = vesselAngle1Radians
if vesselsCount > 1:
useVesselAngleRadians += (v/(vesselsCount - 1) - 0.5)*vesselAngle1SpreadRadians
vx, vd1, vd2, vd3 = getCircleProjectionAxes(ocx[v], ocd1[v], ocd2[v], ocd3[v], ostiumLength, useVesselAngleRadians, vesselAngle2Radians)
vd1 = [ vesselOuterRadius*d for d in vd1 ]
vd2 = [ -vesselOuterRadius*d for d in vd2 ]
vd3 = [ -vesselEndDerivative*d for d in vd3 ]
vcx.append(vx)
vcd1.append(vd1)
vcd2.append(vd2)
vcd3.append(vd3)
vox.append([])
vod1.append([])
vod2.append([])
vod3.append([])
for n3 in range(2):
radius = vesselInnerRadius if (n3 == 0) else vesselOuterRadius
vAxis1 = vector.setMagnitude(vd1, radius)
vAxis2 = vector.setMagnitude(vd2, radius)
if vesselsCount == 1:
startRadians = 0.5*math.pi
else:
startRadians = 0.5*radiansPerElementVessel*elementsCountAcross
if v == (vesselsCount - 1):
startRadians -= math.pi
px, pd1 = createCirclePoints(vx, vAxis1, vAxis2, elementsCountAroundVessel, startRadians)
vox [-1].append(px)
vod1[-1].append(pd1)
vod2[-1].append([ vd3 ]*elementsCountAroundVessel)
if useCubicHermiteThroughVesselWall:
vod3[-1].append([ vector.setMagnitude(vector.crossproduct3(d1, vd3), vesselWallThickness) for d1 in pd1 ])
# calculate common ostium vessel node derivatives map
mvPointsx = [ None ]*vesselsCount
mvPointsd1 = [ None ]*vesselsCount
mvPointsd2 = [ None ]*vesselsCount
mvPointsd3 = [ None ]*vesselsCount
mvDerivativesMap = [ None ]*vesselsCount
mvMeanCount = [ None ]*vesselsCount # stores 1 if first reference to common point between vessels, 2 if second. Otherwise 0.
for v in range(vesselsCount):
if vesselsCount == 1:
mvPointsx[v], mvPointsd1[v], mvPointsd2[v], mvPointsd3[v], mvDerivativesMap[v] = \
ox, od1, od2, od3 if useCubicHermiteThroughOstiumWall else None, None
mvMeanCount[v] = [ 0 ]*elementsCountsAroundVessels[v]
else:
iv = max(0, v - 1)
oa = elementsCountAroundMid - iv*oinc
ob = elementsCountAroundMid + nodesCountFreeEnd - 1 + iv*oinc
mvPointsx [v] = []
mvPointsd1[v] = []
mvPointsd2[v] = []
mvPointsd3[v] = [] if useCubicHermiteThroughOstiumWall else None
mvDerivativesMap[v] = []
for n3 in range(2):
mvPointsd1[v].append([])
mvPointsd2[v].append([])
mvPointsx [v].append([])
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v].append([])
mvDerivativesMap[v].append([])
if v == 0: # first end vessel
mvPointsd1[v][n3] += od1[n3][oa:ob + 1]
mvPointsd2[v][n3] += od2[n3][oa:ob + 1]
mvPointsx [v][n3] += ox [n3][oa:ob + 1]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][oa:ob + 1]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(nodesCountFreeEnd - 2):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
mvPointsx [v][n3] += reversed(xx [iv][n3])
mvPointsd1[v][n3] += reversed(xd1[iv][n3])
mvPointsd2[v][n3] += reversed(xd2[iv][n3])
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += reversed(xd3[iv][n3])
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, -1, 0), (1, 0, 0), None ) )
if n3 == 0:
mvMeanCount[v] = [ 1 ] + [ 0 ]*(nodesCountFreeEnd - 2) + [ 1 ]*elementsCountAcross
elif v < (vesselsCount - 1): # middle vessels
# left:
mvPointsx [v][n3] += ox [n3][oa - oinc:oa + 1]
mvPointsd1[v][n3] += od1[n3][oa - oinc:oa + 1]
mvPointsd2[v][n3] += od2[n3][oa - oinc:oa + 1]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][oa - oinc:oa + 1]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(oinc - 1):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
# across
mvPointsx [v][n3] += xx [iv][n3]
mvPointsd1[v][n3] += xd1[iv][n3]
mvPointsd2[v][n3] += xd2[iv][n3]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += xd3[iv][n3]
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 0, 0), None ) )
# right
mvPointsx [v][n3] += ox [n3][ob:ob + oinc + 1]
mvPointsd1[v][n3] += od1[n3][ob:ob + oinc + 1]
mvPointsd2[v][n3] += od2[n3][ob:ob + oinc + 1]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][ob:ob + oinc + 1]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(oinc - 1):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
# across reverse
mvPointsx [v][n3] += reversed(xx [iv + 1][n3])
mvPointsd1[v][n3] += reversed(xd1[iv + 1][n3])
mvPointsd2[v][n3] += reversed(xd2[iv + 1][n3])
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += reversed(xd3[iv + 1][n3])
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, -1, 0), (1, 0, 0), None ) )
if n3 == 0:
mvMeanCount[v] = [ 1 ] + [ 0 ]*(oinc - 1) + [ 2 ]*(elementsCountAcross + 1) + [ 0 ]*(oinc - 1) + [ 1 ]*elementsCountAcross
else: # last end vessel
mvPointsx [v][n3] += ox [n3][ob:] + [ ox [n3][0] ]
mvPointsd1[v][n3] += od1[n3][ob:] + [ od1[n3][0] ]
mvPointsd2[v][n3] += od2[n3][ob:] + [ od2[n3][0] ]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][ob:] + [ od3[n3][0] ]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(nodesCountFreeEnd - 2):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
mvPointsx [v][n3] += xx [iv][n3]
mvPointsd1[v][n3] += xd1[iv][n3]
mvPointsd2[v][n3] += xd2[iv][n3]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += xd3[iv][n3]
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 0, 0), None ) )
if n3 == 0:
mvMeanCount[v] = [ 2 ] + [ 0 ]*(nodesCountFreeEnd - 2) + [ 2 ]*elementsCountAcross
# calculate derivative 2 around free sides of inlets to fit vessel derivatives
for v in range(vesselsCount):
for n3 in range(2):
#print('v',v,'n3',n3,'elementsAround',elementsCountsAroundVessels[v])
#print('mvPointsx [v][n3]', mvPointsx [v][n3])
#print('mvPointsd1[v][n3]', mvPointsd1[v][n3])
#print('mvPointsd2[v][n3]', mvPointsd2[v][n3])
#print('mvDerivativesMap[v][n3]', mvDerivativesMap[v][n3])
for n1 in range(elementsCountsAroundVessels[v]):
d2Map = mvDerivativesMap[v][n3][n1][1] if (mvDerivativesMap[v] and mvDerivativesMap[v][n3][n1]) else None
sf1 = d2Map[0] if d2Map else 0.0
sf2 = d2Map[1] if d2Map else 1.0
nx = [ vox[v][n3][n1], mvPointsx[v][n3][n1] ]
nd2 = [ [ d*elementsCountAlong for d in vod2[v][n3][n1] ], [ (sf1*mvPointsd1[v][n3][n1][c] + sf2*mvPointsd2[v][n3][n1][c]) for c in range(3) ] ]
nd2f = interp.smoothCubicHermiteDerivativesLine(nx, nd2, fixStartDerivative = True, fixEndDirection = True)
ndf = [ d/elementsCountAlong for d in nd2f[1] ]
# assign components to set original values:
if sf1 == 0:
for c in range(3):
mvPointsd2[v][n3][n1][c] = sf2*ndf[c]
elif sf2 == 0:
if mvMeanCount[v][n1] < 2:
for c in range(3):
mvPointsd1[v][n3][n1][c] = sf1*ndf[c]
else:
# take mean of values from this and last vessel
for c in range(3):
mvPointsd1[v][n3][n1][c] = 0.5*(mvPointsd1[v][n3][n1][c] + sf1*ndf[c])
else:
#print('v', v, 'n3', n3, 'n1', n1, ':', vector.magnitude(ndf), 'vs.', vector.magnitude(nd2[1]), 'd2Map', d2Map)
pass
if isOutlet:
# reverse directions of d1 and d2 on vessels and ostium base
for c in range(3):
for n3 in range(2):
for n1 in range(elementsCountAroundOstium):
od1[n3][n1][c] = -od1[n3][n1][c]
od2[n3][n1][c] = -od2[n3][n1][c]
for iv in range(vesselsCount - 1):
for n1 in range(elementsCountAcross - 1):
xd1[iv][n3][n1][c] = -xd1[iv][n3][n1][c]
xd2[iv][n3][n1][c] = -xd2[iv][n3][n1][c]
for v in range(vesselsCount):
for n1 in range(elementsCountsAroundVessels[v]):
vod1[v][n3][n1][c] = -vod1[v][n3][n1][c]
# d2 is referenced all around, so only change once per vessel
for v in range(vesselsCount):
vod2[v][0][0][c] = -vod2[v][0][0][c]
##############
# Create nodes
##############
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS3, 1)
nodetemplateLinearS3 = nodes.createNodetemplate()
nodetemplateLinearS3.defineField(coordinates)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
nodeIdentifier = startNodeIdentifier
oNodeId = []
for n3 in range(2):
oNodeId.append([])
for n1 in range(elementsCountAroundOstium):
node = nodes.createNode(nodeIdentifier, nodetemplate if useCubicHermiteThroughOstiumWall else nodetemplateLinearS3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, ox [n3][n1])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, od1[n3][n1])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, od2[n3][n1])
if useCubicHermiteThroughOstiumWall:
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, od3[n3][n1])
oNodeId[n3].append(nodeIdentifier)
nodeIdentifier += 1
xNodeId = []
for iv in range(vesselsCount - 1):
xNodeId.append([])
for n3 in range(2):
xNodeId[iv].append([])
for n2 in range(elementsCountAcross - 1):
node = nodes.createNode(nodeIdentifier, nodetemplate if useCubicHermiteThroughOstiumWall else nodetemplateLinearS3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, xx [iv][n3][n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, xd1[iv][n3][n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, xd2[iv][n3][n2])
if useCubicHermiteThroughOstiumWall:
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, xd3[iv][n3][n2])
xNodeId[iv][n3].append(nodeIdentifier)
nodeIdentifier += 1
#for v in range(vesselsCount):
# node = nodes.createNode(nodeIdentifier, nodetemplate)
# cache.setNode(node)
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, vcx [v])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, vcd1[v])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, vcd2[v])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, vcd3[v])
# nodeIdentifier += 1
# for n3 in range(2):
# for n1 in range(elementsCountsAroundVessels[v]):
# node = nodes.createNode(nodeIdentifier, nodetemplate if useCubicHermiteThroughVesselWall else nodetemplateLinearS3)
# cache.setNode(node)
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, vox [v][n3][n1])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, vod1[v][n3][n1])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, vod2[v][n3][n1])
# if useCubicHermiteThroughVesselWall:
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, vod3[v][n3][n1])
# #vNodeId.append(nodeIdentifier)
# nodeIdentifier += 1
# get identifiers of nodes around each vessel at ostium end
mvNodeId = [ None ]*vesselsCount
for v in range(vesselsCount):
if vesselsCount == 1:
mvNodeId[v] = oNodeId
else:
iv = max(0, v - 1)
mvNodeId[v] = [ None, None ]
oa = elementsCountAroundMid - iv*oinc
ob = elementsCountAroundMid + nodesCountFreeEnd - 1 + iv*oinc
for n3 in range(2):
if v == 0: # first end vessel
mvNodeId[v][n3] = oNodeId[n3][oa:ob + 1] + (list(reversed(xNodeId[iv][n3])) if (v == 0) else xNodeId[iv][n3])
elif v == (vesselsCount - 1): # last end vessels
mvNodeId[v][n3] = oNodeId[n3][ob:] + [ oNodeId[n3][0] ] + (list(reversed(xNodeId[iv][n3])) if (v == 0) else xNodeId[iv][n3])
else: # mid vessels
mvNodeId[v][n3] = oNodeId[n3][oa - oinc:oa + 1] + xNodeId[iv][n3] + oNodeId[n3][ob:ob + oinc + 1] + list(reversed(xNodeId[iv + 1][n3]))
#################
# Create elementss
#################
mesh = fm.findMeshByDimension(3)
elementIdentifier = startElementIdentifier
tricubichermite = eftfactory_tricubichermite(mesh, useCrossDerivatives)
#tricubicHermiteBasis = fm.createElementbasis(3, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
#eft = tricubichermite.createEftBasic()
#elementtemplate = mesh.createElementtemplate()
#elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
#elementtemplate.defineField(coordinates, -1, eft)
#elementtemplateX = mesh.createElementtemplate()
#elementtemplateX.setElementShapeType(Element.SHAPE_TYPE_CUBE)
for v in range(vesselsCount):
if isOutlet:
startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap = \
mvPointsx[v], mvPointsd1[v], mvPointsd2[v], mvPointsd3[v], mvNodeId[v], mvDerivativesMap[v]
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap = \
vox[v], vod1[v], vod2[v], vod3[v] if useCubicHermiteThroughVesselWall else None, None, None
# reverse order of nodes around:
for px in [ startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap, \
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap ]:
if px:
for n3 in range(2):
px[n3] = [ px[n3][0] ] + px[n3][len(px[n3]) - 1:0:-1]
if vesselsCount > 1:
# must switch in and out xi1 maps around corners in startDerivativesMap
for n3 in range(2):
for n1 in range(elementsCountsAroundVessels[v]):
derivativesMap = startDerivativesMap[n3][n1]
if len(derivativesMap) == 4:
startDerivativesMap[n3][n1] = derivativesMap[3], derivativesMap[1], derivativesMap[2], derivativesMap[0]
else:
startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap = \
vox[v], vod1[v], vod2[v], vod3[v] if useCubicHermiteThroughVesselWall else None, None, None
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap = \
mvPointsx[v], mvPointsd1[v], mvPointsd2[v], mvPointsd3[v], mvNodeId[v], mvDerivativesMap[v]
#print('endPointsx ', endPointsx )
#print('endPointsd1', endPointsd1)
#print('endPointsd2', endPointsd2)
#print('endPointsd3', endPointsd3)
#print('endNodeId', endNodeId)
#print('endDerivativesMap', endDerivativesMap)
nodeIdentifier, elementIdentifier = createAnnulusMesh3d(
nodes, mesh, nodeIdentifier, elementIdentifier,
startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap,
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap,
forceMidLinearXi3 = not useCubicHermiteThroughVesselWall,
elementsCountRadial = elementsCountAlong,
meshGroups = vesselMeshGroups[v] if vesselMeshGroups else [])
fm.endChange()
return nodeIdentifier, elementIdentifier, (ox, od1, od2, od3, oNodeId, oPositions)
def generateBaseMesh(cls, region, options):
"""
Generate the base tricubic Hermite mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: [] empty list of AnnotationGroup
"""
elementsCountAlong = options['Number of elements along']
elementsCountAcross = options['Number of elements across']
wallThickness = [ options['Wall thickness left'], options['Wall thickness right'] ]
flangeLength = options['Flange length']
bulgeRadius = options['Bulge radius']
useCrossDerivatives = options['Use cross derivatives']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS3, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D2_DS1DS3, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D2_DS2DS3, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1)
mesh = fm.findMeshByDimension(3)
tricubichermite = eftfactory_tricubichermite(mesh, useCrossDerivatives)
eft = tricubichermite.createEftBasic()
eftOuter = tricubichermite.createEftTubeSeptumOuter()
eftInner1 = tricubichermite.createEftTubeSeptumInner1()
eftInner2 = tricubichermite.createEftTubeSeptumInner2()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = elementtemplate.defineField(coordinates, -1, eft)
elementtemplateOuter = mesh.createElementtemplate()
elementtemplateOuter.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = elementtemplateOuter.defineField(coordinates, -1, eftOuter)
elementtemplateInner1 = mesh.createElementtemplate()
elementtemplateInner1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = elementtemplateInner1.defineField(coordinates, -1, eftInner1)
elementtemplateInner2 = mesh.createElementtemplate()
elementtemplateInner2.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = elementtemplateInner2.defineField(coordinates, -1, eftInner2)
cache = fm.createFieldcache()
# create nodes
nodeIdentifier = 1
#radiansPerElementAcross = math.pi/elementsCountAcross
bevelAngle = math.pi/2
sinBevelAngle = math.sin(bevelAngle)
cosBevelAngle = math.cos(bevelAngle)
x = [ 0.0, 0.0, 0.0 ]
dx_ds1 = [ 0.0, 0.0, 0.0 ]
dx_ds2 = [ 0.0, 0.0, 1.0 / elementsCountAlong ]
dx_ds3 = [ 0.0, 0.0, 0.0 ]
zero = [ 0.0, 0.0, 0.0 ]
wallThicknessSeptum = wallThickness[0]
#wallThicknessMin = min(wallThickness)
wallThicknessMax = max(wallThickness)
for n3 in range(2):
sign = -1.0 if (n3 == 0) else 1.0
radiusY = 0.5*wallThicknessSeptum
radiusX = 0.5 - wallThicknessMax
for n2 in range(elementsCountAlong + 1):
x[2] = n2 / elementsCountAlong
for n1 in range(elementsCountAcross + 3):
if (n1 == 0) or (n1 == (elementsCountAcross + 2)):
flip = -1.0 if (n1 == 0) else 1.0
x[0] = radiusX + wallThickness[n3]
if n1 == 0:
x[0] = -x[0]
x[1] = -sign*(radiusY + flangeLength)
#if wallThickness[0] > wallThickness[1]:
# x[1] -= flangeLength
#elif wallThickness[0] < wallThickness[1]:
# x[1] += flangeLength
dx_ds1[0] = 0.0
dx_ds1[1] = 2.0*flip*(radiusY + flangeLength)
dx_ds3[0] = flip*wallThickness[n3]
dx_ds3[1] = 0.0
elif (n1 == 1) or (n1 == (elementsCountAcross + 1)):
flip = -1.0 if (n1 == 1) else 1.0
radius = radiusX
x[0] = flip*radius
x[1] = -sign*(radiusY + flangeLength)
#dx_ds1[0] = -sign*2.0*radiusX/elementsCountAcross*cosBevelAngle
#dx_ds1[1] = 2.0*radiusX/elementsCountAcross*sinBevelAngle
mag1x = radiusX/elementsCountAcross
mag1y = flangeLength
#mag1min = radiusX/elementsCountAcross + flangeLength + math.sqrt(mag1x*mag1x + mag1y*mag1y)
mag1min = 2.0*math.sqrt(mag1x*mag1x + mag1y*mag1y)
mag1max = 2.0*(radiusY + flangeLength)
mag1 = mag1min if (mag1min < mag1max) else mag1max
dx_ds1[0] = -sign*mag1*cosBevelAngle
dx_ds1[1] = mag1*sinBevelAngle
#if ((n3 == 1) and (wallThickness[0] > wallThickness[1])) or \
# ((n3 == 0) and (wallThickness[0] < wallThickness[1])):
dx_ds3[0] = wallThickness[n3]
dx_ds3[1] = 0.0
#else:
# dx_ds3[0] = wallThickness[n3]*sinBevelAngle
# dx_ds3[1] = sign*wallThickness[n3]*cosBevelAngle
if n1 == 1:
dx_ds1[1] = -dx_ds1[1]
dx_ds3[0] = -dx_ds3[0]
else:
f1 = (n1 - 1)/elementsCountAcross
f2 = 1.0 - f1
x[0] = (f1 - f2)*radiusX
x[1] = -sign*radiusY
dx_ds1[0] = 2.0*radiusX/elementsCountAcross
dx_ds1[1] = 0.0
dx_ds3[0] = 0.0
dx_ds3[1] = -wallThicknessSeptum
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, dx_ds1)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, dx_ds2)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, dx_ds3)
if useCrossDerivatives:
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D2_DS1DS3, 1, zero)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D2_DS2DS3, 1, zero)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1, zero)
nodeIdentifier = nodeIdentifier + 1
rimCrossAngle = math.pi/4
sinRimCrossAngle = math.sin(rimCrossAngle)
cosRimCrossAngle = math.cos(rimCrossAngle)
scaleFactorsOuter = [
cosRimCrossAngle, sinRimCrossAngle, cosRimCrossAngle, -sinRimCrossAngle,
cosRimCrossAngle, sinRimCrossAngle, cosRimCrossAngle, -sinRimCrossAngle
]
scaleFactorsInner1 = [ -1.0, 4.0,
cosRimCrossAngle, sinRimCrossAngle, cosRimCrossAngle, sinRimCrossAngle,
cosRimCrossAngle, -sinRimCrossAngle, cosRimCrossAngle, -sinRimCrossAngle
]
scaleFactorsInner2 = [ -1.0, 4.0,
cosRimCrossAngle, -sinRimCrossAngle, cosRimCrossAngle, -sinRimCrossAngle,
cosRimCrossAngle, sinRimCrossAngle, cosRimCrossAngle, sinRimCrossAngle
]
# create elements
elementIdentifier = 1
rno = elementsCountAcross + 3
wno = (elementsCountAlong + 1)*rno
for e2 in range(elementsCountAlong):
bn = e2*rno
element = mesh.createElement(elementIdentifier, elementtemplateOuter)
bni11 = bn + 2
bni12 = bn + wno + 2
bni21 = bn + rno + 2
bni22 = bn + wno + rno + 2
nodeIdentifiers = [ bni11, bni12, bni21, bni22, bni11 - 1, bni12 - 1, bni21 - 1, bni22 - 1 ]
result = element.setNodesByIdentifier(eftOuter, nodeIdentifiers)
#print(result, 'element', elementIdentifier, nodeIdentifiers)
element.setScaleFactors(eftOuter, scaleFactorsOuter)
elementIdentifier = elementIdentifier + 1
element = mesh.createElement(elementIdentifier, elementtemplateInner1)
bni11 = bn + 2
bni12 = bn + 3
bni21 = bn + rno + 2
bni22 = bn + rno + 3
nodeIdentifiers = [ bni11, bni12, bni21, bni22, bni11 + wno, bni12 + wno, bni21 + wno, bni22 + wno ]
result = element.setNodesByIdentifier(eftInner1, nodeIdentifiers)
#print(result, 'element', elementIdentifier, 'nodes', nodeIdentifiers)
element.setScaleFactors(eftInner1, scaleFactorsInner1)
#print(result, 'element', elementIdentifier, 'scale factors', scaleFactorsInner1)
elementIdentifier = elementIdentifier + 1
for e1 in range(elementsCountAcross - 2):
element = mesh.createElement(elementIdentifier, elementtemplate)
bni11 = bn + e1 + 3
bni12 = bn + e1 + 4
bni21 = bn + rno + e1 + 3
bni22 = bn + rno + e1 + 4
nodeIdentifiers = [ bni11, bni12, bni21, bni22, bni11 + wno, bni12 + wno, bni21 + wno, bni22 + wno ]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
#print(result, 'element', elementIdentifier, 'nodes', nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
element = mesh.createElement(elementIdentifier, elementtemplateInner2)
bni11 = bn + rno - 2
bni12 = bn + rno - 1
bni21 = bn + 2*rno -2
bni22 = bn + 2*rno - 1
nodeIdentifiers = [ bni11, bni12, bni21, bni22, bni11 + wno, bni12 + wno, bni21 + wno, bni22 + wno ]
result = element.setNodesByIdentifier(eftInner2, nodeIdentifiers)
#print(result, 'element', elementIdentifier, 'nodes', nodeIdentifiers)
element.setScaleFactors(eftInner2, scaleFactorsInner2)
#print(result, 'element', elementIdentifier, 'scale factors', scaleFactorsInner1)
elementIdentifier = elementIdentifier + 1
element = mesh.createElement(elementIdentifier, elementtemplateOuter)
bni11 = bn + wno + rno - 1
bni12 = bn + rno - 1
bni21 = bn + wno + 2*rno - 1
bni22 = bn + 2*rno - 1
nodeIdentifiers = [ bni11, bni12, bni21, bni22, bni11 + 1, bni12 + 1, bni21 + 1, bni22 + 1 ]
result = element.setNodesByIdentifier(eftOuter, nodeIdentifiers)
#print(result, 'element', elementIdentifier, nodeIdentifiers)
element.setScaleFactors(eftOuter, scaleFactorsOuter)
elementIdentifier = elementIdentifier + 1
if bulgeRadius != 0.0:
# cylindrical polar coordinates:
# r = y - bulgeRadius
# theta = -x / bulgeRadius
# z = z
yxzCoordinates = fm.createFieldComponent(coordinates, [2, 1, 3])
scale = fm.createFieldConstant([1.0, -1.0/bulgeRadius, 1.0 ])
scaleCoordinates = fm.createFieldMultiply(yxzCoordinates, scale)
offset = fm.createFieldConstant([-bulgeRadius, 0.0, 0.0 ])
polarCoordinates = fm.createFieldAdd(scaleCoordinates, offset)
polarCoordinates.setCoordinateSystemType(Field.COORDINATE_SYSTEM_TYPE_CYLINDRICAL_POLAR)
rcCoordinates = fm.createFieldCoordinateTransformation(polarCoordinates)
rcCoordinates.setCoordinateSystemType(Field.COORDINATE_SYSTEM_TYPE_RECTANGULAR_CARTESIAN)
newyxzCoordinates = fm.createFieldSubtract(rcCoordinates, offset)
newCoordinates = fm.createFieldComponent(newyxzCoordinates, [2, 1, 3])
fieldassignment = coordinates.createFieldassignment(newCoordinates)
result = fieldassignment.assign()
fm.endChange()
return []
def createAnnulusMesh3d(nodes,
mesh,
nextNodeIdentifier,
nextElementIdentifier,
startPointsx,
startPointsd1,
startPointsd2,
startPointsd3,
startNodeId,
startDerivativesMap,
endPointsx,
endPointsd1,
endPointsd2,
endPointsd3,
endNodeId,
endDerivativesMap,
forceStartLinearXi3=False,
forceMidLinearXi3=False,
forceEndLinearXi3=False,
maxStartThickness=None,
maxEndThickness=None,
useCrossDerivatives=False,
elementsCountRadial=1,
meshGroups=None,
wallAnnotationGroups=None,
tracksurface=None,
startProportions=None,
endProportions=None,
rescaleStartDerivatives=False,
rescaleEndDerivatives=False,
sampleBlend=0.0):
"""
Create an annulus mesh from a loop of start points/nodes with specified derivative mappings to
a loop of end points/nodes with specified derivative mappings.
Derivative d3 is through the wall. Currently limited to single element layer through wall.
Points/nodes order cycles fastest around the annulus, then through the wall.
Note doesn't support cross derivatives.
Arrays are indexed by n3 (node through wall, size 2), n2 (node along/radial), n1 (node around, variable size)
and coordinate component c.
:param nodes: The nodeset to create nodes in.
:param mesh: The mesh to create elements in.
:param nextNodeIdentifier, nextElementIdentifier: Next identifiers to use and increment.
:param startPointsx, startPointsd1, startPointsd2, startPointsd3, endPointsx, endPointsd1, endPointsd2, endPointsd3:
List array[n3][n1][c] or start/point coordinates and derivatives. To linearise through the wall, pass None to
d3. If both ends are linear through the wall, interior points are linear through the wall.
:param startNodeId, endNodeId: List array [n3][n1] of existing node identifiers to use at start/end. Pass None for
argument if no nodes are specified at end. These arguments are 'all or nothing'.
:param startDerivativesMap, endDerivativesMap: List array[n3][n1] of mappings for d/dxi1, d/dxi2, d/dxi3 at
start/end of form:
( (1, -1, 0), (1, 0, 0), None ) where the first tuple means d/dxi1 = d/ds1 - d/ds2. Only 0, 1 and -1 may be
used.
None means use default e.g. d/dxi2 = d/ds2.
Pass None for the entire argument to use the defaults d/dxi1 = d/ds1, d/dxi2 = d/ds2, d/dxi3 = d/ds3.
Pass a 4th mapping to apply to d/dxi1 on other side of node; if not supplied first mapping applies both sides.
:param forceStartLinearXi3, forceMidLinearXi3, forceEndLinearXi3: Force start, middle or
end elements to be linear through the wall, even if d3 is supplied at either end.
Can only use forceMidLinearXi3 only if at least one end is linear in d3.
:param maxStartThickness, maxEndThickness: Optional maximum override on start/end thicknesses.
:param useCrossDerivatives: May only be True if no derivatives maps are in use.
:param elementsCountRadial: Optional number of elements in radial direction between start and end.
:param meshGroups: Optional sequence of Zinc MeshGroup for adding all new elements to, or a sequence of
length elementsCountRadial containing sequences of mesh groups to add rows of radial elements to
from start to end.
:param wallAnnotationGroups: Annotation groups for adding all new elements to a sequence
of groups to add to elements through wall.
:param tracksurface: Description for outer surface representation used for creating annulus mesh. Provides
information for creating radial nodes on annulus that sit on tracksurface. Need startProportions and endProportions
to work.
:param startProportions: Proportion around and along of startPoints on tracksurface. These vary with nodes
around as for startPoints. Values only given for tracksurface for outer layer (xi3 == 1).
:param endProportions: Proportion around and along of endPoints on track surface. These vary with nodes
around as for endPoints. Values only given for tracksurface for outer layer (xi3 == 1).
:param rescaleStartDerivatives, rescaleEndDerivatives: Optional flags to compute and multiply additional scale
factors on start, end or both radial derivatives to fit arc length, needed if derivatives are of the wrong scale
for the radial distances and the chosen elementsCountRadial. If either is True, derivatives and sampled radial
nodes are spaced for a gradual change of derivative from that at the other end. If both are True, scaling is set to
give even sampling and arclength derivatives.
:param sampleBlend: Real value varying from 0.0 to 1.0 controlling weighting of start and end
derivatives when interpolating extra points in-between, where 0.0 = sample with equal end derivatives,
and 1.0 = proportional to current magnitudes, interpolated in between.
:return: Final values of nextNodeIdentifier, nextElementIdentifier
"""
assert (elementsCountRadial >=
1), 'createAnnulusMesh3d: Invalid number of radial elements'
startLinearXi3 = (not startPointsd3) or forceStartLinearXi3
endLinearXi3 = (not endPointsd3) or forceEndLinearXi3
midLinearXi3 = (startLinearXi3 and endLinearXi3) or (
(startLinearXi3 or endLinearXi3) and forceMidLinearXi3)
# get list whether each row of nodes in elements is linear in Xi3
# this is for element use; start/end nodes may have d3 even if element is linear
rowLinearXi3 = [
startLinearXi3
] + [midLinearXi3] * (elementsCountRadial - 1) + [endLinearXi3]
assert (not useCrossDerivatives) or ((not startDerivativesMap) and (not endDerivativesMap)), \
'createAnnulusMesh3d: Cannot use cross derivatives with derivatives map'
nodesCountWall = len(startPointsx)
assert (len(startPointsd1) == nodesCountWall) and (len(startPointsd2) == nodesCountWall) and \
(startLinearXi3 or (len(startPointsd3) == nodesCountWall)) and \
(len(endPointsx) == nodesCountWall) and (len(endPointsd1) == nodesCountWall) and \
(len(endPointsd2) == nodesCountWall) and (endLinearXi3 or (len(endPointsd3) == nodesCountWall)) and \
((startNodeId is None) or (len(startNodeId) == nodesCountWall)) and \
((endNodeId is None) or (len(endNodeId) == nodesCountWall)) and \
((startDerivativesMap is None) or (len(startDerivativesMap) == nodesCountWall)) and \
((endDerivativesMap is None) or (len(endDerivativesMap) == nodesCountWall)),\
'createAnnulusMesh3d: Mismatch in number of layers through wall'
elementsCountAround = nodesCountAround = len(startPointsx[0])
assert (
nodesCountAround > 1
), 'createAnnulusMesh3d: Invalid number of points/nodes around annulus'
for n3 in range(nodesCountWall):
assert (len(startPointsx[n3]) == nodesCountAround) and (len(startPointsd1[n3]) == nodesCountAround) and \
(len(startPointsd2[n3]) == nodesCountAround) and \
(startLinearXi3 or (len(startPointsd3[n3]) == nodesCountAround)) and\
(len(endPointsx[n3]) == nodesCountAround) and (len(endPointsd1[n3]) == nodesCountAround) and \
(len(endPointsd2[n3]) == nodesCountAround) and \
(endLinearXi3 or (len(endPointsd3[n3]) == nodesCountAround)) and \
((startNodeId is None) or (len(startNodeId[n3]) == nodesCountAround)) and\
((endNodeId is None) or (len(endNodeId[n3]) == nodesCountAround)) and \
((startDerivativesMap is None) or (len(startDerivativesMap[n3]) == nodesCountAround)) and \
((endDerivativesMap is None) or (len(endDerivativesMap[n3]) == nodesCountAround)), \
'createAnnulusMesh3d: Mismatch in number of points/nodes in layers through wall'
rowMeshGroups = meshGroups
if meshGroups:
assert isinstance(
meshGroups,
Sequence), 'createAnnulusMesh3d: Mesh groups is not a sequence'
if (len(meshGroups) == 0) or (not isinstance(meshGroups[0], Sequence)):
rowMeshGroups = [meshGroups] * elementsCountRadial
else:
assert len(meshGroups) == elementsCountRadial, \
'createAnnulusMesh3d: Length of meshGroups sequence does not equal elementsCountRadial'
if wallAnnotationGroups:
assert len(wallAnnotationGroups) == nodesCountWall - 1, \
'createAnnulusMesh3d: Length of wallAnnotationGroups sequence does not equal elementsCountThroughWall'
if tracksurface:
assert startProportions and endProportions, \
'createAnnulusMesh3d: Missing start and/or end proportions for use with tracksurface'
assert len(startProportions) == nodesCountAround, \
'createAnnulusMesh3d: Length of startProportions does not equal nodesCountAround'
assert len(endProportions) == nodesCountAround, \
'createAnnulusMesh3d: Length of endProportions does not equal nodesCountAround'
fm = mesh.getFieldmodule()
fm.beginChange()
cache = fm.createFieldcache()
coordinates = findOrCreateFieldCoordinates(fm)
# Build arrays of points from start to end
px = [[] for n3 in range(nodesCountWall)]
pd1 = [[] for n3 in range(nodesCountWall)]
pd2 = [[] for n3 in range(nodesCountWall)]
pd3 = [[] for n3 in range(nodesCountWall)]
# Find total wall thickness
thicknessProportions = []
thicknesses = []
thicknesses.append([
vector.magnitude([
(startPointsx[nodesCountWall - 1][n1][c] - startPointsx[0][n1][c])
for c in range(3)
]) for n1 in range(nodesCountAround)
])
for n2 in range(1, elementsCountRadial):
thicknesses.append([None] * nodesCountAround)
thicknesses.append([
vector.magnitude([
(endPointsx[nodesCountWall - 1][n1][c] - endPointsx[0][n1][c])
for c in range(3)
]) for n1 in range(nodesCountAround)
])
for n3 in range(nodesCountWall):
px[n3] = [startPointsx[n3], endPointsx[n3]]
pd1[n3] = [startPointsd1[n3], endPointsd1[n3]]
pd2[n3] = [startPointsd2[n3], endPointsd2[n3]]
pd3[n3] = [
startPointsd3[n3] if (startPointsd3 is not None) else None,
endPointsd3[n3] if (endPointsd3 is not None) else None
]
startThicknessList = \
[vector.magnitude([(startPointsx[n3][n1][c] - startPointsx[n3 - (1 if n3 > 0 else 0)][n1][c])
for c in range(3)]) for n1 in range(len(startPointsx[n3]))]
endThicknessList = \
[vector.magnitude([(endPointsx[n3][n1][c] - endPointsx[n3 - (1 if n3 > 0 else 0)][n1][c])
for c in range(3)]) for n1 in range(len(endPointsx[n3]))]
thicknessList = [startThicknessList,
endThicknessList] # thickness of each layer
startThicknessProportions = [
thicknessList[0][c] / thicknesses[0][c]
for c in range(nodesCountAround)
]
endThicknessProportions = [
thicknessList[1][c] / thicknesses[-1][c]
for c in range(nodesCountAround)
]
thicknessProportions.append(
[startThicknessProportions, endThicknessProportions])
if rescaleStartDerivatives:
scaleFactorMapStart = [[] for n3 in range(nodesCountWall)]
if rescaleEndDerivatives:
scaleFactorMapEnd = [[] for n3 in range(nodesCountWall)]
# following code adds in-between points, but also handles rescaling for 1 radial element
for n3 in range(nodesCountWall):
for n2 in range(1, elementsCountRadial):
px[n3].insert(n2, [None] * nodesCountAround)
pd1[n3].insert(n2, [None] * nodesCountAround)
pd2[n3].insert(n2, [None] * nodesCountAround)
pd3[n3].insert(n2,
None if midLinearXi3 else [None] * nodesCountAround)
thicknessProportions[n3].insert(n2, [None] * nodesCountAround)
if maxStartThickness:
for n1 in range(nodesCountAround):
thicknesses[0][n1] = min(thicknesses[0][n1], maxStartThickness)
if maxEndThickness:
for n1 in range(nodesCountAround):
thicknesses[-1][n1] = min(thicknesses[-1][n1], maxEndThickness)
n3 = nodesCountWall - 1
for n1 in range(nodesCountAround):
ax = startPointsx[n3][n1]
ad1, ad2 = getMappedD1D2(
[startPointsd1[n3][n1], startPointsd2[n3][n1]] +
([startPointsd3[n3][n1]] if startPointsd3 else []),
startDerivativesMap[n3][n1] if startDerivativesMap else None)
bx = endPointsx[n3][n1]
bd1, bd2 = getMappedD1D2(
[endPointsd1[n3][n1], endPointsd2[n3][n1]] +
([endPointsd3[n3][n1]] if endPointsd3 else []),
endDerivativesMap[n3][n1] if endDerivativesMap else None)
# sample between start and end points and derivatives
# scaling end derivatives to arc length gives even curvature along the curve
aMag = vector.magnitude(ad2)
bMag = vector.magnitude(bd2)
ad2Scaled = vector.setMagnitude(
ad2,
0.5 * ((1.0 + sampleBlend) * aMag + (1.0 - sampleBlend) * bMag))
bd2Scaled = vector.setMagnitude(
bd2,
0.5 * ((1.0 + sampleBlend) * bMag + (1.0 - sampleBlend) * aMag))
scaling = interp.computeCubicHermiteDerivativeScaling(
ax, ad2Scaled, bx, bd2Scaled)
ad2Scaled = [d * scaling for d in ad2Scaled]
bd2Scaled = [d * scaling for d in bd2Scaled]
derivativeMagnitudeStart = None if rescaleStartDerivatives else vector.magnitude(
ad2)
derivativeMagnitudeEnd = None if rescaleEndDerivatives else vector.magnitude(
bd2)
if tracksurface:
mx, md2, md1, md3, mProportions = \
tracksurface.createHermiteCurvePoints(startProportions[n1][0], startProportions[n1][1],
endProportions[n1][0], endProportions[n1][1], elementsCountRadial,
derivativeStart=[d / elementsCountRadial for d in ad2Scaled],
derivativeEnd=[d / elementsCountRadial for d in bd2Scaled])
mx, md2, md1 = \
tracksurface.resampleHermiteCurvePointsSmooth(mx, md2, md1, md3, mProportions,
derivativeMagnitudeStart, derivativeMagnitudeEnd)[0:3]
# interpolate thicknesses using xi calculated from radial arclength distances to points
arcLengthInsideToRadialPoint = \
[0.0] + [interp.getCubicHermiteArcLength(mx[n2], md2[n2], mx[n2 + 1], md2[n2 + 1])
for n2 in range(elementsCountRadial)]
arclengthInsideToOutside = sum(arcLengthInsideToRadialPoint)
thi = []
for n2 in range(elementsCountRadial + 1):
xi2 = arcLengthInsideToRadialPoint[
n2 - 1] / arclengthInsideToOutside
thi.append(thicknesses[-1][n1] * xi2 + thicknesses[0][n1] *
(1.0 - xi2))
thiProportion = []
for m3 in range(nodesCountWall):
thiProportionRadial = []
for n2 in range(elementsCountRadial + 1):
xi2 = arcLengthInsideToRadialPoint[
n2 - 1] / arclengthInsideToOutside
thiProportionRadial.append(
thicknessProportions[m3][-1][n1] * xi2 +
thicknessProportions[m3][0][n1] * (1.0 - xi2))
thiProportion.append(thiProportionRadial)
else:
mx, md2, me, mxi = interp.sampleCubicHermiteCurvesSmooth(
[ax, bx], [ad2Scaled, bd2Scaled], elementsCountRadial,
derivativeMagnitudeStart, derivativeMagnitudeEnd)[0:4]
md1 = interp.interpolateSampleLinear([ad1, bd1], me, mxi)
thi = interp.interpolateSampleLinear(
[thicknesses[0][n1], thicknesses[-1][n1]], me, mxi)
thiProportion = []
for m3 in range(nodesCountWall):
thiProportion.append(
interp.interpolateSampleLinear([
thicknessProportions[m3][0][n1],
thicknessProportions[m3][-1][n1]
], me, mxi))
# set scalefactors if rescaling, make same on inside for now
if rescaleStartDerivatives:
scaleFactor = vector.magnitude(md2[0]) / vector.magnitude(ad2)
scaleFactorMapStart[n3].append(scaleFactor)
if rescaleEndDerivatives:
scaleFactor = vector.magnitude(md2[-1]) / vector.magnitude(bd2)
scaleFactorMapEnd[n3].append(scaleFactor)
for n2 in range(1, elementsCountRadial):
px[n3][n2][n1] = mx[n2]
pd1[n3][n2][n1] = md1[n2]
pd2[n3][n2][n1] = md2[n2]
thicknesses[n2][n1] = thi[n2]
for m3 in range(nodesCountWall):
thicknessProportions[m3][n2][n1] = thiProportion[m3][n2]
xi3List = [[[[] for n1 in range(nodesCountAround)]
for n2 in range(elementsCountRadial + 1)]
for n3 in range(nodesCountWall)]
for n1 in range(nodesCountAround):
for n2 in range(elementsCountRadial + 1):
xi3 = 0.0
for n3 in range(nodesCountWall):
xi3 += thicknessProportions[n3][n2][n1]
xi3List[n3][n2][n1] = xi3
# now get inner positions from normal and thickness, derivatives from curvature
for n2 in range(1, elementsCountRadial):
# first smooth derivative 1 around outer loop
pd1[-1][n2] = \
interp.smoothCubicHermiteDerivativesLoop(px[-1][n2], pd1[-1][n2],
magnitudeScalingMode=interp.DerivativeScalingMode.HARMONIC_MEAN)
for n3 in range(0, nodesCountWall - 1):
for n1 in range(nodesCountAround):
xi3 = 1 - xi3List[n3][n2][n1]
normal = vector.normalise(
vector.crossproduct3(pd1[-1][n2][n1], pd2[-1][n2][n1]))
thickness = thicknesses[n2][n1] * xi3
d3 = [d * thickness for d in normal]
px[n3][n2][n1] = [(px[-1][n2][n1][c] - d3[c])
for c in range(3)]
# calculate inner d1 from curvature around
n1m = n1 - 1
n1p = (n1 + 1) % nodesCountAround
curvature = 0.5 * (interp.getCubicHermiteCurvature(
px[-1][n2][n1m], pd1[-1][n2][n1m], px[-1][n2][n1], pd1[-1]
[n2][n1], normal, 1.0) + interp.getCubicHermiteCurvature(
px[-1][n2][n1], pd1[-1][n2][n1], px[-1][n2][n1p],
pd1[-1][n2][n1p], normal, 0.0))
factor = 1.0 + curvature * thickness
pd1[n3][n2][n1] = [factor * d for d in pd1[-1][n2][n1]]
# calculate inner d2 from curvature radially
n2m = n2 - 1
n2p = n2 + 1
curvature = 0.5 * (interp.getCubicHermiteCurvature(
px[-1][n2m][n1], pd2[-1][n2m][n1], px[-1][n2][n1], pd2[-1]
[n2][n1], normal, 1.0) + interp.getCubicHermiteCurvature(
px[-1][n2][n1], pd2[-1][n2][n1], px[-1][n2p][n1],
pd2[-1][n2p][n1], normal, 0.0))
factor = 1.0 + curvature * thickness
pd2[n3][n2][n1] = [factor * d for d in pd2[-1][n2][n1]]
d2Scaled = [factor * d for d in pd2[-1][n2][n1]]
if vector.dotproduct(vector.normalise(pd2[-1][n2][n1]),
vector.normalise(d2Scaled)) == -1:
pd2[n3][n2][n1] = [-factor * d for d in pd2[-1][n2][n1]]
if not midLinearXi3:
pd3[n3][n2][n1] = pd3[-1][n2][n1] = \
[d * thicknesses[n2][n1] * thicknessProportions[n3 + 1][n2][n1] for d in normal]
# smooth derivative 1 around inner loop
pd1[n3][n2] = interp.smoothCubicHermiteDerivativesLoop(
px[n3][n2],
pd1[n3][n2],
magnitudeScalingMode=interp.DerivativeScalingMode.HARMONIC_MEAN
)
for n3 in range(0, nodesCountWall):
# smooth derivative 2 radially/along annulus
for n1 in range(nodesCountAround):
mx = [px[n3][n2][n1] for n2 in range(elementsCountRadial + 1)]
md2 = [pd2[n3][n2][n1] for n2 in range(elementsCountRadial + 1)]
# replace mapped start/end d2
md2[0] = getMappedD1D2(
[startPointsd1[n3][n1], startPointsd2[n3][n1]] +
([startPointsd3[n3][n1]] if startPointsd3 else []),
startDerivativesMap[n3][n1]
if startDerivativesMap else None)[1]
md2[-1] = getMappedD1D2(
[endPointsd1[n3][n1], endPointsd2[n3][n1]] +
([endPointsd3[n3][n1]] if endPointsd3 else []),
endDerivativesMap[n3][n1] if endDerivativesMap else None)[1]
sd2 = interp.smoothCubicHermiteDerivativesLine(
mx,
md2,
fixAllDirections=True,
fixStartDerivative=not rescaleStartDerivatives,
fixStartDirection=rescaleStartDerivatives,
fixEndDerivative=not rescaleEndDerivatives,
fixEndDirection=rescaleEndDerivatives,
magnitudeScalingMode=interp.DerivativeScalingMode.HARMONIC_MEAN
)
if rescaleStartDerivatives:
scaleFactor = vector.magnitude(sd2[0]) / vector.magnitude(
md2[0])
scaleFactorMapStart[n3].append(scaleFactor)
if rescaleEndDerivatives:
scaleFactor = vector.magnitude(sd2[-1]) / vector.magnitude(
md2[-1])
scaleFactorMapEnd[n3].append(scaleFactor)
for n2 in range(1, elementsCountRadial):
pd2[n3][n2][n1] = sd2[n2]
##############
# Create nodes
##############
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS3, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS2DS3, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D3_DS1DS2DS3, 1)
nodetemplateLinearS3 = nodes.createNodetemplate()
nodetemplateLinearS3.defineField(coordinates)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplateLinearS3.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
nodeIdentifier = nextNodeIdentifier
nodeId = [[] for n3 in range(nodesCountWall)]
for n2 in range(elementsCountRadial + 1):
for n3 in range(nodesCountWall):
if (n2 == 0) and (startNodeId is not None):
rowNodeId = copy.deepcopy(startNodeId[n3])
elif (n2 == elementsCountRadial) and (endNodeId is not None):
rowNodeId = copy.deepcopy(endNodeId[n3])
else:
rowNodeId = []
nodetemplate1 = nodetemplate if pd3[n3][
n2] else nodetemplateLinearS3
for n1 in range(nodesCountAround):
node = nodes.createNode(nodeIdentifier, nodetemplate1)
rowNodeId.append(nodeIdentifier)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
px[n3][n2][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
pd1[n3][n2][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
pd2[n3][n2][n1])
if pd3[n3][n2]:
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS3,
1, pd3[n3][n2][n1])
nodeIdentifier = nodeIdentifier + 1
nodeId[n3].append(rowNodeId)
#################
# Create elements
#################
tricubichermite = eftfactory_tricubichermite(mesh, useCrossDerivatives)
bicubichermitelinear = eftfactory_bicubichermitelinear(
mesh, useCrossDerivatives)
elementIdentifier = nextElementIdentifier
elementtemplateStandard = mesh.createElementtemplate()
elementtemplateStandard.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementtemplateX = mesh.createElementtemplate()
elementtemplateX.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementsCountWall = nodesCountWall - 1
for e2 in range(elementsCountRadial):
nonlinearXi3 = (not rowLinearXi3[e2]) or (not rowLinearXi3[e2 + 1])
eftFactory = tricubichermite if nonlinearXi3 else bicubichermitelinear
eftStandard = eftFactory.createEftBasic()
elementtemplateStandard.defineField(coordinates, -1, eftStandard)
mapStartDerivatives = (e2 == 0) and (startDerivativesMap
or rescaleStartDerivatives)
mapStartLinearDerivativeXi3 = nonlinearXi3 and rowLinearXi3[e2]
mapEndDerivatives = (e2 == (elementsCountRadial - 1)) and (
endDerivativesMap or rescaleEndDerivatives)
mapEndLinearDerivativeXi3 = nonlinearXi3 and rowLinearXi3[e2 + 1]
mapDerivatives = mapStartDerivatives or mapStartLinearDerivativeXi3 or \
mapEndDerivatives or mapEndLinearDerivativeXi3
for e3 in range(elementsCountWall):
for e1 in range(elementsCountAround):
en = (e1 + 1) % elementsCountAround
nids = [
nodeId[e3][e2][e1], nodeId[e3][e2][en],
nodeId[e3][e2 + 1][e1], nodeId[e3][e2 + 1][en],
nodeId[e3 + 1][e2][e1], nodeId[e3 + 1][e2][en],
nodeId[e3 + 1][e2 + 1][e1], nodeId[e3 + 1][e2 + 1][en]
]
scaleFactors = []
if mapDerivatives:
eft1 = eftFactory.createEftNoCrossDerivatives()
# work out if scaling by global -1
scaleMinus1 = mapStartLinearDerivativeXi3 or mapEndLinearDerivativeXi3
if (not scaleMinus1
) and mapStartDerivatives and startDerivativesMap:
for n3 in range(2):
n3Idx = n3 + e3
# need to handle 3 or 4 maps (e1 uses last 3, en uses first 3)
for map in startDerivativesMap[n3Idx][e1][-3:]:
if map and (-1 in map):
scaleMinus1 = True
break
for map in startDerivativesMap[n3Idx][en][:3]:
if map and (-1 in map):
scaleMinus1 = True
break
if (not scaleMinus1
) and mapEndDerivatives and endDerivativesMap:
for n3 in range(2):
n3Idx = n3 + e3
# need to handle 3 or 4 maps (e1 uses last 3, en uses first 3)
for map in endDerivativesMap[n3Idx][e1][-3:]:
if map and (-1 in map):
scaleMinus1 = True
break
for map in endDerivativesMap[n3Idx][en][:3]:
if map and (-1 in map):
scaleMinus1 = True
break
# make node scale factors vary fastest by local node varying across lower xi
nodeScaleFactorIds = []
for n3 in range(2):
n3Idx = n3 + e3
if mapStartDerivatives and rescaleStartDerivatives:
for i in range(2):
derivativesMap = (
startDerivativesMap[n3Idx][e1][1] if
(i == 0) else startDerivativesMap[n3Idx]
[en][1]) if startDerivativesMap else None
nodeScaleFactorIds.append(
getQuadrantID(derivativesMap
if derivativesMap else (0, 1,
0)))
if mapEndDerivatives and rescaleEndDerivatives:
for i in range(2):
derivativesMap = (
endDerivativesMap[n3Idx][e1][1] if
(i == 0) else endDerivativesMap[n3Idx][en]
[1]) if endDerivativesMap else None
nodeScaleFactorIds.append(
getQuadrantID(derivativesMap
if derivativesMap else (0, 1,
0)))
setEftScaleFactorIds(eft1, [1] if scaleMinus1 else [],
nodeScaleFactorIds)
firstNodeScaleFactorIndex = 2 if scaleMinus1 else 1
firstStartNodeScaleFactorIndex = \
firstNodeScaleFactorIndex if (mapStartDerivatives and rescaleStartDerivatives) else None
firstEndNodeScaleFactorIndex = \
(firstNodeScaleFactorIndex + (2 if firstStartNodeScaleFactorIndex else 0)) \
if (mapEndDerivatives and rescaleEndDerivatives) else None
layerNodeScaleFactorIndexOffset = \
4 if (firstStartNodeScaleFactorIndex and firstEndNodeScaleFactorIndex) else 2
if scaleMinus1:
scaleFactors.append(-1.0)
for n3 in range(2):
n3Idx = n3 + e3
if firstStartNodeScaleFactorIndex:
scaleFactors.append(scaleFactorMapStart[n3Idx][e1])
scaleFactors.append(scaleFactorMapStart[n3Idx][en])
if firstEndNodeScaleFactorIndex:
scaleFactors.append(scaleFactorMapEnd[n3Idx][e1])
scaleFactors.append(scaleFactorMapEnd[n3Idx][en])
if mapStartLinearDerivativeXi3:
eftFactory.setEftLinearDerivative2(
eft1, [1, 5, 2, 6], Node.VALUE_LABEL_D_DS3,
[Node.VALUE_LABEL_D2_DS1DS3])
if mapStartDerivatives:
for i in range(2):
lns = [1, 5] if (i == 0) else [2, 6]
for n3 in range(2):
n3Idx = n3 + e3
derivativesMap = \
(startDerivativesMap[n3Idx][e1] if (i == 0) else startDerivativesMap[n3Idx][en]) \
if startDerivativesMap else (None, None, None)
# handle different d1 on each side of node
d1Map = \
derivativesMap[0] if ((i == 1) or (len(derivativesMap) < 4)) else derivativesMap[3]
d2Map = derivativesMap[1] if derivativesMap[
1] else (0, 1, 0)
d3Map = derivativesMap[2]
# use temporary to safely swap DS1 and DS2:
ln = [lns[n3]]
if d1Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D2_DS1DS2, [])])
if d3Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D2_DS2DS3, [])])
if d2Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D_DS2,
derivativeSignsToExpressionTerms(
(Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D_DS3), d2Map,
(firstStartNodeScaleFactorIndex +
i + n3 *
layerNodeScaleFactorIndexOffset)
if rescaleStartDerivatives else
None))
if d1Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D2_DS1DS2,
derivativeSignsToExpressionTerms(
(Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D_DS3), d1Map))
if d3Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D2_DS2DS3,
derivativeSignsToExpressionTerms(
(Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D_DS3), d3Map))
if mapEndLinearDerivativeXi3:
eftFactory.setEftLinearDerivative2(
eft1, [3, 7, 4, 8], Node.VALUE_LABEL_D_DS3,
[Node.VALUE_LABEL_D2_DS1DS3])
if mapEndDerivatives:
for i in range(2):
lns = [3, 7] if (i == 0) else [4, 8]
for n3 in range(2):
n3Idx = n3 + e3
derivativesMap = \
(endDerivativesMap[n3Idx][e1] if (i == 0) else endDerivativesMap[n3Idx][en]) \
if endDerivativesMap else (None, None, None)
# handle different d1 on each side of node
d1Map = derivativesMap[0] if ((i == 1) or (len(derivativesMap) < 4)) else \
derivativesMap[3]
d2Map = derivativesMap[1] if derivativesMap[
1] else (0, 1, 0)
d3Map = derivativesMap[2]
# use temporary to safely swap DS1 and DS2:
ln = [lns[n3]]
if d1Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D2_DS1DS2, [])])
if d3Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D_DS3,
[(Node.VALUE_LABEL_D2_DS2DS3, [])])
if d2Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D_DS2,
derivativeSignsToExpressionTerms(
(Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D_DS3), d2Map,
(firstEndNodeScaleFactorIndex + i +
n3 *
layerNodeScaleFactorIndexOffset)
if rescaleEndDerivatives else
None))
if d1Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D2_DS1DS2,
derivativeSignsToExpressionTerms(
(Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D_DS3), d1Map))
if d3Map:
remapEftNodeValueLabel(
eft1, ln, Node.VALUE_LABEL_D2_DS2DS3,
derivativeSignsToExpressionTerms(
(Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D_DS3), d3Map))
elementtemplateX.defineField(coordinates, -1, eft1)
elementtemplate1 = elementtemplateX
else:
eft1 = eftStandard
elementtemplate1 = elementtemplateStandard
element = mesh.createElement(elementIdentifier,
elementtemplate1)
result2 = element.setNodesByIdentifier(eft1, nids)
if scaleFactors:
result3 = element.setScaleFactors(eft1, scaleFactors)
# print('create element annulus', element.isValid(), elementIdentifier, eft1.validate(),
# result2, result3 if scaleFactors else None, nids)
elementIdentifier += 1
if rowMeshGroups:
for meshGroup in rowMeshGroups[e2]:
meshGroup.addElement(element)
if wallAnnotationGroups:
for annotationGroup in wallAnnotationGroups[e3]:
meshGroup = annotationGroup.getMeshGroup(mesh)
meshGroup.addElement(element)
fm.endChange()
return nodeIdentifier, elementIdentifier
def generateBaseMesh(cls, region, options):
"""
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: [] empty list of AnnotationGroup
"""
elementsCountUp = options['Number of elements up']
elementsCountAround = options['Number of elements around']
useCrossDerivatives = options['Use cross derivatives']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplateApex = nodes.createNodetemplate()
nodetemplateApex.defineField(coordinates)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1)
else:
nodetemplate = nodetemplateApex
mesh = fm.findMeshByDimension(2)
bicubicHermiteBasis = fm.createElementbasis(
2, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
eft = mesh.createElementfieldtemplate(bicubicHermiteBasis)
if not useCrossDerivatives:
for n in range(4):
eft.setFunctionNumberOfTerms(n * 4 + 4, 0)
# Apex1: collapsed on xi2 = 0
eftApex1 = mesh.createElementfieldtemplate(bicubicHermiteBasis)
eftApex1.setNumberOfLocalNodes(3)
eftApex1.setNumberOfLocalScaleFactors(7)
# GRC: allow scale factor identifier for global -1.0 to be prescribed
eftApex1.setScaleFactorType(
1, Elementfieldtemplate.SCALE_FACTOR_TYPE_GLOBAL_GENERAL)
eftApex1.setScaleFactorIdentifier(1, 1)
for s in range(6):
si = s + 2
# 3 scale factors per node: cos(theta), sin(theta), arc angle radians
sid = (s // 3) * 100 + (s %
3) + 1 # add 100 for different 'version'
eftApex1.setScaleFactorType(
si, Elementfieldtemplate.SCALE_FACTOR_TYPE_NODE_GENERAL)
eftApex1.setScaleFactorIdentifier(si, sid)
# basis nodes 1, 2 -> local node 1
ln = 1
eftApex1.setTermNodeParameter(1, 1, ln, Node.VALUE_LABEL_VALUE, 1)
# 0 terms = zero parameter for d/dxi1 basis
eftApex1.setFunctionNumberOfTerms(2, 0)
# 2 terms for d/dxi2 via general linear map:
eftApex1.setFunctionNumberOfTerms(3, 2)
eftApex1.setTermNodeParameter(3, 1, ln, Node.VALUE_LABEL_D_DS1, 1)
eftApex1.setTermScaling(3, 1, [2])
eftApex1.setTermNodeParameter(3, 2, ln, Node.VALUE_LABEL_D_DS2, 1)
eftApex1.setTermScaling(3, 2, [3])
# 2 terms for cross derivative 1 2 to correct circular apex: -sin(theta).phi, cos(theta).phi
eftApex1.setFunctionNumberOfTerms(4, 2)
eftApex1.setTermNodeParameter(4, 1, ln, Node.VALUE_LABEL_D_DS1, 1)
eftApex1.setTermScaling(4, 1, [3, 4])
eftApex1.setTermNodeParameter(4, 2, ln, Node.VALUE_LABEL_D_DS2, 1)
eftApex1.setTermScaling(4, 2, [1, 2, 4])
# basis node 2 -> local node 1
eftApex1.setTermNodeParameter(5, 1, ln, Node.VALUE_LABEL_VALUE, 1)
# 0 terms = zero parameter for d/dxi1 basis
eftApex1.setFunctionNumberOfTerms(6, 0)
# 2 terms for d/dxi2 via general linear map:
eftApex1.setFunctionNumberOfTerms(7, 2)
eftApex1.setTermNodeParameter(7, 1, ln, Node.VALUE_LABEL_D_DS1, 1)
eftApex1.setTermScaling(7, 1, [5])
eftApex1.setTermNodeParameter(7, 2, ln, Node.VALUE_LABEL_D_DS2, 1)
eftApex1.setTermScaling(7, 2, [6])
# 2 terms for cross derivative 1 2 to correct circular apex: -sin(theta).phi, cos(theta).phi
eftApex1.setFunctionNumberOfTerms(8, 2)
eftApex1.setTermNodeParameter(8, 1, ln, Node.VALUE_LABEL_D_DS1, 1)
eftApex1.setTermScaling(8, 1, [6, 7])
eftApex1.setTermNodeParameter(8, 2, ln, Node.VALUE_LABEL_D_DS2, 1)
eftApex1.setTermScaling(8, 2, [1, 5, 7])
# basis nodes 3, 4 -> regular local nodes 2, 3
for bn in range(2, 4):
fo = bn * 4
ni = bn
eftApex1.setTermNodeParameter(fo + 1, 1, ni,
Node.VALUE_LABEL_VALUE, 1)
eftApex1.setTermNodeParameter(fo + 2, 1, ni,
Node.VALUE_LABEL_D_DS1, 1)
eftApex1.setTermNodeParameter(fo + 3, 1, ni,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
eftApex1.setTermNodeParameter(fo + 4, 1, ni,
Node.VALUE_LABEL_D2_DS1DS2, 1)
else:
eftApex1.setFunctionNumberOfTerms(fo + 4, 0)
# Apex2: collapsed on xi2 = 1
eftApex2 = mesh.createElementfieldtemplate(bicubicHermiteBasis)
eftApex2.setNumberOfLocalNodes(3)
eftApex2.setNumberOfLocalScaleFactors(7)
# GRC: allow scale factor identifier for global -1.0 to be prescribed
eftApex2.setScaleFactorType(
1, Elementfieldtemplate.SCALE_FACTOR_TYPE_GLOBAL_GENERAL)
eftApex2.setScaleFactorIdentifier(1, 1)
for s in range(6):
si = s + 2
# 3 scale factors per node: cos(theta), sin(theta), arc angle radians
sid = (s // 3) * 100 + (s %
3) + 1 # add 100 for different 'version'
eftApex2.setScaleFactorType(
si, Elementfieldtemplate.SCALE_FACTOR_TYPE_NODE_GENERAL)
eftApex2.setScaleFactorIdentifier(si, sid)
# basis nodes 1, 2 -> regular local nodes 1, 2 (for each layer)
for bn in range(2):
fo = bn * 4
ni = bn + 1
eftApex2.setTermNodeParameter(fo + 1, 1, ni,
Node.VALUE_LABEL_VALUE, 1)
eftApex2.setTermNodeParameter(fo + 2, 1, ni,
Node.VALUE_LABEL_D_DS1, 1)
eftApex2.setTermNodeParameter(fo + 3, 1, ni,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
eftApex2.setTermNodeParameter(fo + 4, 1, ni,
Node.VALUE_LABEL_D2_DS1DS2, 1)
else:
eftApex2.setFunctionNumberOfTerms(fo + 4, 0)
# basis nodes 3, 4 -> local node 3
ln = 3
fo3 = 8
eftApex2.setTermNodeParameter(fo3 + 1, 1, ln, Node.VALUE_LABEL_VALUE,
1)
# 0 terms = zero parameter for d/dxi1 basis
eftApex2.setFunctionNumberOfTerms(fo3 + 2, 0)
# 2 terms for d/dxi2 via general linear map:
eftApex2.setFunctionNumberOfTerms(fo3 + 3, 2)
eftApex2.setTermNodeParameter(fo3 + 3, 1, ln, Node.VALUE_LABEL_D_DS1,
1)
eftApex2.setTermScaling(fo3 + 3, 1, [2])
eftApex2.setTermNodeParameter(fo3 + 3, 2, ln, Node.VALUE_LABEL_D_DS2,
1)
eftApex2.setTermScaling(fo3 + 3, 2, [3])
# 2 terms for cross derivative 1 2 to correct circular apex: -sin(theta).phi, cos(theta).phi
eftApex2.setFunctionNumberOfTerms(fo3 + 4, 2)
eftApex2.setTermNodeParameter(fo3 + 4, 1, ln, Node.VALUE_LABEL_D_DS1,
1)
eftApex2.setTermScaling(fo3 + 4, 1, [1, 3, 4])
eftApex2.setTermNodeParameter(fo3 + 4, 2, ln, Node.VALUE_LABEL_D_DS2,
1)
eftApex2.setTermScaling(fo3 + 4, 2, [2, 4])
# basis node 4 -> local node 3
eftApex2.setTermNodeParameter(fo3 + 5, 1, ln, Node.VALUE_LABEL_VALUE,
1)
# 0 terms = zero parameter for d/dxi1 basis
eftApex2.setFunctionNumberOfTerms(fo3 + 6, 0)
# 2 terms for d/dxi2 via general linear map:
eftApex2.setFunctionNumberOfTerms(fo3 + 7, 2)
eftApex2.setTermNodeParameter(fo3 + 7, 1, ln, Node.VALUE_LABEL_D_DS1,
1)
eftApex2.setTermScaling(fo3 + 7, 1, [5])
eftApex2.setTermNodeParameter(fo3 + 7, 2, ln, Node.VALUE_LABEL_D_DS2,
1)
eftApex2.setTermScaling(fo3 + 7, 2, [6])
# 2 terms for cross derivative 1 2 to correct circular apex: -sin(theta).phi, cos(theta).phi
eftApex2.setFunctionNumberOfTerms(fo3 + 8, 2)
eftApex2.setTermNodeParameter(fo3 + 8, 1, ln, Node.VALUE_LABEL_D_DS1,
1)
eftApex2.setTermScaling(fo3 + 8, 1, [1, 6, 7])
eftApex2.setTermNodeParameter(fo3 + 8, 2, ln, Node.VALUE_LABEL_D_DS2,
1)
eftApex2.setTermScaling(fo3 + 8, 2, [5, 7])
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
elementtemplate.defineField(coordinates, -1, eft)
elementtemplateApex1 = mesh.createElementtemplate()
elementtemplateApex1.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
elementtemplateApex1.defineField(coordinates, -1, eftApex1)
elementtemplateApex2 = mesh.createElementtemplate()
elementtemplateApex2.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
elementtemplateApex2.defineField(coordinates, -1, eftApex2)
cache = fm.createFieldcache()
# create nodes
nodeIdentifier = 1
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
radiansPerElementUp = math.pi / elementsCountUp
x = [0.0, 0.0, 0.0]
dx_ds1 = [0.0, 0.0, 0.0]
dx_ds2 = [0.0, 0.0, 0.0]
zero = [0.0, 0.0, 0.0]
radius = 0.5
# create apex1 node
node = nodes.createNode(nodeIdentifier, nodetemplateApex)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
[0.0, 0.0, -radius])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
[0.0, radius * radiansPerElementUp, 0.0])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
[radius * radiansPerElementUp, 0.0, 0.0])
nodeIdentifier = nodeIdentifier + 1
# create regular rows between apexes
for n2 in range(1, elementsCountUp):
radiansUp = n2 * radiansPerElementUp
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
radius * cosRadiansAround * sinRadiansUp,
radius * sinRadiansAround * sinRadiansUp,
-radius * cosRadiansUp
]
dx_ds1 = [
radius * -sinRadiansAround * sinRadiansUp *
radiansPerElementAround, radius * cosRadiansAround *
sinRadiansUp * radiansPerElementAround, 0.0
]
dx_ds2 = [
radius * cosRadiansAround * cosRadiansUp *
radiansPerElementUp, radius * sinRadiansAround *
cosRadiansUp * radiansPerElementUp,
radius * sinRadiansUp * radiansPerElementUp
]
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
dx_ds1)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
dx_ds2)
if useCrossDerivatives:
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1, zero)
nodeIdentifier = nodeIdentifier + 1
# create apex2 node
node = nodes.createNode(nodeIdentifier, nodetemplateApex)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
[0.0, 0.0, radius])
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS1, 1,
[0.0, -radius * radiansPerElementUp, 0.0])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
[radius * radiansPerElementUp, 0.0, 0.0])
nodeIdentifier = nodeIdentifier + 1
# create elements
elementIdentifier = 1
# create Apex1 elements, editing eft scale factor identifiers around apex
# scale factor identifiers follow convention of offsetting by 100 for each 'version'
bni1 = 1
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eftApex1.setScaleFactorIdentifier(2, va * 100 + 1)
eftApex1.setScaleFactorIdentifier(3, va * 100 + 2)
eftApex1.setScaleFactorIdentifier(4, va * 100 + 3)
eftApex1.setScaleFactorIdentifier(5, vb * 100 + 1)
eftApex1.setScaleFactorIdentifier(6, vb * 100 + 2)
eftApex1.setScaleFactorIdentifier(7, vb * 100 + 3)
# redefine field in template for changes to eftApex1:
elementtemplateApex1.defineField(coordinates, -1, eftApex1)
element = mesh.createElement(elementIdentifier,
elementtemplateApex1)
bni2 = e1 + 2
bni3 = (e1 + 1) % elementsCountAround + 2
nodeIdentifiers = [bni1, bni2, bni3]
element.setNodesByIdentifier(eftApex1, nodeIdentifiers)
# set general linear map coefficients
radiansAround = e1 * radiansPerElementAround
radiansAroundNext = (
(e1 + 1) % elementsCountAround) * radiansPerElementAround
scalefactors = [
-1.0,
math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround
]
result = element.setScaleFactors(eftApex1, scalefactors)
elementIdentifier = elementIdentifier + 1
# create regular rows between apexes
for e2 in range(elementsCountUp - 2):
for e1 in range(elementsCountAround):
element = mesh.createElement(elementIdentifier,
elementtemplate)
bni1 = e2 * elementsCountAround + e1 + 2
bni2 = e2 * elementsCountAround + (e1 +
1) % elementsCountAround + 2
nodeIdentifiers = [
bni1, bni2, bni1 + elementsCountAround,
bni2 + elementsCountAround
]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
# create Apex2 elements, editing eft scale factor identifiers around apex
# scale factor identifiers follow convention of offsetting by 100 for each 'version'
bni3 = 2 + (elementsCountUp - 1) * elementsCountAround
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eftApex2.setScaleFactorIdentifier(2, va * 100 + 1)
eftApex2.setScaleFactorIdentifier(3, va * 100 + 2)
eftApex2.setScaleFactorIdentifier(4, va * 100 + 3)
eftApex2.setScaleFactorIdentifier(5, vb * 100 + 1)
eftApex2.setScaleFactorIdentifier(6, vb * 100 + 2)
eftApex2.setScaleFactorIdentifier(7, vb * 100 + 3)
# redefine field in template for changes to eftApex2:
elementtemplateApex1.defineField(coordinates, -1, eftApex2)
element = mesh.createElement(elementIdentifier,
elementtemplateApex1)
bni1 = bni3 - elementsCountAround + e1
bni2 = bni3 - elementsCountAround + (e1 + 1) % elementsCountAround
nodeIdentifiers = [bni1, bni2, bni3]
result = element.setNodesByIdentifier(eftApex2, nodeIdentifiers)
# set general linear map coefficients
radiansAround = math.pi + e1 * radiansPerElementAround
radiansAroundNext = math.pi + (
(e1 + 1) % elementsCountAround) * radiansPerElementAround
scalefactors = [
-1.0, -math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
-math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround
]
result = element.setScaleFactors(eftApex2, scalefactors)
elementIdentifier = elementIdentifier + 1
fm.endChange()
return []
def generateBaseMesh(cls, region, options):
"""
Generate the base tricubic Hermite or bicubic Hermite linear mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: [] empty list of AnnotationGroup
"""
elementsCountAround = options['Number of elements around']
elementsCountUp = options['Number of elements up']
elementsCountThroughWall = options['Number of elements through wall']
useCrossDerivatives = options['Use cross derivatives']
useCubicHermiteThroughWall = not (options['Use linear through wall'])
excludeBottomRows = options['Exclude bottom rows']
excludeTopRows = options['Exclude top rows']
wallThickness = options['Wall thickness']
wallThicknessRatioApex = options['Wall thickness ratio apex']
lengthRatio = options['Length ratio']
elementLengthRatioEquatorApex = options[
'Element length ratio equator/apex']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplateApex = nodes.createNodetemplate()
nodetemplateApex.defineField(coordinates)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCubicHermiteThroughWall:
nodetemplateApex.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3,
1)
if useCrossDerivatives:
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1)
if useCubicHermiteThroughWall:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3,
1)
nodetemplate.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D2_DS1DS3, 1)
nodetemplate.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D2_DS2DS3, 1)
nodetemplate.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1)
else:
nodetemplate = nodetemplateApex
mesh = fm.findMeshByDimension(3)
if useCubicHermiteThroughWall:
eftfactory = eftfactory_tricubichermite(mesh, useCrossDerivatives)
else:
eftfactory = eftfactory_bicubichermitelinear(
mesh, useCrossDerivatives)
eft = eftfactory.createEftBasic()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementtemplate.defineField(coordinates, -1, eft)
cache = fm.createFieldcache()
# create nodes
nodeIdentifier = 1
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
x = [0.0, 0.0, 0.0]
dx_ds1 = [0.0, 0.0, 0.0]
dx_ds2 = [0.0, 0.0, 0.0]
dx_ds3 = [0.0, 0.0, 0.0]
zero = [0.0, 0.0, 0.0]
# pre-calculate positions and tangent/normal vectors up (elementsCountUp + 1) node layers
outerWidth = 0.5
outerLength = outerWidth * lengthRatio
bOuter = 2.0 / (1.0 + elementLengthRatioEquatorApex / lengthRatio)
aOuter = 1.0 - bOuter
innerWidth = outerWidth - wallThickness
innerLength = outerLength - wallThickness * wallThicknessRatioApex
lengthRatioInner = innerLength / innerWidth if (
innerWidth > 0.0) else lengthRatio
bInner = 2.0 / (1.0 + elementLengthRatioEquatorApex / lengthRatio)
aInner = 1.0 - bInner
positionOuterArray = [(0, 0)] * (elementsCountUp + 1)
positionInnerArray = [(0, 0)] * (elementsCountUp + 1)
radiansUpOuterArray = [0] * (elementsCountUp + 1)
radiansUpInnerArray = [0] * (elementsCountUp + 1)
vector2OuterArray = [(0, 0)] * (elementsCountUp + 1)
vector2InnerArray = [(0, 0)] * (elementsCountUp + 1)
for n2 in range(elementsCountUp + 1):
if n2 * 2 <= elementsCountUp:
xi = n2 * 2 / elementsCountUp
else:
xi = 2.0 - (n2 * 2 / elementsCountUp)
nxiOuter = aOuter * xi * xi + bOuter * xi
dnxiOuter = 2.0 * aOuter * xi + bOuter
radiansUpOuterArray[
n2] = radiansUpOuter = nxiOuter * math.pi * 0.5 if (
n2 * 2 <= elementsCountUp) else (math.pi -
nxiOuter * math.pi * 0.5)
dRadiansUpOuter = dnxiOuter * math.pi / elementsCountUp
cosRadiansUpOuter = math.cos(radiansUpOuter)
sinRadiansUpOuter = math.sin(radiansUpOuter)
positionOuterArray[n2] = positionOuter = (outerWidth *
sinRadiansUpOuter,
-outerLength *
cosRadiansUpOuter)
vector2OuterArray[n2] = (outerWidth * cosRadiansUpOuter *
dRadiansUpOuter, outerLength *
sinRadiansUpOuter * dRadiansUpOuter)
nxiInner = aInner * xi * xi + bInner * xi
dnxiInner = 2.0 * aInner * xi + bInner
radiansUpInnerArray[
n2] = radiansUpInner = nxiInner * math.pi * 0.5 if (
n2 * 2 <= elementsCountUp) else (math.pi -
nxiInner * math.pi * 0.5)
dRadiansUpInner = dnxiInner * math.pi / elementsCountUp
cosRadiansUpInner = math.cos(radiansUpInner)
sinRadiansUpInner = math.sin(radiansUpInner)
positionInnerArray[n2] = positionInner = (innerWidth *
sinRadiansUpInner,
-innerLength *
cosRadiansUpInner)
vector2InnerArray[n2] = (innerWidth * cosRadiansUpInner *
dRadiansUpInner, innerLength *
sinRadiansUpInner * dRadiansUpInner)
# now create the nodes
for n3 in range(elementsCountThroughWall + 1):
n3_fraction = n3 / elementsCountThroughWall
for n2 in range(excludeBottomRows,
elementsCountUp + 1 - excludeTopRows):
positionOuter = positionOuterArray[n2]
positionInner = positionInnerArray[n2]
position = (positionOuter[0] * n3_fraction + positionInner[0] *
(1.0 - n3_fraction),
positionOuter[1] * n3_fraction + positionInner[1] *
(1.0 - n3_fraction))
radiansUpOuter = radiansUpOuterArray[n2]
sinRadiansUpOuter = math.sin(radiansUpOuter)
radiansUpInner = radiansUpInnerArray[n2]
sinRadiansUpInner = math.sin(radiansUpInner)
vector2Outer = vector2OuterArray[n2]
vector2Inner = vector2InnerArray[n2]
vector2 = (vector2Outer[0] * n3_fraction + vector2Inner[0] *
(1.0 - n3_fraction), vector2Outer[1] * n3_fraction +
vector2Inner[1] * (1.0 - n3_fraction))
vector3 = ((positionOuter[0] - positionInner[0]) /
elementsCountThroughWall,
(positionOuter[1] - positionInner[1]) /
elementsCountThroughWall)
if n2 == 0:
# create bottom apex node
node = nodes.createNode(nodeIdentifier, nodetemplateApex)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
[0.0, 0.0, position[1]])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
[0.0, vector2[0], 0.0])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
[vector2[0], 0.0, 0.0])
if useCubicHermiteThroughWall:
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS3,
1,
[0.0, 0.0, vector3[1]])
nodeIdentifier = nodeIdentifier + 1
elif n2 < elementsCountUp:
# create regular rows between apexes
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
position[0] * cosRadiansAround,
position[0] * sinRadiansAround, position[1]
]
dx_ds1 = [
position[0] * -sinRadiansAround *
radiansPerElementAround, position[0] *
cosRadiansAround * radiansPerElementAround, 0.0
]
dx_ds2 = [
vector2[0] * cosRadiansAround,
vector2[0] * sinRadiansAround, vector2[1]
]
dx_ds3 = [
vector3[0] * cosRadiansAround,
vector3[0] * sinRadiansAround, vector3[1]
]
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE,
1, x)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1,
1, dx_ds1)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2,
1, dx_ds2)
if useCubicHermiteThroughWall:
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS3, 1, dx_ds3)
if useCrossDerivatives:
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
if useCubicHermiteThroughWall:
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS3, 1,
zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS2DS3, 1,
zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D3_DS1DS2DS3,
1, zero)
nodeIdentifier = nodeIdentifier + 1
else:
# create top apex node
node = nodes.createNode(nodeIdentifier, nodetemplateApex)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
[0.0, 0.0, position[1]])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
[0.0, vector2[0], 0.0])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
[-vector2[0], 0.0, 0.0])
if useCubicHermiteThroughWall:
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS3,
1,
[0.0, 0.0, vector3[1]])
nodeIdentifier = nodeIdentifier + 1
# create elements
elementIdentifier = 1
# now (node offset through wall) varies with number of excluded rows
now = 0
if excludeBottomRows == 0:
now += 1 # bottom apex node
if excludeTopRows == 0:
now += 1 # top apex node
fullNodeRows = elementsCountUp - 1
if excludeBottomRows > 1:
fullNodeRows -= (excludeBottomRows - 1)
if excludeTopRows > 1:
fullNodeRows -= (excludeTopRows - 1)
if fullNodeRows > 0:
now += fullNodeRows * elementsCountAround
row2NodeOffset = 2 if (excludeBottomRows == 0) else 1
for e3 in range(elementsCountThroughWall):
no = e3 * now
if excludeBottomRows == 0:
# create bottom apex elements, editing eft scale factor identifiers around apex
# scale factor identifiers follow convention of offsetting by 100 for each 'version'
elementtemplate1 = mesh.createElementtemplate()
elementtemplate1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eft1 = eftfactory.createEftShellPoleBottom(
va * 100, vb * 100)
elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier,
elementtemplate1)
bni1 = no + 1
bni2 = no + e1 + 2
bni3 = no + (e1 + 1) % elementsCountAround + 2
nodeIdentifiers = [
bni1, bni2, bni3, bni1 + now, bni2 + now, bni3 + now
]
element.setNodesByIdentifier(eft1, nodeIdentifiers)
# set general linear map coefficients
radiansAround = e1 * radiansPerElementAround
radiansAroundNext = (
(e1 + 1) %
elementsCountAround) * radiansPerElementAround
scalefactors = [
-1.0,
math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround,
math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround
]
result = element.setScaleFactors(eft1, scalefactors)
elementIdentifier = elementIdentifier + 1
# create regular rows between apexes
rowLimit = (elementsCountUp - 2)
if excludeBottomRows > 1:
rowLimit -= (excludeBottomRows - 1)
if excludeTopRows > 1:
rowLimit -= (excludeTopRows - 1)
for e2 in range(0, rowLimit):
for e1 in range(elementsCountAround):
element = mesh.createElement(elementIdentifier,
elementtemplate)
bni11 = no + e2 * elementsCountAround + e1 + row2NodeOffset
bni12 = no + e2 * elementsCountAround + (
e1 + 1) % elementsCountAround + row2NodeOffset
bni21 = no + (
e2 + 1) * elementsCountAround + e1 + row2NodeOffset
bni22 = no + (e2 + 1) * elementsCountAround + (
e1 + 1) % elementsCountAround + row2NodeOffset
nodeIdentifiers = [
bni11, bni12, bni21, bni22, bni11 + now, bni12 + now,
bni21 + now, bni22 + now
]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
if excludeTopRows == 0:
# create top apex elements, editing eft scale factor identifiers around apex
# scale factor identifiers follow convention of offsetting by 100 for each 'version'
elementtemplate1 = mesh.createElementtemplate()
elementtemplate1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eft1 = eftfactory.createEftShellPoleTop(va * 100, vb * 100)
elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier,
elementtemplate1)
bni3 = no + now
bni1 = bni3 - elementsCountAround + e1
bni2 = bni3 - elementsCountAround + (
e1 + 1) % elementsCountAround
nodeIdentifiers = [
bni1, bni2, bni3, bni1 + now, bni2 + now, bni3 + now
]
element.setNodesByIdentifier(eft1, nodeIdentifiers)
# set general linear map coefficients
radiansAround = math.pi + e1 * radiansPerElementAround
radiansAroundNext = math.pi + (
(e1 + 1) %
elementsCountAround) * radiansPerElementAround
scalefactors = [
-1.0, -math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
-math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround,
-math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
-math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround
]
result = element.setScaleFactors(eft1, scalefactors)
elementIdentifier = elementIdentifier + 1
if False: # (wallThickness < 0.5): # and (wallThicknessRatioApex != 1.0):
r = fm.createFieldMagnitude(coordinates)
const05 = fm.createFieldConstant([0.5])
d = fm.createFieldSubtract(const05, r)
d_r = fm.createFieldDivide(d, r)
rRatio = 1.0 - wallThicknessRatioApex
rScale = fm.createFieldConstant([rRatio])
zScale = fm.createFieldMultiply(d_r, rScale)
one = fm.createFieldConstant([1.0])
one_plus_zScale = fm.createFieldAdd(one, zScale)
scale = fm.createFieldConcatenate([one, one, one_plus_zScale])
newCoordinates = fm.createFieldMultiply(coordinates, scale)
fieldassignment = coordinates.createFieldassignment(newCoordinates)
fieldassignment.assign()
fm.endChange()
return []
def generate(self):
coordinate_dimensions = 2
elements_count = self.__options['number of elements']
node_coordinates = self.__options['node coordinates']
node_derivatives1 = self.__options['node derivatives 1']
node_derivatives2 = self.__options['node derivatives 2'] * 2
fieldmodule = self.__region.getFieldmodule()
with ChangeManager(fieldmodule):
fieldmodule.beginChange()
coordinates = findOrCreateFieldCoordinates(
fieldmodule, components_count=coordinate_dimensions)
cache = fieldmodule.createFieldcache()
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
node_template = nodes.createNodetemplate()
node_template.defineField(coordinates)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
node_template.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
mesh = fieldmodule.findMeshByDimension(2)
bicubic_hermite_basis = fieldmodule.createElementbasis(
2, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
eft = mesh.createElementfieldtemplate(bicubic_hermite_basis)
for n in range(4):
eft.setFunctionNumberOfTerms(n * 4 + 4, 0)
element_template = mesh.createElementtemplate()
element_template.setElementShapeType(Element.SHAPE_TYPE_SQUARE)
result = element_template.defineField(coordinates, -1, eft)
cache = fieldmodule.createFieldcache()
#################
# Create nodes
#################
node_identifier = 1
for n in range(len(node_coordinates)):
node = nodes.createNode(node_identifier, node_template)
cache.setNode(node)
x = node_coordinates[n]
d2 = node_derivatives2[n]
if n % 2 == 0:
d1 = [-i for i in node_derivatives1[n]]
else:
d1 = node_derivatives1[n]
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1, d1)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1, d2)
node_identifier = node_identifier + 1
#################
# Create elements
#################
element_identifier = 1
for e1 in range(1, elements_count + 1):
element = mesh.createElement(element_identifier,
element_template)
if e1 == 1:
bni = 1
else:
bni = previous + 2
previous = bni
node_identifiers = [bni, bni + 1, bni + 2, bni + 3]
# print(node_identifiers)
result = element.setNodesByIdentifier(eft, node_identifiers)
element_identifier = element_identifier + 1
fieldmodule.defineAllFaces()
def generateBaseMesh(cls, region, options):
"""
Generate the base tricubic Hermite mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: [] empty list of AnnotationGroup
"""
elementsCount1 = options['Number of elements 1']
elementsCount2 = options['Number of elements 2']
elementsCount3 = options['Number of elements 3']
useCrossDerivatives = options['Use cross derivatives']
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS3,
1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS2DS3,
1)
nodetemplate.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1)
mesh = fm.findMeshByDimension(3)
tricubichermite = eftfactory_tricubichermite(mesh, useCrossDerivatives)
eft = tricubichermite.createEftBasic()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = elementtemplate.defineField(coordinates, -1, eft)
cache = fm.createFieldcache()
# create nodes
nodeIdentifier = 1
x = [0.0, 0.0, 0.0]
dx_ds1 = [1.0 / elementsCount1, 0.0, 0.0]
dx_ds2 = [0.0, 1.0 / elementsCount2, 0.0]
dx_ds3 = [0.0, 0.0, 1.0 / elementsCount3]
zero = [0.0, 0.0, 0.0]
for n3 in range(elementsCount3 + 1):
x[2] = n3 / elementsCount3
for n2 in range(elementsCount2 + 1):
x[1] = n2 / elementsCount2
for n1 in range(elementsCount1 + 1):
x[0] = n1 / elementsCount1
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
dx_ds1)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
dx_ds2)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS3, 1,
dx_ds3)
if useCrossDerivatives:
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS3, 1, zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS2DS3, 1, zero)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1, zero)
nodeIdentifier = nodeIdentifier + 1
# create elements
elementIdentifier = 1
no2 = (elementsCount1 + 1)
no3 = (elementsCount2 + 1) * no2
for e3 in range(elementsCount3):
for e2 in range(elementsCount2):
for e1 in range(elementsCount1):
element = mesh.createElement(elementIdentifier,
elementtemplate)
bni = e3 * no3 + e2 * no2 + e1 + 1
nodeIdentifiers = [
bni, bni + 1, bni + no2, bni + no2 + 1, bni + no3,
bni + no3 + 1, bni + no2 + no3, bni + no2 + no3 + 1
]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
fm.endChange()
return []
def createNodesAndElements(region, x, d1, d2, d3, xFlat, d1Flat, d2Flat,
xOrgan, d1Organ, d2Organ, organCoordinateFieldName,
elementsCountAround, elementsCountAlong,
elementsCountThroughWall, annotationGroupsAround,
annotationGroupsAlong, annotationGroupsThroughWall,
firstNodeIdentifier, firstElementIdentifier,
useCubicHermiteThroughWall, useCrossDerivatives,
closedProximalEnd):
"""
Create nodes and elements for the coordinates and flat coordinates fields.
:param x, d1, d2, d3: coordinates and derivatives of coordinates field.
:param xFlat, d1Flat, d2Flat, d3Flat: coordinates and derivatives of
flat coordinates field.
:param xOrgan, d1Organ, d2Organ, d3Organ, organCoordinateFieldName: coordinates, derivatives and name of organ
coordinates field.
:param elementsCountAround: Number of elements around tube.
:param elementsCountAlong: Number of elements along tube.
:param elementsCountThroughWall: Number of elements through wall.
:param annotationGroupsAround: Annotation groups of elements around.
:param annotationGroupsAlong: Annotation groups of elements along.
:param annotationGroupsThroughWall: Annotation groups of elements through wall.
:param firstNodeIdentifier, firstElementIdentifier: first node and
element identifier to use.
:param useCubicHermiteThroughWall: use linear when false
:param useCrossDerivatives: use cross derivatives when true
:return nodeIdentifier, elementIdentifier, allAnnotationGroups
"""
nodeIdentifier = firstNodeIdentifier
elementIdentifier = firstElementIdentifier
zero = [0.0, 0.0, 0.0]
fm = region.getFieldmodule()
fm.beginChange()
cache = fm.createFieldcache()
# Coordinates field
coordinates = findOrCreateFieldCoordinates(fm)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS2, 1)
if useCubicHermiteThroughWall:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3, 1)
if useCrossDerivatives:
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS1DS3,
1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D2_DS2DS3,
1)
nodetemplate.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D3_DS1DS2DS3, 1)
mesh = fm.findMeshByDimension(3)
if useCubicHermiteThroughWall:
eftfactory = eftfactory_tricubichermite(mesh, useCrossDerivatives)
else:
eftfactory = eftfactory_bicubichermitelinear(mesh, useCrossDerivatives)
eft = eftfactory.createEftBasic()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
result = elementtemplate.defineField(coordinates, -1, eft)
if xFlat:
# Flat coordinates field
bicubichermitelinear = eftfactory_bicubichermitelinear(
mesh, useCrossDerivatives)
eftFlat1 = bicubichermitelinear.createEftBasic()
eftFlat2 = bicubichermitelinear.createEftOpenTube()
flatCoordinates = findOrCreateFieldCoordinates(fm,
name="flat coordinates")
flatNodetemplate1 = nodes.createNodetemplate()
flatNodetemplate1.defineField(flatCoordinates)
flatNodetemplate1.setValueNumberOfVersions(flatCoordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
flatNodetemplate1.setValueNumberOfVersions(flatCoordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
flatNodetemplate1.setValueNumberOfVersions(flatCoordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
flatNodetemplate1.setValueNumberOfVersions(
flatCoordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
flatNodetemplate2 = nodes.createNodetemplate()
flatNodetemplate2.defineField(flatCoordinates)
flatNodetemplate2.setValueNumberOfVersions(flatCoordinates, -1,
Node.VALUE_LABEL_VALUE, 2)
flatNodetemplate2.setValueNumberOfVersions(flatCoordinates, -1,
Node.VALUE_LABEL_D_DS1, 2)
flatNodetemplate2.setValueNumberOfVersions(flatCoordinates, -1,
Node.VALUE_LABEL_D_DS2, 2)
if useCrossDerivatives:
flatNodetemplate2.setValueNumberOfVersions(
flatCoordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 2)
flatElementtemplate1 = mesh.createElementtemplate()
flatElementtemplate1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
flatElementtemplate1.defineField(flatCoordinates, -1, eftFlat1)
flatElementtemplate2 = mesh.createElementtemplate()
flatElementtemplate2.setElementShapeType(Element.SHAPE_TYPE_CUBE)
flatElementtemplate2.defineField(flatCoordinates, -1, eftFlat2)
if xOrgan:
# Organ coordinates field
bicubichermitelinear = eftfactory_bicubichermitelinear(
mesh, useCrossDerivatives)
eftOrgan = bicubichermitelinear.createEftBasic()
organCoordinates = findOrCreateFieldCoordinates(
fm, name=organCoordinateFieldName)
organNodetemplate = nodes.createNodetemplate()
organNodetemplate.defineField(organCoordinates)
organNodetemplate.setValueNumberOfVersions(organCoordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
organNodetemplate.setValueNumberOfVersions(organCoordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
organNodetemplate.setValueNumberOfVersions(organCoordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
organNodetemplate.setValueNumberOfVersions(
organCoordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
organElementtemplate = mesh.createElementtemplate()
organElementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
organElementtemplate.defineField(organCoordinates, -1, eftOrgan)
# Create nodes
# Coordinates field
for n in range(len(x)):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
x[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
d1[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
d2[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1,
d3[n])
if useCrossDerivatives:
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS1DS3, 1, zero)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS2DS3, 1, zero)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D3_DS1DS2DS3, 1,
zero)
# print('NodeIdentifier = ', nodeIdentifier, x[n], d1[n], d2[n])
nodeIdentifier = nodeIdentifier + 1
# Flat coordinates field
if xFlat:
nodeIdentifier = firstNodeIdentifier
for n2 in range(elementsCountAlong + 1):
for n3 in range(elementsCountThroughWall + 1):
for n1 in range(elementsCountAround):
i = n2 * (elementsCountAround +
1) * (elementsCountThroughWall +
1) + (elementsCountAround + 1) * n3 + n1
node = nodes.findNodeByIdentifier(nodeIdentifier)
node.merge(flatNodetemplate2 if n1 ==
0 else flatNodetemplate1)
cache.setNode(node)
# print('NodeIdentifier', nodeIdentifier, 'version 1, xList Index =', i+1)
flatCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE,
1, xFlat[i])
flatCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1,
1, d1Flat[i])
flatCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2,
1, d2Flat[i])
if useCrossDerivatives:
flatCoordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 1, zero)
if n1 == 0:
# print('NodeIdentifier', nodeIdentifier, 'version 2, xList Index =', i+elementsCountAround+1)
flatCoordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_VALUE, 2,
xFlat[i + elementsCountAround])
flatCoordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS1, 2,
d1Flat[i + elementsCountAround])
flatCoordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS2, 2,
d2Flat[i + elementsCountAround])
if useCrossDerivatives:
flatCoordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D2_DS1DS2, 2, zero)
nodeIdentifier = nodeIdentifier + 1
# Organ coordinates field
if xOrgan:
nodeIdentifier = firstNodeIdentifier
for n in range(len(xOrgan)):
node = nodes.findNodeByIdentifier(nodeIdentifier)
node.merge(organNodetemplate)
cache.setNode(node)
organCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
xOrgan[n])
organCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
d1Organ[n])
organCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
d2Organ[n])
if useCrossDerivatives:
organCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D2_DS1DS2,
1, zero)
nodeIdentifier = nodeIdentifier + 1
# create elements
elementtemplate3 = mesh.createElementtemplate()
elementtemplate3.setElementShapeType(Element.SHAPE_TYPE_CUBE)
radiansPerElementAround = math.pi * 2.0 / elementsCountAround
allAnnotationGroups = []
if closedProximalEnd:
# Create apex
for e3 in range(elementsCountThroughWall):
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eft1 = eftfactory.createEftShellPoleBottom(va * 100, vb * 100)
elementtemplate3.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier,
elementtemplate3)
bni1 = e3 + 1
bni2 = elementsCountThroughWall + 1 + elementsCountAround * e3 + e1 + 1
bni3 = elementsCountThroughWall + 1 + elementsCountAround * e3 + (
e1 + 1) % elementsCountAround + 1
nodeIdentifiers = [
bni1, bni2, bni3, bni1 + 1, bni2 + elementsCountAround,
bni3 + elementsCountAround
]
element.setNodesByIdentifier(eft1, nodeIdentifiers)
# set general linear map coefficients
radiansAround = e1 * radiansPerElementAround
radiansAroundNext = (
(e1 + 1) % elementsCountAround) * radiansPerElementAround
scalefactors = [
-1.0,
math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround,
math.sin(radiansAround),
math.cos(radiansAround), radiansPerElementAround,
math.sin(radiansAroundNext),
math.cos(radiansAroundNext), radiansPerElementAround
]
result = element.setScaleFactors(eft1, scalefactors)
elementIdentifier = elementIdentifier + 1
annotationGroups = annotationGroupsAround[e1] + annotationGroupsAlong[0] + \
annotationGroupsThroughWall[e3]
if annotationGroups:
allAnnotationGroups = mergeAnnotationGroups(
allAnnotationGroups, annotationGroups)
for annotationGroup in annotationGroups:
meshGroup = annotationGroup.getMeshGroup(mesh)
meshGroup.addElement(element)
# Create regular elements
now = elementsCountAround * (elementsCountThroughWall + 1)
for e2 in range(1 if closedProximalEnd else 0, elementsCountAlong):
for e3 in range(elementsCountThroughWall):
for e1 in range(elementsCountAround):
if closedProximalEnd:
bni11 = (e2 -
1) * now + e3 * elementsCountAround + e1 + 1 + (
elementsCountThroughWall + 1)
bni12 = (e2-1) * now + e3 * elementsCountAround + (e1 + 1) % elementsCountAround + 1 + \
(elementsCountThroughWall + 1)
bni21 = (e2 - 1) * now + (
e3 + 1) * elementsCountAround + e1 + 1 + (
elementsCountThroughWall + 1)
bni22 = (e2-1) * now + (e3 + 1) * elementsCountAround + (e1 + 1) % elementsCountAround + 1 + \
(elementsCountThroughWall + 1)
else:
bni11 = e2 * now + e3 * elementsCountAround + e1 + 1
bni12 = e2 * now + e3 * elementsCountAround + (
e1 + 1) % elementsCountAround + 1
bni21 = e2 * now + (e3 + 1) * elementsCountAround + e1 + 1
bni22 = e2 * now + (e3 + 1) * elementsCountAround + (
e1 + 1) % elementsCountAround + 1
nodeIdentifiers = [
bni11, bni12, bni11 + now, bni12 + now, bni21, bni22,
bni21 + now, bni22 + now
]
onOpening = e1 > elementsCountAround - 2
element = mesh.createElement(elementIdentifier,
elementtemplate)
element.setNodesByIdentifier(eft, nodeIdentifiers)
if xFlat:
element.merge(flatElementtemplate2
if onOpening else flatElementtemplate1)
element.setNodesByIdentifier(
eftFlat2 if onOpening else eftFlat1, nodeIdentifiers)
if xOrgan:
element.merge(organElementtemplate)
element.setNodesByIdentifier(eftOrgan, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
annotationGroups = annotationGroupsAround[e1] + annotationGroupsAlong[e2] + \
annotationGroupsThroughWall[e3]
if annotationGroups:
allAnnotationGroups = mergeAnnotationGroups(
allAnnotationGroups, annotationGroups)
for annotationGroup in annotationGroups:
meshGroup = annotationGroup.getMeshGroup(mesh)
meshGroup.addElement(element)
fm.endChange()
return nodeIdentifier, elementIdentifier, allAnnotationGroups