def computeCubicHermiteArcLength(v1, d1, v2, d2, rescaleDerivatives):
"""
Compute arc length between v1 and v2, scaling unit d1 and d2.
Iterative; not optimised.
:param d1: Initial derivative at v1.
:param d2: Initial derivative at v2.
:param rescaleDerivatives: If True, rescale initial d1 and d2 to |v2 - v|
:return: Arc length.
"""
if rescaleDerivatives:
lastArcLength = math.sqrt(
sum((v2[i] - v1[i]) * (v2[i] - v1[i]) for i in range(len(v1))))
else:
lastArcLength = getCubicHermiteArcLength(v1, d1, v2, d2)
d1 = vector.normalise(d1)
d2 = vector.normalise(d2)
tol = 1.0E-6
for iters in range(100):
#print('iter',iters,'=',lastArcLength)
d1s = [lastArcLength * d for d in d1]
d2s = [lastArcLength * d for d in d2]
arcLength = getCubicHermiteArcLength(v1, d1s, v2, d2s)
if iters > 9:
arcLength = 0.8 * arcLength + 0.2 * lastArcLength
if math.fabs(arcLength - lastArcLength) < tol * arcLength:
#print('computeCubicHermiteArcLength converged at iter',iters,'=',arcLength,', closeness', math.fabs(arcLength - lastArcLength))
return arcLength
lastArcLength = arcLength
print('computeCubicHermiteArcLength: Max iters reached:', iters, '=',
arcLength, ', closeness', math.fabs(arcLength - lastArcLength))
return arcLength
def createEllipsoidPoints(centre, poleAxis, sideAxis, elementsCountAround,
elementsCountUp, height):
'''
Generate a set of points and derivatives for circle of revolution of an ellipse
starting at pole poleAxis from centre.
:param centre: Centre of full ellipsoid.
:param poleAxis: Vector in direction of starting pole, magnitude is ellipse axis length.
:param sideAxis: Vector normal to poleAxis, magnitude is ellipse side axis length.
:param height: Height of arc of ellipsoid from starting pole along poleAxis.
:return: Lists nx, nd1, nd2. Ordered fastest around, starting at pole. Suitable for passing to TrackSurface.
'''
nx = []
nd1 = []
nd2 = []
magPoleAxis = vector.magnitude(poleAxis)
magSideAxis = vector.magnitude(sideAxis)
unitPoleAxis = vector.normalise(poleAxis)
unitSideAxis1 = vector.normalise(sideAxis)
unitSideAxis2 = vector.normalise(vector.crossproduct3(sideAxis, poleAxis))
useHeight = min(max(0.0, height), 2.0 * magPoleAxis)
totalRadiansUp = getEllipseRadiansToX(magPoleAxis,
0.0,
magPoleAxis - useHeight,
initialTheta=0.5 * math.pi *
useHeight / magPoleAxis)
radiansUp = 0.0
lengthUp = getEllipseArcLength(magPoleAxis, magSideAxis, radiansUp,
totalRadiansUp)
elementLengthUp = lengthUp / elementsCountUp
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
for n2 in range(elementsCountUp + 1):
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
radius = sinRadiansUp * magSideAxis
d2r, d2z = vector.setMagnitude(
[cosRadiansUp * magSideAxis, sinRadiansUp * magPoleAxis],
elementLengthUp)
cx = [(centre[c] + cosRadiansUp * poleAxis[c]) for c in range(3)]
elementLengthAround = radius * radiansPerElementAround
radiansAround = 0.0
for n in range(elementsCountAround):
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
nx.append([(cx[c] + radius * (cosRadiansAround * unitSideAxis1[c] +
sinRadiansAround * unitSideAxis2[c]))
for c in range(3)])
nd1.append([
(elementLengthAround * (-sinRadiansAround * unitSideAxis1[c] +
cosRadiansAround * unitSideAxis2[c]))
for c in range(3)
])
nd2.append([(d2r * (cosRadiansAround * unitSideAxis1[c] +
sinRadiansAround * unitSideAxis2[c]) -
d2z * unitPoleAxis[c]) for c in range(3)])
radiansAround += radiansPerElementAround
radiansUp = updateEllipseAngleByArcLength(magPoleAxis, magSideAxis,
radiansUp, elementLengthUp)
return nx, nd1, nd2
def getCircleProjectionAxes(ax,
ad1,
ad2,
ad3,
length,
angle1radians,
angle2radians,
angle3radians=None):
'''
Project coordinates and orthogonal unit axes ax, ad1, ad2, ad3 by length in
direction of ad3, rotated towards ad1 by angle1radians and ad2 by
angle2radians such that it conforms to a circular arc of the given length,
tangential to ad3 at the start and the final bd3 at the end.
All vectors must be length 3.
Assumes angles 1 and 2 are not large e.g. less than 90 degrees.
Note: not robust for all inputs.
:param angle3radians: Optional final rotation of projection axes about bd3.
:return: Final coordinates and orthogonal unit axes: bx, bd1, bd2, bd3
'''
if (math.fabs(angle1radians) < 0.000001) and (math.fabs(angle2radians) <
0.000001):
bx = [(ax[c] + length * ad3[c]) for c in range(3)]
bd1 = copy.deepcopy(ad1)
bd2 = copy.deepcopy(ad2)
bd3 = copy.deepcopy(ad3)
else:
cosAngle1 = math.cos(angle1radians)
sinAngle1 = math.sin(angle1radians)
cosAngle2 = math.cos(angle2radians)
sinAngle2 = math.sin(angle2radians)
f1 = sinAngle1 * cosAngle2
f2 = cosAngle1 * sinAngle2
f3 = cosAngle1 * cosAngle2
angleAroundRadians = math.atan2(f2, f1)
fh = math.sqrt(f1 * f1 + f2 * f2)
arcAngleRadians = 0.5 * math.pi - math.atan2(f3, fh)
arcRadius = length / arcAngleRadians
br = arcRadius * (1.0 - math.cos(arcAngleRadians))
w1 = br * math.cos(angleAroundRadians) # f1/fh
w2 = br * math.sin(angleAroundRadians) # f2/fh
w3 = arcRadius * math.sin(arcAngleRadians)
bx = [(ax[c] + w1 * ad1[c] + w2 * ad2[c] + w3 * ad3[c])
for c in range(3)]
bd3 = vector.normalise([(f1 * ad1[c] + f2 * ad2[c] + f3 * ad3[c])
for c in range(3)])
bd1 = vector.normalise(vector.crossproduct3(ad2, bd3))
bd2 = vector.crossproduct3(bd3, bd1)
if angle3radians:
cosAngle3 = math.cos(angle3radians)
sinAngle3 = math.sin(angle3radians)
bd1, bd2 = [
(cosAngle3 * bd1[c] + sinAngle3 * bd2[c]) for c in range(3)
], [(cosAngle3 * bd2[c] - sinAngle3 * bd1[c]) for c in range(3)]
return bx, bd1, bd2, bd3
def calculate_surface_axes(d1, d2, direction):
'''
:return: Vectors ax1, ax2, ax3: ax1 in-plane in 3-D vector direction,
ax2 in-plane normal to a and ax3 normal to the surface plane.
Vectors all have unit magnitude.
'''
ax3 = vector.normalise(vector.crossproduct3(d1, d2))
delta_xi1, delta_xi2 = calculate_surface_delta_xi(d1, d2, direction)
ax1 = vector.normalise([ delta_xi1*d1[c] + delta_xi2*d2[c] for c in range(3) ])
ax2 = vector.normalise(vector.crossproduct3(ax3, ax1))
return ax1, ax2, ax3
def createEllipsePerimeter(centre, majorAxis, minorAxis, elementsCountAround,
height):
"""
Generate a set of points and derivatives for an ellipse
starting at pole majorAxis from centre.
:param elementsCountAround: Number of elements around.
:param centre: Centre of full ellipse.
:param majorAxis: Vector in direction of starting major radius, magnitude is ellipse major radius.
:param minorAxis: Vector normal to major axis, magnitude is ellipse minor axis length.
:param height: Height of arc of ellipsoid from starting point along majorAxis.
:return: Lists nx, nd1. Ordered fastest around, starting at major radius.
"""
nx = []
nd1 = []
magMajorAxis = vector.magnitude(majorAxis)
magMinorAxis = vector.magnitude(minorAxis)
unitMajorAxis = vector.normalise(majorAxis)
unitMinorAxis = vector.normalise(minorAxis)
useHeight = min(max(0.0, height), 2.0 * magMajorAxis)
totalRadians = math.acos((magMajorAxis - useHeight) / magMajorAxis)
radians = 0.0
arcLengthUp = geometry.getEllipseArcLength(magMajorAxis, magMinorAxis,
radians, totalRadians,
'integrate')
elementsCountUp = elementsCountAround // 2
elementArcLength = arcLengthUp / elementsCountUp
radians = geometry.updateEllipseAngleByArcLength(magMajorAxis,
magMinorAxis,
radians,
-arcLengthUp,
method='Newton')
for n1 in range(2 * elementsCountUp + 1):
cosRadians = math.cos(radians)
sinRadians = math.sin(radians)
nx.append([
(centre[c] + cosRadians * majorAxis[c] + sinRadians * minorAxis[c])
for c in range(3)
])
ndab = vector.setMagnitude(
[-sinRadians * magMajorAxis, cosRadians * magMinorAxis],
elementArcLength)
nd1.append([(ndab[0] * unitMajorAxis[c] + ndab[1] * unitMinorAxis[c])
for c in range(3)])
radians = geometry.updateEllipseAngleByArcLength(magMajorAxis,
magMinorAxis,
radians,
elementArcLength,
method='Newton')
return nx, nd1
def createEllipsePoints(cx,
radian,
axis1,
axis2,
elementsCountAround,
startRadians=0.0):
'''
Create ellipse points centred at cx, from axis1 around through axis2.
Assumes axis1 and axis2 are orthogonal.
:param cx: centre
:param radian: Part of ellipse to be created based on radian (will be 2*math.pi for a complete ellipse).
:param axis1: Vector from cx to inside at zero angle
:param axis2: Vector from cx to inside at 90 degree angle.
:param elementsCountAround: Number of elements around.
:param startRadians: Angle from axis1 to start creating the ellipse.
:return: lists px, pd1
'''
px = []
pd1 = []
magAxis1 = vector.magnitude(axis1)
magAxis2 = vector.magnitude(axis2)
totalEllipsePerimeter = getApproximateEllipsePerimeter(magAxis1, magAxis2)
partOfEllipsePerimeter = radian * totalEllipsePerimeter / (2 * math.pi)
elementLength = partOfEllipsePerimeter / elementsCountAround
if radian != 2 * math.pi:
elementsCountAround = elementsCountAround + 1
unitSideAxis1 = vector.normalise(axis1)
unitSideAxis2 = vector.normalise(axis2)
for n in range(elementsCountAround):
angle = startRadians
arcLength = n * elementLength
newAngle = updateEllipseAngleByArcLength(magAxis1, magAxis2, angle,
arcLength)
cosRadiansAround = math.cos(newAngle)
sinRadiansAround = math.sin(newAngle)
x = [
cx[0] + cosRadiansAround * axis1[0] - sinRadiansAround * axis2[0],
cx[1] + cosRadiansAround * axis1[1] + sinRadiansAround * axis2[1],
cx[2] + cosRadiansAround * axis1[2] + sinRadiansAround * axis2[2]
]
px.append(x)
rd1 = [
magAxis1 * (-sinRadiansAround * unitSideAxis1[c]) + magAxis2 *
(cosRadiansAround * unitSideAxis2[c]) for c in range(3)
]
rd1Norm = vector.normalise(rd1)
pd1.append([elementLength * (rd1Norm[c]) for c in range(3)])
return px, pd1
def projectHermiteCurvesThroughWall(nx, nd1, nd2, n, wallThickness, loop = False):
'''
From Hermite curve nx, nd1 with cross direction nd2, project normal to wall
by wall thickness to get coordinates, d1 affected by curvature etc.
Assumes 3 components.
:param n: Index into nx, nd1, nd2 of where to project.
:param wallThickness: Use positive from in to out, negative from outside to in.
:return: x, d1, d2, d3
'''
maxPointIndex = len(nx) - 1
assert (0 <= n <= maxPointIndex), 'projectHermiteCurvesThroughWall. Invalid index'
unitNormal = vector.normalise(vector.crossproduct3(nd1[n], nd2[n]))
x = [ (nx[n][c] + wallThickness*unitNormal[c]) for c in range(3) ]
# calculate inner d1 from curvature around
curvature = 0.0
count = 0
if loop or (n > 0) and (nx[n - 1]):
curvature += getCubicHermiteCurvature(nx[n - 1], nd1[n - 1], nx[n], nd1[n], unitNormal, 1.0)
count += 1
if loop or (n < maxPointIndex) and (nx[n - maxPointIndex]):
curvature += getCubicHermiteCurvature(nx[n], nd1[n], nx[n - maxPointIndex], nd1[n - maxPointIndex], unitNormal, 0.0)
count += 1
curvature /= count
factor = 1.0 - curvature*wallThickness
d1 = [ factor*c for c in nd1[n] ]
d2 = copy.deepcopy(nd2[n]) # magnitude can't be determined here
d3 = vector.setMagnitude(unitNormal, math.fabs(wallThickness))
return x, d1, d2, d3
def resampleHermiteCurvePointsSmooth(self,
nx,
nd1,
nd2,
nd3,
nProportions,
derivativeMagnitudeStart=None,
derivativeMagnitudeEnd=None):
'''
Call interp.sampleCubicHermiteCurvesSmooth on nx, nd1 and recalculate positions, nd2, nd3 for points.
:return: nx[], nd1[], nd2[], nd3[], nProportions[]
'''
elementsCount = len(nx) - 1
#print(nx, nd1, elementsCount, derivativeMagnitudeStart, derivativeMagnitudeEnd)
nx, nd1 = interp.sampleCubicHermiteCurvesSmooth(
nx, nd1, elementsCount, derivativeMagnitudeStart,
derivativeMagnitudeEnd)[0:2]
mag2 = vector.magnitude(nd2[0])
if mag2 > 0.0:
nd2[0] = vector.setMagnitude(nd2[0], vector.magnitude(nd1[0]))
for n in range(1, elementsCount):
p = self.findNearestPosition(
nx[n], self.createPositionProportion(*nProportions[n]))
nProportions[n] = self.getProportion(p)
_, sd1, sd2 = self.evaluateCoordinates(p, derivatives=True)
_, d2, d3 = calculate_surface_axes(sd1, sd2,
vector.normalise(nd1[n]))
nd2[n] = vector.setMagnitude(d2, vector.magnitude(nd1[n]))
nd3[n] = d3
mag2 = vector.magnitude(nd2[-1])
if mag2 > 0.0:
nd2[-1] = vector.setMagnitude(nd2[-1], vector.magnitude(nd1[-1]))
return nx, nd1, nd2, nd3, nProportions
def getPlaneNormalVector(self):
"""
Get plane normal vector
:return: Unit normal vector.
"""
p = self._plane
return vector.normalise([p[0], p[1], p[2]])
def normalToEllipse(v1, v2):
"""
Find unit normal vector of an ellipse using two vectors in the ellipse. The direction is v1xv2
:param v1: vector 1.
:param v2: vector 2.
:return:
"""
nte = vector.normalise(vector.crossproduct3(v1, v2))
return nte
def computeNextCentre(centre, arcLength, axis):
"""
compute next centre coordinate
:param axis:
:param arcLength: the length to go forward.
:param centre: the start centre.
:return: next centre coordinates.
"""
centre = [
centre[c] + arcLength * vector.normalise(axis)[c] for c in range(3)
]
return centre
def createMirrorCurve(self):
"""
generate coordinates and derivatives for the mirror curve
:return: Coordinates and derivatives for the mirror curve
"""
btx = self.px
btd1 = self.pd1
btd2 = self.pd2
btd3 = self.pd3
n2a = self.elementsCountAcrossShell
rcx = []
tmdx = btx[n2a][self.elementsCountAcrossMinor // 2]
tmdd3 = btd3[n2a][self.elementsCountAcrossMinor // 2]
tmux = [
0.5 * (btx[self.elementsCountUp][0][c] +
btx[self.elementsCountUp][self.elementsCountAcrossMinor][c])
for c in range(3)
]
rcx.append(tmdx)
rcx.append(tmux)
rcd3 = [vector.setMagnitude(tmdd3, -1), vector.setMagnitude(tmdd3, -1)]
rscx, rscd1 = sampleCubicHermiteCurves(rcx,
rcd3,
self.elementsCountUp - n2a,
arcLengthDerivatives=True)[0:2]
# get d2, d3
rscd2 = []
rscd3 = []
for n in range(len(rscx)):
d3 = vector.normalise([
btx[self.elementsCountUp][self.elementsCountAcrossMinor][c] -
btx[self.elementsCountUp][0][c] for c in range(3)
])
d2 = vector.normalise(vector.crossproduct3(d3, rscd1[n]))
rscd2.append(d2)
rscd3.append(d3)
return rscx, rscd1, rscd2, rscd3
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 generateBase1DMesh(self):
"""
Generate nodes around the perimeter of the ellipse.
"""
nx, nd1 = createEllipsePerimeter(self.centre, self.majorAxis,
self.minorAxis,
self.elementsCountAround,
self.majorRadius)
nte = normalToEllipse(self.majorAxis, self.minorAxis)
tbx, tbd1, tbd2, tbd3 = [], [], [], []
for n in range(self.elementsCountAround + 1):
tbx.append(nx[n])
tbd1.append(nd1[n])
tbd2.append(nte)
tbd3.append(vector.normalise(vector.crossproduct3(tbd1[n], nte)))
self.setRimNodes(tbx, tbd1, tbd2, tbd3)
def generateBase1DMesh(self, rx):
"""
Generate nodes around the perimeter of the ellipse.
"""
btx = self.px
btd1 = self.pd1
btd2 = self.pd2
btd3 = self.pd3
ratio = rx / self.elementsCountAcrossShell if self.elementsCountAcrossShell > 0 else 0
majorAxis = [
d * (1 - ratio * (1 - self.coreMajorRadius / self.majorRadius))
for d in self.majorAxis
]
minorAxis = [
d * (1 - ratio * (1 - self.coreMinorRadius / self.minorRadius))
for d in self.minorAxis
]
majorRadius = vector.magnitude(majorAxis)
nx, nd1 = createEllipsePerimeter(self.centre, majorAxis, minorAxis,
self.elementsCountAround, majorRadius)
nte = normalToEllipse(self.majorAxis, self.minorAxis)
tbx, tbd1, tbd2, tbd3 = [], [], [], []
for n in range(self.elementsCountAround + 1):
tbx.append(nx[n])
tbd1.append(nd1[n])
tbd2.append(nte)
tbd3.append(vector.normalise(vector.crossproduct3(tbd1[n], nte)))
for n in range(self.elementsCountAround + 1):
n1, n2 = self.__shield.convertRimIndex(n, rx)
btx[n2][n1] = tbx[n]
btd1[n2][n1] = tbd1[n]
btd2[n2][n1] = tbd2[n]
btd3[n2][n1] = tbd3[n]
def warpSegmentPoints(xList, d1List, d2List, segmentAxis, segmentLength, sx,
sd1, sd2, elementsCountAround, elementsCountAlongSegment,
nSegment, faceMidPointZ):
"""
Warps points in segment to account for bending and twisting
along central path defined by nodes sx and derivatives sd1 and sd2.
:param xList: coordinates of segment points.
:param d1List: derivatives around axis of segment.
:param d2List: derivatives along axis of segment.
:param segmentAxis: axis perpendicular to segment plane.
:param sx: coordinates of points on central path.
:param sd1: derivatives of points along central path.
:param sd2: derivatives representing cross axes.
:param elementsCountAround: Number of elements around segment.
:param elementsCountAlongSegment: Number of elements along segment.
:param nSegment: Segment index along central path.
:param faceMidPointZ: z-coordinate of midpoint for each element
groups along the segment.
:return coordinates and derivatives of warped points.
"""
xWarpedList = []
d1WarpedList = []
d2WarpedList = []
smoothd2WarpedList = []
d3WarpedUnitList = []
for nAlongSegment in range(elementsCountAlongSegment + 1):
n2 = elementsCountAlongSegment * nSegment + nAlongSegment
xElementAlongSegment = xList[elementsCountAround *
nAlongSegment:elementsCountAround *
(nAlongSegment + 1)]
d1ElementAlongSegment = d1List[elementsCountAround *
nAlongSegment:elementsCountAround *
(nAlongSegment + 1)]
d2ElementAlongSegment = d2List[elementsCountAround *
nAlongSegment:elementsCountAround *
(nAlongSegment + 1)]
xMid = [0.0, 0.0, faceMidPointZ[nAlongSegment]]
# Rotate to align segment axis with tangent of central line
unitTangent = vector.normalise(sd1[n2])
cp = vector.crossproduct3(segmentAxis, unitTangent)
dp = vector.dotproduct(segmentAxis, unitTangent)
if vector.magnitude(
cp) > 0.0: # path tangent not parallel to segment axis
axisRot = vector.normalise(cp)
thetaRot = math.acos(vector.dotproduct(segmentAxis, unitTangent))
rotFrame = matrix.getRotationMatrixFromAxisAngle(axisRot, thetaRot)
midRot = [
rotFrame[j][0] * xMid[0] + rotFrame[j][1] * xMid[1] +
rotFrame[j][2] * xMid[2] for j in range(3)
]
else: # path tangent parallel to segment axis (z-axis)
if dp == -1.0: # path tangent opposite direction to segment axis
thetaRot = math.pi
axisRot = [1.0, 0, 0]
rotFrame = matrix.getRotationMatrixFromAxisAngle(
axisRot, thetaRot)
midRot = [
rotFrame[j][0] * xMid[0] + rotFrame[j][1] * xMid[1] +
rotFrame[j][2] * xMid[2] for j in range(3)
]
else: # segment axis in same direction as unit tangent
midRot = xMid
translateMatrix = [sx[n2][j] - midRot[j] for j in range(3)]
for n1 in range(elementsCountAround):
x = xElementAlongSegment[n1]
d1 = d1ElementAlongSegment[n1]
d2 = d2ElementAlongSegment[n1]
if vector.magnitude(
cp) > 0.0: # path tangent not parallel to segment axis
xRot1 = [
rotFrame[j][0] * x[0] + rotFrame[j][1] * x[1] +
rotFrame[j][2] * x[2] for j in range(3)
]
d1Rot1 = [
rotFrame[j][0] * d1[0] + rotFrame[j][1] * d1[1] +
rotFrame[j][2] * d1[2] for j in range(3)
]
d2Rot1 = [
rotFrame[j][0] * d2[0] + rotFrame[j][1] * d2[1] +
rotFrame[j][2] * d2[2] for j in range(3)
]
if n1 == 0:
# Project sd2 onto plane normal to sd1
v = sd2[n2]
pt = [midRot[j] + sd2[n2][j] for j in range(3)]
dist = vector.dotproduct(v, unitTangent)
ptOnPlane = [
pt[j] - dist * unitTangent[j] for j in range(3)
]
newVector = [ptOnPlane[j] - midRot[j] for j in range(3)]
# Rotate first point to align with planar projection of sd2
firstVector = vector.normalise(
[xRot1[j] - midRot[j] for j in range(3)])
thetaRot2 = math.acos(
vector.dotproduct(vector.normalise(newVector),
firstVector))
cp2 = vector.crossproduct3(vector.normalise(newVector),
firstVector)
if vector.magnitude(cp2) > 0.0:
cp2 = vector.normalise(cp2)
signThetaRot2 = vector.dotproduct(unitTangent, cp2)
axisRot2 = unitTangent
rotFrame2 = matrix.getRotationMatrixFromAxisAngle(
axisRot2, -signThetaRot2 * thetaRot2)
else:
rotFrame2 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
else: # path tangent parallel to segment axis
xRot1 = [
rotFrame[j][0] * x[0] + rotFrame[j][1] * x[1] +
rotFrame[j][2] * x[2] for j in range(3)
] if dp == -1.0 else x
d1Rot1 = [
rotFrame[j][0] * d1[0] + rotFrame[j][1] * d1[1] +
rotFrame[j][2] * d1[2] for j in range(3)
] if dp == -1.0 else d1
d2Rot1 = [
rotFrame[j][0] * d2[0] + rotFrame[j][1] * d2[1] +
rotFrame[j][2] * d2[2] for j in range(3)
] if dp == -1.0 else d2
# Rotate to align start of elementsAround with sd2
if n1 == 0:
v = vector.normalise(sd2[n2])
startVector = vector.normalise(
[xRot1[j] - midRot[j] for j in range(3)])
axisRot2 = unitTangent
thetaRot2 = dp * -math.acos(
vector.dotproduct(v, startVector))
rotFrame2 = matrix.getRotationMatrixFromAxisAngle(
axisRot2, thetaRot2)
xRot2 = [
rotFrame2[j][0] * xRot1[0] + rotFrame2[j][1] * xRot1[1] +
rotFrame2[j][2] * xRot1[2] for j in range(3)
]
d1Rot2 = [
rotFrame2[j][0] * d1Rot1[0] + rotFrame2[j][1] * d1Rot1[1] +
rotFrame2[j][2] * d1Rot1[2] for j in range(3)
]
d2Rot2 = [
rotFrame2[j][0] * d2Rot1[0] + rotFrame2[j][1] * d2Rot1[1] +
rotFrame2[j][2] * d2Rot1[2] for j in range(3)
]
xTranslate = [xRot2[j] + translateMatrix[j] for j in range(3)]
xWarpedList.append(xTranslate)
d1WarpedList.append(d1Rot2)
d2WarpedList.append(d2Rot2)
# Smooth d2 for segment
smoothd2Raw = []
for n1 in range(elementsCountAround):
nx = []
nd2 = []
for n2 in range(elementsCountAlongSegment + 1):
n = n2 * elementsCountAround + n1
nx.append(xWarpedList[n])
nd2.append(d2WarpedList[n])
smoothd2 = interp.smoothCubicHermiteDerivativesLine(
nx, nd2, fixStartDerivative=True, fixEndDerivative=True)
smoothd2Raw.append(smoothd2)
# Re-arrange smoothd2
for n2 in range(elementsCountAlongSegment + 1):
for n1 in range(elementsCountAround):
smoothd2WarpedList.append(smoothd2Raw[n1][n2])
# Calculate unit d3
for n in range(len(xWarpedList)):
d3Unit = vector.normalise(
vector.crossproduct3(vector.normalise(d1WarpedList[n]),
vector.normalise(smoothd2WarpedList[n])))
d3WarpedUnitList.append(d3Unit)
return xWarpedList, d1WarpedList, smoothd2WarpedList, d3WarpedUnitList
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 replaceElementWithInlet4(self, element, startElementId, nodetemplate, startNodeId, tubeLength, innerDiameter, wallThickness):
'''
Replace element with 4 element X-layout tube inlet.
Inlet axis is at given length from centre of xi3=0 face, oriented with dx/dxi1.
8 new nodes are created.
'''
fm = self._mesh.getFieldmodule()
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
fm.beginChange()
cache = fm.createFieldcache()
diff1 = self._mesh.getChartDifferentialoperator(1, 1)
diff2 = self._mesh.getChartDifferentialoperator(1, 2)
coordinates = getOrCreateCoordinateField(fm)
cache.setMeshLocation(element, [0.5, 0.5, 1.0])
result, fc = coordinates.evaluateReal(cache, 3)
resulta, a = coordinates.evaluateDerivative(diff1, cache, 3)
resultb, b = coordinates.evaluateDerivative(diff2, cache, 3)
n = vector.normalise(vector.crossproduct3(a, b))
#print(resulta, 'a =', a, ',', resultb, ' b=', b, ' fc=', fc, ' n=',n)
ic = [ (fc[i] + tubeLength*n[i]) for i in range(3) ]
na = vector.normalise(a)
nb = vector.normalise(b)
a = vector.normalise([ -(na[i] + nb[i]) for i in range(3) ])
b = vector.normalise(vector.crossproduct3(a, n))
zero = [ 0.0, 0.0, 0.0 ]
nodeIdentifier = startNodeId
elementsCountAround = 4
radiansPerElementAround = math.pi*2.0/elementsCountAround
for n3 in range(2):
radius = innerDiameter*0.5 + n3*wallThickness
for n1 in range(elementsCountAround):
radiansAround = n1*radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [ (ic[i] + radius*(cosRadiansAround*a[i] + sinRadiansAround*b[i])) for i in range(3) ]
dx_ds1 = [ radiansPerElementAround*radius*(-sinRadiansAround*a[i] + cosRadiansAround*b[i]) for i in range(3) ]
dx_ds2 = [ -tubeLength*c for c in n ]
dx_ds3 = [ wallThickness*(cosRadiansAround*a[i] + sinRadiansAround*b[i]) for i in range(3) ]
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 self._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
eft0 = element.getElementfieldtemplate(coordinates, -1)
nids0 = getElementNodeIdentifiers(element, eft0)
orig_nids = [ nids0[0], nids0[2], nids0[3], nids0[1], nids0[4], nids0[6], nids0[7], nids0[5] ]
elementIdentifier = startElementId
elementtemplate1 = self._mesh.createElementtemplate()
elementtemplate1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
for e in range(4):
eft1 = self.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
if e == 0:
remapEftNodeValueLabel(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, [1]), (Node.VALUE_LABEL_D_DS2, [1]) ])
remapEftNodeValueLabel(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS1, [ (Node.VALUE_LABEL_D_DS2, []) ])
remapEftNodeValueLabel(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, [1]), (Node.VALUE_LABEL_D_DS2, []) ])
remapEftNodeValueLabel(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS1, [ (Node.VALUE_LABEL_D_DS2, []) ])
elif e == 1:
remapEftNodeValueLabel(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, [1]), (Node.VALUE_LABEL_D_DS2, []) ])
remapEftNodeValueLabel(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, []), (Node.VALUE_LABEL_D_DS2, []) ])
elif e == 2:
remapEftNodeValueLabel(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, []), (Node.VALUE_LABEL_D_DS2, []) ])
remapEftNodeValueLabel(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS1, [ (Node.VALUE_LABEL_D_DS2, [1]) ])
remapEftNodeValueLabel(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, []), (Node.VALUE_LABEL_D_DS2, [1]) ])
remapEftNodeValueLabel(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS1, [ (Node.VALUE_LABEL_D_DS2, [1]) ])
elif e == 3:
remapEftNodeValueLabel(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, []), (Node.VALUE_LABEL_D_DS2, [1]) ])
remapEftNodeValueLabel(eft1, [ 3, 7 ], Node.VALUE_LABEL_D_DS1, [ (Node.VALUE_LABEL_D_DS1, [1]) ])
remapEftNodeValueLabel(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS2, [ (Node.VALUE_LABEL_D_DS1, [1]), (Node.VALUE_LABEL_D_DS2, [1]) ])
remapEftNodeValueLabel(eft1, [ 4, 8 ], Node.VALUE_LABEL_D_DS1, [ (Node.VALUE_LABEL_D_DS1, [1]) ])
ea = e
eb = (e + 1) % 4
ec = ea + 4
ed = eb + 4
nids = [
startNodeId + ea, startNodeId + eb, orig_nids[ea], orig_nids[eb],
startNodeId + ec, startNodeId + ed, orig_nids[ec], orig_nids[ed]
]
elementtemplate1.defineField(coordinates, -1, eft1)
element = self._mesh.createElement(elementIdentifier, elementtemplate1)
result2 = element.setNodesByIdentifier(eft1, nids)
if eft1.getNumberOfLocalScaleFactors() == 1:
result3 = element.setScaleFactors(eft1, [ -1.0 ])
else:
result3 = 7
#print('create element in', element.isValid(), elementIdentifier, result2, result3, nids)
elementIdentifier += 1
fm.endChange()
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 getTriplePoints(self, n3):
'''
Compute coordinates and derivatives of points where 3 square elements merge.
:param n3: Index of through-wall coordinates to use.
'''
n1a = self.elementsCountRim
n1b = n1a + 1
n1c = n1a + 2
m1a = self.elementsCountAcross - self.elementsCountRim
m1b = m1a - 1
m1c = m1a - 2
n2a = self.elementsCountRim
n2b = n2a + 1
n2c = n2a + 2
# left
ltx = []
if self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_AROUND:
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][n1c], self.px[n3][n2c][n1b]],
[[(-self.pd1[n3][n2a][n1c][c] - self.pd3[n3][n2a][n1c][c])
for c in range(3)], self.pd1[n3][n2c][n1b]],
2,
arcLengthDerivatives=True)[0:2]
ltx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][n1b], self.px[n3][n2c][n1c]],
[[-self.pd3[n3][n2a][n1b][c] for c in range(3)],
[(self.pd1[n3][n2c][n1c][c] + self.pd3[n3][n2c][n1c][c])
for c in range(3)]],
2,
arcLengthDerivatives=True)[0:2]
ltx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2c][n1a], self.px[n3][n2b][n1c]],
[[(self.pd1[n3][n2c][n1a][c] - self.pd3[n3][n2c][n1a][c])
for c in range(3)], self.pd3[n3][n2b][n1c]],
2,
arcLengthDerivatives=True)[0:2]
ltx.append(tx[1])
elif self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_REGULAR:
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][n1c], self.px[n3][n2c][n1b]],
[[(-self.pd1[n3][n2a][n1c][c] + self.pd2[n3][n2a][n1c][c])
for c in range(3)], self.pd2[n3][n2c][n1b]],
2,
arcLengthDerivatives=True)[0:2]
ltx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][n1b], self.px[n3][n2c][n1c]], [
self.pd2[n3][n2a][n1b],
[(self.pd1[n3][n2c][n1c][c] + self.pd2[n3][n2c][n1c][c])
for c in range(3)]
],
2,
arcLengthDerivatives=True)[0:2]
ltx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2c][n1a], self.px[n3][n2b][n1c]],
[[(self.pd1[n3][n2c][n1a][c] - self.pd2[n3][n2c][n1a][c])
for c in range(3)], self.pd1[n3][n2b][n1c]],
2,
arcLengthDerivatives=True)[0:2]
ltx.append(tx[1])
#x = [ (ltx[0][c] + ltx[1][c] + ltx[2][c])/3.0 for c in range(3) ]
x = [(ltx[0][c] + ltx[2][c]) / 2.0 for c in range(3)]
if self.trackSurface:
p = self.trackSurface.findNearestPosition(
x,
startPosition=self.trackSurface.createPositionProportion(
*(self.pProportions[n2b][n1c])))
self.pProportions[n2b][n1b] = self.trackSurface.getProportion(p)
x, sd1, sd2 = self.trackSurface.evaluateCoordinates(
p, derivatives=True)
d1, d2, d3 = calculate_surface_axes(sd1, sd2,
vector.normalise(sd1))
self.pd3[n3][n2b][n1b] = d3
self.px[n3][n2b][n1b] = x
if self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_AROUND:
self.pd3[n3][n2b][n1b] = [
(self.px[n3][n2b][n1c][c] - self.px[n3][n2b][n1b][c])
for c in range(3)
]
self.pd1[n3][n2b][n1b] = [
(self.px[n3][n2c][n1b][c] - self.px[n3][n2b][n1b][c])
for c in range(3)
]
elif self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_REGULAR:
self.pd1[n3][n2b][n1b] = [
(self.px[n3][n2b][n1c][c] - self.px[n3][n2b][n1b][c])
for c in range(3)
]
self.pd2[n3][n2b][n1b] = [
(self.px[n3][n2c][n1b][c] - self.px[n3][n2b][n1b][c])
for c in range(3)
]
if not self.trackSurface:
if self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_AROUND:
self.pd2[n3][n2b][n1b] = vector.normalise(
vector.crossproduct3(self.pd3[n3][n2b][n1b],
self.pd1[n3][n2b][n1b]))
elif self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_REGULAR:
self.pd3[n3][n2b][n1b] = vector.normalise(
vector.crossproduct3(self.pd1[n3][n2b][n1b],
self.pd2[n3][n2b][n1b]))
# right
rtx = []
if self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_AROUND:
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][m1c], self.px[n3][n2c][m1b]],
[[(self.pd1[n3][n2a][m1c][c] - self.pd3[n3][n2a][m1c][c])
for c in range(3)], self.pd1[n3][n2c][m1b]],
2,
arcLengthDerivatives=True)[0:2]
rtx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][m1b], self.px[n3][n2c][m1c]],
[[-self.pd3[n3][n2a][m1b][c] for c in range(3)],
[(-self.pd3[n3][n2c][m1c][c] + self.pd1[n3][n2c][m1c][c])
for c in range(3)]],
2,
arcLengthDerivatives=True)[0:2]
rtx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2c][m1a], self.px[n3][n2b][m1c]],
[[(-self.pd1[n3][n2c][m1a][c] - self.pd3[n3][n2c][m1a][c])
for c in range(3)], [-d for d in self.pd3[n3][n2b][m1c]]],
2,
arcLengthDerivatives=True)[0:2]
rtx.append(tx[1])
elif self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_REGULAR:
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][m1c], self.px[n3][n2c][m1b]],
[[(self.pd1[n3][n2a][m1c][c] + self.pd2[n3][n2a][m1c][c])
for c in range(3)], self.pd2[n3][n2c][m1b]],
2,
arcLengthDerivatives=True)[0:2]
rtx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2a][m1b], self.px[n3][n2c][m1c]], [
self.pd2[n3][n2a][m1b],
[(-self.pd1[n3][n2c][m1c][c] + self.pd2[n3][n2c][m1c][c])
for c in range(3)]
],
2,
arcLengthDerivatives=True)[0:2]
rtx.append(tx[1])
tx, td1 = sampleCubicHermiteCurves(
[self.px[n3][n2c][m1a], self.px[n3][n2b][m1c]],
[[(-self.pd1[n3][n2c][m1a][c] - self.pd2[n3][n2c][m1a][c])
for c in range(3)], [-d for d in self.pd1[n3][n2b][m1c]]],
2,
arcLengthDerivatives=True)[0:2]
rtx.append(tx[1])
#x = [ (rtx[0][c] + rtx[1][c] + rtx[2][c])/3.0 for c in range(3) ]
x = [(rtx[0][c] + rtx[2][c]) / 2.0 for c in range(3)]
if self.trackSurface:
p = self.trackSurface.findNearestPosition(
x,
startPosition=self.trackSurface.createPositionProportion(
*(self.pProportions[n2b][m1c])))
self.pProportions[n2b][m1b] = self.trackSurface.getProportion(p)
x, sd1, sd2 = self.trackSurface.evaluateCoordinates(
p, derivatives=True)
d1, d2, d3 = calculate_surface_axes(sd1, sd2,
vector.normalise(sd1))
self.pd3[n3][n2b][m1b] = d3
self.px[n3][n2b][m1b] = x
if self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_AROUND:
self.pd3[n3][n2b][m1b] = [
(self.px[n3][n2b][m1b][c] - self.px[n3][n2b][m1c][c])
for c in range(3)
]
self.pd1[n3][n2b][m1b] = [
(self.px[n3][n2c][m1b][c] - self.px[n3][n2b][m1b][c])
for c in range(3)
]
elif self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_REGULAR:
self.pd1[n3][n2b][m1b] = [
(self.px[n3][n2b][m1b][c] - self.px[n3][n2b][m1c][c])
for c in range(3)
]
self.pd2[n3][n2b][m1b] = [
(self.px[n3][n2c][m1b][c] - self.px[n3][n2b][m1b][c])
for c in range(3)
]
if not self.trackSurface:
if self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_AROUND:
self.pd2[n3][n2b][m1b] = vector.normalise(
vector.crossproduct3(self.pd3[n3][n2b][m1b],
self.pd1[n3][n2b][m1b]))
elif self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_REGULAR:
self.pd3[n3][n2b][m1b] = vector.normalise(
vector.crossproduct3(self.pd1[n3][n2b][m1b],
self.pd2[n3][n2b][m1b]))
def createCylinderMesh3d(self, fieldModule, coordinates):
"""
Create an extruded shape (ellipse/circle) mesh. Currently limited to ellipse or circle base with the alongAxis
perpendicular to the base.
:param fieldModule: Zinc fieldModule to create elements in.
:param coordinates: Coordinate field to define.
:return: Final values of nextNodeIdentifier, nextElementIdentifier.
"""
assert (self._elementsCountAlong >
0), 'createCylinderMesh3d: Invalid number of along elements'
assert (self._elementsCountAcrossMinor >
3), 'createCylinderMesh3d: Invalid number of across elements'
assert (self._elementsCountAcrossMinor % 2 == 0), 'createCylinderMesh3d: number of across elements' \
' is not an even number'
assert (self._elementsCountAcrossMajor >
1), 'createCylinderMesh3d: Invalid number of up elements'
assert (self._cylinderShape in [self._cylinderShape.CYLINDER_SHAPE_FULL,
self._cylinderShape.CYLINDER_SHAPE_LOWER_HALF]), \
'createCylinderMesh3d: Invalid cylinder mode.'
nodes = fieldModule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
mesh = fieldModule.findMeshByDimension(3)
elementsCountRim = self._elementsCountAcrossRim
shieldMode = ShieldShape2D.SHIELD_SHAPE_FULL if self._cylinderShape is self._cylinderShape.CYLINDER_SHAPE_FULL \
else ShieldShape2D.SHIELD_SHAPE_LOWER_HALF
ellipseShape = EllipseShape.Ellipse_SHAPE_FULL \
if self._cylinderShape is self._cylinderShape.CYLINDER_SHAPE_FULL else EllipseShape.Ellipse_SHAPE_LOWER_HALF
self._shield = ShieldMesh2D(self._elementsCountAcrossMinor,
self._elementsCountAcrossMajor,
elementsCountRim,
None,
self._elementsCountAlong,
shieldMode,
shieldType=ShieldRimDerivativeMode.
SHIELD_RIM_DERIVATIVE_MODE_AROUND)
# generate ellipses mesh along cylinder axis
n3Count = 0 if self._cylinderType == CylinderType.CYLINDER_STRAIGHT else self._elementsCountAlong
self._ellipses = []
for n3 in range(n3Count + 1):
ellipse = Ellipse2D(self._centres[n3],
self._majorAxis[n3],
self._minorAxis[n3],
self._elementsCountAcrossMajor,
self._elementsCountAcrossMinor,
self._elementsCountAcrossShell,
self._elementsCountAcrossTransition,
self._shellProportion,
self._coreMajorRadii[n3],
self._coreMinorRadii[n3],
ellipseShape=ellipseShape)
self._ellipses.append(ellipse)
self.copyEllipsesNodesToShieldNodes(n3)
for n3 in range(n3Count + 1):
self.calculateD2Derivatives(n3, n3Count)
if self._cylinderType == CylinderType.CYLINDER_TAPERED:
self.smoothd2Derivatives()
# The other ellipses for a straight cylinder.
if self._cylinderType == CylinderType.CYLINDER_STRAIGHT:
arcLengthAlong = vector.magnitude(
self._base._alongAxis) / self._elementsCountAlong
for n2 in range(self._elementsCountUp + 1):
for n3 in range(self._elementsCountAlong + 1):
for n1 in range(self._elementsCountAcrossMinor + 1):
if self._shield.px[0][n2][n1]:
temx = [
self._shield.px[0][n2][n1][c] +
n3 * arcLengthAlong *
vector.normalise(self._base._alongAxis)[c]
for c in range(3)
]
self._shield.px[n3][n2][n1] = temx
self._shield.pd1[n3][n2][n1] = self._shield.pd1[0][
n2][n1]
self._shield.pd2[n3][n2][n1] = self._shield.pd2[0][
n2][n1]
self._shield.pd3[n3][n2][n1] = self._shield.pd3[0][
n2][n1]
self.generateNodes(nodes, fieldModule, coordinates)
self.generateElements(mesh, fieldModule, coordinates)
if self._end is None:
self._end = CylinderEnds(
self._elementsCountAcrossMajor, self._elementsCountAcrossMinor,
self._elementsCountAcrossShell,
self._elementsCountAcrossTransition, self._shellProportion,
self._centres[-1], self._shield.pd2[-1][0][1],
vector.setMagnitude(self._base._majorAxis,
self._majorRadii[-1]),
self._minorRadii[-1])
self.setEndsNodes()
def warpSegmentPoints(xList, d1List, d2List, segmentAxis, sx, sd1, sd2,
elementsCountAround, elementsCountAlongSegment,
refPointZ, innerRadiusAlong, closedProximalEnd):
"""
Warps points in segment to account for bending and twisting
along central path defined by nodes sx and derivatives sd1 and sd2.
:param xList: coordinates of segment points.
:param d1List: derivatives around axis of segment.
:param d2List: derivatives along axis of segment.
:param segmentAxis: axis perpendicular to segment plane.
:param sx: coordinates of points on central path.
:param sd1: derivatives of points along central path.
:param sd2: derivatives representing cross axes.
:param elementsCountAround: Number of elements around segment.
:param elementsCountAlongSegment: Number of elements along segment.
:param refPointZ: z-coordinate of reference point for each element
groups along the segment to be used for transformation.
:param innerRadiusAlong: radius of segment along length.
:param closedProximalEnd: True if proximal end of segment is a closed end.
:return coordinates and derivatives of warped points.
"""
xWarpedList = []
d1WarpedList = []
d2WarpedList = []
d2WarpedListFinal = []
d3WarpedUnitList = []
for nAlongSegment in range(elementsCountAlongSegment + 1):
xElementAlongSegment = xList[elementsCountAround *
nAlongSegment:elementsCountAround *
(nAlongSegment + 1)]
d1ElementAlongSegment = d1List[elementsCountAround *
nAlongSegment:elementsCountAround *
(nAlongSegment + 1)]
d2ElementAlongSegment = d2List[elementsCountAround *
nAlongSegment:elementsCountAround *
(nAlongSegment + 1)]
centroid = [0.0, 0.0, refPointZ[nAlongSegment]]
# Rotate to align segment axis with tangent of central line
unitTangent = vector.normalise(sd1[nAlongSegment])
cp = vector.crossproduct3(segmentAxis, unitTangent)
dp = vector.dotproduct(segmentAxis, unitTangent)
if vector.magnitude(
cp) > 0.0: # path tangent not parallel to segment axis
axisRot = vector.normalise(cp)
thetaRot = math.acos(vector.dotproduct(segmentAxis, unitTangent))
rotFrame = matrix.getRotationMatrixFromAxisAngle(axisRot, thetaRot)
centroidRot = [
rotFrame[j][0] * centroid[0] + rotFrame[j][1] * centroid[1] +
rotFrame[j][2] * centroid[2] for j in range(3)
]
else: # path tangent parallel to segment axis (z-axis)
if dp == -1.0: # path tangent opposite direction to segment axis
thetaRot = math.pi
axisRot = [1.0, 0, 0]
rotFrame = matrix.getRotationMatrixFromAxisAngle(
axisRot, thetaRot)
centroidRot = [
rotFrame[j][0] * centroid[0] +
rotFrame[j][1] * centroid[1] + rotFrame[j][2] * centroid[2]
for j in range(3)
]
else: # segment axis in same direction as unit tangent
rotFrame = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
centroidRot = centroid
translateMatrix = [
sx[nAlongSegment][j] - centroidRot[j] for j in range(3)
]
for n1 in range(elementsCountAround):
x = xElementAlongSegment[n1]
d1 = d1ElementAlongSegment[n1]
d2 = d2ElementAlongSegment[n1]
if vector.magnitude(
cp) > 0.0: # path tangent not parallel to segment axis
xRot1 = [
rotFrame[j][0] * x[0] + rotFrame[j][1] * x[1] +
rotFrame[j][2] * x[2] for j in range(3)
]
d1Rot1 = [
rotFrame[j][0] * d1[0] + rotFrame[j][1] * d1[1] +
rotFrame[j][2] * d1[2] for j in range(3)
]
d2Rot1 = [
rotFrame[j][0] * d2[0] + rotFrame[j][1] * d2[1] +
rotFrame[j][2] * d2[2] for j in range(3)
]
# xTranslate = [xRot1[j] + translateMatrix[j] for j in range(3)]
else: # path tangent parallel to segment axis
xRot1 = [
rotFrame[j][0] * x[0] + rotFrame[j][1] * x[1] +
rotFrame[j][2] * x[2] for j in range(3)
] if dp == -1.0 else x
d1Rot1 = [
rotFrame[j][0] * d1[0] + rotFrame[j][1] * d1[1] +
rotFrame[j][2] * d1[2] for j in range(3)
] if dp == -1.0 else d1
d2Rot1 = [
rotFrame[j][0] * d2[0] + rotFrame[j][1] * d2[1] +
rotFrame[j][2] * d2[2] for j in range(3)
] if dp == -1.0 else d2
# xTranslate = [xRot1[j] + translateMatrix[j] for j in range(3)]
if n1 == 0: # Find angle between xCentroidRot and first node in the face
vectorToFirstNode = [
xRot1[c] - centroidRot[c] for c in range(3)
]
if vector.magnitude(vectorToFirstNode) > 0.0:
cp = vector.crossproduct3(
vector.normalise(vectorToFirstNode),
vector.normalise(sd2[nAlongSegment]))
if vector.magnitude(cp) > 1e-7:
cp = vector.normalise(cp)
signThetaRot2 = vector.dotproduct(unitTangent, cp)
thetaRot2 = math.acos(
vector.dotproduct(
vector.normalise(vectorToFirstNode),
sd2[nAlongSegment]))
axisRot2 = unitTangent
rotFrame2 = matrix.getRotationMatrixFromAxisAngle(
axisRot2, signThetaRot2 * thetaRot2)
else:
rotFrame2 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
else:
rotFrame2 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
xRot2 = [
rotFrame2[j][0] * xRot1[0] + rotFrame2[j][1] * xRot1[1] +
rotFrame2[j][2] * xRot1[2] for j in range(3)
]
d1Rot2 = [
rotFrame2[j][0] * d1Rot1[0] + rotFrame2[j][1] * d1Rot1[1] +
rotFrame2[j][2] * d1Rot1[2] for j in range(3)
]
d2Rot2 = [
rotFrame2[j][0] * d2Rot1[0] + rotFrame2[j][1] * d2Rot1[1] +
rotFrame2[j][2] * d2Rot1[2] for j in range(3)
]
xTranslate = [xRot2[j] + translateMatrix[j] for j in range(3)]
xWarpedList.append(xTranslate)
d1WarpedList.append(d1Rot2)
d2WarpedList.append(d2Rot2)
# Scale d2 with curvature of central path
d2WarpedListScaled = []
vProjectedList = []
for nAlongSegment in range(elementsCountAlongSegment + 1):
for n1 in range(elementsCountAround):
n = nAlongSegment * elementsCountAround + n1
# Calculate norm
sd1Normalised = vector.normalise(sd1[nAlongSegment])
v = [xWarpedList[n][c] - sx[nAlongSegment][c] for c in range(3)]
dp = vector.dotproduct(v, sd1Normalised)
dpScaled = [dp * c for c in sd1Normalised]
vProjected = [v[c] - dpScaled[c] for c in range(3)]
vProjectedList.append(vProjected)
if vector.magnitude(vProjected) > 0.0:
vProjectedNormlised = vector.normalise(vProjected)
else:
vProjectedNormlised = [0.0, 0.0, 0.0]
# Calculate curvature along at each node
if nAlongSegment == 0:
curvature = interp.getCubicHermiteCurvature(
sx[0], sd1[0], sx[1], sd1[1], vProjectedNormlised, 0.0)
elif nAlongSegment == elementsCountAlongSegment:
curvature = interp.getCubicHermiteCurvature(
sx[-2], sd1[-2], sx[-1], sd1[-1], vProjectedNormlised, 1.0)
else:
curvature = 0.5 * (interp.getCubicHermiteCurvature(
sx[nAlongSegment - 1], sd1[nAlongSegment - 1],
sx[nAlongSegment], sd1[nAlongSegment], vProjectedNormlised,
1.0) + interp.getCubicHermiteCurvature(
sx[nAlongSegment], sd1[nAlongSegment],
sx[nAlongSegment + 1], sd1[nAlongSegment + 1],
vProjectedNormlised, 0.0))
# Scale
factor = 1.0 - curvature * innerRadiusAlong[nAlongSegment]
d2 = [factor * c for c in d2WarpedList[n]]
d2WarpedListScaled.append(d2)
# Smooth d2 for segment
smoothd2Raw = []
for n1 in range(elementsCountAround):
nx = []
nd2 = []
for n2 in range(elementsCountAlongSegment + 1):
n = n2 * elementsCountAround + n1
nx.append(xWarpedList[n])
nd2.append(d2WarpedListScaled[n])
smoothd2 = interp.smoothCubicHermiteDerivativesLine(
nx, nd2, fixStartDerivative=True, fixEndDerivative=True)
smoothd2Raw.append(smoothd2)
# Re-arrange smoothd2
for n2 in range(elementsCountAlongSegment + 1):
for n1 in range(elementsCountAround):
d2WarpedListFinal.append(smoothd2Raw[n1][n2])
# Calculate unit d3
for n in range(len(xWarpedList)):
d3Unit = vector.normalise(
vector.crossproduct3(vector.normalise(d1WarpedList[n]),
vector.normalise(d2WarpedListFinal[n])))
d3WarpedUnitList.append(d3Unit)
return xWarpedList, d1WarpedList, d2WarpedListFinal, d3WarpedUnitList
def getCoordinatesFromInner(xInner, d1Inner, d2Inner, d3Inner,
wallThicknessList, relativeThicknessList,
elementsCountAround, elementsCountAlong,
elementsCountThroughWall, transitElementList):
"""
Generates coordinates from inner to outer surface using coordinates
and derivatives of inner surface.
:param xInner: Coordinates on inner surface
:param d1Inner: Derivatives on inner surface around tube
:param d2Inner: Derivatives on inner surface along tube
:param d3Inner: Derivatives on inner surface through wall
:param wallThicknessList: Wall thickness for each element along tube
:param relativeThicknessList: Relative wall thickness for each element through wall
:param elementsCountAround: Number of elements around tube
:param elementsCountAlong: Number of elements along tube
:param elementsCountThroughWall: Number of elements through tube wall
:param transitElementList: stores true if element around is a transition
element that is between a big and a small element.
return nodes and derivatives for mesh, and curvature along inner surface.
"""
xOuter = []
curvatureAroundInner = []
curvatureAlong = []
curvatureList = []
xList = []
d1List = []
d2List = []
d3List = []
if relativeThicknessList:
xi3 = 0.0
xi3List = [0.0]
for n3 in range(elementsCountThroughWall):
xi3 += relativeThicknessList[n3]
xi3List.append(xi3)
relativeThicknessList.append(relativeThicknessList[-1])
for n2 in range(elementsCountAlong + 1):
wallThickness = wallThicknessList[n2]
for n1 in range(elementsCountAround):
n = n2 * elementsCountAround + n1
norm = d3Inner[n]
# Calculate outer coordinates
x = [xInner[n][i] + norm[i] * wallThickness for i in range(3)]
xOuter.append(x)
# Calculate curvature along elements around
prevIdx = n - 1 if (
n1 != 0) else (n2 + 1) * elementsCountAround - 1
nextIdx = n + 1 if (
n1 < elementsCountAround - 1) else n2 * elementsCountAround
kappam = interp.getCubicHermiteCurvatureSimple(
xInner[prevIdx], d1Inner[prevIdx], xInner[n], d1Inner[n], 1.0)
kappap = interp.getCubicHermiteCurvatureSimple(
xInner[n], d1Inner[n], xInner[nextIdx], d1Inner[nextIdx], 0.0)
if not transitElementList[n1] and not transitElementList[
(n1 - 1) % elementsCountAround]:
curvatureAround = 0.5 * (kappam + kappap)
elif transitElementList[n1]:
curvatureAround = kappam
elif transitElementList[(n1 - 1) % elementsCountAround]:
curvatureAround = kappap
curvatureAroundInner.append(curvatureAround)
# Calculate curvature along
if n2 == 0:
curvature = interp.getCubicHermiteCurvature(
xInner[n], d2Inner[n], xInner[n + elementsCountAround],
d2Inner[n + elementsCountAround],
vector.normalise(d3Inner[n]), 0.0)
elif n2 == elementsCountAlong:
curvature = interp.getCubicHermiteCurvature(
xInner[n - elementsCountAround],
d2Inner[n - elementsCountAround], xInner[n], d2Inner[n],
vector.normalise(d3Inner[n]), 1.0)
else:
curvature = 0.5 * (interp.getCubicHermiteCurvature(
xInner[n - elementsCountAround],
d2Inner[n - elementsCountAround], xInner[n], d2Inner[n],
vector.normalise(d3Inner[n]),
1.0) + interp.getCubicHermiteCurvature(
xInner[n], d2Inner[n], xInner[n + elementsCountAround],
d2Inner[n + elementsCountAround],
vector.normalise(d3Inner[n]), 0.0))
curvatureAlong.append(curvature)
for n3 in range(elementsCountThroughWall + 1):
xi3 = xi3List[
n3] if relativeThicknessList else 1.0 / elementsCountThroughWall * n3
for n1 in range(elementsCountAround):
n = n2 * elementsCountAround + n1
norm = d3Inner[n]
innerx = xInner[n]
outerx = xOuter[n]
dWall = [wallThickness * c for c in norm]
# x
x = interp.interpolateCubicHermite(innerx, dWall, outerx,
dWall, xi3)
xList.append(x)
# dx_ds1
factor = 1.0 + wallThickness * xi3 * curvatureAroundInner[n]
d1 = [factor * c for c in d1Inner[n]]
d1List.append(d1)
# dx_ds2
curvature = curvatureAlong[n]
distance = vector.magnitude(
[x[i] - xInner[n][i] for i in range(3)])
factor = 1.0 - curvature * distance
d2 = [factor * c for c in d2Inner[n]]
d2List.append(d2)
curvatureList.append(curvature)
#dx_ds3
d3 = [
c * wallThickness *
(relativeThicknessList[n3] if relativeThicknessList else
1.0 / elementsCountThroughWall) for c in norm
]
d3List.append(d3)
return xList, d1List, d2List, d3List, curvatureList
def getPlaneProjectionOnCentralPath(x, elementsCountAround, elementsCountAlong,
segmentLength, sx, sd1, sd2, sd12):
"""
Projects reference point used for warping onto the central path and find coordinates
and derivatives at projected location.
:param x: coordinates of nodes.
:param elementsCountAround: number of elements around.
:param elementsCountAlong: number of elements along.
:param segmentLength: Length of segment.
:param sx: coordinates of equally spaced points on central path.
:param sd1: tangent of equally spaced points on central path.
:param sd2: derivative representing cross axis at equally spaced points on central path.
:param sd12: rate of change of cross axis at equally spaced points on central path.
:return: coordinates and derivatives on project points and z-coordinates of reference points.
"""
# Use first node in each group of elements along as reference for warping later
zRefList = []
for n2 in range(elementsCountAlong + 1):
zFirstNodeAlong = x[n2 * elementsCountAround][2]
zRefList.append(zFirstNodeAlong)
# Find sx, sd1, sd2 at projection of reference points on central path
lengthElementAlong = segmentLength / elementsCountAlong
# Append values from first node on central path
sxRefList = []
sd1RefList = []
sd2RefList = []
sxRefList.append(sx[0])
sd1RefList.append(sd1[0])
sd2RefList.append(sd2[0])
# Interpolate the ones in between
for n2 in range(1, elementsCountAlong):
ei = int(zRefList[n2] // lengthElementAlong + 1)
xi = (zRefList[n2] - lengthElementAlong *
(ei - 1)) / lengthElementAlong
sxRef = interp.interpolateCubicHermite(sx[ei - 1], sd1[ei - 1], sx[ei],
sd1[ei], xi)
sd1Ref = interp.interpolateCubicHermiteDerivative(
sx[ei - 1], sd1[ei - 1], sx[ei], sd1[ei], xi)
sd2Ref = interp.interpolateCubicHermite(sd2[ei - 1], sd12[ei - 1],
sd2[ei], sd12[ei], xi)
sxRefList.append(sxRef)
sd1RefList.append(sd1Ref)
sd2RefList.append(sd2Ref)
# Append values from last node on central path
sxRefList.append(sx[-1])
sd1RefList.append(sd1[-1])
sd2RefList.append(sd2[-1])
# Project sd2 to plane orthogonal to sd1
sd2ProjectedListRef = []
for n in range(len(sd2RefList)):
sd1Normalised = vector.normalise(sd1RefList[n])
dp = vector.dotproduct(sd2RefList[n], sd1Normalised)
dpScaled = [dp * c for c in sd1Normalised]
sd2Projected = vector.normalise(
[sd2RefList[n][c] - dpScaled[c] for c in range(3)])
sd2ProjectedListRef.append(sd2Projected)
return sxRefList, sd1RefList, sd2ProjectedListRef, zRefList
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']
segmentCount = options['Number of segments']
elementsCountAround = options['Number of elements around']
elementsCountAlongSegment = options['Number of elements along segment']
elementsCountThroughWall = options['Number of elements through wall']
duodenumLength = options['Duodenum length']
jejunumLength = options['Jejunum length']
duodenumInnerRadius = options['Duodenum inner radius']
duodenumJejunumInnerRadius = options['Duodenum-jejunum inner radius']
jejunumIleumInnerRadius = options['Jejunum-ileum inner radius']
ileumInnerRadius = options['Ileum inner radius']
wallThickness = options['Wall thickness']
useCrossDerivatives = options['Use cross derivatives']
useCubicHermiteThroughWall = not(options['Use linear through wall'])
elementsCountAlong = int(elementsCountAlongSegment*segmentCount)
startPhase = 0.0
firstNodeIdentifier = 1
firstElementIdentifier = 1
# Central path
tmpRegion = region.createRegion()
centralPath.generate(tmpRegion)
cx, cd1, cd2, cd12 = extractPathParametersFromRegion(tmpRegion)
# for i in range(len(cx)):
# print(i, '[', cx[i], ',', cd1[i], ',', cd2[i],',', cd12[i], '],')
del tmpRegion
# find arclength of colon
length = 0.0
elementsCountIn = len(cx) - 1
sd1 = interp.smoothCubicHermiteDerivativesLine(cx, cd1, fixAllDirections = True,
magnitudeScalingMode = interp.DerivativeScalingMode.HARMONIC_MEAN)
for e in range(elementsCountIn):
arcLength = interp.getCubicHermiteArcLength(cx[e], sd1[e], cx[e + 1], sd1[e + 1])
# print(e+1, arcLength)
length += arcLength
segmentLength = length / segmentCount
elementAlongLength = length / elementsCountAlong
# print('Length = ', length)
# Sample central path
sx, sd1, se, sxi, ssf = interp.sampleCubicHermiteCurves(cx, cd1, elementsCountAlongSegment*segmentCount)
sd2, sd12 = interp.interpolateSampleCubicHermite(cd2, cd12, se, sxi, ssf)
# Generate variation of radius & tc width along length
lengthList = [0.0, duodenumLength, duodenumLength + jejunumLength, length]
innerRadiusList = [duodenumInnerRadius, duodenumJejunumInnerRadius, jejunumIleumInnerRadius, ileumInnerRadius]
innerRadiusSegmentList, dInnerRadiusSegmentList = interp.sampleParameterAlongLine(lengthList, innerRadiusList,
segmentCount)
# Create annotation groups for small intestine sections
elementsAlongDuodenum = round(duodenumLength / elementAlongLength)
elementsAlongJejunum = round(jejunumLength / elementAlongLength)
elementsAlongIleum = elementsCountAlong - elementsAlongDuodenum - elementsAlongJejunum
elementsCountAlongGroups = [elementsAlongDuodenum, elementsAlongJejunum, elementsAlongIleum]
smallintestineGroup = AnnotationGroup(region, get_smallintestine_term("small intestine"))
duodenumGroup = AnnotationGroup(region, get_smallintestine_term("duodenum"))
jejunumGroup = AnnotationGroup(region, get_smallintestine_term("jejunum"))
ileumGroup = AnnotationGroup(region, get_smallintestine_term("ileum"))
annotationGroupAlong = [[smallintestineGroup, duodenumGroup],
[smallintestineGroup, jejunumGroup],
[smallintestineGroup, ileumGroup]]
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([ ])
annotationGroupsThroughWall = []
for i in range(elementsCountThroughWall):
annotationGroupsThroughWall.append([ ])
xExtrude = []
d1Extrude = []
d2Extrude = []
d3UnitExtrude = []
# Create object
smallIntestineSegmentTubeMeshInnerPoints = CylindricalSegmentTubeMeshInnerPoints(
elementsCountAround, elementsCountAlongSegment, segmentLength,
wallThickness, innerRadiusSegmentList, dInnerRadiusSegmentList, startPhase)
for nSegment in range(segmentCount):
# Create inner points
xInner, d1Inner, d2Inner, transitElementList, segmentAxis, radiusAlongSegmentList = \
smallIntestineSegmentTubeMeshInnerPoints.getCylindricalSegmentTubeMeshInnerPoints(nSegment)
# Project reference point for warping onto central path
start = nSegment*elementsCountAlongSegment
end = (nSegment + 1)*elementsCountAlongSegment + 1
sxRefList, sd1RefList, sd2ProjectedListRef, zRefList = \
tubemesh.getPlaneProjectionOnCentralPath(xInner, elementsCountAround, elementsCountAlongSegment,
segmentLength, sx[start:end], sd1[start:end], sd2[start:end],
sd12[start:end])
# Warp segment points
xWarpedList, d1WarpedList, d2WarpedList, d3WarpedUnitList = tubemesh.warpSegmentPoints(
xInner, d1Inner, d2Inner, segmentAxis, sxRefList, sd1RefList, sd2ProjectedListRef,
elementsCountAround, elementsCountAlongSegment, zRefList, radiusAlongSegmentList,
closedProximalEnd=False)
# Store points along length
xExtrude = xExtrude + (xWarpedList if nSegment == 0 else xWarpedList[elementsCountAround:])
d1Extrude = d1Extrude + (d1WarpedList if nSegment == 0 else d1WarpedList[elementsCountAround:])
# Smooth d2 for nodes between segments and recalculate d3
if nSegment == 0:
d2Extrude = d2Extrude + (d2WarpedList[:-elementsCountAround])
d3UnitExtrude = d3UnitExtrude + (d3WarpedUnitList[:-elementsCountAround])
else:
xSecondFace = xWarpedList[elementsCountAround:elementsCountAround*2]
d2SecondFace = d2WarpedList[elementsCountAround:elementsCountAround*2]
for n1 in range(elementsCountAround):
nx = [xLastTwoFaces[n1], xLastTwoFaces[n1 + elementsCountAround], xSecondFace[n1]]
nd2 = [d2LastTwoFaces[n1], d2LastTwoFaces[n1 + elementsCountAround], d2SecondFace[n1]]
d2 = interp.smoothCubicHermiteDerivativesLine(nx, nd2, fixStartDerivative = True,
fixEndDerivative = True)[1]
d2Extrude.append(d2)
d3Unit = vector.normalise(vector.crossproduct3(vector.normalise(d1LastTwoFaces[n1 + elementsCountAround]),
vector.normalise(d2)))
d3UnitExtrude.append(d3Unit)
d2Extrude = d2Extrude + \
(d2WarpedList[elementsCountAround:-elementsCountAround] if nSegment < segmentCount - 1 else
d2WarpedList[elementsCountAround:])
d3UnitExtrude = d3UnitExtrude + \
(d3WarpedUnitList[elementsCountAround:-elementsCountAround] if nSegment < segmentCount - 1 else
d3WarpedUnitList[elementsCountAround:])
xLastTwoFaces = xWarpedList[-elementsCountAround*2:]
d1LastTwoFaces = d1WarpedList[-elementsCountAround*2:]
d2LastTwoFaces = d2WarpedList[-elementsCountAround*2:]
# Create coordinates and derivatives
xList, d1List, d2List, d3List, curvatureList = tubemesh.getCoordinatesFromInner(xExtrude, d1Extrude,
d2Extrude, d3UnitExtrude, [wallThickness]*(elementsCountAlong+1),
elementsCountAround, elementsCountAlong, elementsCountThroughWall, transitElementList)
flatWidthList, xiList = smallIntestineSegmentTubeMeshInnerPoints.getFlatWidthAndXiList()
# Create flat and texture coordinates
xFlat, d1Flat, d2Flat, xTexture, d1Texture, d2Texture = tubemesh.createFlatAndTextureCoordinates(
xiList, flatWidthList, length, wallThickness, elementsCountAround,
elementsCountAlong, elementsCountThroughWall, transitElementList)
# Create nodes and elements
nextNodeIdentifier, nextElementIdentifier, annotationGroups = tubemesh.createNodesAndElements(
region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat, xTexture, d1Texture, d2Texture,
elementsCountAround, elementsCountAlong, elementsCountThroughWall,
annotationGroupsAround, annotationGroupsAlong, annotationGroupsThroughWall,
firstNodeIdentifier, firstElementIdentifier, useCubicHermiteThroughWall, useCrossDerivatives,
closedProximalEnd=False)
return annotationGroups
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
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 generateOstiumMesh(region,
options,
trackSurface,
centrePosition,
axis1,
startNodeIdentifier=1,
startElementIdentifier=1,
vesselMeshGroups=None,
ostiumMeshGroups=None):
'''
:param vesselMeshGroups: List (over number of vessels) of list of mesh groups to add vessel elements to.
:param ostiumMeshGroups: List of mesh groups to add only row of elements at ostium end 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()
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodeIdentifier = startNodeIdentifier
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)
mesh = fm.findMeshByDimension(3)
elementIdentifier = startElementIdentifier
# 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 = []
if (vesselWallThickness > 0.0) and (ostiumWallThickness > 0.0):
commonOstiumWallThickness = 2.0 / (1.0 / vesselWallThickness +
1.0 / ostiumWallThickness)
else:
commonOstiumWallThickness = vesselWallThickness
# 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]),
commonOstiumWallThickness)
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 [1]: # was range(2), now using curvature for inside:
#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
# calculate inner d2 derivatives around ostium from outer using track surface curvature
factor = 1.0
for n1 in range(elementsCountAroundOstium):
trackDirection = vector.normalise(od2[1][n1])
trackDistance = factor * vector.magnitude(od2[1][n1])
tx = [None, ox[1][n1], None]
td1 = [None, vector.setMagnitude(od2[1][n1], trackDistance), None]
td2 = [None, vector.setMagnitude(od1[1][n1], -trackDistance), None]
positionBackward = trackSurface.trackVector(oPositions[n1],
trackDirection,
-trackDistance)
tx[0], d1, d2 = trackSurface.evaluateCoordinates(positionBackward,
derivatives=True)
sd1, sd2, sd3 = calculate_surface_axes(d1, d2, trackDirection)
td1[0] = vector.setMagnitude(sd1, trackDistance)
td2[0] = vector.setMagnitude(sd2, trackDistance)
positionForward = trackSurface.trackVector(oPositions[n1],
trackDirection,
trackDistance)
tx[2], d1, d2 = trackSurface.evaluateCoordinates(positionForward,
derivatives=True)
sd1, sd2, sd3 = calculate_surface_axes(d1, d2, trackDirection)
td1[2] = vector.setMagnitude(sd1, trackDistance)
td2[2] = vector.setMagnitude(sd2, trackDistance)
newd2 = interp.projectHermiteCurvesThroughWall(tx, td1, td2, 1,
-ostiumWallThickness)[1]
# assign components to set in all lists:
for c in range(3):
od2[0][n1][c] = newd2[c] / factor
#for n in [ 0, 1, 2 ]:
# node = nodes.createNode(nodeIdentifier, nodetemplateLinearS3)
# cache.setNode(node)
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, tx [n])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, td1[n])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, td2[n])
# nodeIdentifier += 1
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
##############
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
#################
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 vesselMeshGroups or ostiumMeshGroups:
rowMeshGroups = []
for i in range(elementsCountAlong):
rowMeshGroups.append(
copy.copy(vesselMeshGroups[v]) if vesselMeshGroups else [])
else:
rowMeshGroups = None
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]
if ostiumMeshGroups:
rowMeshGroups[0] += ostiumMeshGroups
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]
if ostiumMeshGroups:
rowMeshGroups[-1] += ostiumMeshGroups
#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,
maxStartThickness=vesselWallThickness,
maxEndThickness=vesselWallThickness,
elementsCountRadial=elementsCountAlong,
meshGroups=rowMeshGroups)
fm.endChange()
return nodeIdentifier, elementIdentifier, (ox, od1, od2, od3, oNodeId,
oPositions)
