def interpolateNodesCubicHermite(cache, coordinates, xi, normal_scale, \
node1, derivative1, scale1, cross_derivative1, cross_scale1, \
node2, derivative2, scale2, cross_derivative2, cross_scale2):
"""
Interpolates position and first derivative with cubic Hermite basis.
Interpolates cross derivative linearly.
:param cache: Field cache to evaluate in.
:param coordinates: Coordinates field.
:param xi: Element coordinate to interpolate at.
:param normal_scale: Magnitude of normal derivative to return.
:param node1, node2: Start and end nodes.
:param derivative1, derivative2: Node value label for derivatives.
:param scale1, scale2: Real value scaling derivatives, to reverse if needed.
:param cross_derivative1, cross_derivative2: Node value label for cross derivatives.
:param cross_scale1, cross_scale2: Real value scaling cross_derivatives, to reverse if needed.
:return: x, dx_ds, dx_ds_cross, dx_ds_normal
"""
cache.setNode(node1)
result, v1 = coordinates.getNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, 3)
result, d1 = coordinates.getNodeParameters(cache, -1, derivative1, 1, 3)
result, d1c = coordinates.getNodeParameters(cache, -1, cross_derivative1,
1, 3)
d1 = [scale1 * d for d in d1]
d1c = [cross_scale1 * d for d in d1c]
cache.setNode(node2)
result, v2 = coordinates.getNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1, 3)
result, d2 = coordinates.getNodeParameters(cache, -1, derivative2, 1, 3)
result, d2c = coordinates.getNodeParameters(cache, -1, cross_derivative2,
1, 3)
d2 = [scale2 * d for d in d2]
d2c = [cross_scale2 * d for d in d2c]
arcLength = interp.computeCubicHermiteArcLength(v1, d1, v2, d2, True)
mag = arcLength / vector.magnitude(d1)
d1 = [mag * d for d in d1]
mag = arcLength / vector.magnitude(d2)
d2 = [mag * d for d in d2]
xr = 1.0 - xi
x = interp.interpolateCubicHermite(v1, d1, v2, d2, xi)
dx_ds = interp.interpolateCubicHermiteDerivative(v1, d1, v2, d2, xi)
scale = min(xi, xr)
dx_ds = [scale * d for d in dx_ds]
dx_ds_cross = [(xr * d1c[c] + xi * d2c[c]) for c in range(3)]
radialVector = vector.normalise(vector.crossproduct3(dx_ds_cross, dx_ds))
dx_ds_normal = [normal_scale * d for d in radialVector]
return x, dx_ds, dx_ds_cross, dx_ds_normal
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: annotationGroups
"""
centralPath = options['Central path']
elementsCountAround = options['Number of elements around']
elementsCountAlong = options['Number of elements along']
elementsCountThroughWall = options['Number of elements through wall']
wallThickness = options['Wall thickness']
mucosaRelThickness = options['Mucosa relative thickness']
submucosaRelThickness = options['Submucosa relative thickness']
circularRelThickness = options[
'Circular muscle layer relative thickness']
longitudinalRelThickness = options[
'Longitudinal muscle layer relative thickness']
useCrossDerivatives = options['Use cross derivatives']
useCubicHermiteThroughWall = not (options['Use linear through wall'])
firstNodeIdentifier = 1
firstElementIdentifier = 1
# Central path
esophagusTermsAlong = [
None, 'cervical part of esophagus', 'thoracic part of esophagus',
'abdominal part of esophagus'
]
arcLengthOfGroupsAlong = []
for i in range(len(esophagusTermsAlong)):
tmpRegion = region.createRegion()
centralPath.generate(tmpRegion)
cxGroup, cd1Group, cd2Group, cd3Group, cd12Group, cd13Group = \
extractPathParametersFromRegion(tmpRegion, [Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1,
Node.VALUE_LABEL_D_DS2, Node.VALUE_LABEL_D_DS3,
Node.VALUE_LABEL_D2_DS1DS2, Node.VALUE_LABEL_D2_DS1DS3],
groupName=esophagusTermsAlong[i])
arcLength = 0.0
for e in range(len(cxGroup) - 1):
arcLength += interp.getCubicHermiteArcLength(
cxGroup[e], cd1Group[e], cxGroup[e + 1], cd1Group[e + 1])
arcLengthOfGroupsAlong.append(arcLength)
if i == 0:
cx = cxGroup
cd1 = cd1Group
cd2 = cd2Group
cd3 = cd3Group
cd12 = cd12Group
cd13 = cd13Group
del tmpRegion
# Sample central path
sx, sd1, se, sxi, ssf = interp.sampleCubicHermiteCurves(
cx, cd1, elementsCountAlong)
sd2, sd12 = interp.interpolateSampleCubicHermite(
cd2, cd12, se, sxi, ssf)
sd3, sd13 = interp.interpolateSampleCubicHermite(
cd3, cd13, se, sxi, ssf)
centralPathLength = arcLengthOfGroupsAlong[0]
elementAlongLength = centralPathLength / elementsCountAlong
elementsCountAlongGroups = []
groupLength = 0.0
e = 0
elementsCount = 1
length = elementAlongLength
for i in range(1, len(esophagusTermsAlong)):
groupLength += arcLengthOfGroupsAlong[i]
if e == elementsCountAlong - 2:
elementsCount += 1
elementsCountAlongGroups.append(elementsCount)
else:
while length < groupLength:
elementsCount += 1
e += 1
length += elementAlongLength
# check which end is grouplength closer to
distToUpperEnd = abs(length - groupLength)
distToLowerEnd = abs(groupLength -
(length - elementsCountAlong))
if distToLowerEnd < distToUpperEnd:
elementsCount -= 1
elementsCountAlongGroups.append(elementsCount)
e -= 1
length -= elementAlongLength
else:
elementsCountAlongGroups.append(elementsCount)
elementsCount = 0
majorRadiusElementList = sd2
minorRadiusElementList = sd3
# Create annotation groups along esophagus
esophagusGroup = AnnotationGroup(region,
get_esophagus_term("esophagus"))
cervicalGroup = AnnotationGroup(
region, get_esophagus_term("cervical part of esophagus"))
thoracicGroup = AnnotationGroup(
region, get_esophagus_term("thoracic part of esophagus"))
abdominalGroup = AnnotationGroup(
region, get_esophagus_term("abdominal part of esophagus"))
annotationGroupAlong = [[esophagusGroup, cervicalGroup],
[esophagusGroup, thoracicGroup],
[esophagusGroup, abdominalGroup]]
annotationGroupsAlong = []
for i in range(len(elementsCountAlongGroups)):
elementsCount = elementsCountAlongGroups[i]
for n in range(elementsCount):
annotationGroupsAlong.append(annotationGroupAlong[i])
annotationGroupsAround = []
for i in range(elementsCountAround):
annotationGroupsAround.append([])
# Groups through wall
longitudinalMuscleGroup = AnnotationGroup(
region,
get_esophagus_term("esophagus smooth muscle longitudinal layer"))
circularMuscleGroup = AnnotationGroup(
region,
get_esophagus_term("esophagus smooth muscle circular layer"))
submucosaGroup = AnnotationGroup(
region, get_esophagus_term("submucosa of esophagus"))
mucosaGroup = AnnotationGroup(region,
get_esophagus_term("esophagus mucosa"))
if elementsCountThroughWall == 1:
relativeThicknessList = [1.0]
annotationGroupsThroughWall = [[]]
else:
relativeThicknessList = [
mucosaRelThickness, submucosaRelThickness,
circularRelThickness, longitudinalRelThickness
]
annotationGroupsThroughWall = [[mucosaGroup], [submucosaGroup],
[circularMuscleGroup],
[longitudinalMuscleGroup]]
xToSample = []
d1ToSample = []
for n2 in range(elementsCountAlong + 1):
# Create inner points
cx = [0.0, 0.0, elementAlongLength * n2]
axis1 = [vector.magnitude(majorRadiusElementList[n2]), 0.0, 0.0]
axis2 = [0.0, vector.magnitude(minorRadiusElementList[n2]), 0.0]
xInner, d1Inner = geometry.createEllipsePoints(cx,
2 * math.pi,
axis1,
axis2,
elementsCountAround,
startRadians=0.0)
xToSample += xInner
d1ToSample += d1Inner
d2ToSample = [[0.0, 0.0, elementAlongLength]
] * (elementsCountAround * (elementsCountAlong + 1))
# Sample along length
xInnerRaw = []
d2InnerRaw = []
xToWarp = []
d1ToWarp = []
d2ToWarp = []
flatWidthList = []
xiList = []
for n1 in range(elementsCountAround):
xForSamplingAlong = []
d2ForSamplingAlong = []
for n2 in range(elementsCountAlong + 1):
idx = n2 * elementsCountAround + n1
xForSamplingAlong.append(xToSample[idx])
d2ForSamplingAlong.append(d2ToSample[idx])
xSampled, d2Sampled = interp.sampleCubicHermiteCurves(
xForSamplingAlong,
d2ForSamplingAlong,
elementsCountAlong,
arcLengthDerivatives=True)[0:2]
xInnerRaw.append(xSampled)
d2InnerRaw.append(d2Sampled)
# Re-arrange sample order & calculate dx_ds1 and dx_ds3 from dx_ds2
for n2 in range(elementsCountAlong + 1):
xAround = []
d2Around = []
for n1 in range(elementsCountAround):
x = xInnerRaw[n1][n2]
d2 = d2InnerRaw[n1][n2]
xAround.append(x)
d2Around.append(d2)
d1Around = []
for n1 in range(elementsCountAround):
v1 = xAround[n1]
v2 = xAround[(n1 + 1) % elementsCountAround]
d1 = d2 = [v2[c] - v1[c] for c in range(3)]
arcLengthAround = interp.computeCubicHermiteArcLength(
v1, d1, v2, d2, True)
dx_ds1 = [c * arcLengthAround for c in vector.normalise(d1)]
d1Around.append(dx_ds1)
d1Smoothed = interp.smoothCubicHermiteDerivativesLoop(
xAround, d1Around)
xToWarp += xAround
d1ToWarp += d1Smoothed
d2ToWarp += d2Around
# Flat width and xi
flatWidth = 0.0
xiFace = []
for n1 in range(elementsCountAround):
v1 = xAround[n1]
d1 = d1Smoothed[n1]
v2 = xAround[(n1 + 1) % elementsCountAround]
d2 = d1Smoothed[(n1 + 1) % elementsCountAround]
flatWidth += interp.getCubicHermiteArcLength(v1, d1, v2, d2)
flatWidthList.append(flatWidth)
for n1 in range(elementsCountAround + 1):
xi = 1.0 / elementsCountAround * n1
xiFace.append(xi)
xiList.append(xiFace)
# Project reference point for warping onto central path
sxRefList, sd1RefList, sd2ProjectedListRef, zRefList = \
tubemesh.getPlaneProjectionOnCentralPath(xToWarp, elementsCountAround, elementsCountAlong,
centralPathLength, sx, sd1, sd2, sd12)
# Warp points
segmentAxis = [0.0, 0.0, 1.0]
closedProximalEnd = False
innerRadiusAlong = []
for n2 in range(elementsCountAlong + 1):
firstNodeAlong = xToWarp[n2 * elementsCountAround]
midptSegmentAxis = [0.0, 0.0, elementAlongLength * n2]
radius = vector.magnitude(firstNodeAlong[c] - midptSegmentAxis[c]
for c in range(3))
innerRadiusAlong.append(radius)
xWarpedList, d1WarpedList, d2WarpedList, d3WarpedUnitList = \
tubemesh.warpSegmentPoints(xToWarp, d1ToWarp, d2ToWarp, segmentAxis, sxRefList, sd1RefList,
sd2ProjectedListRef, elementsCountAround, elementsCountAlong,
zRefList, innerRadiusAlong, closedProximalEnd)
# Create coordinates and derivatives
transitElementList = [0] * elementsCountAround
xList, d1List, d2List, d3List, curvatureList = \
tubemesh.getCoordinatesFromInner(xWarpedList, d1WarpedList, d2WarpedList, d3WarpedUnitList,
[wallThickness]*(elementsCountAlong+1), relativeThicknessList,
elementsCountAround, elementsCountAlong, elementsCountThroughWall,
transitElementList)
# Create flat coordinates
xFlat, d1Flat, d2Flat = tubemesh.createFlatCoordinates(
xiList, flatWidthList, length, wallThickness,
relativeThicknessList, elementsCountAround, elementsCountAlong,
elementsCountThroughWall, transitElementList)
# Create nodes and elements
xOrgan = []
d1Organ = []
d2Organ = []
nodeIdentifier, elementIdentifier, annotationGroups = \
tubemesh.createNodesAndElements(region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat,
xOrgan, d1Organ, d2Organ, None, elementsCountAround, elementsCountAlong,
elementsCountThroughWall, annotationGroupsAround, annotationGroupsAlong,
annotationGroupsThroughWall, firstNodeIdentifier, firstElementIdentifier,
useCubicHermiteThroughWall, useCrossDerivatives, closedProximalEnd)
# annotation fiducial points
fm = region.getFieldmodule()
fm.beginChange()
mesh = fm.findMeshByDimension(3)
cache = fm.createFieldcache()
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)
markerNames = [
"proximodorsal midpoint on serosa of upper esophageal sphincter",
"proximoventral midpoint on serosa of upper esophageal sphincter",
"distal point of lower esophageal sphincter serosa on the greater curvature of stomach",
"distal point of lower esophageal sphincter serosa on the lesser curvature of stomach"
]
totalElements = elementIdentifier
radPerElementAround = math.pi * 2.0 / elementsCountAround
elementAroundHalfPi = int(0.25 * elementsCountAround)
xi1HalfPi = (math.pi * 0.5 - radPerElementAround *
elementAroundHalfPi) / radPerElementAround
elementAroundPi = int(0.5 * elementsCountAround)
xi1Pi = (math.pi -
radPerElementAround * elementAroundPi) / radPerElementAround
markerElementIdentifiers = [
elementsCountAround * elementsCountThroughWall -
elementAroundHalfPi, elementAroundHalfPi + 1 +
elementsCountAround * (elementsCountThroughWall - 1),
totalElements - elementsCountAround,
totalElements - elementsCountAround + elementAroundPi
]
markerXis = [[1.0 - xi1HalfPi, 0.0, 1.0], [xi1HalfPi, 0.0, 1.0],
[0.0, 1.0, 1.0], [xi1Pi, 1.0, 1.0]]
for n in range(len(markerNames)):
markerGroup = findOrCreateAnnotationGroupForTerm(
annotationGroups, region, get_esophagus_term(markerNames[n]))
markerElement = mesh.findElementByIdentifier(
markerElementIdentifiers[n])
markerXi = markerXis[n]
cache.setMeshLocation(markerElement, markerXi)
markerPoint = markerPoints.createNode(nodeIdentifier,
markerTemplateInternal)
nodeIdentifier += 1
cache.setNode(markerPoint)
markerName.assignString(cache, markerGroup.getName())
markerLocation.assignMeshLocation(cache, markerElement, markerXi)
for group in [esophagusGroup, markerGroup]:
group.getNodesetGroup(nodes).addNode(markerPoint)
fm.endChange()
return annotationGroups
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
"""
elementsCountAround = options['Number of elements around']
elementsCountUp = options['Number of elements up']
elementsCountRadial = options['Number of elements radial']
useCrossDerivatives = options['Use cross derivatives']
radius = 0.5 * options['Diameter']
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)
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)
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
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]
dx_ds3 = [0.0, 0.0, 0.0]
zero = [0.0, 0.0, 0.0]
cubicArcLengthList = [0.0] * (elementsCountUp + 1)
# Pre-calculate cubicArcLength along elementsCountUp
for n2 in range(1, elementsCountUp + 1):
radiansUp = n2 * radiansPerElementUp
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
# Calculate cubic hermite arclength linking point on axis to surface on sphere
v1 = [0.0, 0.0, -radius + n2 * 2.0 * radius / elementsCountUp]
d1 = [0.0, 1.0, 0.0]
v2 = [
radius * math.cos(math.pi / 2.0) * sinRadiansUp,
radius * math.sin(math.pi / 2.0) * sinRadiansUp,
-radius * cosRadiansUp
]
d2 = [
math.cos(math.pi / 2.0) * sinRadiansUp,
math.sin(math.pi / 2.0) * sinRadiansUp, -cosRadiansUp
]
cubicArcLengthList[n2] = interp.computeCubicHermiteArcLength(
v1, d1, v2, d2, True)
# Create node for bottom pole
node = nodes.createNode(nodeIdentifier, nodetemplate)
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,
[radius * radiansPerElementUp, 0.0, 0.0])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
[0.0, radius * radiansPerElementUp, 0.0])
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS3, 1,
[0.0, 0.0, -radius * 2.0 / elementsCountUp])
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 nodes along axis between top and bottom poles
for n2 in range(1, elementsCountUp):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_VALUE, 1,
[0.0, 0.0, -radius + n2 * 2.0 * radius / elementsCountUp])
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS1, 1,
[cubicArcLengthList[n2] / elementsCountRadial, 0.0, 0.0])
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS2, 1,
[0.0, 0.0, radius * 2.0 / elementsCountUp])
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS3, 1,
[0.0, cubicArcLengthList[n2] / elementsCountRadial, 0.0])
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 nodes for top pole
node = nodes.createNode(nodeIdentifier, nodetemplate)
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,
[radius * radiansPerElementUp, 0.0, 0.0])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
[0.0, radius * radiansPerElementUp, 0.0])
coordinates.setNodeParameters(
cache, -1, Node.VALUE_LABEL_D_DS3, 1,
[0.0, 0.0, radius * 2.0 / elementsCountUp])
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 other nodes
for n3 in range(1, elementsCountRadial + 1):
xi = 1 / elementsCountRadial * n3
radiansUpArcOriginList = [0.0] * (elementsCountUp)
# Pre-calculate RC for points on vertical arc running between top and bottom poles
pt = [0.0, radius * xi, 0.0]
arcOrigin = (radius * radius - pt[2] * pt[2] -
pt[1] * pt[1]) / (-2.0 * pt[1])
RC = math.sqrt(arcOrigin * arcOrigin + radius * radius)
radiansUpArcOriginList[0] = math.acos(-radius / RC)
# Identify nodes on the vertical arc using radiansAround = pi/2
for n2 in range(1, elementsCountUp):
radiansUp = n2 * radiansPerElementUp
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
# Calculate node coordinates on arc using cubic hermite interpolation
cubicArcLength = cubicArcLengthList[n2]
v1 = [0.0, 0.0, -radius + n2 * 2.0 * radius / elementsCountUp]
d1 = [math.cos(math.pi / 2.0), math.sin(math.pi / 2.0), 0.0]
d1 = vector.normalise(d1)
d1 = [d * cubicArcLength for d in d1]
v2 = [
radius * math.cos(math.pi / 2.0) * sinRadiansUp,
radius * math.sin(math.pi / 2.0) * sinRadiansUp,
-radius * cosRadiansUp
]
d2 = [
math.cos(math.pi / 2.0) * sinRadiansUp,
math.sin(math.pi / 2.0) * sinRadiansUp, -cosRadiansUp
]
d2 = vector.normalise(d2)
d2 = [d * cubicArcLength for d in d2]
x = interp.interpolateCubicHermite(v1, d1, v2, d2, xi)
# Calculate radiansUp for each point wrt arcOrigin
radiansUpArcOriginList[n2] = math.acos(x[2] / RC)
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)
cubicArcLength = cubicArcLengthList[n2]
# Calculate node coordinates on arc using cubic hermite interpolation
v1 = [
0.0, 0.0, -radius + n2 * 2.0 * radius / elementsCountUp
]
d1 = [cosRadiansAround, sinRadiansAround, 0.0]
d1 = vector.normalise(d1)
d1 = [d * cubicArcLength for d in d1]
v2 = [
radius * cosRadiansAround * sinRadiansUp,
radius * sinRadiansAround * sinRadiansUp,
-radius * cosRadiansUp
]
d2 = [
cosRadiansAround * sinRadiansUp,
sinRadiansAround * sinRadiansUp, -cosRadiansUp
]
d2 = vector.normalise(d2)
d2 = [d * cubicArcLength for d in d2]
x = interp.interpolateCubicHermite(v1, d1, v2, d2, xi)
# For dx_ds1 - Calculate radius wrt origin where interpolated points lie on
orthoRadius = vector.magnitude(x)
orthoRadiansUp = math.pi - math.acos(x[2] / orthoRadius)
sinOrthoRadiansUp = math.sin(orthoRadiansUp)
cosOrthoRadiansUp = math.cos(orthoRadiansUp)
# For dx_ds2 - Assign radiansUp from radiansUpArcOriginList and calculate diff between radiansUp as we move up
radiansUpArcOrigin = radiansUpArcOriginList[n2]
sinRadiansUpArcOrigin = math.sin(radiansUpArcOrigin)
cosRadiansUpArcOrigin = math.cos(radiansUpArcOrigin)
radiansPerElementUpArcOrigin = radiansUpArcOriginList[
n2] - radiansUpArcOriginList[n2 - 1]
dx_ds1 = [
orthoRadius * -sinRadiansAround * sinOrthoRadiansUp *
radiansPerElementAround,
orthoRadius * cosRadiansAround * sinOrthoRadiansUp *
radiansPerElementAround, 0.0
]
dx_ds2 = [
RC * cosRadiansAround * cosRadiansUpArcOrigin *
radiansPerElementUpArcOrigin, RC * sinRadiansAround *
cosRadiansUpArcOrigin * radiansPerElementUpArcOrigin,
-RC * sinRadiansUpArcOrigin *
radiansPerElementUpArcOrigin
]
dx_ds3 = interp.interpolateCubicHermiteDerivative(
v1, d1, v2, d2, xi)
dx_ds3 = vector.normalise(dx_ds3)
dx_ds3 = [
d * cubicArcLength / elementsCountRadial
for d in dx_ds3
]
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
#################
mesh = fm.findMeshByDimension(3)
tricubichermite = eftfactory_tricubichermite(mesh, useCrossDerivatives)
eft = tricubichermite.createEftBasic()
tricubicHermiteBasis = fm.createElementbasis(
3, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
# Regular elements
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementtemplate.defineField(coordinates, -1, eft)
# Bottom tetrahedon elements
elementtemplate1 = mesh.createElementtemplate()
elementtemplate1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
# Axial elements
elementtemplate2 = mesh.createElementtemplate()
elementtemplate2.setElementShapeType(Element.SHAPE_TYPE_CUBE)
# Top tetrahedron elements
elementtemplate3 = mesh.createElementtemplate()
elementtemplate3.setElementShapeType(Element.SHAPE_TYPE_CUBE)
# Bottom pyramid elements
elementtemplate4 = mesh.createElementtemplate()
elementtemplate4.setElementShapeType(Element.SHAPE_TYPE_CUBE)
# Top pyramid elements
elementtemplate5 = mesh.createElementtemplate()
elementtemplate5.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementIdentifier = 1
no2 = elementsCountAround
no3 = elementsCountAround * (elementsCountUp - 1)
rni = (1 + elementsCountUp) - no3 - no2 + 1 # regular node identifier
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
for e3 in range(elementsCountRadial):
# Create elements on bottom pole
radiansIncline = math.pi * 0.5 * e3 / elementsCountRadial
radiansInclineNext = math.pi * 0.5 * (e3 + 1) / elementsCountRadial
if e3 == 0:
# Create tetrahedron elements on the bottom pole
bni1 = elementsCountUp + 2
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eft1 = tricubichermite.createEftTetrahedronBottom(
va * 100, vb * 100, 10000)
elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier,
elementtemplate1)
nodeIdentifiers = [1, 2, bni1 + va, bni1 + vb]
result1 = element.setNodesByIdentifier(
eft1, nodeIdentifiers)
# set general linear map coefficients
radiansAround = va * radiansPerElementAround
radiansAroundNext = vb * radiansPerElementAround
scalefactors = [
-1.0,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext), radiansPerElementAround,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext), radiansPerElementAround,
math.cos(radiansIncline),
math.sin(radiansIncline),
math.cos(radiansInclineNext),
math.sin(radiansInclineNext)
]
result2 = element.setScaleFactors(eft1, scalefactors)
# print('Tetrahedron Bottom element', elementIdentifier, result1, result2, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
else:
# Create pyramid elements on the bottom pole
bni4 = elementsCountUp + 1 + (e3 - 1) * no3 + 1
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eft4 = tricubichermite.createEftPyramidBottom(
va * 100, vb * 100, 100000 + e3 * 2)
elementtemplate4.defineField(coordinates, -1, eft4)
element = mesh.createElement(elementIdentifier,
elementtemplate4)
nodeIdentifiers = [
1, bni4 + va, bni4 + vb, bni4 + no3 + va,
bni4 + no3 + vb
]
result1 = element.setNodesByIdentifier(
eft4, nodeIdentifiers)
# set general linear map coefficients
radiansAround = va * radiansPerElementAround
radiansAroundNext = vb * radiansPerElementAround
scalefactors = [
-1.0,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext), radiansPerElementAround,
math.cos(radiansIncline),
math.sin(radiansIncline),
math.cos(radiansInclineNext),
math.sin(radiansInclineNext)
]
result2 = element.setScaleFactors(eft4, scalefactors)
# print('pyramid bottom element', elementIdentifier, result1, result2, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
# create regular radial elements
for e2 in range(1, elementsCountUp - 1):
if e3 == 0:
for e1 in range(elementsCountAround):
# create central radial elements: 6 node wedges
va = e1
vb = (e1 + 1) % elementsCountAround
eft2 = tricubichermite.createEftWedgeRadial(
va * 100, vb * 100)
elementtemplate2.defineField(coordinates, -1, eft2)
element = mesh.createElement(elementIdentifier,
elementtemplate2)
bni2 = elementsCountUp + 1 + (e2 - 1) * no2 + 1
nodeIdentifiers = [
e3 + e2 + 1, e3 + e2 + 2, bni2 + va, bni2 + vb,
bni2 + va + elementsCountAround,
bni2 + vb + elementsCountAround
]
result1 = element.setNodesByIdentifier(
eft2, nodeIdentifiers)
# set general linear map coefficients
radiansAround = va * radiansPerElementAround
radiansAroundNext = vb * radiansPerElementAround
scalefactors = [
-1.0,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext),
radiansPerElementAround,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext),
radiansPerElementAround
]
result2 = element.setScaleFactors(eft2, scalefactors)
# print('axis element', elementIdentifier, result1, result2, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
else:
# Regular elements
bni = rni + e3 * no3 + e2 * no2
for e1 in range(elementsCountAround):
element = mesh.createElement(elementIdentifier,
elementtemplate)
na = e1
nb = (e1 + 1) % elementsCountAround
nodeIdentifiers = [
bni + na, bni + nb, bni + no2 + na, bni + no2 + nb,
bni + no3 + na, bni + no3 + nb,
bni + no3 + no2 + na, bni + no3 + no2 + nb
]
result = element.setNodesByIdentifier(
eft, nodeIdentifiers)
# print('regular element', elementIdentifier, result, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
# Create elements on top pole
radiansIncline = math.pi * 0.5 * e3 / elementsCountRadial
radiansInclineNext = math.pi * 0.5 * (e3 + 1) / elementsCountRadial
if e3 == 0:
# # Create tetrahedron elements on the top pole
bni3 = elementsCountUp + 1 + (elementsCountUp - 2) * no2 + 1
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eft3 = tricubichermite.createEftTetrahedronTop(
va * 100, vb * 100, 100000)
elementtemplate3.defineField(coordinates, -1, eft3)
element = mesh.createElement(elementIdentifier,
elementtemplate3)
nodeIdentifiers = [
elementsCountUp, elementsCountUp + 1, bni3 + va,
bni3 + vb
]
result1 = element.setNodesByIdentifier(
eft3, nodeIdentifiers)
# set general linear map coefficients
radiansAround = va * radiansPerElementAround
radiansAroundNext = vb * radiansPerElementAround
scalefactors = [
-1.0,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext), radiansPerElementAround,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext), radiansPerElementAround,
math.cos(radiansIncline),
math.sin(radiansIncline),
math.cos(radiansInclineNext),
math.sin(radiansInclineNext)
]
result2 = element.setScaleFactors(eft3, scalefactors)
# print('Tetrahedron top element', elementIdentifier, result1, result2, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
else:
# Create pyramid elements on the top pole
bni5 = elementsCountUp + 1 + (e3 - 1) * no3 + (
elementsCountUp - 2) * no2 + 1
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eft5 = tricubichermite.createEftPyramidTop(
va * 100, vb * 100, 100000 + e3 * 2)
elementtemplate5.defineField(coordinates, -1, eft5)
element = mesh.createElement(elementIdentifier,
elementtemplate5)
nodeIdentifiers = [
bni5 + va, bni5 + vb, elementsCountUp + 1,
bni5 + no3 + va, bni5 + no3 + vb
]
result1 = element.setNodesByIdentifier(
eft5, nodeIdentifiers)
# set general linear map coefficients
radiansAround = va * radiansPerElementAround
radiansAroundNext = vb * radiansPerElementAround
scalefactors = [
-1.0,
math.cos(radiansAround),
math.sin(radiansAround), radiansPerElementAround,
math.cos(radiansAroundNext),
math.sin(radiansAroundNext), radiansPerElementAround,
math.cos(radiansIncline),
math.sin(radiansIncline),
math.cos(radiansInclineNext),
math.sin(radiansInclineNext)
]
result2 = element.setScaleFactors(eft5, scalefactors)
# print('pyramid top element', elementIdentifier, result1, result2, nodeIdentifiers)
elementIdentifier = elementIdentifier + 1
fm.endChange()
return []
def createFlatCoordinates(xiList, lengthAroundList, totalLengthAlong,
wallThickness, relativeThicknessList,
elementsCountAround, elementsCountAlong,
elementsCountThroughWall, transitElementList):
"""
Calculates flat coordinates for a tube when it is opened into a flat preparation.
:param xiList: List containing xi for each point around the outer surface of the tube.
:param lengthAroundList: List of total arclength around the outer surface for each element along.
:param totalLengthAlong: Total length along tube.
:param wallThickness: Thickness of wall.
:param elementsCountAround: Number of elements around tube.
:param elementsCountAlong: Number of elements along tube.
:param elementsCountThroughWall: Number of elements through wall.
:param transitElementList: stores true if element around is a
transition element between a big and small element.
:return: coordinates and derivatives of flat coordinates field.
"""
if relativeThicknessList:
xi3 = 0.0
xi3List = [0.0]
for n3 in range(elementsCountThroughWall):
xi3 += relativeThicknessList[n3]
xi3List.append(xi3)
relativeThicknessList.append(relativeThicknessList[-1])
# Calculate flat coordinates and derivatives
xFlatList = []
d1FlatList = []
d2FlatList = []
for n2 in range(elementsCountAlong + 1):
xiFace = xiList[n2]
lengthAround = lengthAroundList[n2]
d1List = []
for n1 in range(len(xiFace)):
d1 = (xiFace[n1] - xiFace[n1 - 1]) if n1 > 0 else (xiFace[n1 + 1] -
xiFace[n1])
d1List.append(d1)
# To modify derivative along transition elements
for i in range(len(transitElementList)):
if transitElementList[i]:
d1List[i + 1] = d1List[i + 2]
xPad = (lengthAroundList[0] - lengthAround) * 0.5
for n3 in range(elementsCountThroughWall + 1):
z = wallThickness * (xi3List[n3] if relativeThicknessList else
1.0 / elementsCountThroughWall * n3)
for n1 in range(elementsCountAround + 1):
xFlat = [
xPad + xiFace[n1] * lengthAround,
totalLengthAlong / elementsCountAlong * n2, z
]
d1Flat = [d1List[n1] * lengthAround, 0.0, 0.0]
xFlatList.append(xFlat)
d1FlatList.append(d1Flat)
for n2 in range(elementsCountAlong):
for n3 in range(elementsCountThroughWall + 1):
for n1 in range(elementsCountAround + 1):
nodeIdx = n2 * (elementsCountAround +
1) * (elementsCountThroughWall +
1) + n3 * (elementsCountAround + 1) + n1
nodeNextElementAlong = nodeIdx + (elementsCountAround + 1) * (
elementsCountThroughWall + 1)
# print(nodeIdx + 1, nodeNextElementAlong + 1)
v1 = xFlatList[nodeNextElementAlong]
v2 = xFlatList[nodeIdx]
d1 = d2 = [v1[i] - v2[i] for i in range(3)]
arclength = interp.computeCubicHermiteArcLength(
v1, d1, v2, d2, True)
d2Flat = vector.setMagnitude(d1, arclength)
d2FlatList.append(d2Flat)
d2FlatList = d2FlatList + d2FlatList[-(elementsCountAround + 1) *
(elementsCountThroughWall + 1):]
return xFlatList, d1FlatList, d2FlatList
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 = []):
'''
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 nodetemplate: Full tricubic Hermite node template, can omit cross derivatives.
: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 list of Zinc MeshGroup for adding new elements to.
: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'
elementsCountWall = 1
nodesCountWall = elementsCountWall + 1
assert (len(startPointsx) == nodesCountWall) and (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'
fm = mesh.getFieldmodule()
fm.beginChange()
cache = fm.createFieldcache()
coordinates = zinc_utils.getOrCreateCoordinateField(fm)
# Build arrays of points from start to end
px = [ [], [] ]
pd1 = [ [], [] ]
pd2 = [ [], [] ]
pd3 = [ [], [] ]
for n3 in range(2):
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 ]
if elementsCountRadial > 1:
# add in-between points
startPointsd = [ startPointsd1, startPointsd2, startPointsd3 ]
startPointsdslimit = 2 if (startPointsd3 is None) else 3
endPointsd = [ endPointsd1, endPointsd2, endPointsd3 ]
endPointsdslimit = 2 if (endPointsd3 is None) else 3
for n3 in range(2):
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)
# compute on outside / n3 = 1, then map to inside using thickness
thicknesses = []
thicknesses.append([ vector.magnitude([ (startPointsx[1][n1][c] - startPointsx[0][n1][c]) for c in range(3) ]) for n1 in range(nodesCountAround) ])
if maxStartThickness:
for n1 in range(nodesCountAround):
thicknesses[0][n1] = min(thicknesses[0][n1], maxStartThickness)
for n2 in range(1, elementsCountRadial):
thicknesses.append([ None ]*nodesCountAround)
thicknesses.append([ vector.magnitude([ (endPointsx[1][n1][c] - endPointsx[0][n1][c]) for c in range(3) ]) for n1 in range(nodesCountAround) ])
if maxEndThickness:
for n1 in range(nodesCountAround):
thicknesses[-1][n1] = min(thicknesses[-1][n1], maxEndThickness)
n3 == 1
for n1 in range(nodesCountAround):
ax = startPointsx [n3][n1]
if (startDerivativesMap is None) or (startDerivativesMap[n3][n1][0] is None):
ad1 = startPointsd1[n3][n1]
else:
derivativesMap = startDerivativesMap[n3][n1][0]
ad1 = [ 0.0, 0.0, 0.0 ]
for ds in range(startPointsdslimit):
if derivativesMap[ds] != 0.0:
for c in range(3):
ad1[c] += derivativesMap[ds]*startPointsd[ds][n3][n1][c]
if len(startDerivativesMap[n3][n1]) > 3:
# average with d1 map for other side
derivativesMap = startDerivativesMap[n3][n1][3]
ad1 = [ 0.5*d for d in ad1 ]
if not derivativesMap:
for c in range(3):
ad1[c] += 0.5*startPointsd[0][n3][n1][c]
else:
for ds in range(startPointsdslimit):
if derivativesMap[ds] != 0.0:
for c in range(3):
ad1[c] += 0.5*derivativesMap[ds]*startPointsd[ds][n3][n1][c]
if (startDerivativesMap is None) or (startDerivativesMap[n3][n1][1] is None):
ad2 = startPointsd2[n3][n1]
else:
derivativesMap = startDerivativesMap[n3][n1][1]
ad2 = [ 0.0, 0.0, 0.0 ]
for ds in range(startPointsdslimit):
if derivativesMap[ds] != 0.0:
for c in range(3):
ad2[c] += derivativesMap[ds]*startPointsd[ds][n3][n1][c]
bx = endPointsx [n3][n1]
if (endDerivativesMap is None) or (endDerivativesMap[n3][n1][0] is None):
bd1 = endPointsd1[n3][n1]
else:
derivativesMap = endDerivativesMap[n3][n1][0]
bd1 = [ 0.0, 0.0, 0.0 ]
for ds in range(endPointsdslimit):
if derivativesMap[ds] != 0.0:
for c in range(3):
bd1[c] += derivativesMap[ds]*endPointsd[ds][n3][n1][c]
if len(endDerivativesMap[n3][n1]) > 3:
# average with d1 map for other side
derivativesMap = endDerivativesMap[n3][n1][3]
bd1 = [ 0.5*d for d in bd1 ]
if not derivativesMap:
for c in range(3):
bd1[c] += 0.5*endPointsd[0][n3][n1][c]
else:
for ds in range(endPointsdslimit):
if derivativesMap[ds] != 0.0:
for c in range(3):
bd1[c] += 0.5*derivativesMap[ds]*endPointsd[ds][n3][n1][c]
if (endDerivativesMap is None) or (endDerivativesMap[n3][n1][1] is None):
bd2 = endPointsd2[n3][n1]
else:
derivativesMap = endDerivativesMap[n3][n1][1]
bd2 = [ 0.0, 0.0, 0.0 ]
for ds in range(endPointsdslimit):
if derivativesMap[ds] != 0.0:
for c in range(3):
bd2[c] += derivativesMap[ds]*endPointsd[ds][n3][n1][c]
# scaling end derivatives to arc length gives even curvature along the curve
arcLength = interp.computeCubicHermiteArcLength(ax, ad2, bx, bd2, rescaleDerivatives = False)
scaledDerivatives = [ vector.setMagnitude(d2, arcLength) for d2 in [ ad2, bd2 ]]
mx, md2, me, mxi = interp.sampleCubicHermiteCurvesSmooth([ ax, bx ], scaledDerivatives, elementsCountRadial,
derivativeMagnitudeStart = vector.magnitude(ad2),
derivativeMagnitudeEnd = vector.magnitude(bd2))[0:4]
md1 = interp.interpolateSampleLinear([ ad1, bd1 ], me, mxi)
thi = interp.interpolateSampleLinear([ thicknesses[0][n1], thicknesses[-1][n1] ], me, mxi)
#md2 = interp.smoothCubicHermiteDerivativesLine(mx, md2, fixStartDerivative = True, fixEndDerivative = True)
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]
# 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 n1 in range(nodesCountAround):
normal = vector.normalise(vector.crossproduct3(pd1[1][n2][n1], pd2[1][n2][n1]))
thickness = thicknesses[n2][n1]
d3 = [ d*thickness for d in normal ]
px [0][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[0][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[0][n2][n1] = [ factor*d for d in pd2[1][n2][n1] ]
if not midLinearXi3:
pd3[0][n2][n1] = pd3[1][n2][n1] = d3
# smooth derivative 1 around inner loop
pd1[0][n2] = interp.smoothCubicHermiteDerivativesLoop(px[0][n2], pd1[0][n2], magnitudeScalingMode = interp.DerivativeScalingMode.HARMONIC_MEAN)
for n3 in range(0, 1): # was (0, nodesCountWall)
# smooth derivative 2 radially/along annulus
for n1 in range(nodesCountAround):
sd2 = interp.smoothCubicHermiteDerivativesLine(
[ px [n3][n2][n1] for n2 in range(elementsCountRadial + 1) ],
[ pd2[n3][n2][n1] for n2 in range(elementsCountRadial + 1) ],
fixAllDirections = True, fixStartDerivative = True, fixEndDerivative = True,
magnitudeScalingMode = interp.DerivativeScalingMode.HARMONIC_MEAN)
for n2 in range(elementsCountRadial + 1):
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(2):
for n2 in range(elementsCountRadial + 1):
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)
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 is not None)
mapStartLinearDerivativeXi3 = nonlinearXi3 and rowLinearXi3[e2]
mapEndDerivatives = (e2 == (elementsCountRadial - 1)) and (endDerivativesMap is not None)
mapEndLinearDerivativeXi3 = nonlinearXi3 and rowLinearXi3[e2 + 1]
mapDerivatives = mapStartDerivatives or mapStartLinearDerivativeXi3 or mapEndDerivatives or mapEndLinearDerivativeXi3
for e1 in range(elementsCountAround):
en = (e1 + 1)%elementsCountAround
nids = [ nodeId[0][e2][e1], nodeId[0][e2][en], nodeId[0][e2 + 1][e1], nodeId[0][e2 + 1][en],
nodeId[1][e2][e1], nodeId[1][e2][en], nodeId[1][e2 + 1][e1], nodeId[1][e2 + 1][en] ]
if mapDerivatives:
eft1 = eftFactory.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
if mapStartLinearDerivativeXi3:
eftFactory.setEftLinearDerivative(eft1, [ 1, 5 ], Node.VALUE_LABEL_D_DS3, 1, 5, 1)
eftFactory.setEftLinearDerivative(eft1, [ 2, 6 ], Node.VALUE_LABEL_D_DS3, 2, 6, 1)
if mapStartDerivatives:
for i in range(2):
lns = [ 1, 5 ] if (i == 0) else [ 2, 6 ]
for n3 in range(2):
derivativesMap = startDerivativesMap[n3][e1] if (i == 0) else startDerivativesMap[n3][en]
# handle different d1 on each side of node
d1Map = derivativesMap[0] if ((i == 1) or (len(derivativesMap) < 4)) else derivativesMap[3]
d2Map = derivativesMap[1]
d3Map = derivativesMap[2]
# use temporary to safely swap DS1 and DS2:
ln = [ lns[n3] ]
if d1Map is not None:
remapEftNodeValueLabel(eft1, ln, Node.VALUE_LABEL_D_DS1, [ ( Node.VALUE_LABEL_D2_DS1DS2, [] ) ])
if d3Map is not None:
remapEftNodeValueLabel(eft1, ln, Node.VALUE_LABEL_D_DS3, [ ( Node.VALUE_LABEL_D2_DS2DS3, [] ) ])
if d2Map is not None:
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))
if d1Map is not None:
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 is not None:
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.setEftLinearDerivative(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS3, 3, 7, 1)
eftFactory.setEftLinearDerivative(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS3, 4, 8, 1)
if mapEndDerivatives:
for i in range(2):
lns = [ 3, 7 ] if (i == 0) else [ 4, 8 ]
for n3 in range(2):
derivativesMap = endDerivativesMap[n3][e1] if (i == 0) else endDerivativesMap[n3][en]
# handle different d1 on each side of node
d1Map = derivativesMap[0] if ((i == 1) or (len(derivativesMap) < 4)) else derivativesMap[3]
d2Map = derivativesMap[1]
d3Map = derivativesMap[2]
# use temporary to safely swap DS1 and DS2:
ln = [ lns[n3] ]
if d1Map is not None:
remapEftNodeValueLabel(eft1, ln, Node.VALUE_LABEL_D_DS1, [ ( Node.VALUE_LABEL_D2_DS1DS2, [] ) ])
if d3Map is not None:
remapEftNodeValueLabel(eft1, ln, Node.VALUE_LABEL_D_DS3, [ ( Node.VALUE_LABEL_D2_DS2DS3, [] ) ])
if d2Map is not None:
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))
if d1Map is not None:
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 is not None:
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 mapDerivatives:
result3 = element.setScaleFactors(eft1, [ -1.0 ])
#else:
# result3 = '-'
#print('create element annulus', element.isValid(), elementIdentifier, result2, result3, nids)
elementIdentifier += 1
for meshGroup in meshGroups:
meshGroup.addElement(element)
fm.endChange()
return nodeIdentifier, elementIdentifier