def get_curve_circle_points(x1, xd1, x2, xd2, r1, rd1, r2, rd2, xi, dmag, side, elementsCountAround):
'''
:param dmag: Magnitude of derivative on curve.
:param side: Vector in side direction of first node around.
Need not be unit or exactly normal to curve at xi.
:return: x[], d1[] around, d2[] along
'''
cx = interpolateCubicHermite(x1, xd1, x2, xd2, xi)
cxd = interpolateCubicHermiteDerivative(x1, xd1, x2, xd2, xi)
mag_cxd = magnitude(cxd)
cxd2 = interpolateCubicHermiteSecondDerivative(x1, xd1, x2, xd2, xi)
mag_cxd2 = magnitude(cxd2)
r = interpolateCubicHermite([ r1 ], [ rd1 ], [ r2 ], [ rd2 ], xi)[0]
rd = interpolateCubicHermiteDerivative([ r1 ], [ rd1 ], [ r2 ], [ rd2 ], xi)[0]
axis1 = normalize(cxd)
axis3 = normalize(cross(axis1, side))
axis2 = cross(axis3, axis1)
x, d1 = createCirclePoints(cx, mult(axis2, r), mult(axis3, r), elementsCountAround)
curvatureVector = mult(cxd2, 1.0/(mag_cxd*mag_cxd))
d2 = []
radialGrowth = rd/(mag_cxd*r)
for e in range(elementsCountAround):
radialVector = sub(x[e], cx)
dmagFinal = dmag*(1.0 - dot(radialVector, curvatureVector))
# add curvature and radius change components:
d2.append(add(mult(cxd, dmagFinal/mag_cxd), mult(radialVector, dmagFinal*radialGrowth)))
return x, d1, d2
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 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 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 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
"""
paCount = options['Number of elements around parent']
c1Count = options['Number of elements around child 1']
c2Count = options['Number of elements around child 2']
parentRadius = 0.5 * options['Parent diameter']
parentLength = options['Parent length']
parentLengthScaleFactor = options['Parent length scale factor']
child1AngleRadians = math.radians(options['Child 1 angle degrees'])
child1Radius = 0.5 * options['Child 1 diameter']
child1Length = options['Child 1 length']
child1LengthScaleFactor = options['Child 1 length scale factor']
child2AngleRadians = math.radians(options['Child 2 angle degrees'])
child2Radius = 0.5 * options['Child 2 diameter']
child2Length = options['Child 2 length']
child2LengthScaleFactor = options['Child 2 length scale factor']
useCrossDerivatives = False
# centres:
paCentre = [0.0, 0.0, -parentLength]
c1Centre = [
child1Length * math.sin(child1AngleRadians), 0.0,
child1Length * math.cos(child1AngleRadians)
]
c2Centre = [
child2Length * math.sin(child2AngleRadians), 0.0,
child2Length * math.cos(child2AngleRadians)
]
c12 = sub(c1Centre, c2Centre)
pac1Count, pac2Count, c1c2Count = get_tube_bifurcation_connection_elements_counts(
paCount, c1Count, c2Count)
# parent ring
paAxis3 = [0.0, 0.0, parentLength]
paAxis2 = mult(normalize(cross(paAxis3, c12)), parentRadius)
paAxis1 = mult(normalize(cross(paAxis2, paAxis3)), parentRadius)
paStartRadians = -math.pi * (pac1Count / paCount)
pax, pad1 = createCirclePoints(paCentre, paAxis1, paAxis2, paCount,
paStartRadians)
pad2 = [mult(paAxis3, parentLengthScaleFactor)] * paCount
# child 1 ring
c1Axis3 = c1Centre
c1Axis2 = mult(normalize(cross(c1Axis3, c12)), child1Radius)
c1Axis1 = mult(normalize(cross(c1Axis2, c1Axis3)), child1Radius)
c1StartRadians = -math.pi * (pac1Count / c1Count)
c1x, c1d1 = createCirclePoints(c1Centre, c1Axis1, c1Axis2, c1Count,
c1StartRadians)
c1d2 = [mult(c1Axis3, child1LengthScaleFactor)] * c1Count
# child 2 ring
c2Axis3 = c2Centre
c2Axis2 = mult(normalize(cross(c2Axis3, c12)), child2Radius)
c2Axis1 = mult(normalize(cross(c2Axis2, c2Axis3)), child2Radius)
c2StartRadians = -math.pi * (c1c2Count / c2Count)
c2x, c2d1 = createCirclePoints(c2Centre, c2Axis1, c2Axis2, c2Count,
c2StartRadians)
c2d2 = [mult(c2Axis3, child2LengthScaleFactor)] * c2Count
rox, rod1, rod2, cox, cod1, cod2, paStartIndex, c1StartIndex, c2StartIndex = \
make_tube_bifurcation_points(paCentre, pax, pad2, c1Centre, c1x, c1d2, c2Centre, c2x, c2d2)
fm = region.getFieldmodule()
coordinates = findOrCreateFieldCoordinates(fm)
cache = fm.createFieldcache()
nodes = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
##############
# Create nodes
##############
nodeIdentifier = 1
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)
paNodeId = []
for n in range(paCount):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
pax[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
pad1[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
pad2[n])
paNodeId.append(nodeIdentifier)
nodeIdentifier = nodeIdentifier + 1
roNodeId = []
for n in range(len(rox)):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
rox[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
rod1[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
rod2[n])
roNodeId.append(nodeIdentifier)
nodeIdentifier = nodeIdentifier + 1
coNodeId = []
for n in range(len(cox)):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
cox[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
cod1[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
cod2[n])
coNodeId.append(nodeIdentifier)
nodeIdentifier = nodeIdentifier + 1
c1NodeId = []
for n in range(c1Count):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
c1x[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
c1d1[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
c1d2[n])
c1NodeId.append(nodeIdentifier)
nodeIdentifier = nodeIdentifier + 1
c2NodeId = []
for n in range(c2Count):
node = nodes.createNode(nodeIdentifier, nodetemplate)
cache.setNode(node)
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_VALUE, 1,
c2x[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS1, 1,
c2d1[n])
coordinates.setNodeParameters(cache, -1, Node.VALUE_LABEL_D_DS2, 1,
c2d2[n])
c2NodeId.append(nodeIdentifier)
nodeIdentifier = nodeIdentifier + 1
#################
# Create elements
#################
elementIdentifier = 1
elementIdentifier = make_tube_bifurcation_elements_2d(
region, coordinates, elementIdentifier, paNodeId, paStartIndex,
c1NodeId, c1StartIndex, c2NodeId, c2StartIndex, roNodeId, coNodeId,
useCrossDerivatives)
return []