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 []