def get_bifurcation_triple_point(p1x, p1d, p2x, p2d, p3x, p3d):
'''
Get coordinates and derivatives of triple point between p1, p2 and p3 with derivatives.
:param p1x..p3d: Point coordinates and derivatives, numbered anticlockwise around triple point.
All derivatives point away from triple point.
Returned d1 points from triple point to p2, d2 points from triple point to p3.
:return: x, d1, d2
'''
trx1 = interpolateCubicHermite(p1x, mult(p1d, -2.0), p2x, mult(p2d, 2.0), 0.5)
trx2 = interpolateCubicHermite(p2x, mult(p2d, -2.0), p3x, mult(p3d, 2.0), 0.5)
trx3 = interpolateCubicHermite(p3x, mult(p3d, -2.0), p1x, mult(p1d, 2.0), 0.5)
trx = [ (trx1[c] + trx2[c] + trx3[c])/3.0 for c in range(3) ]
td1 = interpolateLagrangeHermiteDerivative(trx, p1x, p1d, 0.0)
td2 = interpolateLagrangeHermiteDerivative(trx, p2x, p2d, 0.0)
td3 = interpolateLagrangeHermiteDerivative(trx, p3x, p3d, 0.0)
n12 = cross(td1, td2)
n23 = cross(td2, td3)
n31 = cross(td3, td1)
norm = normalize([ (n12[c] + n23[c] + n31[c]) for c in range(3) ])
sd1 = smoothCubicHermiteDerivativesLine([ trx, p1x ], [ normalize(cross(norm, cross(td1, norm))), p1d ], fixStartDirection=True, fixEndDerivative=True)[0]
sd2 = smoothCubicHermiteDerivativesLine([ trx, p2x ], [ normalize(cross(norm, cross(td2, norm))), p2d ], fixStartDirection=True, fixEndDerivative=True)[0]
sd3 = smoothCubicHermiteDerivativesLine([ trx, p3x ], [ normalize(cross(norm, cross(td3, norm))), p3d ], fixStartDirection=True, fixEndDerivative=True)[0]
trd1 = mult(sub(sd2, add(sd3, sd1)), 0.5)
trd2 = mult(sub(sd3, add(sd1, sd2)), 0.5)
return trx, trd1, trd2
def smoothTriplePointsCurves(self, n2b, n1b, m1a):
"""
Smooth row and column curves passing triple points (i.e., row 1 and columns 1 and -2).
"""
btx = self.px
btd1 = self.pd1
btd2 = self.pd2
btd3 = self.pd3
# smooth shield row 1
btd3[n2b][n1b:m1a] = smoothCubicHermiteDerivativesLine(
btx[n2b][n1b:m1a], btd3[n2b][n1b:m1a])
# smooth Shield columns 1, -2
for n1 in [1, -2]:
tx = []
td1 = []
for n2 in range(1, self.elementsCountUp + 1):
tx.append(btx[n2][n1])
td1.append(btd1[n2][n1])
td1 = smoothCubicHermiteDerivativesLine(tx,
td1,
fixEndDirection=True)
for n in range(self.elementsCountUp):
btd1[n + 1][n1] = td1[n]
def smoothTriplePointsCurves(self):
"""
Smooth row and column curves passing triple points (i.e., row 1 and columns 1 and -2).
"""
btx = self.px
btd1 = self.pd1
btd2 = self.pd2
btd3 = self.pd3
n1c = 1 + self.elementsCountAcrossRim
n1y = self.elementsCountAcrossMinor - self.elementsCountAcrossRim
n1x = n1y - 1
n2a = self.elementsCountAcrossShell
n2c = 1 + self.elementsCountAcrossRim
n2m = self.elementsCountUp
# smooth shield row n2c
btd3[n2c][n1c:n1y] = smoothCubicHermiteDerivativesLine(
btx[n2c][n1c:n1y], btd3[n2c][n1c:n1y])
# smooth Shield columns n1c, n1x
for n1 in [n1c, n1x]:
tx = []
td1 = []
for n2 in range(n2c, n2m + 1):
tx.append(btx[n2][n1])
td1.append(btd1[n2][n1])
td1 = smoothCubicHermiteDerivativesLine(tx,
td1,
fixEndDirection=True,
fixStartDerivative=True)
for n in range(n2m - n2c + 1):
btd1[n + n2c][n1] = td1[n]
# sample nodes to triple points
for n1 in [n1c, n1x]:
c1 = 1 if n1 == n1c else -1
txm, td3m, pe, pxi, psf = sampleCubicHermiteCurves(
[btx[n2a][n1], btx[n2c][n1]],
[[-btd3[n2a][n1][c] for c in range(3)],
[btd1[n2c][n1][c] + c1 * btd3[n2c][n1][c] for c in range(3)]],
1 + self.elementsCountAcrossTransition - 1,
arcLengthDerivatives=True)
td1m = interpolateSampleCubicHermite(
[btd1[n2a][n1], [-c1 * d for d in btd1[n2c][n1]]],
[[0.0, 0.0, 0.0]] * 2, pe, pxi, psf)[0]
for n2 in range(n2a + 1, n2c):
btx[n2][n1] = txm[n2 - n2a]
btd1[n2][n1] = td1m[n2 - n2a]
btd3[n2][n1] = [-d for d in td3m[n2 - n2a]]
# smooth
self.__shield.smoothDerivativesToTriplePoints(0, fixAllDirections=True)
def getSemilunarValveSinusPoints(centre, axisSide1, axisSide2, radius, sinusRadialDisplacement, startMidCusp, elementsCountAround = 6):
'''
Get points around a circle of radius with every second point displaced radially.
:return: x[], d1[] for 6 points around
'''
assert elementsCountAround == 6, 'getArterialRootLowerPoints. Only supports 6 elements around'
px = []
pd1 = []
# every second outer points is displaced by sinusRadialDisplacement to make sinus dilatation
nMidCusp = 0 if startMidCusp else 1
radiusPlus = radius + sinusRadialDisplacement
radiansPerElementAround = 2.0*math.pi/elementsCountAround
for n in range(elementsCountAround):
radiansAround = n*radiansPerElementAround
midCusp = (n % 2) == nMidCusp
r = radiusPlus if midCusp else radius
rcosRadiansAround = r*math.cos(radiansAround)
rsinRadiansAround = r*math.sin(radiansAround)
px.append([ (centre[c] + rcosRadiansAround*axisSide1[c] + rsinRadiansAround*axisSide2[c]) for c in range(3) ])
pd1.append([ radiansPerElementAround*(-rsinRadiansAround*axisSide1[c] + rcosRadiansAround*axisSide2[c]) for c in range(3) ])
# smooth to get derivative in sinus
sd1 = interp.smoothCubicHermiteDerivativesLine(px[1 - nMidCusp:3 - nMidCusp], pd1[1 - nMidCusp:3 - nMidCusp], fixStartDerivative=True, fixEndDirection=True)
magSinus = vector.magnitude(sd1[1])
for n in range(nMidCusp, elementsCountAround, 2):
pd1[n] = vector.setMagnitude(pd1[n], magSinus)
return px, pd1
def smoothDerivativesAroundRim(self, n3, n3d=None, rx=0):
'''
Smooth derivatives around rim.
:param n3: Index of through-wall coordinates to use.
:param n3d: Which n3 index to copy initial derivatives from. If None, use n3.
:param rx: rim index from 0 (around outside) to self.elementsCountRim
'''
assert 0 <= rx <= self.elementsCountRim
if not n3d:
n3d = n3
tx = []
td1 = []
for ix in range(self.elementsCountAroundFull + 1):
n1, n2 = self.convertRimIndex(ix, rx)
tx.append(self.px[n3][n2][n1])
if n2 > self.elementsCountRim: # regular rows
if n1 <= self.elementsCountRim:
td1.append([-d for d in self.pd2[n3d][n2][n1]])
else:
td1.append(self.pd2[n3d][n2][n1])
else:
td1.append(self.pd1[n3d][n2][n1])
td1 = smoothCubicHermiteDerivativesLine(tx, td1)
for ix in range(self.elementsCountAroundFull + 1):
n1, n2 = self.convertRimIndex(ix, rx)
if n2 > self.elementsCountRim: # regular rows
if n1 <= self.elementsCountRim:
self.pd2[n3][n2][n1] = [-d for d in td1[ix]]
else:
self.pd2[n3][n2][n1] = td1[ix]
else:
self.pd1[n3][n2][n1] = td1[ix]
def createRegularColumnCurves(self):
"""
up regular columns of shield: get d1, initial d3 below regular rows
"""
btx = self.px
btd1 = self.pd1
btd2 = self.pd2
btd3 = self.pd3
elementsCountRim = self.elementsCountAcrossRim
n1d = elementsCountRim + 2
n1x = self.elementsCountAcrossMinor - elementsCountRim - 1
n2a = self.elementsCountAcrossShell
n2b = elementsCountRim
n2d = 2 + n2b
n2m = self.elementsCountUp
for n1 in range(n1d, n1x):
txm, td1m, pe, pxi, psf = sampleCubicHermiteCurves(
[btx[n2a][n1], btx[n2d][n1]],
[[-btd3[n2a][n1][c] for c in range(3)], btd1[n2d][n1]],
2 + self.elementsCountAcrossTransition - 1,
arcLengthDerivatives=True)
td3m = interpolateSampleCubicHermite(
[btd1[n2a][n1], btd3[n2d][n1]], [[0.0, 0.0, 0.0]] * 2, pe, pxi,
psf)[0]
tx = []
td1 = []
for n2 in range(n2m + 1):
if n2 <= n2a:
tx.append(btx[n2][n1])
td1.append([-btd3[n2][n1][c] for c in range(3)])
elif (n2 > n2a) and (n2 < n2d):
tx.append(txm[n2 - n2a])
td1.append(td1m[n2 - n2a])
else:
tx.append(btx[n2][n1])
td1.append(btd1[n2][n1])
td1 = smoothCubicHermiteDerivativesLine(tx,
td1,
fixStartDirection=True,
fixEndDirection=True)
for n2 in range(n2m + 1):
if n2 <= n2a:
btd3[n2][n1] = [-td1[n2][c] for c in range(3)]
elif (n2 > n2a) and (n2 < n2d):
btx[n2][n1] = tx[n2]
if n2 <= n2b:
btd1[n2][n1] = td3m[n2 - n2a]
btd3[n2][n1] = [-d for d in td1[n2]]
else:
btd1[n2][n1] = td1[n2]
btd3[n2][n1] = td3m[n2 - n2a]
else:
btd1[n2][n1] = td1[n2]
def smoothPath(cls, region, options, editGroupName,
mode: DerivativeScalingMode):
x, d1 = extractPathParametersFromRegion(
region, [Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1])
d1 = smoothCubicHermiteDerivativesLine(x,
d1,
magnitudeScalingMode=mode)
setPathParameters(region, [Node.VALUE_LABEL_D_DS1], [d1],
editGroupName)
return False, True # settings not changed, nodes changed
def smoothd2Derivatives(self):
"""
smooth d2 derivatives using initial values calculated by calculateD2Derivatives
"""
btx = self._shield.px
btd1 = self._shield.pd1
btd2 = self._shield.pd2
btd3 = self._shield.pd3
for n2 in range(self._elementsCountAcrossMajor + 1):
for n1 in range(self._elementsCountAcrossMinor + 1):
td2 = []
tx = []
if btx[0][n2][n1]:
for n3 in range(self._elementsCountAlong + 1):
tx.append(btx[n3][n2][n1])
td2.append(btd2[n3][n2][n1])
td2 = smoothCubicHermiteDerivativesLine(
tx, td2, fixStartDirection=True)
for n3 in range(self._elementsCountAlong + 1):
btd2[n3][n2][n1] = td2[n3]
def createRegularColumnCurves(self):
"""
up regular columns of shield: get d1, initial d3 below regular rows
"""
btx = self.px
btd1 = self.pd1
btd2 = self.pd2
btd3 = self.pd3
for n1 in range(2, self.elementsCountAcrossMinor - 1):
tx, td1, pe, pxi, psf = sampleCubicHermiteCurves(
[btx[0][n1], btx[2][n1]],
[[-btd3[0][n1][c] for c in range(3)], btd1[2][n1]],
2,
lengthFractionStart=1,
arcLengthDerivatives=True)
for n2 in range(3, self.elementsCountUp + 1):
tx.append(btx[n2][n1])
td1.append(btd1[n2][n1])
td1 = smoothCubicHermiteDerivativesLine(tx,
td1,
fixStartDirection=True,
fixEndDirection=True)
td3 = \
interpolateSampleCubicHermite([btd1[0][n1], btd3[2][n1]], [[0.0, 0.0, 0.0]] * 2, pe, pxi, psf)[
0]
for n2 in range(self.elementsCountUp + 1):
if n2 < 2:
btx[n2][n1] = tx[n2]
if n2 == 0:
btd3[n2][n1] = [-td1[0][c] for c in range(3)]
else:
btd3[n2][n1] = td3[n2]
if n2 == 0:
btd1[n2][n1] = td3[n2]
else:
btd1[n2][n1] = td1[n2]
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 createRegularRowCurves(self, rscx, rscd1, rscd3):
"""
generate curves along regular rows using the mirror curve obtained from createMirrorCurve.
:param rscx: Coordinates of the nodes on the middle curve.
:param rscd1: d1 derivatives of the nodes on the middle curve.
:param rscd3: d3 derivatives of the nodes on the middle curve.
"""
btx = self.px
btd1 = self.pd1
btd2 = self.pd2
btd3 = self.pd3
elementsCountRim = self.elementsCountAcrossRim
n2a = self.elementsCountAcrossShell
n2b = elementsCountRim
n2d = n2b + 2
n2m = self.elementsCountUp
n1a = self.elementsCountAcrossShell
n1b = elementsCountRim
n1z = self.elementsCountAcrossMinor - self.elementsCountAcrossShell
for n2 in range(n2d, n2m + 1):
txm, td3m, pe, pxi, psf = sampleCubicHermiteCurves(
[btx[n2][n1a], rscx[n2 - n2a], btx[n2][n1z]], [
vector.setMagnitude(btd3[n2][n1a], -1.0), rscd3[n2 - n2a],
btd3[n2][n1z]
],
self.elementsCountAcrossMinor -
2 * self.elementsCountAcrossShell,
arcLengthDerivatives=True)
td1m = interpolateSampleCubicHermite(
[[-btd1[n2][n1a][c]
for c in range(3)], rscd1[n2 - n2a], btd1[n2][n1z]],
[[0.0, 0.0, 0.0]] * 3, pe, pxi, psf)[0]
tx = []
td3 = []
for n1 in range(self.elementsCountAcrossMinor + 1):
if n1 <= n1a:
tx.append(btx[n2][n1])
td3.append([-btd3[n2][n1][c] for c in range(3)])
elif (n1 > n1a) and (n1 < n1z):
tx.append(txm[n1 - n1a])
td3.append(td3m[n1 - n1a])
else:
tx.append(btx[n2][n1])
td3.append((btd3[n2][n1]))
td3 = smoothCubicHermiteDerivativesLine(tx,
td3,
fixStartDirection=True,
fixEndDirection=True)
for n1 in range(self.elementsCountAcrossMinor + 1):
if n1 <= n1a:
btd3[n2][n1] = [-td3[n1][c] for c in range(3)]
elif (n1 > n1a) and (n1 < n1z):
btx[n2][n1] = tx[n1]
if n2 == n2m:
if n1 <= n1b:
btd1[n2][n1] = vector.setMagnitude(
btd1[n2m][-1], -1.0)
else:
btd1[n2][n1] = vector.setMagnitude(
btd1[n2m][-1], 1.0)
else:
if n1 <= n1b:
btd1[n2][n1] = [-d for d in td1m[n1 - n1a]]
else:
btd1[n2][n1] = td1m[n1 - n1a]
if n1 <= n1b:
btd3[n2][n1] = [-d for d in td3[n1]]
else:
btd3[n2][n1] = td3[n1]
else:
btd3[n2][n1] = td3[n1]
def generateBaseMesh(cls,
region,
options,
baseCentre=[0.0, 0.0, 0.0],
axisSide1=[0.0, -1.0, 0.0],
axisUp=[0.0, 0.0, 1.0]):
"""
Generate the base bicubic-linear Hermite mesh. See also generateMesh().
Optional extra parameters allow centre and axes to be set.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:param baseCentre: Centre of valve on ventriculo-arterial junction.
:param axisSide: Unit vector in first side direction where angle around starts.
:param axisUp: Unit vector in outflow direction of valve.
:return: list of AnnotationGroup
"""
unitScale = options['Unit scale']
outerHeight = unitScale * options['Outer height']
innerDepth = unitScale * options['Inner depth']
cuspHeight = unitScale * options['Cusp height']
innerRadius = unitScale * 0.5 * options['Inner diameter']
sinusRadialDisplacement = unitScale * options[
'Sinus radial displacement']
wallThickness = unitScale * options['Wall thickness']
cuspThickness = unitScale * options['Cusp thickness']
aorticNotPulmonary = options['Aortic not pulmonary']
useCrossDerivatives = False
fm = region.getFieldmodule()
fm.beginChange()
coordinates = zinc_utils.getOrCreateCoordinateField(fm)
cache = fm.createFieldcache()
if aorticNotPulmonary:
arterialRootGroup = AnnotationGroup(region,
'root of aorta',
FMANumber=3740,
lyphID='Lyph ID unknown')
cuspGroups = [
AnnotationGroup(region,
'posterior cusp of aortic valve',
FMANumber=7253,
lyphID='Lyph ID unknown'),
AnnotationGroup(region,
'right cusp of aortic valve',
FMANumber=7252,
lyphID='Lyph ID unknown'),
AnnotationGroup(region,
'left cusp of aortic valve',
FMANumber=7251,
lyphID='Lyph ID unknown')
]
else:
arterialRootGroup = AnnotationGroup(region,
'root of pulmonary trunk',
FMANumber=8612,
lyphID='Lyph ID unknown')
cuspGroups = [
AnnotationGroup(region,
'right cusp of pulmonary valve',
FMANumber=7250,
lyphID='Lyph ID unknown'),
AnnotationGroup(region,
'anterior cusp of pulmonary valve',
FMANumber=7249,
lyphID='Lyph ID unknown'),
AnnotationGroup(region,
'left cusp of pulmonary valve',
FMANumber=7247,
lyphID='Lyph ID unknown')
]
allGroups = [arterialRootGroup
] # groups that all elements in scaffold will go in
annotationGroups = allGroups + cuspGroups
# annotation fiducial points
fiducialGroup = zinc_utils.getOrCreateGroupField(fm, 'fiducial')
fiducialCoordinates = zinc_utils.getOrCreateCoordinateField(
fm, 'fiducial_coordinates')
fiducialLabel = zinc_utils.getOrCreateLabelField(fm, 'fiducial_label')
#fiducialElementXi = zinc_utils.getOrCreateElementXiField(fm, 'fiducial_element_xi')
datapoints = fm.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
fiducialPoints = zinc_utils.getOrCreateNodesetGroup(
fiducialGroup, datapoints)
datapointTemplateExternal = datapoints.createNodetemplate()
datapointTemplateExternal.defineField(fiducialCoordinates)
datapointTemplateExternal.defineField(fiducialLabel)
#################
# Create nodes
#################
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1,
Node.VALUE_LABEL_D_DS3, 1)
# most nodes in this scaffold do not have a DS3 derivative
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)
# several only have a DS1 derivative
nodetemplateLinearS2S3 = nodes.createNodetemplate()
nodetemplateLinearS2S3.defineField(coordinates)
nodetemplateLinearS2S3.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplateLinearS2S3.setValueNumberOfVersions(
coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodeIdentifier = max(1, zinc_utils.getMaximumNodeIdentifier(nodes) + 1)
elementsCountAround = 6
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
axisSide2 = vector.crossproduct3(axisUp, axisSide1)
outerRadius = innerRadius + wallThickness
cuspOuterLength2 = 0.5 * getApproximateEllipsePerimeter(
innerRadius, cuspHeight)
cuspOuterWallArcLength = cuspOuterLength2 * innerRadius / (
innerRadius + cuspHeight)
noduleOuterAxialArcLength = cuspOuterLength2 - cuspOuterWallArcLength
noduleOuterRadialArcLength = innerRadius
cuspOuterWalld1 = interp.interpolateLagrangeHermiteDerivative(
[innerRadius, outerHeight + innerDepth - cuspHeight], [0.0, 0.0],
[-innerRadius, 0.0], 0.0)
sin60 = math.sin(math.pi / 3.0)
cuspThicknessLowerFactor = 4.5 # GRC fudge factor
cuspInnerLength2 = 0.5 * getApproximateEllipsePerimeter(
innerRadius - cuspThickness / sin60,
cuspHeight - cuspThicknessLowerFactor * cuspThickness)
noduleInnerAxialArcLength = cuspInnerLength2 * (
cuspHeight - cuspThicknessLowerFactor * cuspThickness) / (
innerRadius - cuspThickness / sin60 + cuspHeight -
cuspThicknessLowerFactor * cuspThickness)
noduleInnerRadialArcLength = innerRadius - cuspThickness / math.tan(
math.pi / 3.0)
nMidCusp = 0 if aorticNotPulmonary else 1
# lower points
ix, id1 = createCirclePoints(
[(baseCentre[c] - axisUp[c] * innerDepth) for c in range(3)],
[axisSide1[c] * innerRadius for c in range(3)],
[axisSide2[c] * innerRadius
for c in range(3)], elementsCountAround)
ox, od1 = getSemilunarValveSinusPoints(baseCentre,
axisSide1,
axisSide2,
outerRadius,
sinusRadialDisplacement,
startMidCusp=aorticNotPulmonary)
lowerx, lowerd1 = [ix, ox], [id1, od1]
# upper points
topCentre = [(baseCentre[c] + axisUp[c] * outerHeight)
for c in range(3)]
# twice as many on inner:
ix, id1 = createCirclePoints(
topCentre, [axisSide1[c] * innerRadius for c in range(3)],
[axisSide2[c] * innerRadius
for c in range(3)], elementsCountAround * 2)
# tweak inner points so elements attached to cusps are narrower
cuspRadiansFactor = 0.25 # GRC fudge factor
midDerivativeFactor = 1.0 + 0.5 * (1.0 - cuspRadiansFactor
) # GRC test compromise
cuspAttachmentRadians = cuspRadiansFactor * radiansPerElementAround
cuspAttachmentRadialDisplacement = wallThickness * 0.333 # GRC fudge factor
cuspAttachmentRadius = innerRadius - cuspAttachmentRadialDisplacement
for cusp in range(3):
n1 = cusp * 2 - 1 + nMidCusp
n2 = n1 * 2
id1[n2 + 2] = [2.0 * d for d in id1[n2 + 2]]
# side 1
radiansAround = n1 * radiansPerElementAround + cuspAttachmentRadians
rcosRadiansAround = cuspAttachmentRadius * math.cos(radiansAround)
rsinRadiansAround = cuspAttachmentRadius * math.sin(radiansAround)
ix[n2 + 1] = [(topCentre[c] + rcosRadiansAround * axisSide1[c] +
rsinRadiansAround * axisSide2[c]) for c in range(3)]
id1[n2 + 1] = interp.interpolateLagrangeHermiteDerivative(
ix[n2 + 1], ix[n2 + 2], id1[n2 + 2], 0.0)
# side 2
n1 = ((cusp + 1) * 2 - 1 + nMidCusp) % elementsCountAround
n2 = n1 * 2
radiansAround = n1 * radiansPerElementAround - cuspAttachmentRadians
rcosRadiansAround = cuspAttachmentRadius * math.cos(radiansAround)
rsinRadiansAround = cuspAttachmentRadius * math.sin(radiansAround)
ix[n2 - 1] = [(topCentre[c] + rcosRadiansAround * axisSide1[c] +
rsinRadiansAround * axisSide2[c]) for c in range(3)]
id1[n2 - 1] = interp.interpolateHermiteLagrangeDerivative(
ix[n2 - 2], id1[n2 - 2], ix[n2 - 1], 1.0)
ox, od1 = createCirclePoints(
topCentre, [axisSide1[c] * outerRadius for c in range(3)],
[axisSide2[c] * outerRadius
for c in range(3)], elementsCountAround)
upperx, upperd1 = [ix, ox], [id1, od1]
# get lower and upper derivative 2
zero = [0.0, 0.0, 0.0]
upperd2factor = outerHeight
upd2 = [d * upperd2factor for d in axisUp]
lowerOuterd2 = interp.smoothCubicHermiteDerivativesLine(
[lowerx[1][nMidCusp], upperx[1][nMidCusp]], [upd2, upd2],
fixStartDirection=True,
fixEndDerivative=True)[0]
lowerd2factor = 2.0 * (outerHeight + innerDepth) - upperd2factor
lowerInnerd2 = [d * lowerd2factor for d in axisUp]
lowerd2 = [[lowerInnerd2] * elementsCountAround,
[lowerOuterd2] * elementsCountAround
] # some lowerd2[0] to be fitted below
upperd2 = [[upd2] * (elementsCountAround * 2),
[upd2] * elementsCountAround]
# get lower and upper derivative 1 or 2 pointing to/from cusps
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
if (n1 % 2) == nMidCusp:
lowerd2[0][n1] = [
-cuspOuterWallArcLength *
(cosRadiansAround * axisSide1[c] +
sinRadiansAround * axisSide2[c]) for c in range(3)
]
else:
upperd1[0][n1 * 2] = [
(cuspOuterWalld1[0] * (cosRadiansAround * axisSide1[c] +
sinRadiansAround * axisSide2[c]) +
cuspOuterWalld1[1] * axisUp[c]) for c in range(3)
]
# inner wall and mid sinus points; only every second one is used
sinusDepth = innerDepth - cuspThicknessLowerFactor * cuspThickness # GRC test
sinusCentre = [(baseCentre[c] - sinusDepth * axisUp[c])
for c in range(3)]
sinusx, sinusd1 = createCirclePoints(
sinusCentre, [axisSide1[c] * innerRadius for c in range(3)],
[axisSide2[c] * innerRadius
for c in range(3)], elementsCountAround)
# get sinusd2, parallel to lower inclined lines
sd2 = interp.smoothCubicHermiteDerivativesLine(
[[innerRadius, -sinusDepth], [innerRadius, outerHeight]],
[[wallThickness + sinusRadialDisplacement, innerDepth],
[0.0, upperd2factor]],
fixStartDirection=True,
fixEndDerivative=True)[0]
sinusd2 = [None] * elementsCountAround
for cusp in range(3):
n1 = cusp * 2 + nMidCusp
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
sinusd2[n1] = [(sd2[0] * (cosRadiansAround * axisSide1[c] +
sinRadiansAround * axisSide2[c]) +
sd2[1] * axisUp[c]) for c in range(3)]
# get points on arc between mid sinus and upper cusp points
arcx = []
arcd1 = []
scaled1 = 2.5 # GRC fudge factor
for cusp in range(3):
n1 = cusp * 2 + nMidCusp
n1m = n1 - 1
n1p = (n1 + 1) % elementsCountAround
n2m = n1m * 2 + 1
n2p = n1p * 2 - 1
ax, ad1 = interp.sampleCubicHermiteCurves(
[upperx[0][n2m], sinusx[n1]],
[[-scaled1 * d for d in upperd2[0][n2m]],
[scaled1 * d for d in sinusd1[n1]]],
elementsCountOut=2,
addLengthStart=0.5 * vector.magnitude(upperd2[0][n2m]),
lengthFractionStart=0.5,
addLengthEnd=0.5 * vector.magnitude(sinusd1[n1]),
lengthFractionEnd=0.5,
arcLengthDerivatives=False)[0:2]
arcx.append(ax[1])
arcd1.append(ad1[1])
ax, ad1 = interp.sampleCubicHermiteCurves(
[
sinusx[n1],
upperx[0][n2p],
], [[scaled1 * d for d in sinusd1[n1]],
[scaled1 * d for d in upperd2[0][n2p]]],
elementsCountOut=2,
addLengthStart=0.5 * vector.magnitude(sinusd1[n1]),
lengthFractionStart=0.5,
addLengthEnd=0.5 * vector.magnitude(upperd2[0][n2p]),
lengthFractionEnd=0.5,
arcLengthDerivatives=False)[0:2]
arcx.append(ax[1])
arcd1.append(ad1[1])
if nMidCusp == 0:
arcx.append(arcx.pop(0))
arcd1.append(arcd1.pop(0))
# cusp nodule points
noduleCentre = [(baseCentre[c] + axisUp[c] * (cuspHeight - innerDepth))
for c in range(3)]
nodulex = [[], []]
noduled1 = [[], []]
noduled2 = [[], []]
noduled3 = [[], []]
cuspRadialThickness = cuspThickness / sin60
for i in range(3):
nodulex[0].append(noduleCentre)
n1 = i * 2 + nMidCusp
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
nodulex[1].append([(noduleCentre[c] + cuspRadialThickness *
(cosRadiansAround * axisSide1[c] +
sinRadiansAround * axisSide2[c]))
for c in range(3)])
n1 = i * 2 - 1 + nMidCusp
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
noduled1[0].append([
noduleOuterRadialArcLength * (cosRadiansAround * axisSide1[c] +
sinRadiansAround * axisSide2[c])
for c in range(3)
])
noduled1[1].append(
vector.setMagnitude(noduled1[0][i],
noduleInnerRadialArcLength))
n1 = i * 2 + 1 + nMidCusp
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
noduled2[0].append([
noduleOuterRadialArcLength * (cosRadiansAround * axisSide1[c] +
sinRadiansAround * axisSide2[c])
for c in range(3)
])
noduled2[1].append(
vector.setMagnitude(noduled2[0][i],
noduleInnerRadialArcLength))
noduled3[0].append(
[noduleOuterAxialArcLength * axisUp[c] for c in range(3)])
noduled3[1].append(
[noduleInnerAxialArcLength * axisUp[c] for c in range(3)])
# Create nodes
lowerNodeId = [[], []]
for n3 in range(2):
for n1 in range(elementsCountAround):
node = nodes.createNode(nodeIdentifier, nodetemplateLinearS3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
lowerx[n3][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
lowerd1[n3][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
lowerd2[n3][n1])
lowerNodeId[n3].append(nodeIdentifier)
nodeIdentifier += 1
sinusNodeId = []
for n1 in range(elementsCountAround):
if (n1 % 2) != nMidCusp:
sinusNodeId.append(None)
continue
node = nodes.createNode(nodeIdentifier, nodetemplateLinearS3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
sinusx[n1])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
sinusd1[n1])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
sinusd2[n1])
sinusNodeId.append(nodeIdentifier)
nodeIdentifier += 1
arcNodeId = []
for n1 in range(elementsCountAround):
node = nodes.createNode(nodeIdentifier, nodetemplateLinearS2S3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
arcx[n1])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
arcd1[n1])
arcNodeId.append(nodeIdentifier)
nodeIdentifier += 1
noduleNodeId = [[], []]
for n3 in range(2):
for n1 in range(3):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
nodulex[n3][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
noduled1[n3][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
noduled2[n3][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS3, 1,
noduled3[n3][n1])
noduleNodeId[n3].append(nodeIdentifier)
nodeIdentifier += 1
upperNodeId = [[], []]
for n3 in range(2):
for n1 in range(len(upperx[n3])):
node = nodes.createNode(nodeIdentifier, nodetemplateLinearS3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
upperx[n3][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS1, 1,
upperd1[n3][n1])
coordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_D_DS2, 1,
upperd2[n3][n1])
upperNodeId[n3].append(nodeIdentifier)
nodeIdentifier += 1
#################
# Create elements
#################
mesh = fm.findMeshByDimension(3)
allMeshGroups = [allGroup.getMeshGroup(mesh) for allGroup in allGroups]
cuspMeshGroups = [
cuspGroup.getMeshGroup(mesh) for cuspGroup in cuspGroups
]
linearHermiteLinearBasis = fm.createElementbasis(
3, Elementbasis.FUNCTION_TYPE_LINEAR_LAGRANGE)
linearHermiteLinearBasis.setFunctionType(
2, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
hermiteLinearLinearBasis = fm.createElementbasis(
3, Elementbasis.FUNCTION_TYPE_LINEAR_LAGRANGE)
hermiteLinearLinearBasis.setFunctionType(
1, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
bicubichermitelinear = eftfactory_bicubichermitelinear(
mesh, useCrossDerivatives)
eftDefault = bicubichermitelinear.createEftNoCrossDerivatives()
elementIdentifier = max(
1,
zinc_utils.getMaximumElementIdentifier(mesh) + 1)
elementtemplate1 = mesh.createElementtemplate()
elementtemplate1.setElementShapeType(Element.SHAPE_TYPE_CUBE)
# wall elements
for cusp in range(3):
n1 = cusp * 2 - 1 + nMidCusp
n2 = n1 * 2
for e in range(6):
eft1 = None
scalefactors = None
if (e == 0) or (e == 5):
# 6 node linear-hermite-linear collapsed wedge element expanding from zero width on outer wall of root, attaching to vertical part of cusp
eft1 = mesh.createElementfieldtemplate(
linearHermiteLinearBasis)
# switch mappings to use DS2 instead of default DS1
remapEftNodeValueLabel(eft1, [1, 2, 3, 4, 5, 6, 7, 8],
Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS2, [])])
if e == 0:
nids = [
lowerNodeId[0][n1], arcNodeId[n1],
upperNodeId[0][n2], upperNodeId[0][n2 + 1],
lowerNodeId[1][n1], upperNodeId[1][n1]
]
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
remapEftNodeValueLabel(eft1, [2],
Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [1])])
else:
nids = [
arcNodeId[n1 + 1], lowerNodeId[0][n1 - 4],
upperNodeId[0][n2 + 3], upperNodeId[0][n2 - 8],
lowerNodeId[1][n1 - 4], upperNodeId[1][n1 - 4]
]
remapEftNodeValueLabel(eft1, [1],
Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [])])
ln_map = [1, 2, 3, 4, 5, 5, 6, 6]
remapEftLocalNodes(eft1, 6, ln_map)
elif (e == 1) or (e == 4):
# 6 node hermite-linear-linear collapsed wedge element on lower wall
eft1 = mesh.createElementfieldtemplate(
hermiteLinearLinearBasis)
if e == 1:
nids = [
lowerNodeId[0][n1], lowerNodeId[0][n1 + 1],
arcNodeId[n1], sinusNodeId[n1 + 1],
lowerNodeId[1][n1], lowerNodeId[1][n1 + 1]
]
else:
nids = [
lowerNodeId[0][n1 + 1], lowerNodeId[0][n1 - 4],
sinusNodeId[n1 + 1], arcNodeId[n1 + 1],
lowerNodeId[1][n1 + 1], lowerNodeId[1][n1 - 4]
]
ln_map = [1, 2, 3, 4, 5, 6, 5, 6]
remapEftLocalNodes(eft1, 6, ln_map)
else:
# 8 node elements with wedges on two sides
if e == 2:
eft1 = bicubichermitelinear.createEftNoCrossDerivatives(
)
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
nids = [
arcNodeId[n1], sinusNodeId[n1 + 1],
upperNodeId[0][n2 + 1], upperNodeId[0][n2 + 2],
lowerNodeId[1][n1], lowerNodeId[1][n1 + 1],
upperNodeId[1][n1], upperNodeId[1][n1 + 1]
]
remapEftNodeValueLabel(eft1, [1],
Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [1])])
else:
eft1 = eftDefault
nids = [
sinusNodeId[n1 + 1], arcNodeId[n1 + 1],
upperNodeId[0][n2 + 2], upperNodeId[0][n2 + 3],
lowerNodeId[1][n1 + 1], lowerNodeId[1][n1 - 4],
upperNodeId[1][n1 + 1], upperNodeId[1][n1 - 4]
]
remapEftNodeValueLabel(eft1, [2],
Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [])])
result = elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier,
elementtemplate1)
result2 = element.setNodesByIdentifier(eft1, nids)
if scalefactors:
result3 = element.setScaleFactors(eft1, scalefactors)
else:
result3 = 7
#print('create arterial root wall', cusp, e, 'element',elementIdentifier, result, result2, result3, nids)
elementIdentifier += 1
for meshGroup in allMeshGroups:
meshGroup.addElement(element)
# cusps (leaflets)
for cusp in range(3):
n1 = cusp * 2 - 1 + nMidCusp
n2 = n1 * 2
meshGroups = allMeshGroups + [cuspMeshGroups[cusp]]
for e in range(2):
eft1 = bicubichermitelinear.createEftNoCrossDerivatives()
setEftScaleFactorIds(eft1, [1], [])
scalefactors = [-1.0]
if e == 0:
nids = [
lowerNodeId[0][n1], lowerNodeId[0][n1 + 1],
upperNodeId[0][n2], noduleNodeId[0][cusp],
arcNodeId[n1], sinusNodeId[n1 + 1],
upperNodeId[0][n2 + 1], noduleNodeId[1][cusp]
]
remapEftNodeValueLabel(eft1, [4, 8],
Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1])])
remapEftNodeValueLabel(eft1, [4, 8],
Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [5], Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [1])])
remapEftNodeValueLabel(eft1, [6], Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS2, [1])])
remapEftNodeValueLabel(eft1, [7], Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1])])
else:
nids = [
lowerNodeId[0][n1 + 1], lowerNodeId[0][n1 - 4],
noduleNodeId[0][cusp], upperNodeId[0][n2 - 8],
sinusNodeId[n1 + 1], arcNodeId[n1 + 1],
noduleNodeId[1][cusp], upperNodeId[0][n2 + 3]
]
remapEftNodeValueLabel(eft1, [3, 7],
Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS3, [])])
remapEftNodeValueLabel(eft1, [3, 7],
Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS2, [])])
remapEftNodeValueLabel(eft1, [4, 8],
Node.VALUE_LABEL_D_DS1,
[(Node.VALUE_LABEL_D_DS1, [1])])
remapEftNodeValueLabel(eft1, [5], Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS2, [1])])
remapEftNodeValueLabel(eft1, [6], Node.VALUE_LABEL_D_DS2,
[(Node.VALUE_LABEL_D_DS1, [])])
result = elementtemplate1.defineField(coordinates, -1, eft1)
element = mesh.createElement(elementIdentifier,
elementtemplate1)
result2 = element.setNodesByIdentifier(eft1, nids)
if scalefactors:
result3 = element.setScaleFactors(eft1, scalefactors)
else:
result3 = 7
#print('create semilunar cusp', cusp, e, 'element',elementIdentifier, result, result2, result3, nids)
elementIdentifier += 1
for meshGroup in meshGroups:
meshGroup.addElement(element)
# create annotation points
datapoint = fiducialPoints.createNode(-1, datapointTemplateExternal)
cache.setNode(datapoint)
fiducialCoordinates.setNodeParameters(cache, -1,
Node.VALUE_LABEL_VALUE, 1,
noduleCentre)
fiducialLabel.assignString(
cache, 'aortic valve ctr'
if aorticNotPulmonary else 'pulmonary valve ctr')
fm.endChange()
return annotationGroups
def getCylindricalSegmentInnerPoints(elementsCountAround,
elementsCountAlongSegment, segmentLength,
wallThickness, startRadius,
startRadiusDerivative, endRadius,
endRadiusDerivative, startPhase):
"""
Generates a 3-D cylindrical segment mesh with variable numbers of elements
around, along the central path, and through wall.
:param elementsCountAround: Number of elements around.
:param elementsCountAlongSegment: Number of elements along cylindrical segment.
:param segmentLength: Length of a cylindrical segment.
:param wallThickness: Thickness of wall.
:param startRadius: Inner radius at proximal end.
:param startRadiusDerivative: Rate of change of inner radius at proximal end.
:param endRadius: Inner radius at distal end.
:param endRadiusDerivative: Rate of change of inner radius at distal end.
:param startPhase: Phase at start.
:return coordinates, derivatives on inner surface of a cylindrical segment.
:return transitElementList: stores true if element around is an element that
transits between a big and small element.
:return xiList: List of xi for each node around. xi refers to node position
along the width when cylindrical segment is opened into a flat preparation,
nominally in [0.0, 1.0].
:return flatWidthList: List of width around elements for each element
along cylindrical segment when the segment is opened into a flat preparation.
:return segmentAxis: Axis of segment.
:return sRadiusAlongSegment: radius of each element along segment.
"""
transitElementList = [0] * elementsCountAround
# create nodes
segmentAxis = [0.0, 0.0, 1.0]
xFinal = []
d1Final = []
d2Final = []
xiList = []
flatWidthList = []
sRadiusAlongSegment = []
for n2 in range(elementsCountAlongSegment + 1):
phase = startPhase + n2 * 360.0 / elementsCountAlongSegment
xi = (phase if phase <= 360.0 else phase - 360.0) / 360.0
radius = interp.interpolateCubicHermite([startRadius],
[startRadiusDerivative],
[endRadius],
[endRadiusDerivative], xi)[0]
sRadiusAlongSegment.append(radius)
z = segmentLength / elementsCountAlongSegment * n2 + startPhase / 360.0 * segmentLength
xLoop, d1Loop = createCirclePoints([0.0, 0.0, z], [radius, 0.0, 0.0],
[0.0, radius, 0.0],
elementsCountAround,
startRadians=0.0)
xFinal = xFinal + xLoop
d1Final = d1Final + d1Loop
# Smooth d2 for segment
smoothd2Raw = []
for n1 in range(elementsCountAround):
nx = []
nd2 = []
for n2 in range(elementsCountAlongSegment + 1):
n = n2 * elementsCountAround + n1
nx.append(xFinal[n])
nd2.append(segmentAxis)
smoothd2 = interp.smoothCubicHermiteDerivativesLine(nx, nd2)
smoothd2Raw.append(smoothd2)
# Re-arrange smoothd2
for n2 in range(elementsCountAlongSegment + 1):
radius = sRadiusAlongSegment[n2]
flatWidth = 2.0 * math.pi * (radius + wallThickness)
flatWidthList.append(flatWidth)
xiFace = []
for n1 in range(elementsCountAround):
d2Final.append(smoothd2Raw[n1][n2])
for n1 in range(elementsCountAround + 1):
xi = 1.0 / elementsCountAround * n1
xiFace.append(xi)
xiList.append(xiFace)
return xFinal, d1Final, d2Final, transitElementList, xiList, flatWidthList, segmentAxis, sRadiusAlongSegment
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 generateBaseMesh(cls, region, options):
'''
Generate the base bicubic Hermite mesh.
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: list of AnnotationGroup
'''
elementsCountUpNeck = options['Number of elements up neck']
elementsCountUpBody = options['Number of elements up body']
elementsCountAround = options['Number of elements around']
height = options['Height']
majorDiameter = options['Major diameter']
minorDiameter = options['Minor diameter']
radius = 0.5 * options['Urethra diameter']
bladderWallThickness = options['Bladder wall thickness']
useCrossDerivatives = options['Use cross derivatives']
elementsCountAroundOstium = options['Number of elements around ostium']
elementsCountAnnulusRadially = options['Number of elements radially on annulus']
ostiumPositionAround = options['Ostium position around']
ostiumPositionUp = options['Ostium position up']
ostiumOptions = options['Ureter']
ostiumDefaultOptions = ostiumOptions.getScaffoldSettings()
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
cache = fm.createFieldcache()
mesh = fm.findMeshByDimension(3)
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplateApex = nodes.createNodetemplate()
nodetemplateApex.defineField(coordinates)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplateApex.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
if useCrossDerivatives:
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D2_DS1DS2, 1)
else:
nodetemplate = nodetemplateApex
eftfactory = eftfactory_bicubichermitelinear(mesh, useCrossDerivatives)
eft = eftfactory.createEftBasic()
elementtemplate = mesh.createElementtemplate()
elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
elementtemplate.defineField(coordinates, -1, eft)
neckGroup = AnnotationGroup(region, get_bladder_term("neck of urinary bladder"))
bodyGroup = AnnotationGroup(region, get_bladder_term("dome of the bladder"))
urinaryBladderGroup = AnnotationGroup(region, get_bladder_term("urinary bladder"))
annotationGroups = [neckGroup, bodyGroup, urinaryBladderGroup]
neckMeshGroup = neckGroup.getMeshGroup(mesh)
bodyMeshGroup = bodyGroup.getMeshGroup(mesh)
urinaryBladderMeshGroup = urinaryBladderGroup.getMeshGroup(mesh)
# create nodes
# create neck of the bladder
nodeIdentifier = 1
radiansPerElementAround = 2.0*math.pi/elementsCountAround
radiansPerElementUpNeck = (math.pi/4)/elementsCountUpNeck
# create lower part of the ellipsoidal
neckHeight = height - height * math.cos(math.pi / 4)
ellipsoidal_x = []
ellipsoidal_d1 = []
ellipsoidal_d2 = []
for n2 in range(0, elementsCountUpNeck+1):
radiansUp = n2 * radiansPerElementUpNeck
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
majorRadius = 0.5 * majorDiameter * sinRadiansUp
minorRadius = 0.5 * minorDiameter * sinRadiansUp
if n2 == 0:
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-majorRadius * sinRadiansAround,
minorRadius * cosRadiansAround,
-height - neckHeight
]
dx_ds1 = [
-majorRadius * cosRadiansAround * radiansPerElementAround,
minorRadius * -sinRadiansAround * radiansPerElementAround,
0.0
]
dx_ds2 = [
-0.5 * majorDiameter * sinRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
0.5 * minorDiameter * cosRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
height * sinRadiansUp * radiansPerElementUpNeck
]
ellipsoidal_x.append(x)
ellipsoidal_d1.append(dx_ds1)
ellipsoidal_d2.append(dx_ds2)
else:
for n1 in range(elementsCountAround):
neckHeight = height - height * math.cos(math.pi/4)
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-majorRadius * sinRadiansAround,
minorRadius * cosRadiansAround,
-height - neckHeight + n2 * 2 * neckHeight / elementsCountUpNeck
]
dx_ds1 = [
-majorRadius * cosRadiansAround * radiansPerElementAround,
minorRadius * -sinRadiansAround * radiansPerElementAround,
0.0
]
dx_ds2 = [
-0.5 * majorDiameter * sinRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
0.5 * minorDiameter * cosRadiansAround * cosRadiansUp * radiansPerElementUpNeck,
height * sinRadiansUp * radiansPerElementUpNeck
]
ellipsoidal_x.append(x)
ellipsoidal_d1.append(dx_ds1)
ellipsoidal_d2.append(dx_ds2)
# create tube nodes
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
tube_x = []
tube_d1 = []
tube_d2 = []
for n2 in range(0, elementsCountUpNeck + 1):
radiansUp = n2 * radiansPerElementUpNeck
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
if n2 == 0:
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-radius * sinRadiansAround,
radius * cosRadiansAround,
-height - neckHeight
]
dx_ds1 = [
-radiansPerElementAround * radius * cosRadiansAround,
radiansPerElementAround * radius * -sinRadiansAround,
0.0
]
dx_ds2 = [0, 0, height / (2 * elementsCountUpNeck)]
tube_x.append(x)
tube_d1.append(dx_ds1)
tube_d2.append(dx_ds2)
else:
for n1 in range(elementsCountAround):
neckHeight = height - height* math.cos(math.pi/4)
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-radius * sinRadiansAround,
radius * cosRadiansAround,
-height - neckHeight + n2 * 2 * neckHeight / elementsCountUpNeck
]
dx_ds1 = [
-radiansPerElementAround * radius * cosRadiansAround,
radiansPerElementAround * radius * -sinRadiansAround,
0.0
]
dx_ds2 = [0, 0, height / elementsCountUpNeck]
tube_x.append(x)
tube_d1.append(dx_ds1)
tube_d2.append(dx_ds2)
# interpolation between the lower part of the ellipsoidal and the tube
m1 = 0
z_bottom = ellipsoidal_x[-1][2]
z_top = ellipsoidal_x[0][2]
delta_z = z_top - z_bottom
interpolatedNodes = []
interpolatedNodes_d1 = []
interpolatedNodes_d2 = []
for n2 in range(elementsCountUpNeck+1):
xi = 1.0 - (ellipsoidal_x[m1][2] - z_bottom) / delta_z
for n1 in range(elementsCountAround):
phi_inner, _, phi_outer, _ = getCubicHermiteBasis(xi)
x = [(phi_inner*tube_x[m1][c] + phi_outer*ellipsoidal_x[m1][c]) for c in range(3)]
d1 = [(phi_inner*tube_d1[m1][c] + phi_outer*ellipsoidal_d1[m1][c]) for c in range(3)]
d2 = [(phi_inner*tube_d2[m1][c] + phi_outer*ellipsoidal_d2[m1][c]) for c in range(3)]
interpolatedNodes.append(x)
interpolatedNodes_d1.append(d1)
interpolatedNodes_d2.append(d2)
m1 += 1
# smoothing the derivatives
sd2Raw = []
for n1 in range(elementsCountAround):
lineSmoothingNodes = []
lineSmoothingNodes_d2 = []
for n2 in range(elementsCountUpNeck+1):
lineSmoothingNodes.append(interpolatedNodes[n1 + n2 * elementsCountAround])
lineSmoothingNodes_d2.append(interpolatedNodes_d2[n1 + n2 * elementsCountAround])
sd2 = smoothCubicHermiteDerivativesLine(lineSmoothingNodes, lineSmoothingNodes_d2,
fixAllDirections=False,
fixStartDerivative=True, fixEndDerivative=True,
fixStartDirection=False, fixEndDirection=False)
sd2Raw.append(sd2)
# re-arrange the derivatives order
d2RearrangedList = []
for n2 in range(elementsCountUpNeck+1):
for n1 in range(elementsCountAround):
d2 = sd2Raw[n1][n2]
d2RearrangedList.append(d2)
# create tracksurface at the outer layer of the neck
nodesOnTrackSurface = []
nodesOnTrackSurface_d1 = []
nodesOnTrackSurface_d2 = []
for n2 in range(elementsCountUpNeck+1):
for n1 in range(elementsCountAround):
if (n1 <= elementsCountAround / 2):
nodesOnTrackSurface.append(interpolatedNodes[n2 * elementsCountAround + n1])
nodesOnTrackSurface_d1.append(interpolatedNodes_d1[n2 * elementsCountAround + n1])
nodesOnTrackSurface_d2.append(d2RearrangedList[n2 * elementsCountAround + n1])
# nodes and derivatives of the neck of the bladder
listOuterNeck_x = []
listOuterNeck_d1 = []
listOuterNeck_d2 = []
elementsCount1 = elementsCountAround // 2
elementsCount2 = elementsCountUpNeck
tracksurfaceOstium1 = TrackSurface(elementsCount1, elementsCount2, nodesOnTrackSurface, nodesOnTrackSurface_d1,
nodesOnTrackSurface_d2)
ostium1Position = tracksurfaceOstium1.createPositionProportion(ostiumPositionAround, ostiumPositionUp)
ostium1Position.xi1 = 1.0
ostium1Position.xi2 = 1.0
ostiumElementPositionAround = ostium1Position.e1
ostiumElementPositionUp = ostium1Position.e2
for n2 in range(len(interpolatedNodes)):
listOuterNeck_x.append(interpolatedNodes[n2])
listOuterNeck_d1.append(interpolatedNodes_d1[n2])
listOuterNeck_d2.append(d2RearrangedList[n2])
# create body of the bladder
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
radiansPerElementUpBody = (3 * math.pi / 4) / elementsCountUpBody
# create regular rows
listOuterBody_x = []
listOuterBody_d1 = []
listOuterBody_d2 = []
for n2 in range(1, elementsCountUpBody):
radiansUp = (math.pi / 4) + n2 * radiansPerElementUpBody
cosRadiansUp = math.cos(radiansUp)
sinRadiansUp = math.sin(radiansUp)
majorRadius = 0.5 * majorDiameter * sinRadiansUp
minorRadius = 0.5 * minorDiameter * sinRadiansUp
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
x = [
-majorRadius * sinRadiansAround,
minorRadius * cosRadiansAround,
-height * cosRadiansUp
]
dx_ds1 = [
-majorRadius * cosRadiansAround * radiansPerElementAround,
minorRadius * -sinRadiansAround * radiansPerElementAround,
0.0
]
dx_ds2 = [
-0.5 * majorDiameter * sinRadiansAround * cosRadiansUp * radiansPerElementUpBody,
0.5 * minorDiameter * cosRadiansAround * cosRadiansUp * radiansPerElementUpBody,
height*sinRadiansUp * radiansPerElementUpBody
]
listOuterBody_x.append(x)
listOuterBody_d1.append(dx_ds1)
listOuterBody_d2.append(dx_ds2)
# create outer apex node
outerApexNode_x = []
outerApexNode_d1 = []
outerApexNode_d2 = []
x = [0.0, 0.0, height]
dx_ds1 = [height*radiansPerElementUpBody/2, 0.0, 0.0]
dx_ds2 = [0.0, height*radiansPerElementUpBody/2, 0.0]
outerApexNode_x.append(x)
outerApexNode_d1.append(dx_ds1)
outerApexNode_d2.append(dx_ds2)
# set nodes of outer layer of the bladder
listTotalOuter_x = listOuterNeck_x + listOuterBody_x + outerApexNode_x
listTotalOuter_d1 = listOuterNeck_d1 + listOuterBody_d1 + outerApexNode_d1
listTotalOuter_d2 = listOuterNeck_d2 + listOuterBody_d2 + outerApexNode_d2
outerLayer_x = []
outerLayer_d1 = []
outerLayer_d2 = []
for n2 in range(len(listTotalOuter_x)):
if (n2 != (ostiumElementPositionUp + 1) * elementsCountAround + ostiumElementPositionAround + 1) and\
(n2 != (ostiumElementPositionUp + 1) * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 1):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, listTotalOuter_x[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, listTotalOuter_d1[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, listTotalOuter_d2[n2])
nodeIdentifier += 1
outerLayer_x.append(listTotalOuter_x[n2])
outerLayer_d1.append(listTotalOuter_d1[n2])
outerLayer_d2.append(listTotalOuter_d2[n2])
# create and set nodes of inner layer of the bladder
listTotalInner_x = []
listTotalInner_d1 = []
listTotalInner_d2 = []
for n2 in range(elementsCountUpNeck + elementsCountUpBody):
loop_x = [listTotalOuter_x[n2 * elementsCountAround + n1] for n1 in range(elementsCountAround)]
loop_d1 = [listTotalOuter_d1[n2 * elementsCountAround + n1] for n1 in range(elementsCountAround)]
loop_d2 = [listTotalOuter_d2[n2 * elementsCountAround + n1] for n1 in range(elementsCountAround)]
for n1 in range(elementsCountAround):
x, d1, _, _ = interp.projectHermiteCurvesThroughWall(loop_x, loop_d1, loop_d2, n1,
-bladderWallThickness, loop=True)
listTotalInner_x.append(x)
listTotalInner_d1.append(d1)
listInner_d2 = []
for n2 in range(elementsCountAround):
nx = [listTotalOuter_x[n1 * elementsCountAround + n2] for n1 in range(elementsCountUpNeck + elementsCountUpBody)]
nd1 = [listTotalOuter_d1[n1 * elementsCountAround + n2] for n1 in range(elementsCountUpNeck + elementsCountUpBody)]
nd2 = [listTotalOuter_d2[n1 * elementsCountAround + n2] for n1 in range(elementsCountUpNeck + elementsCountUpBody)]
for n1 in range(elementsCountUpNeck + elementsCountUpBody):
_, d2, _, _ = interp.projectHermiteCurvesThroughWall(nx, nd2, nd1, n1,
bladderWallThickness, loop=False)
listInner_d2.append(d2)
# re-arrange the derivatives order
for n2 in range(elementsCountUpNeck + elementsCountUpBody):
for n1 in range(elementsCountAround):
rearranged_d2 = listInner_d2[n1 * (elementsCountUpNeck + elementsCountUpBody) + n2]
listTotalInner_d2.append(rearranged_d2)
innerLayer_x = []
innerLayer_d1 = []
innerLayer_d2 = []
for n2 in range(len(listTotalInner_x)):
if (n2 != (ostiumElementPositionUp + 1) * elementsCountAround + ostiumElementPositionAround + 1) and \
(n2 != (ostiumElementPositionUp + 1) * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 1):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, listTotalInner_x[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, listTotalInner_d1[n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, listTotalInner_d2[n2])
nodeIdentifier += 1
innerLayer_x.append(listTotalInner_x[n2])
innerLayer_d1.append(listTotalInner_d1[n2])
innerLayer_d2.append(listTotalInner_d2[n2])
# create inner apex node
x = [0.0, 0.0, height - bladderWallThickness]
dx_ds1 = [height*radiansPerElementUpBody/2, 0.0, 0.0]
dx_ds2 = [0.0, height*radiansPerElementUpBody/2, 0.0]
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, x)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, dx_ds1)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, dx_ds2)
listTotalInner_x.append(x)
listTotalInner_d1.append(dx_ds1)
listTotalInner_d2.append(dx_ds2)
innerLayer_x.append(x)
innerLayer_d1.append(dx_ds1)
innerLayer_d2.append(dx_ds2)
nodeIdentifier += 1
# create ureters on the surface
elementIdentifier = 1
# ureter 1
centerUreter1_x, centerUreter1_d1, centerUreter1_d2 = tracksurfaceOstium1.evaluateCoordinates(ostium1Position, derivatives=True)
td1, td2, td3 = calculate_surface_axes(centerUreter1_d1, centerUreter1_d2, [1.0, 0.0, 0.0])
m1 = ostiumElementPositionUp * elementsCountAround + ostiumElementPositionAround
ureter1StartCornerx = listOuterNeck_x[m1]
v1 = [(ureter1StartCornerx[c] - centerUreter1_x[c]) for c in range(3)]
ostium1Direction = vector.crossproduct3(td3, v1)
nodeIdentifier, elementIdentifier, (o1_x, o1_d1, o1_d2, _, o1_NodeId, o1_Positions) = \
generateOstiumMesh(region, ostiumDefaultOptions, tracksurfaceOstium1, ostium1Position, ostium1Direction,
startNodeIdentifier=nodeIdentifier, startElementIdentifier=elementIdentifier)
# ureter 2
tracksurfaceOstium2 = tracksurfaceOstium1.createMirrorX()
ostium2Position = TrackSurfacePosition(elementsCountAround - ostiumElementPositionAround, ostiumElementPositionUp - 1, 0.0, 1.0)
centerUreter2_x, centerUreter2_d1, centerUreter2_d2 = tracksurfaceOstium2.evaluateCoordinates(ostium2Position, derivatives =True)
ad1, ad2, ad3 = calculate_surface_axes(centerUreter2_d1, centerUreter2_d2, [1.0, 0.0, 0.0])
if elementsCountAroundOstium == 4:
m2 = ostiumElementPositionUp * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 1
else:
m2 = ostiumElementPositionUp * elementsCountAround + elementsCountAround - ostiumElementPositionAround - 2
ureter2StartCornerx = listOuterNeck_x[m2]
v2 = [(ureter2StartCornerx[c] - centerUreter2_x[c]) for c in range(3)]
ostium2Direction = vector.crossproduct3(ad3, v2)
nodeIdentifier, elementIdentifier, (o2_x, o2_d1, o2_d2, _, o2_NodeId, o2_Positions) = \
generateOstiumMesh(region, ostiumDefaultOptions, tracksurfaceOstium2, ostium2Position, ostium2Direction,
startNodeIdentifier=nodeIdentifier, startElementIdentifier=elementIdentifier)
# create annulus mesh around ostium
endPoints1_x = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints1_d1 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints1_d2 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endNode1_Id = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endDerivativesMap = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints2_x = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints2_d1 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endPoints2_d2 = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
endNode2_Id = [[None] * elementsCountAroundOstium, [None] * elementsCountAroundOstium]
nodeCountsEachWallLayer = (elementsCountUpNeck + elementsCountUpBody) * elementsCountAround - 1
for n3 in range(2):
n1 = 0
endNode1_Id[n3][n1] = ((1 - n3) * nodeCountsEachWallLayer) + (ostiumElementPositionUp * elementsCountAround) + ostiumElementPositionAround + 1
endNode1_Id[n3][n1 + 1] = endNode1_Id[n3][n1] + elementsCountAround
endNode1_Id[n3][n1 + 2] = endNode1_Id[n3][n1 + 1] + elementsCountAround - 2
endNode1_Id[n3][n1 + 3] = endNode1_Id[n3][n1 + 2] + 1
endNode1_Id[n3][n1 + 4] = endNode1_Id[n3][n1 + 3] + 1
endNode1_Id[n3][n1 + 5] = endNode1_Id[n3][n1 + 1] + 1
endNode1_Id[n3][n1 + 6] = endNode1_Id[n3][n1] + 2
endNode1_Id[n3][n1 + 7] = endNode1_Id[n3][n1] + 1
if ostiumElementPositionAround == 0:
endNode2_Id[n3][n1] = ((1 - n3) * nodeCountsEachWallLayer) + (ostiumElementPositionUp * elementsCountAround)\
+ elementsCountAround - ostiumElementPositionAround - 1
endNode2_Id[n3][n1 + 1] = endNode2_Id[n3][n1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 2] = endNode2_Id[n3][n1 + 1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 3] = endNode2_Id[n3][n1 + 2] + 1
endNode2_Id[n3][n1 + 4] = endNode2_Id[n3][n1 + 3] - elementsCountAround + 1
endNode2_Id[n3][n1 + 5] = endNode2_Id[n3][n1 + 4] - elementsCountAround + 2
endNode2_Id[n3][n1 + 6] = endNode2_Id[n3][n1 + 5] - elementsCountAround
endNode2_Id[n3][n1 + 7] = endNode2_Id[n3][n1] + 1
else:
endNode2_Id[n3][n1] = ((1 - n3) * nodeCountsEachWallLayer) + (ostiumElementPositionUp * elementsCountAround)\
+ elementsCountAround - ostiumElementPositionAround - 1
endNode2_Id[n3][n1 + 1] = endNode2_Id[n3][n1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 2] = endNode2_Id[n3][n1 + 1] + elementsCountAround - 1
endNode2_Id[n3][n1 + 3] = endNode2_Id[n3][n1 + 2] + 1
endNode2_Id[n3][n1 + 4] = endNode2_Id[n3][n1 + 3] + 1
endNode2_Id[n3][n1 + 5] = endNode2_Id[n3][n1 + 1] + 1
endNode2_Id[n3][n1 + 6] = endNode2_Id[n3][n1] + 2
endNode2_Id[n3][n1 + 7] = endNode2_Id[n3][n1] + 1
for n3 in range(2):
for n1 in range(elementsCountAroundOstium):
nc1 = endNode1_Id[n3][n1] - (1 - n3) * nodeCountsEachWallLayer - 1
endPoints1_x[n3][n1] = innerLayer_x[nc1]
endPoints1_d1[n3][n1] = innerLayer_d1[nc1]
endPoints1_d2[n3][n1] = [innerLayer_d2[nc1][c] for c in range(3)]
nc2 = endNode2_Id[n3][n1] - (1 - n3) * nodeCountsEachWallLayer - 1
endPoints2_x[n3][n1] = innerLayer_x[nc2]
endPoints2_d1[n3][n1] = innerLayer_d1[nc2]
endPoints2_d2[n3][n1] = innerLayer_d2[nc2]
for n1 in range(elementsCountAroundOstium):
if n1 == 0:
endDerivativesMap[0][n1] = ((-1, 0, 0), (-1, -1, 0), None, (0, 1, 0))
endDerivativesMap[1][n1] = ((-1, 0, 0), (-1, -1, 0), None, (0, 1, 0))
elif n1 == 1:
endDerivativesMap[0][n1] = ((0, 1, 0), (-1, 0, 0), None)
endDerivativesMap[1][n1] = ((0, 1, 0), (-1, 0, 0), None)
elif n1 == 2:
endDerivativesMap[0][n1] = ((0, 1, 0), (-1, 1, 0), None, (1, 0, 0))
endDerivativesMap[1][n1] = ((0, 1, 0), (-1, 1, 0), None, (1, 0, 0))
elif n1 == 3:
endDerivativesMap[0][n1] = ((1, 0, 0), (0, 1, 0), None)
endDerivativesMap[1][n1] = ((1, 0, 0), (0, 1, 0), None)
elif n1 == 4:
endDerivativesMap[0][n1] = ((1, 0, 0), (1, 1, 0), None, (0, -1, 0))
endDerivativesMap[1][n1] = ((1, 0, 0), (1, 1, 0), None, (0, -1, 0))
elif n1 == 5:
endDerivativesMap[0][n1] = ((0, -1, 0), (1, 0, 0), None)
endDerivativesMap[1][n1] = ((0, -1, 0), (1, 0, 0), None)
elif n1 == 6:
endDerivativesMap[0][n1] = ((0, -1, 0), (1, -1, 0), None, (-1, 0, 0))
endDerivativesMap[1][n1] = ((0, -1, 0), (1, -1, 0), None, (-1, 0, 0))
else:
endDerivativesMap[0][n1] = ((-1, 0, 0), (0, -1, 0), None)
endDerivativesMap[1][n1] = ((-1, 0, 0), (0, -1, 0), None)
nodeIdentifier, elementIdentifier = createAnnulusMesh3d(
nodes, mesh, nodeIdentifier, elementIdentifier,
o1_x, o1_d1, o1_d2, None, o1_NodeId, None,
endPoints1_x, endPoints1_d1, endPoints1_d2, None, endNode1_Id, endDerivativesMap,
elementsCountRadial=elementsCountAnnulusRadially, meshGroups=[neckMeshGroup, urinaryBladderMeshGroup])
nodeIdentifier, elementIdentifier = createAnnulusMesh3d(
nodes, mesh, nodeIdentifier, elementIdentifier,
o2_x, o2_d1, o2_d2, None, o2_NodeId, None,
endPoints2_x, endPoints2_d1, endPoints2_d2, None, endNode2_Id, endDerivativesMap,
elementsCountRadial=elementsCountAnnulusRadially, meshGroups=[neckMeshGroup, urinaryBladderMeshGroup])
# create elements
for e3 in range(1):
newl = (e3 + 1) * ((elementsCountUpNeck + elementsCountUpBody) * elementsCountAround - 1)
# create bladder neck elements
for e2 in range(elementsCountUpNeck):
for e1 in range(elementsCountAround):
if e2 == ostiumElementPositionUp:
if (e1 == ostiumElementPositionAround or e1 == ostiumElementPositionAround + 1):
pass
elif (e1 == elementsCountAround - ostiumElementPositionAround - 2 or e1 == elementsCountAround - 1 - ostiumElementPositionAround):
pass
else:
bni1 = e2 * elementsCountAround + e1 + 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
if e1 < ostiumElementPositionAround:
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
elif (ostiumElementPositionAround + 1 < e1 < elementsCountAround - ostiumElementPositionAround - 2):
bni3 = bni1 + elementsCountAround - 1
bni4 = bni2 + elementsCountAround - 1
elif e1 > elementsCountAround - ostiumElementPositionAround - 1:
bni3 = bni1 + elementsCountAround - 2
if e1 == elementsCountAround - 1:
bni4 = bni2 + elementsCountAround
else:
bni4 = bni2 + elementsCountAround - 2
element = mesh.createElement(elementIdentifier, elementtemplate)
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
elif e2 == ostiumElementPositionUp + 1:
if (e1 == ostiumElementPositionAround or e1 == ostiumElementPositionAround + 1):
pass
elif (e1 == elementsCountAround - ostiumElementPositionAround - 2 or e1 == elementsCountAround - 1 - ostiumElementPositionAround):
pass
else:
if e1 < ostiumElementPositionAround:
bni1 = e2 * elementsCountAround + e1 + 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
bni3 = bni1 + elementsCountAround - 2
bni4 = bni2 + elementsCountAround - 2
elif (ostiumElementPositionAround + 1 < e1 < elementsCountAround - ostiumElementPositionAround - 2):
bni1 = e2 * elementsCountAround + e1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround
bni3 = bni1 + elementsCountAround - 1
bni4 = bni2 + elementsCountAround - 1
elif e1 > elementsCountAround - ostiumElementPositionAround - 1:
bni1 = e2 * elementsCountAround + e1 - 1
bni3 = bni1 + elementsCountAround
if e1 == elementsCountAround - 1:
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
bni4 = bni2 + elementsCountAround - 2
else:
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround - 1
bni4 = bni2 + elementsCountAround
element = mesh.createElement(elementIdentifier, elementtemplate)
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
elif e2 > ostiumElementPositionUp + 1:
element = mesh.createElement(elementIdentifier, elementtemplate)
bni1 = e2 * elementsCountAround + e1 - 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround - 1
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
else:
element = mesh.createElement(elementIdentifier, elementtemplate)
bni1 = e2 * elementsCountAround + e1 + 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround + 1
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
neckMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
# create bladder body elements
for e2 in range(elementsCountUpNeck, (elementsCountUpNeck + elementsCountUpBody - 1)):
for e1 in range(elementsCountAround):
element = mesh.createElement(elementIdentifier, elementtemplate)
bni1 = e2 * elementsCountAround + e1 - 1
bni2 = e2 * elementsCountAround + (e1 + 1) % elementsCountAround - 1
bni3 = bni1 + elementsCountAround
bni4 = bni2 + elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni4 + newl,
bni1, bni2, bni3, bni4]
result = element.setNodesByIdentifier(eft, nodeIdentifiers)
bodyMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
# create apex elements
bni3 = (elementsCountUpNeck + elementsCountUpBody) * elementsCountAround - 1
elementtemplateApex = mesh.createElementtemplate()
elementtemplateApex.setElementShapeType(Element.SHAPE_TYPE_CUBE)
for e1 in range(elementsCountAround):
va = e1
vb = (e1 + 1) % elementsCountAround
eftApex = eftfactory.createEftShellPoleTop(va, vb)
elementtemplateApex.defineField(coordinates, -1, eftApex)
# redefine field in template for changes to eftApex:
element = mesh.createElement(elementIdentifier, elementtemplateApex)
bni1 = bni3 - elementsCountAround + e1
bni2 = bni3 - elementsCountAround + (e1 + 1) % elementsCountAround
nodeIdentifiers = [bni1 + newl, bni2 + newl, bni3 + newl, bni1, bni2, bni3]
result = element.setNodesByIdentifier(eftApex, nodeIdentifiers)
bodyMeshGroup.addElement(element)
urinaryBladderMeshGroup.addElement(element)
elementIdentifier += 1
fm.endChange()
return annotationGroups
def make_tube_bifurcation_points(paCentre, pax, pad2, c1Centre, c1x, c1d2,
c2Centre, c2x, c2d2):
'''
Gets first ring of coordinates and derivatives between parent pa and
children c1, c2, and over the crotch between c1 and c2.
:return rox, rod1, rod2, cox, cod1, cod2
'''
paCount = len(pax)
c1Count = len(c1x)
c2Count = len(c2x)
pac1Count, pac2Count, c1c2Count = get_tube_bifurcation_connection_elements_counts(
paCount, c1Count, c2Count)
# convert to number of nodes, includes both 6-way points
pac1NodeCount = pac1Count + 1
pac2NodeCount = pac2Count + 1
c1c2NodeCount = c1c2Count + 1
paStartIndex = 0
c1StartIndex = 0
c2StartIndex = 0
pac1x = [None] * pac1NodeCount
pac1d1 = [None] * pac1NodeCount
pac1d2 = [None] * pac1NodeCount
for n in range(pac1NodeCount):
pan = (paStartIndex + n) % paCount
c1n = (c1StartIndex + n) % c1Count
x1, d1, x2, d2 = pax[pan], mult(pad2[pan],
2.0), c1x[c1n], mult(c1d2[c1n], 2.0)
pac1x[n] = interpolateCubicHermite(x1, d1, x2, d2, 0.5)
pac1d1[n] = [0.0, 0.0, 0.0]
pac1d2[n] = mult(
interpolateCubicHermiteDerivative(x1, d1, x2, d2, 0.5), 0.5)
paStartIndex2 = paStartIndex + pac1Count
c1StartIndex2 = c1StartIndex + pac1Count
c2StartIndex2 = c2StartIndex + c1c2Count
pac2x = [None] * pac2NodeCount
pac2d1 = [None] * pac2NodeCount
pac2d2 = [None] * pac2NodeCount
for n in range(pac2NodeCount):
pan = (paStartIndex2 + n) % paCount
c2n = (c2StartIndex2 + n) % c2Count
x1, d1, x2, d2 = pax[pan], mult(pad2[pan],
2.0), c2x[c2n], mult(c2d2[c2n], 2.0)
pac2x[n] = interpolateCubicHermite(x1, d1, x2, d2, 0.5)
pac2d1[n] = [0.0, 0.0, 0.0]
pac2d2[n] = mult(
interpolateCubicHermiteDerivative(x1, d1, x2, d2, 0.5), 0.5)
c1c2x = [None] * c1c2NodeCount
c1c2d1 = [None] * c1c2NodeCount
c1c2d2 = [None] * c1c2NodeCount
for n in range(c1c2NodeCount):
c1n = (c1StartIndex2 + n) % c1Count
c2n = (c2StartIndex2 - n) % c2Count # note: reversed
x1, d1, x2, d2 = c2x[c2n], mult(c2d2[c2n],
-2.0), c1x[c1n], mult(c1d2[c1n], 2.0)
c1c2x[n] = interpolateCubicHermite(x1, d1, x2, d2, 0.5)
c1c2d1[n] = [0.0, 0.0, 0.0]
c1c2d2[n] = mult(
interpolateCubicHermiteDerivative(x1, d1, x2, d2, 0.5), 0.5)
# get hex triple points
hex1, hex1d1, hex1d2 = get_bifurcation_triple_point(
pax[paStartIndex], mult(pad2[paStartIndex], -1.0), c1x[c1StartIndex],
c1d2[c1StartIndex], c2x[c1StartIndex], c2d2[c2StartIndex])
hex2, hex2d1, hex2d2 = get_bifurcation_triple_point(
pax[paStartIndex2], mult(pad2[paStartIndex2],
-1.0), c2x[c2StartIndex2],
c2d2[c2StartIndex2], c1x[c1StartIndex2], c1d2[c1StartIndex2])
# smooth around loops through hex points to get d1
loop1x = [hex2] + pac2x[1:-1] + [hex1]
loop1d1 = [[-d for d in hex2d2]] + pac2d1[1:-1] + [hex1d1]
loop2x = [hex1] + pac1x[1:-1] + [hex2]
loop2d1 = [[-d for d in hex1d2]] + pac1d1[1:-1] + [hex2d1]
loop1d1 = smoothCubicHermiteDerivativesLine(
loop1x,
loop1d1,
fixStartDirection=True,
fixEndDirection=True,
magnitudeScalingMode=DerivativeScalingMode.HARMONIC_MEAN)
loop2d1 = smoothCubicHermiteDerivativesLine(
loop2x,
loop2d1,
fixStartDirection=True,
fixEndDirection=True,
magnitudeScalingMode=DerivativeScalingMode.HARMONIC_MEAN)
# smooth over "crotch" between c1 and c2
crotchx = [hex2] + c1c2x[1:-1] + [hex1]
crotchd1 = [add(hex2d1, hex2d2)] + c1c2d1[1:-1] + [[
(-hex1d1[c] - hex1d2[c]) for c in range(3)
]]
crotchd1 = smoothCubicHermiteDerivativesLine(
crotchx,
crotchd1,
fixStartDerivative=True,
fixEndDerivative=True,
magnitudeScalingMode=DerivativeScalingMode.HARMONIC_MEAN)
rox = [hex1] + pac1x[1:-1] + [hex2] + pac2x[1:-1]
rod1 = [loop1d1[-1]] + loop2d1[1:] + loop1d1[1:-1]
rod2 = [[-d for d in loop2d1[0]]
] + pac1d2[1:-1] + [[-d for d in loop1d1[0]]] + pac2d2[1:-1]
cox = crotchx[1:-1]
cod1 = crotchd1[1:-1]
cod2 = c1c2d2[1:-1]
return rox, rod1, rod2, cox, cod1, cod2, paStartIndex, c1StartIndex, c2StartIndex
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 smoothDerivativesToTriplePoints(self, n3, fixAllDirections=False):
'''
Smooth derivatives leading to triple points where 3 square elements merge.
:param n3: Index of through-wall coordinates to use.
'''
n1a = self.elementsCountRim
n1b = n1a + 1
m1a = self.elementsCountAcross - self.elementsCountRim
m1b = m1a - 1
n2a = self.elementsCountRim
n2b = n2a + 1
n2c = n2a + 2
if self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_AROUND:
# left
tx = []
td3 = []
for n2 in range(0, n2c):
tx.append(self.px[n3][n2][n1b])
td3.append([-d for d in self.pd3[n3][n2][n1b]] if (
n2 < n2b) else [(self.pd1[n3][n2][n1b][c] +
self.pd3[n3][n2][n1b][c])
for c in range(3)])
td3 = smoothCubicHermiteDerivativesLine(
tx,
td3,
fixAllDirections=fixAllDirections,
fixEndDerivative=True,
magnitudeScalingMode=DerivativeScalingMode.HARMONIC_MEAN)
for n2 in range(0, n2b):
self.pd3[n3][n2][n1b] = [-d for d in td3[n2]]
# right
tx = []
td3 = []
for n2 in range(0, n2c):
tx.append(self.px[n3][n2][m1b])
td3.append([-d for d in self.pd3[n3][n2][m1b]] if (
n2 < n2b) else [(-self.pd3[n3][n2][m1b][c] +
self.pd1[n3][n2][m1b][c])
for c in range(3)])
td3 = smoothCubicHermiteDerivativesLine(
tx,
td3,
fixAllDirections=fixAllDirections,
fixEndDerivative=True,
magnitudeScalingMode=DerivativeScalingMode.HARMONIC_MEAN)
for n2 in range(0, n2b):
self.pd3[n3][n2][m1b] = [-d for d in td3[n2]]
elif self._type == ShieldRimDerivativeMode.SHIELD_RIM_DERIVATIVE_MODE_REGULAR:
# left
tx = []
td2 = []
for n2 in range(0, n2c):
tx.append(self.px[n3][n2][n1b])
td2.append(self.pd2[n3][n2][n1b] if (
n2 < n2b) else [(self.pd1[n3][n2][n1b][c] +
self.pd2[n3][n2][n1b][c])
for c in range(3)])
td2 = smoothCubicHermiteDerivativesLine(
tx,
td2,
fixAllDirections=fixAllDirections,
fixEndDerivative=True,
magnitudeScalingMode=DerivativeScalingMode.HARMONIC_MEAN)
for n2 in range(0, n2b):
self.pd2[n3][n2][n1b] = td2[n2]
# right
tx = []
td2 = []
for n2 in range(0, n2c):
tx.append(self.px[n3][n2][m1b])
td2.append(self.pd2[n3][n2][m1b] if (
n2 < n2b) else [(-self.pd1[n3][n2][m1b][c] +
self.pd2[n3][n2][m1b][c])
for c in range(3)])
td2 = smoothCubicHermiteDerivativesLine(
tx,
td2,
fixAllDirections=fixAllDirections,
fixEndDerivative=True,
magnitudeScalingMode=DerivativeScalingMode.HARMONIC_MEAN)
for n2 in range(0, n2b):
self.pd2[n3][n2][m1b] = td2[n2]
def generateBaseMesh(region, options):
"""
Generate the base tricubic Hermite mesh. See also generateMesh().
:param region: Zinc region to define model in. Must be empty.
:param options: Dict containing options. See getDefaultOptions().
:return: annotationGroups
"""
centralPath = options['Central path']
segmentProfile = options['Segment profile']
segmentCount = options['Number of segments']
startPhase = options['Start phase'] % 360.0
proximalLength = options['Proximal length']
transverseLength = options['Transverse length']
distalLength = options['Distal length']
proximalInnerRadius = options['Proximal inner radius']
proximalTCWidth = options['Proximal tenia coli width']
proximalTransverseInnerRadius = options[
'Proximal-transverse inner radius']
proximalTransverseTCWidth = options[
'Proximal-transverse tenia coli width']
transverseDistalInnerRadius = options['Transverse-distal inner radius']
transverseDistalTCWidth = options['Transverse-distal tenia coli width']
distalInnerRadius = options['Distal inner radius']
distalTCWidth = options['Distal tenia coli width']
segmentSettings = segmentProfile.getScaffoldSettings()
elementsCountAroundTC = segmentSettings[
'Number of elements around tenia coli']
elementsCountAroundHaustrum = segmentSettings[
'Number of elements around haustrum']
cornerInnerRadiusFactor = segmentSettings['Corner inner radius factor']
haustrumInnerRadiusFactor = segmentSettings[
'Haustrum inner radius factor']
segmentLengthEndDerivativeFactor = segmentSettings[
'Segment length end derivative factor']
segmentLengthMidDerivativeFactor = segmentSettings[
'Segment length mid derivative factor']
tcCount = segmentSettings['Number of tenia coli']
tcThickness = segmentSettings['Tenia coli thickness']
elementsCountAround = (elementsCountAroundTC +
elementsCountAroundHaustrum) * tcCount
elementsCountAlongSegment = segmentSettings[
'Number of elements along segment']
elementsCountThroughWall = segmentSettings[
'Number of elements through wall']
wallThickness = segmentSettings['Wall thickness']
useCrossDerivatives = segmentSettings['Use cross derivatives']
useCubicHermiteThroughWall = not (
segmentSettings['Use linear through wall'])
elementsCountAlong = int(elementsCountAlongSegment * segmentCount)
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
# print('Length = ', length)
# Sample central path
sx, sd1, se, sxi, ssf = interp.sampleCubicHermiteCurves(
cx, cd1, elementsCountAlongSegment * segmentCount)
sd2 = interp.interpolateSampleCubicHermite(cd2, cd12, se, sxi, ssf)[0]
# Generate variation of radius & tc width along length
lengthList = [
0.0, proximalLength, proximalLength + transverseLength, length
]
innerRadiusList = [
proximalInnerRadius, proximalTransverseInnerRadius,
transverseDistalInnerRadius, distalInnerRadius
]
innerRadiusAlongElementList, dInnerRadiusAlongElementList = interp.sampleParameterAlongLine(
lengthList, innerRadiusList, elementsCountAlong)
tcWidthList = [
proximalTCWidth, proximalTransverseTCWidth,
transverseDistalTCWidth, distalTCWidth
]
tcWidthAlongElementList, dTCWidthAlongElementList = interp.sampleParameterAlongLine(
lengthList, tcWidthList, elementsCountAlong)
xExtrude = []
d1Extrude = []
d2Extrude = []
d3UnitExtrude = []
# Create object
colonSegmentTubeMeshInnerPoints = ColonSegmentTubeMeshInnerPoints(
region, elementsCountAroundTC, elementsCountAroundHaustrum,
elementsCountAlongSegment, tcCount,
segmentLengthEndDerivativeFactor, segmentLengthMidDerivativeFactor,
segmentLength, wallThickness, cornerInnerRadiusFactor,
haustrumInnerRadiusFactor, innerRadiusAlongElementList,
dInnerRadiusAlongElementList, tcWidthAlongElementList, startPhase)
for nSegment in range(segmentCount):
# Create inner points
xInner, d1Inner, d2Inner, transitElementList, segmentAxis, annotationGroups, annotationArray, \
faceMidPointsZ = colonSegmentTubeMeshInnerPoints.getColonSegmentTubeMeshInnerPoints(nSegment)
# Warp segment points
xWarpedList, d1WarpedList, d2WarpedList, d3WarpedUnitList = tubemesh.warpSegmentPoints(
xInner, d1Inner, d2Inner, segmentAxis, segmentLength, sx, sd1,
sd2, elementsCountAround, elementsCountAlongSegment, nSegment,
faceMidPointsZ)
# Store points along length
xExtrude = xExtrude + (xWarpedList if nSegment == 0 else
xWarpedList[elementsCountAround:])
d1Extrude = d1Extrude + (d1WarpedList if nSegment == 0 else
d1WarpedList[elementsCountAround:])
d2Extrude = d2Extrude + (d2WarpedList if nSegment == 0 else
d2WarpedList[elementsCountAround:])
d3UnitExtrude = d3UnitExtrude + (
d3WarpedUnitList
if nSegment == 0 else d3WarpedUnitList[elementsCountAround:])
contractedWallThicknessList = colonSegmentTubeMeshInnerPoints.getContractedWallThicknessList(
)
# Create coordinates and derivatives
xList, d1List, d2List, d3List, curvatureList = tubemesh.getCoordinatesFromInner(
xExtrude, d1Extrude, d2Extrude, d3UnitExtrude,
contractedWallThicknessList, elementsCountAround,
elementsCountAlong, elementsCountThroughWall, transitElementList)
relaxedLengthList, xiList = colonSegmentTubeMeshInnerPoints.getRelaxedLengthAndXiList(
)
if tcThickness > 0:
tubeTCWidthList = colonSegmentTubeMeshInnerPoints.getTubeTCWidthList(
)
xList, d1List, d2List, d3List, annotationGroups, annotationArray = getTeniaColi(
region, xList, d1List, d2List, d3List, curvatureList, tcCount,
elementsCountAroundTC, elementsCountAroundHaustrum,
elementsCountAlong, elementsCountThroughWall, tubeTCWidthList,
tcThickness, sx, annotationGroups, annotationArray)
# Create flat and texture coordinates
xFlat, d1Flat, d2Flat, xTexture, d1Texture, d2Texture = createFlatAndTextureCoordinatesTeniaColi(
xiList, relaxedLengthList, length, wallThickness, tcCount,
tcThickness, elementsCountAroundTC,
elementsCountAroundHaustrum, elementsCountAlong,
elementsCountThroughWall, transitElementList)
# Create nodes and elements
nextNodeIdentifier, nextElementIdentifier, annotationGroups = createNodesAndElementsTeniaColi(
region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat,
xTexture, d1Texture, d2Texture, elementsCountAroundTC,
elementsCountAroundHaustrum, elementsCountAlong,
elementsCountThroughWall, tcCount, annotationGroups,
annotationArray, firstNodeIdentifier, firstElementIdentifier,
useCubicHermiteThroughWall, useCrossDerivatives)
else:
# Create flat and texture coordinates
xFlat, d1Flat, d2Flat, xTexture, d1Texture, d2Texture = tubemesh.createFlatAndTextureCoordinates(
xiList, relaxedLengthList, 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, annotationGroups,
annotationArray, firstNodeIdentifier, firstElementIdentifier,
useCubicHermiteThroughWall, useCrossDerivatives)
return annotationGroups
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']
segmentProfile = options['Segment profile']
segmentCount = options['Number of segments']
startPhase = options['Start phase'] % 360.0
proximalLength = options['Proximal length']
transverseLength = options['Transverse length']
proximalInnerRadius = options['Proximal inner radius']
proximalTCWidth = options['Proximal tenia coli width']
proximalTransverseInnerRadius = options['Proximal-transverse inner radius']
proximalTransverseTCWidth = options['Proximal-transverse tenia coli width']
transverseDistalInnerRadius = options['Transverse-distal inner radius']
transverseDistalTCWidth = options['Transverse-distal tenia coli width']
distalInnerRadius = options['Distal inner radius']
distalTCWidth = options['Distal tenia coli width']
segmentSettings = segmentProfile.getScaffoldSettings()
elementsCountAroundTC = segmentSettings['Number of elements around tenia coli']
elementsCountAroundHaustrum = segmentSettings['Number of elements around haustrum']
cornerInnerRadiusFactor = segmentSettings['Corner inner radius factor']
haustrumInnerRadiusFactor = segmentSettings['Haustrum inner radius factor']
segmentLengthEndDerivativeFactor = segmentSettings['Segment length end derivative factor']
segmentLengthMidDerivativeFactor = segmentSettings['Segment length mid derivative factor']
tcCount = segmentSettings['Number of tenia coli']
tcThickness = segmentSettings['Tenia coli thickness']
elementsCountAround = (elementsCountAroundTC + elementsCountAroundHaustrum)*tcCount
elementsCountAlongSegment = segmentSettings['Number of elements along segment']
elementsCountThroughWall = segmentSettings['Number of elements through wall']
wallThickness = segmentSettings['Wall thickness']
useCrossDerivatives = segmentSettings['Use cross derivatives']
useCubicHermiteThroughWall = not(segmentSettings['Use linear through wall'])
elementsCountAlong = int(elementsCountAlongSegment*segmentCount)
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
# print('Length = ', length)
elementAlongLength = length / elementsCountAlong
# Sample central path
sx, sd1, se, sxi, ssf = interp.sampleCubicHermiteCurves(cx, cd1, elementsCountAlong)
sd2, sd12 = interp.interpolateSampleCubicHermite(cd2, cd12, se, sxi, ssf)
# Generate variation of radius & tc width along length
lengthList = [0.0, proximalLength, proximalLength + transverseLength, length]
innerRadiusList = [proximalInnerRadius, proximalTransverseInnerRadius,
transverseDistalInnerRadius, distalInnerRadius]
innerRadiusAlongElementList, dInnerRadiusAlongElementList = interp.sampleParameterAlongLine(lengthList,
innerRadiusList,
elementsCountAlong)
tcWidthList = [proximalTCWidth, proximalTransverseTCWidth, transverseDistalTCWidth, distalTCWidth]
tcWidthAlongElementList, dTCWidthAlongElementList = interp.sampleParameterAlongLine(lengthList,
tcWidthList,
elementsCountAlong)
# Account for reduced haustrum appearance in transverse and distal pig colon
if tcCount == 2:
haustrumInnerRadiusFactorList = [haustrumInnerRadiusFactor, haustrumInnerRadiusFactor*0.75,
haustrumInnerRadiusFactor*0.5, haustrumInnerRadiusFactor*0.2]
haustrumInnerRadiusFactorAlongElementList = \
interp.sampleParameterAlongLine(lengthList, haustrumInnerRadiusFactorList, elementsCountAlong)[0]
else:
haustrumInnerRadiusFactorAlongElementList = [haustrumInnerRadiusFactor]*(elementsCountAlong+1)
# Create annotation groups for colon sections
elementsAlongInProximal = round(proximalLength/elementAlongLength)
elementsAlongInTransverse = round(transverseLength/elementAlongLength)
elementsAlongInDistal = elementsCountAlong - elementsAlongInProximal - elementsAlongInTransverse
elementsCountAlongGroups = [elementsAlongInProximal, elementsAlongInTransverse, elementsAlongInDistal]
colonGroup = AnnotationGroup(region, get_colon_term("colon"))
if tcCount == 1:
proximalGroup = AnnotationGroup(region, get_colon_term("proximal colon"))
transverseGroup = AnnotationGroup(region, get_colon_term("transverse colon"))
distalGroup = AnnotationGroup(region, get_colon_term("distal colon"))
annotationGroupAlong = [[colonGroup, proximalGroup],
[colonGroup, transverseGroup],
[colonGroup, distalGroup]]
elif tcCount == 2:
spiralGroup = AnnotationGroup(region, get_colon_term("spiral colon"))
transverseGroup = AnnotationGroup(region, get_colon_term("transverse colon"))
distalGroup = AnnotationGroup(region, get_colon_term("distal colon"))
annotationGroupAlong = [[colonGroup, spiralGroup],
[colonGroup, transverseGroup],
[colonGroup, distalGroup]]
elif tcCount == 3:
ascendingGroup = AnnotationGroup(region, get_colon_term("ascending colon"))
transverseGroup = AnnotationGroup(region, get_colon_term("transverse colon"))
descendingGroup = AnnotationGroup(region, get_colon_term("descending colon"))
annotationGroupAlong = [[colonGroup, ascendingGroup],
[colonGroup, transverseGroup],
[colonGroup, descendingGroup]]
annotationGroupsAlong = []
for i in range(len(elementsCountAlongGroups)):
elementsCount = elementsCountAlongGroups[i]
for n in range(elementsCount):
annotationGroupsAlong.append(annotationGroupAlong[i])
annotationGroupsThroughWall = []
for i in range(elementsCountThroughWall):
annotationGroupsThroughWall.append([ ])
xExtrude = []
d1Extrude = []
d2Extrude = []
d3UnitExtrude = []
sxRefExtrudeList = []
# Create object
colonSegmentTubeMeshInnerPoints = ColonSegmentTubeMeshInnerPoints(
region, elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlongSegment,
tcCount, segmentLengthEndDerivativeFactor, segmentLengthMidDerivativeFactor,
segmentLength, wallThickness, cornerInnerRadiusFactor, haustrumInnerRadiusFactorAlongElementList,
innerRadiusAlongElementList, dInnerRadiusAlongElementList, tcWidthAlongElementList,
startPhase)
for nSegment in range(segmentCount):
# Create inner points
xInner, d1Inner, d2Inner, transitElementList, segmentAxis, annotationGroupsAround \
= colonSegmentTubeMeshInnerPoints.getColonSegmentTubeMeshInnerPoints(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, innerRadiusAlongElementList[start:end],
closedProximalEnd=False)
# Store points along length
xExtrude += xWarpedList if nSegment == 0 else xWarpedList[elementsCountAround:]
d1Extrude += d1WarpedList if nSegment == 0 else d1WarpedList[elementsCountAround:]
d2Extrude += d2WarpedList if nSegment == 0 else d2WarpedList[elementsCountAround:]
d3UnitExtrude += d3WarpedUnitList if nSegment == 0 else d3WarpedUnitList[elementsCountAround:]
sxRefExtrudeList += sxRefList if nSegment == 0 else sxRefList[elementsCountAround:]
contractedWallThicknessList = colonSegmentTubeMeshInnerPoints.getContractedWallThicknessList()
# Create coordinates and derivatives
xList, d1List, d2List, d3List, curvatureList = tubemesh.getCoordinatesFromInner(xExtrude, d1Extrude,
d2Extrude, d3UnitExtrude, contractedWallThicknessList,
elementsCountAround, elementsCountAlong, elementsCountThroughWall, transitElementList)
relaxedLengthList, xiList = colonSegmentTubeMeshInnerPoints.getRelaxedLengthAndXiList()
closedProximalEnd = False
if tcThickness > 0:
tubeTCWidthList = colonSegmentTubeMeshInnerPoints.getTubeTCWidthList()
xList, d1List, d2List, d3List, annotationArrayAround = getTeniaColi(
region, xList, d1List, d2List, d3List, curvatureList, tcCount, elementsCountAroundTC,
elementsCountAroundHaustrum, elementsCountAlong, elementsCountThroughWall,
tubeTCWidthList, tcThickness, sxRefExtrudeList, annotationGroupsAround,
closedProximalEnd)
# Create flat and texture coordinates
xFlat, d1Flat, d2Flat, xTexture, d1Texture, d2Texture = createFlatAndTextureCoordinatesTeniaColi(
xiList, relaxedLengthList, length, wallThickness, tcCount, tcThickness,
elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlong,
elementsCountThroughWall, transitElementList, closedProximalEnd)
# Create nodes and elements
nextNodeIdentifier, nextElementIdentifier, annotationGroups = createNodesAndElementsTeniaColi(
region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat, xTexture, d1Texture, d2Texture,
elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlong, elementsCountThroughWall,
tcCount, annotationGroupsAround, annotationGroupsAlong, annotationGroupsThroughWall,
firstNodeIdentifier, firstElementIdentifier, useCubicHermiteThroughWall, useCrossDerivatives,
closedProximalEnd)
else:
# Create flat and texture coordinates
xFlat, d1Flat, d2Flat, xTexture, d1Texture, d2Texture = tubemesh.createFlatAndTextureCoordinates(
xiList, relaxedLengthList, 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)
return annotationGroups
def getPoints(cls, options):
"""
Get point coordinates and derivatives for the arterial valve ring.
Optional extra parameters allow origin and orientation to be set.
:param options: Dict containing options. See getDefaultOptions().
:return: x, d1, d2, d3 all indexed by [n3=wall][n2=inlet->outlet][n1=around] where
d1 is around, d2 is in direction inlet->outlet.
d3 is radial and undefined at n2 == 1.
"""
unitScale = options['Unit scale']
innerRadius = unitScale * 0.5 * options['Inner diameter']
innerRadialDisplacement = unitScale * options[
'Inner radial displacement']
innerSinusRadialDisplacement = unitScale * options[
'Inner sinus radial displacement']
outerAngleRadians = math.radians(options['Outer angle degrees'])
outerHeight = unitScale * options['Outer height']
outerRadialDisplacement = unitScale * options[
'Outer radial displacement']
outerSinusRadialDisplacement = unitScale * options[
'Outer sinus radial displacement']
outletLength = unitScale * options['Outlet length']
sinusAngleRadians = math.radians(options['Sinus angle degrees'])
sinusDepth = unitScale * options['Sinus depth']
wallThickness = unitScale * options['Wall thickness']
rotationAzimuthRadians = math.radians(
options['Rotation azimuth degrees'])
rotationElevationRadians = math.radians(
options['Rotation elevation degrees'])
rotationRollRadians = math.radians(options['Rotation roll degrees'])
centre = [
unitScale * options['Translation x'],
unitScale * options['Translation y'],
unitScale * options['Translation z']
]
outerRadius = innerRadius + wallThickness
innerInletRadius = innerRadius + innerRadialDisplacement
innerInletSinusRadius = innerRadius + innerSinusRadialDisplacement
elementsCountAround = 6 # fixed
radiansPerElementAround = 2.0 * math.pi / elementsCountAround
pi_3 = radiansPerElementAround
#centre = [ 0.0, 0.0, 0.0 ]
#axis1 = [ 1.0, 0.0, 0.0 ]
#axis2 = [ 0.0, 1.0, 0.0 ]
#axis3 = vector.crossproduct3(axis1, axis2)
axis1, axis2, axis3 = eulerToRotationMatrix3([
rotationAzimuthRadians, rotationElevationRadians,
rotationRollRadians
])
x = [[None, None], [None, None]]
d1 = [[None, None], [None, None]]
d2 = [[None, None], [None, None]]
d3 = [[None, None], [None, None]]
# inlet
# inner layer, with sinuses
outletz = outerHeight
inletz = outletz - outletLength
sinusz = -sinusDepth
outletCentre = [(centre[c] + outletz * axis3[c]) for c in range(3)]
inletCentre = [(centre[c] + inletz * axis3[c]) for c in range(3)]
sinusCentre = [(centre[c] + sinusz * axis3[c]) for c in range(3)]
# calculate magnitude of d1, d2 at inner sinus
leafd1mag = innerInletRadius * radiansPerElementAround # was 0.5*
leafd2r, leafd2z = interpolateLagrangeHermiteDerivative(
[innerRadialDisplacement, 0.0], [0.0, outletLength],
[0.0, outletLength], 0.0)
sinusd1mag = innerInletSinusRadius * radiansPerElementAround # initial value only
sinusd1mag = vector.magnitude(
smoothCubicHermiteDerivativesLine(
[[innerInletRadius, 0.0, inletz],
[
innerInletSinusRadius * math.cos(pi_3),
innerInletSinusRadius * math.sin(pi_3), sinusz
]], [[0.0, leafd1mag, 0.0],
[
-sinusd1mag * math.sin(pi_3),
sinusd1mag * math.cos(pi_3), 0.0
]],
fixStartDerivative=True,
fixEndDirection=True)[1])
sinusd2r, sinusd2z = smoothCubicHermiteDerivativesLine(
[[innerInletSinusRadius, -sinusDepth],
[innerInletRadius, outerHeight]], [[
outletLength * math.sin(sinusAngleRadians),
outletLength * math.cos(sinusAngleRadians)
], [0.0, outletLength]],
fixStartDirection=True,
fixEndDerivative=True)[0]
magd3 = wallThickness + outerRadialDisplacement - innerRadialDisplacement
x[0][0] = []
d1[0][0] = []
d2[0][0] = []
d3[0][0] = []
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
if (n1 % 2) == 0:
# leaflet junction
cx = inletCentre
r = innerInletRadius
d1mag = leafd1mag
d2mag1 = leafd2r * cosRadiansAround
d2mag2 = leafd2r * sinRadiansAround
d2mag3 = leafd2z
else:
# sinus / leaflet centre
cx = sinusCentre
r = innerInletSinusRadius
d1mag = sinusd1mag
d2mag1 = sinusd2r * cosRadiansAround
d2mag2 = sinusd2r * sinRadiansAround
d2mag3 = sinusd2z
d3mag1 = magd3 * cosRadiansAround
d3mag2 = magd3 * sinRadiansAround
d3mag3 = 0.0
x[0][0].append([
(cx[c] + r *
(cosRadiansAround * axis1[c] + sinRadiansAround * axis2[c]))
for c in range(3)
])
d1[0][0].append([
d1mag *
(-sinRadiansAround * axis1[c] + cosRadiansAround * axis2[c])
for c in range(3)
])
d2[0][0].append([
(d2mag1 * axis1[c] + d2mag2 * axis2[c] + d2mag3 * axis3[c])
for c in range(3)
])
d3[0][0].append([
(d3mag1 * axis1[c] + d3mag2 * axis2[c] + d3mag3 * axis3[c])
for c in range(3)
])
# outer layer
extRadius = outerRadius + outerRadialDisplacement
leafd2r, leafd2z = smoothCubicHermiteDerivativesLine(
[[extRadius, 0.0], [outerRadius, outerHeight]], [[
-outerHeight * math.sin(outerAngleRadians),
outerHeight * math.cos(outerAngleRadians)
], [0.0, outletLength]],
fixStartDirection=True,
fixEndDerivative=True)[0]
# calculate magnitude of d1, d2 at outer sinus
extSinusRadius = outerRadius + outerSinusRadialDisplacement
leafd1mag = extRadius * radiansPerElementAround
sinusd1mag = extSinusRadius * radiansPerElementAround # initial value only
sinusd1mag = vector.magnitude(
smoothCubicHermiteDerivativesLine(
[[extRadius, 0.0, 0.0],
[
extSinusRadius * math.cos(pi_3),
extSinusRadius * math.sin(pi_3), 0.0
]], [[0.0, leafd1mag, 0.0],
[
-sinusd1mag * math.sin(pi_3),
sinusd1mag * math.cos(pi_3), 0.0
]],
fixStartDerivative=True,
fixEndDirection=True)[1])
sinusd2r, sinusd2z = smoothCubicHermiteDerivativesLine(
[[extSinusRadius, 0.0], [outerRadius, outerHeight]], [[
-outerHeight * math.sin(outerAngleRadians),
outerHeight * math.cos(outerAngleRadians)
], [0.0, outletLength]],
fixStartDirection=True,
fixEndDerivative=True)[0]
centre = centre
x[1][0] = []
d1[1][0] = []
d2[1][0] = []
d3[1][0] = []
for n1 in range(elementsCountAround):
radiansAround = n1 * radiansPerElementAround
cosRadiansAround = math.cos(radiansAround)
sinRadiansAround = math.sin(radiansAround)
if (n1 % 2) == 0:
# leaflet junction
cx = inletCentre
r = extRadius
d1mag = leafd1mag
d2mag1 = leafd2r * cosRadiansAround
d2mag2 = leafd2r * sinRadiansAround
d2mag3 = leafd2z
else:
# sinus / leaflet centre
cx = sinusCentre
r = extSinusRadius
d1mag = sinusd1mag
d2mag1 = sinusd2r * cosRadiansAround
d2mag2 = sinusd2r * sinRadiansAround
d2mag3 = sinusd2z
d3mag1 = magd3 * cosRadiansAround
d3mag2 = magd3 * sinRadiansAround
d3mag3 = 0.0
x[1][0].append([
(centre[c] + r *
(cosRadiansAround * axis1[c] + sinRadiansAround * axis2[c]))
for c in range(3)
])
d1[1][0].append([
d1mag *
(-sinRadiansAround * axis1[c] + cosRadiansAround * axis2[c])
for c in range(3)
])
d2[1][0].append([
(d2mag1 * axis1[c] + d2mag2 * axis2[c] + d2mag3 * axis3[c])
for c in range(3)
])
d3[1][0].append([
(d3mag1 * axis1[c] + d3mag2 * axis2[c] + d3mag3 * axis3[c])
for c in range(3)
])
# outlet
x[0][1], d1[0][1] = createCirclePoints(
outletCentre, [axis1[c] * innerRadius for c in range(3)],
[axis2[c] * innerRadius for c in range(3)], elementsCountAround)
x[1][1], d1[1][1] = createCirclePoints(
outletCentre, [axis1[c] * outerRadius for c in range(3)],
[axis2[c] * outerRadius for c in range(3)], elementsCountAround)
d2[1][1] = d2[0][1] = [[axis3[c] * outletLength
for c in range(3)]] * elementsCountAround
d3[1][1] = d3[0][1] = None
return x, d1, d2, d3
def createArm(halfArmArcAngleRadians, elementLengths, elementLengthCentral,
elementsCount, dipMultiplier, armCount, armIndex):
"""
Create single arm unit.
Base length of element is 1.
Direction: anticlockwise.
Minimum arm length is 2 elements.
:param halfArmArcAngleRadians: angle arising from base node (rad)
:param elementLengths: [Element length along arm, half Element width across arm, Element thickness]
:param elementLengthCentral: Radial element length about central node.
:param elementsCount: list of numbers of elements along arm length, across width and through thickness directions
:param dipMultiplier: factor that wheel nodes protrude by, relative to unit length
:param armCount: number of arms in body
:param armIndex: 0-based
:return: x: positions of nodes in arm
:return: nodeIdentifier: number of last node in arm +1
:return: xnodes_ds1: ds1 derivatives of nodes associated with x
:return: xnodes_ds2: ds2 derivatives of nodes associated with y
:return: rmVertexNodes: indices of nodes at arm vertices around central node (including central node)
"""
elementsCount1, elementsCount2, elementsCount3 = elementsCount
[elementLength, elementWidth, elementHeight] = elementLengths
shorterArmEnd = True
armAngle = 2 * halfArmArcAngleRadians * armIndex
armAngleConst = 2 * halfArmArcAngleRadians
xnodes_ds1 = []
xnodes_ds2 = []
dx_ds1 = [elementLength, 0.0, 0.0]
dx_ds2 = [0.0, elementWidth, 0.0]
nodes_per_layer = (elementsCount1 + 1) * (
elementsCount2 + 1) - 2 # discount 2 armEnd corners
x = []
# nCentre and rmVertexNodes are in pythonic indexing
nCentre = elementsCount1
nCentre = [nCentre, nCentre + nodes_per_layer]
if armIndex == 0:
rmVertexNodes = []
elif armIndex != armCount - 1:
rmVertexNodes = nCentre + [0, nodes_per_layer]
else:
rmVertexNodes = nCentre + [
0, nodes_per_layer, 2 * (elementsCount1 + 1) - 1, 2 *
(elementsCount1 + 1) - 1 + nodes_per_layer
]
dcent = [
elementLengthCentral * math.cos(armAngleConst / 2),
elementLengthCentral * math.sin(armAngleConst / 2), 0.0
]
dvertex = [
elementLengthCentral * dipMultiplier *
math.cos(halfArmArcAngleRadians),
elementLengthCentral * dipMultiplier * math.sin(halfArmArcAngleRadians)
]
dipLength = 0.5 * (elementLengthCentral + elementWidth) * dipMultiplier
dvertex = [
dipLength * math.cos(halfArmArcAngleRadians),
dipLength * math.sin(halfArmArcAngleRadians)
]
dipMag = 2 * dipLength - elementLengthCentral
nid = 0
for e3 in range(elementsCount3 + 1):
x3 = e3 * elementHeight
for e2 in range(elementsCount2 + 1):
for e1 in range(elementsCount1 + 1):
# ignore if armEnd corner nodes
if (e1 == elementsCount1) and ((e2 == 0) or
(e2 == elementsCount2)):
pass
else:
if e1 == 0 and e2 == 0:
x1 = dvertex[0]
x2 = -dvertex[1]
elif e1 == 0 and e2 == elementsCount2:
x1 = dvertex[0]
x2 = dvertex[1]
else:
if e1 == elementsCount1 and shorterArmEnd:
x1 = 0.5 * (elementLength + elementWidth
) + elementLength * (e1 - 1)
else:
x1 = elementLength * e1
x2 = (e2 - 1) * elementWidth
x.append([x1, x2, x3])
# DERIVATIVES
ds1 = dx_ds1.copy()
ds2 = dx_ds2.copy()
if e2 == 1 and e1 == 0:
ds2 = dcent
ds1 = [dcent[0], -dcent[1], dcent[2]]
elif (e1 == 0) and ((e2 == 0) or (e2 == elementsCount2)):
ds2 = [dcent[0], -dcent[1], dcent[2]
] if (e2 == 0) else dcent
ds2 = setMagnitude(ds2, dipMag)
ds1 = rotateAboutZAxis(ds2, -math.pi / 2)
elif e1 == elementsCount1 and e2 == elementsCount2 - 1: # armEnd
ds1 = [elementWidth, 0, 0]
ds2 = [0, 1 * (elementLength + elementWidth), 0]
if shorterArmEnd:
ds2 = [0, 0.5 * (elementLength + elementWidth), 0]
xnodes_ds1.append(ds1)
xnodes_ds2.append(ds2)
nid += 1
# d1 derivatives at dips around central node
nidDip = [
0, elementsCount1 * 2 + 1, nodes_per_layer,
elementsCount1 * 2 + 1 + nodes_per_layer
]
for nid in nidDip:
nx = [x[nid], x[nid + 1]]
nd1 = [xnodes_ds1[nid], xnodes_ds1[nid + 1]]
ds1Smooth = smoothCubicHermiteDerivativesLine(nx,
nd1,
fixStartDirection=True,
fixEndDerivative=True)
xnodes_ds1[nid] = ds1Smooth[0]
# rotate entire arm about origin by armAngle except for centre nodes
tol = 1e-12
for j, n in enumerate(x):
xynew = rotateAboutZAxis(n, armAngle)
[xnew, ynew] = [r for r in xynew][:2]
if (abs(xnew) < tol):
xnew = 0
if (abs(ynew) < tol):
ynew = 0
x[j] = [xnew, ynew, x[j][2]]
xnodes_ds1[j] = rotateAboutZAxis(xnodes_ds1[j], armAngle)
xnodes_ds2[j] = rotateAboutZAxis(xnodes_ds2[j], armAngle)
return (x, xnodes_ds1, xnodes_ds2, rmVertexNodes)
def generateOstiumMesh(region, options, trackSurface, centrePosition, axis1, startNodeIdentifier = 1, startElementIdentifier = 1,
vesselMeshGroups = None):
'''
:param vesselMeshGroups: List (over number of vessels) of list of mesh groups to add vessel elements to.
:return: nextNodeIdentifier, nextElementIdentifier, Ostium points tuple
(ox[n3][n1][c], od1[n3][n1][c], od2[n3][n1][c], od3[n3][n1][c], oNodeId[n3][n1], oPositions).
'''
vesselsCount = options['Number of vessels']
elementsCountAroundOstium = options['Number of elements around ostium']
elementsCountAcross = options['Number of elements across common']
elementsCountsAroundVessels, elementsCountAroundMid = getOstiumElementsCountsAroundVessels(elementsCountAroundOstium, elementsCountAcross, vesselsCount)
elementsCountAroundEnd = (elementsCountAroundOstium - 2*elementsCountAroundMid)//2
#print('\nvesselsCount', vesselsCount, 'elementsCountsAroundOstium', elementsCountAroundOstium, 'elementsCountAcross', elementsCountAcross)
#print('--> elementsCountsAroundVessels', elementsCountsAroundVessels, 'elementsCountAroundMid', elementsCountAroundMid)
elementsCountAlong = options['Number of elements along']
elementsCountThroughWall = options['Number of elements through wall']
unitScale = options['Unit scale']
isOutlet = options['Outlet']
ostiumRadius = 0.5*unitScale*options['Ostium diameter']
ostiumLength = unitScale*options['Ostium length']
ostiumWallThickness = unitScale*options['Ostium wall thickness']
interVesselHeight = unitScale*options['Ostium inter-vessel height']
interVesselDistance = unitScale*options['Ostium inter-vessel distance'] if (vesselsCount > 1) else 0.0
halfInterVesselDistance = 0.5*interVesselDistance
useCubicHermiteThroughOstiumWall = not(options['Use linear through ostium wall'])
vesselEndDerivative = ostiumLength*options['Vessel end length factor']/elementsCountAlong
vesselInnerRadius = 0.5*unitScale*options['Vessel inner diameter']
vesselWallThickness = unitScale*options['Vessel wall thickness']
vesselOuterRadius = vesselInnerRadius + vesselWallThickness
vesselAngle1Radians = math.radians(options['Vessel angle 1 degrees'])
vesselAngle1SpreadRadians = math.radians(options['Vessel angle 1 spread degrees'])
vesselAngle2Radians = math.radians(options['Vessel angle 2 degrees'])
useCubicHermiteThroughVesselWall = not(options['Use linear through vessel wall'])
useCrossDerivatives = False # options['Use cross derivatives'] # not implemented
fm = region.getFieldmodule()
fm.beginChange()
coordinates = findOrCreateFieldCoordinates(fm)
cache = fm.createFieldcache()
# track points in shape of ostium
# get directions in plane of surface at centre:
cx, cd1, cd2 = trackSurface.evaluateCoordinates(centrePosition, True)
trackDirection1, trackDirection2, centreNormal = calculate_surface_axes(cd1, cd2, axis1)
trackDirection2reverse = [ -d for d in trackDirection2 ]
halfCircumference = math.pi*ostiumRadius
circumference = 2.0*halfCircumference
distance = 0.0
elementLengthAroundOstiumMid = 0.0
vesselsSpanAll = interVesselDistance*(vesselsCount - 1)
vesselsSpanMid = interVesselDistance*(vesselsCount - 2)
if vesselsCount == 1:
elementLengthAroundOstiumEnd = circumference/elementsCountAroundOstium
vesselOstiumPositions = [ centrePosition ]
ocx = [ cx ]
ocd1 = [ trackDirection1 ]
ocd2 = [ trackDirection2 ]
ocd3 = [ centreNormal ]
else:
elementLengthAroundOstiumEnd = (circumference + 2.0*interVesselDistance)/(elementsCountAroundOstium - 2*elementsCountAroundMid)
if elementsCountAroundMid > 0:
elementLengthAroundOstiumMid = interVesselDistance*(vesselsCount - 2)/elementsCountAroundMid
vesselOstiumPositions = []
ocx = []
ocd1 = []
ocd2 = []
ocd3 = []
for v in range(vesselsCount):
vesselOstiumPositions.append(trackSurface.trackVector(centrePosition, trackDirection1, (v/(vesselsCount - 1) - 0.5)*vesselsSpanAll))
x, d1, d2 = trackSurface.evaluateCoordinates(vesselOstiumPositions[-1], -1)
d1, d2, d3 = calculate_surface_axes(d1, d2, trackDirection1)
ocx .append(x)
ocd1.append(d1)
ocd2.append(d2)
ocd3.append(d3)
# coordinates around ostium
ox = [ [], [] ]
od1 = [ [], [] ]
od2 = [ [], [] ]
od3 = [ [], [] ]
oPositions = []
for n1 in range(elementsCountAroundOstium):
elementLength = elementLengthAroundOstiumEnd
if distance <= (vesselsSpanMid + halfInterVesselDistance):
position = trackSurface.trackVector(centrePosition, trackDirection1, 0.5*vesselsSpanMid - distance)
sideDirection = trackDirection2reverse
if n1 < elementsCountAroundMid:
elementLength = elementLengthAroundOstiumMid
elif distance < (vesselsSpanMid + halfInterVesselDistance + halfCircumference):
position = vesselOstiumPositions[0]
angleRadians = (distance - (vesselsSpanMid + halfInterVesselDistance))/ostiumRadius
w1 = -math.sin(angleRadians)
w2 = -math.cos(angleRadians)
sideDirection = [ (w1*trackDirection1[c] + w2*trackDirection2[c]) for c in range(3) ]
elif distance < (2.0*vesselsSpanMid + halfInterVesselDistance + halfCircumference + interVesselDistance):
position = trackSurface.trackVector(centrePosition, trackDirection1, distance - (1.5*vesselsSpanMid + interVesselDistance + halfCircumference))
sideDirection = trackDirection2
if 0 <= (n1 - elementsCountAroundEnd - elementsCountAroundMid) < elementsCountAroundMid:
elementLength = elementLengthAroundOstiumMid
elif distance < (2.0*vesselsSpanMid + halfInterVesselDistance + circumference + interVesselDistance):
position = vesselOstiumPositions[-1]
angleRadians = (distance - (2.0*vesselsSpanMid + halfInterVesselDistance + halfCircumference + interVesselDistance))/ostiumRadius
w1 = math.sin(angleRadians)
w2 = math.cos(angleRadians)
sideDirection = [ (w1*trackDirection1[c] + w2*trackDirection2[c]) for c in range(3) ]
else:
position = trackSurface.trackVector(centrePosition, trackDirection1, 0.5*vesselsSpanMid + (circumference + 2.0*(vesselsSpanMid + interVesselDistance)) - distance)
sideDirection = trackDirection2reverse
position = trackSurface.trackVector(position, sideDirection, ostiumRadius)
oPositions.append(position)
px, d1, d2 = trackSurface.evaluateCoordinates(position, True)
pd2, pd1, pd3 = calculate_surface_axes(d1, d2, sideDirection)
# get outer coordinates
opx = px
opd1 = vector.setMagnitude([ -d for d in pd1 ], elementLengthAroundOstiumEnd)
opd2 = vector.setMagnitude(pd2, elementLengthAroundOstiumEnd) # smoothed later
opd3 = vector.setMagnitude(pd3, ostiumWallThickness)
# set inner and outer coordinates (use copy to avoid references to same list later)
ox [0].append([ (opx[c] - opd3[c]) for c in range(3) ])
od1[0].append(copy.copy(opd1))
od2[0].append(copy.copy(opd2))
ox [1].append(opx)
od1[1].append(opd1)
od2[1].append(opd2)
if useCubicHermiteThroughOstiumWall:
od3[0].append(copy.copy(opd3))
od3[1].append(opd3)
distance += elementLength
for n3 in range(2):
od1[n3] = interp.smoothCubicHermiteDerivativesLoop(ox[n3], od1[n3], fixAllDirections = True)
xx = []
xd1 = []
xd2 = []
xd3 = []
# coordinates across common ostium, between vessels
nodesCountFreeEnd = elementsCountsAroundVessels[0] + 1 - elementsCountAcross
oinc = 0 if (vesselsCount <= 2) else elementsCountAroundMid//(vesselsCount - 2)
for iv in range(vesselsCount - 1):
xx .append([ None, None ])
xd1.append([ None, None ])
xd2.append([ None, None ])
xd3.append([ None, None ])
oa = elementsCountAroundMid - iv*oinc
ob = elementsCountAroundMid + nodesCountFreeEnd - 1 + iv*oinc
nx = [ ox[1][oa], ox[1][ob] ]
nd1 = [ [ -d for d in od1[1][oa] ], od1[1][ob] ]
nd2 = [ [ -d for d in od2[1][oa] ], od2[1][ob] ]
if elementsCountAcross > 1:
# add centre point, displaced by interVesselHeight
if vesselsCount == 2:
position = centrePosition
else:
position = trackSurface.trackVector(centrePosition, trackDirection1, (iv/(vesselsCount - 2) - 0.5)*vesselsSpanMid)
mx, d1, d2 = trackSurface.evaluateCoordinates(position, derivatives = True)
md1, md2, md3 = calculate_surface_axes(d1, d2, trackDirection1)
nx .insert(1, [ (mx[c] + interVesselHeight*md3[c]) for c in range(3) ])
nd1.insert(1, vector.setMagnitude(md1, elementLengthAroundOstiumMid if (0 < iv < (vesselsCount - 2)) else elementLengthAroundOstiumEnd))
nd2.insert(1, vector.setMagnitude(md2, ostiumRadius))
nd2 = interp.smoothCubicHermiteDerivativesLine(nx, nd2, fixAllDirections = True)
px, pd2, pe, pxi = interp.sampleCubicHermiteCurves(nx, nd2, elementsCountAcross)[0:4]
pd1 = interp.interpolateSampleLinear(nd1, pe, pxi)
pd3 = [ vector.setMagnitude(vector.crossproduct3(pd1[n2], pd2[n2]), ostiumWallThickness) for n2 in range(elementsCountAcross + 1) ]
lx = [ ([ (px[n2][c] - pd3[n2][c]) for c in range(3) ]) for n2 in range(elementsCountAcross + 1) ]
ld2 = interp.smoothCubicHermiteDerivativesLine(lx, pd2, fixAllDirections = True)
xx [iv][0] = lx [1:elementsCountAcross]
xd1[iv][0] = copy.deepcopy(pd1[1:elementsCountAcross]) # to be smoothed later
xd2[iv][0] = ld2[1:elementsCountAcross]
xx [iv][1] = px [1:elementsCountAcross]
xd1[iv][1] = pd1[1:elementsCountAcross] # to be smoothed later
xd2[iv][1] = pd2[1:elementsCountAcross]
if useCubicHermiteThroughOstiumWall:
xd3[iv][0] = copy.deepcopy(pd3[1:elementsCountAcross])
xd3[iv][1] = pd3[1:elementsCountAcross]
# set smoothed d2 on ostium circumference
od2[0][oa] = [ -d for d in ld2[0] ]
od2[1][oa] = [ -d for d in pd2[0] ]
od2[0][ob] = ld2[-1]
od2[1][ob] = pd2[-1]
# get positions of vessel end centres and rings
vcx = []
vcd1 = []
vcd2 = []
vcd3 = []
vox = []
vod1 = []
vod2 = []
vod3 = []
for v in range(vesselsCount):
elementsCountAroundVessel = elementsCountsAroundVessels[v]
radiansPerElementVessel = 2.0*math.pi/elementsCountAroundVessel
useVesselAngleRadians = vesselAngle1Radians
if vesselsCount > 1:
useVesselAngleRadians += (v/(vesselsCount - 1) - 0.5)*vesselAngle1SpreadRadians
vx, vd1, vd2, vd3 = getCircleProjectionAxes(ocx[v], ocd1[v], ocd2[v], ocd3[v], ostiumLength, useVesselAngleRadians, vesselAngle2Radians)
vd1 = [ vesselOuterRadius*d for d in vd1 ]
vd2 = [ -vesselOuterRadius*d for d in vd2 ]
vd3 = [ -vesselEndDerivative*d for d in vd3 ]
vcx.append(vx)
vcd1.append(vd1)
vcd2.append(vd2)
vcd3.append(vd3)
vox.append([])
vod1.append([])
vod2.append([])
vod3.append([])
for n3 in range(2):
radius = vesselInnerRadius if (n3 == 0) else vesselOuterRadius
vAxis1 = vector.setMagnitude(vd1, radius)
vAxis2 = vector.setMagnitude(vd2, radius)
if vesselsCount == 1:
startRadians = 0.5*math.pi
else:
startRadians = 0.5*radiansPerElementVessel*elementsCountAcross
if v == (vesselsCount - 1):
startRadians -= math.pi
px, pd1 = createCirclePoints(vx, vAxis1, vAxis2, elementsCountAroundVessel, startRadians)
vox [-1].append(px)
vod1[-1].append(pd1)
vod2[-1].append([ vd3 ]*elementsCountAroundVessel)
if useCubicHermiteThroughVesselWall:
vod3[-1].append([ vector.setMagnitude(vector.crossproduct3(d1, vd3), vesselWallThickness) for d1 in pd1 ])
# calculate common ostium vessel node derivatives map
mvPointsx = [ None ]*vesselsCount
mvPointsd1 = [ None ]*vesselsCount
mvPointsd2 = [ None ]*vesselsCount
mvPointsd3 = [ None ]*vesselsCount
mvDerivativesMap = [ None ]*vesselsCount
mvMeanCount = [ None ]*vesselsCount # stores 1 if first reference to common point between vessels, 2 if second. Otherwise 0.
for v in range(vesselsCount):
if vesselsCount == 1:
mvPointsx[v], mvPointsd1[v], mvPointsd2[v], mvPointsd3[v], mvDerivativesMap[v] = \
ox, od1, od2, od3 if useCubicHermiteThroughOstiumWall else None, None
mvMeanCount[v] = [ 0 ]*elementsCountsAroundVessels[v]
else:
iv = max(0, v - 1)
oa = elementsCountAroundMid - iv*oinc
ob = elementsCountAroundMid + nodesCountFreeEnd - 1 + iv*oinc
mvPointsx [v] = []
mvPointsd1[v] = []
mvPointsd2[v] = []
mvPointsd3[v] = [] if useCubicHermiteThroughOstiumWall else None
mvDerivativesMap[v] = []
for n3 in range(2):
mvPointsd1[v].append([])
mvPointsd2[v].append([])
mvPointsx [v].append([])
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v].append([])
mvDerivativesMap[v].append([])
if v == 0: # first end vessel
mvPointsd1[v][n3] += od1[n3][oa:ob + 1]
mvPointsd2[v][n3] += od2[n3][oa:ob + 1]
mvPointsx [v][n3] += ox [n3][oa:ob + 1]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][oa:ob + 1]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(nodesCountFreeEnd - 2):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
mvPointsx [v][n3] += reversed(xx [iv][n3])
mvPointsd1[v][n3] += reversed(xd1[iv][n3])
mvPointsd2[v][n3] += reversed(xd2[iv][n3])
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += reversed(xd3[iv][n3])
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, -1, 0), (1, 0, 0), None ) )
if n3 == 0:
mvMeanCount[v] = [ 1 ] + [ 0 ]*(nodesCountFreeEnd - 2) + [ 1 ]*elementsCountAcross
elif v < (vesselsCount - 1): # middle vessels
# left:
mvPointsx [v][n3] += ox [n3][oa - oinc:oa + 1]
mvPointsd1[v][n3] += od1[n3][oa - oinc:oa + 1]
mvPointsd2[v][n3] += od2[n3][oa - oinc:oa + 1]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][oa - oinc:oa + 1]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(oinc - 1):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
# across
mvPointsx [v][n3] += xx [iv][n3]
mvPointsd1[v][n3] += xd1[iv][n3]
mvPointsd2[v][n3] += xd2[iv][n3]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += xd3[iv][n3]
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 0, 0), None ) )
# right
mvPointsx [v][n3] += ox [n3][ob:ob + oinc + 1]
mvPointsd1[v][n3] += od1[n3][ob:ob + oinc + 1]
mvPointsd2[v][n3] += od2[n3][ob:ob + oinc + 1]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][ob:ob + oinc + 1]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(oinc - 1):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
# across reverse
mvPointsx [v][n3] += reversed(xx [iv + 1][n3])
mvPointsd1[v][n3] += reversed(xd1[iv + 1][n3])
mvPointsd2[v][n3] += reversed(xd2[iv + 1][n3])
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += reversed(xd3[iv + 1][n3])
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, -1, 0), (1, 0, 0), None ) )
if n3 == 0:
mvMeanCount[v] = [ 1 ] + [ 0 ]*(oinc - 1) + [ 2 ]*(elementsCountAcross + 1) + [ 0 ]*(oinc - 1) + [ 1 ]*elementsCountAcross
else: # last end vessel
mvPointsx [v][n3] += ox [n3][ob:] + [ ox [n3][0] ]
mvPointsd1[v][n3] += od1[n3][ob:] + [ od1[n3][0] ]
mvPointsd2[v][n3] += od2[n3][ob:] + [ od2[n3][0] ]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += od3[n3][ob:] + [ od3[n3][0] ]
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 1, 0), None, (1, 0, 0) ) )
for i in range(nodesCountFreeEnd - 2):
mvDerivativesMap[v][n3].append( ( None, None, None ) )
mvDerivativesMap[v][n3].append( ( (1, 0, 0), (1, 1, 0), None, (0, -1, 0) ) )
mvPointsx [v][n3] += xx [iv][n3]
mvPointsd1[v][n3] += xd1[iv][n3]
mvPointsd2[v][n3] += xd2[iv][n3]
if useCubicHermiteThroughOstiumWall:
mvPointsd3[v][n3] += xd3[iv][n3]
for i in range(elementsCountAcross - 1):
mvDerivativesMap[v][n3].append( ( (0, 1, 0), (-1, 0, 0), None ) )
if n3 == 0:
mvMeanCount[v] = [ 2 ] + [ 0 ]*(nodesCountFreeEnd - 2) + [ 2 ]*elementsCountAcross
# calculate derivative 2 around free sides of inlets to fit vessel derivatives
for v in range(vesselsCount):
for n3 in range(2):
#print('v',v,'n3',n3,'elementsAround',elementsCountsAroundVessels[v])
#print('mvPointsx [v][n3]', mvPointsx [v][n3])
#print('mvPointsd1[v][n3]', mvPointsd1[v][n3])
#print('mvPointsd2[v][n3]', mvPointsd2[v][n3])
#print('mvDerivativesMap[v][n3]', mvDerivativesMap[v][n3])
for n1 in range(elementsCountsAroundVessels[v]):
d2Map = mvDerivativesMap[v][n3][n1][1] if (mvDerivativesMap[v] and mvDerivativesMap[v][n3][n1]) else None
sf1 = d2Map[0] if d2Map else 0.0
sf2 = d2Map[1] if d2Map else 1.0
nx = [ vox[v][n3][n1], mvPointsx[v][n3][n1] ]
nd2 = [ [ d*elementsCountAlong for d in vod2[v][n3][n1] ], [ (sf1*mvPointsd1[v][n3][n1][c] + sf2*mvPointsd2[v][n3][n1][c]) for c in range(3) ] ]
nd2f = interp.smoothCubicHermiteDerivativesLine(nx, nd2, fixStartDerivative = True, fixEndDirection = True)
ndf = [ d/elementsCountAlong for d in nd2f[1] ]
# assign components to set original values:
if sf1 == 0:
for c in range(3):
mvPointsd2[v][n3][n1][c] = sf2*ndf[c]
elif sf2 == 0:
if mvMeanCount[v][n1] < 2:
for c in range(3):
mvPointsd1[v][n3][n1][c] = sf1*ndf[c]
else:
# take mean of values from this and last vessel
for c in range(3):
mvPointsd1[v][n3][n1][c] = 0.5*(mvPointsd1[v][n3][n1][c] + sf1*ndf[c])
else:
#print('v', v, 'n3', n3, 'n1', n1, ':', vector.magnitude(ndf), 'vs.', vector.magnitude(nd2[1]), 'd2Map', d2Map)
pass
if isOutlet:
# reverse directions of d1 and d2 on vessels and ostium base
for c in range(3):
for n3 in range(2):
for n1 in range(elementsCountAroundOstium):
od1[n3][n1][c] = -od1[n3][n1][c]
od2[n3][n1][c] = -od2[n3][n1][c]
for iv in range(vesselsCount - 1):
for n1 in range(elementsCountAcross - 1):
xd1[iv][n3][n1][c] = -xd1[iv][n3][n1][c]
xd2[iv][n3][n1][c] = -xd2[iv][n3][n1][c]
for v in range(vesselsCount):
for n1 in range(elementsCountsAroundVessels[v]):
vod1[v][n3][n1][c] = -vod1[v][n3][n1][c]
# d2 is referenced all around, so only change once per vessel
for v in range(vesselsCount):
vod2[v][0][0][c] = -vod2[v][0][0][c]
##############
# Create nodes
##############
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodetemplate = nodes.createNodetemplate()
nodetemplate.defineField(coordinates)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
nodetemplate.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS3, 1)
nodetemplateLinearS3 = nodes.createNodetemplate()
nodetemplateLinearS3.defineField(coordinates)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_VALUE, 1)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS1, 1)
nodetemplateLinearS3.setValueNumberOfVersions(coordinates, -1, Node.VALUE_LABEL_D_DS2, 1)
nodeIdentifier = startNodeIdentifier
oNodeId = []
for n3 in range(2):
oNodeId.append([])
for n1 in range(elementsCountAroundOstium):
node = nodes.createNode(nodeIdentifier, nodetemplate if useCubicHermiteThroughOstiumWall else nodetemplateLinearS3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, ox [n3][n1])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, od1[n3][n1])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, od2[n3][n1])
if useCubicHermiteThroughOstiumWall:
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, od3[n3][n1])
oNodeId[n3].append(nodeIdentifier)
nodeIdentifier += 1
xNodeId = []
for iv in range(vesselsCount - 1):
xNodeId.append([])
for n3 in range(2):
xNodeId[iv].append([])
for n2 in range(elementsCountAcross - 1):
node = nodes.createNode(nodeIdentifier, nodetemplate if useCubicHermiteThroughOstiumWall else nodetemplateLinearS3)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, xx [iv][n3][n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, xd1[iv][n3][n2])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, xd2[iv][n3][n2])
if useCubicHermiteThroughOstiumWall:
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, xd3[iv][n3][n2])
xNodeId[iv][n3].append(nodeIdentifier)
nodeIdentifier += 1
#for v in range(vesselsCount):
# node = nodes.createNode(nodeIdentifier, nodetemplate)
# cache.setNode(node)
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, vcx [v])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, vcd1[v])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, vcd2[v])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, vcd3[v])
# nodeIdentifier += 1
# for n3 in range(2):
# for n1 in range(elementsCountsAroundVessels[v]):
# node = nodes.createNode(nodeIdentifier, nodetemplate if useCubicHermiteThroughVesselWall else nodetemplateLinearS3)
# cache.setNode(node)
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1, vox [v][n3][n1])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1, vod1[v][n3][n1])
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1, vod2[v][n3][n1])
# if useCubicHermiteThroughVesselWall:
# coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS3, 1, vod3[v][n3][n1])
# #vNodeId.append(nodeIdentifier)
# nodeIdentifier += 1
# get identifiers of nodes around each vessel at ostium end
mvNodeId = [ None ]*vesselsCount
for v in range(vesselsCount):
if vesselsCount == 1:
mvNodeId[v] = oNodeId
else:
iv = max(0, v - 1)
mvNodeId[v] = [ None, None ]
oa = elementsCountAroundMid - iv*oinc
ob = elementsCountAroundMid + nodesCountFreeEnd - 1 + iv*oinc
for n3 in range(2):
if v == 0: # first end vessel
mvNodeId[v][n3] = oNodeId[n3][oa:ob + 1] + (list(reversed(xNodeId[iv][n3])) if (v == 0) else xNodeId[iv][n3])
elif v == (vesselsCount - 1): # last end vessels
mvNodeId[v][n3] = oNodeId[n3][ob:] + [ oNodeId[n3][0] ] + (list(reversed(xNodeId[iv][n3])) if (v == 0) else xNodeId[iv][n3])
else: # mid vessels
mvNodeId[v][n3] = oNodeId[n3][oa - oinc:oa + 1] + xNodeId[iv][n3] + oNodeId[n3][ob:ob + oinc + 1] + list(reversed(xNodeId[iv + 1][n3]))
#################
# Create elementss
#################
mesh = fm.findMeshByDimension(3)
elementIdentifier = startElementIdentifier
tricubichermite = eftfactory_tricubichermite(mesh, useCrossDerivatives)
#tricubicHermiteBasis = fm.createElementbasis(3, Elementbasis.FUNCTION_TYPE_CUBIC_HERMITE)
#eft = tricubichermite.createEftBasic()
#elementtemplate = mesh.createElementtemplate()
#elementtemplate.setElementShapeType(Element.SHAPE_TYPE_CUBE)
#elementtemplate.defineField(coordinates, -1, eft)
#elementtemplateX = mesh.createElementtemplate()
#elementtemplateX.setElementShapeType(Element.SHAPE_TYPE_CUBE)
for v in range(vesselsCount):
if isOutlet:
startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap = \
mvPointsx[v], mvPointsd1[v], mvPointsd2[v], mvPointsd3[v], mvNodeId[v], mvDerivativesMap[v]
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap = \
vox[v], vod1[v], vod2[v], vod3[v] if useCubicHermiteThroughVesselWall else None, None, None
# reverse order of nodes around:
for px in [ startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap, \
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap ]:
if px:
for n3 in range(2):
px[n3] = [ px[n3][0] ] + px[n3][len(px[n3]) - 1:0:-1]
if vesselsCount > 1:
# must switch in and out xi1 maps around corners in startDerivativesMap
for n3 in range(2):
for n1 in range(elementsCountsAroundVessels[v]):
derivativesMap = startDerivativesMap[n3][n1]
if len(derivativesMap) == 4:
startDerivativesMap[n3][n1] = derivativesMap[3], derivativesMap[1], derivativesMap[2], derivativesMap[0]
else:
startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap = \
vox[v], vod1[v], vod2[v], vod3[v] if useCubicHermiteThroughVesselWall else None, None, None
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap = \
mvPointsx[v], mvPointsd1[v], mvPointsd2[v], mvPointsd3[v], mvNodeId[v], mvDerivativesMap[v]
#print('endPointsx ', endPointsx )
#print('endPointsd1', endPointsd1)
#print('endPointsd2', endPointsd2)
#print('endPointsd3', endPointsd3)
#print('endNodeId', endNodeId)
#print('endDerivativesMap', endDerivativesMap)
nodeIdentifier, elementIdentifier = createAnnulusMesh3d(
nodes, mesh, nodeIdentifier, elementIdentifier,
startPointsx, startPointsd1, startPointsd2, startPointsd3, startNodeId, startDerivativesMap,
endPointsx, endPointsd1, endPointsd2, endPointsd3, endNodeId, endDerivativesMap,
forceMidLinearXi3 = not useCubicHermiteThroughVesselWall,
elementsCountRadial = elementsCountAlong,
meshGroups = vesselMeshGroups[v] if vesselMeshGroups else [])
fm.endChange()
return nodeIdentifier, elementIdentifier, (ox, od1, od2, od3, oNodeId, oPositions)
def 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 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
