def defineFaceAnnotations(cls, region, options, annotationGroups):
"""
Add face annotation groups from the highest dimension mesh.
Must have defined faces and added subelements for highest dimension groups.
:param region: Zinc region containing model.
:param options: Dict containing options. See getDefaultOptions().
:param annotationGroups: List of annotation groups for top-level elements.
New face annotation groups are appended to this list.
"""
# add epicardium of fibrous ring
fm = region.getFieldmodule()
MeshType_3d_heartventriclesbase1.defineFaceAnnotations(
region, options, annotationGroups)
MeshType_3d_heartatria1.defineFaceAnnotations(region, options,
annotationGroups)
lFibrousRingGroup = getAnnotationGroupForTerm(
annotationGroups, get_heart_term("left fibrous ring"))
rFibrousRingGroup = getAnnotationGroupForTerm(
annotationGroups, get_heart_term("right fibrous ring"))
epiGroup = getAnnotationGroupForTerm(annotationGroups,
get_heart_term("epicardium"))
mesh2d = fm.findMeshByDimension(2)
is_exterior_face_xi3_1 = fm.createFieldAnd(
fm.createFieldIsExterior(),
fm.createFieldIsOnFace(Element.FACE_TYPE_XI3_1))
is_non_septal_fibrous_ring = fm.createFieldXor(
lFibrousRingGroup.getFieldElementGroup(mesh2d),
rFibrousRingGroup.getFieldElementGroup(mesh2d))
is_non_septal_fibrous_ring_epi = fm.createFieldAnd(
is_non_septal_fibrous_ring, is_exterior_face_xi3_1)
epiGroup.getMeshGroup(mesh2d).addElementsConditional(
is_non_septal_fibrous_ring_epi)
def defineFaceAnnotations(cls, region, options, annotationGroups):
"""
Add point annotation groups from the 1D mesh.
:param region: Zinc region containing model.
:param options: Dict containing options. See getDefaultOptions().
:param annotationGroups: List of annotation groups for top-level elements.
New point annotation groups are appended to this list.
"""
# create groups
fm = region.getFieldmodule()
armCount = len(options['Numbers of elements along arms'])
mesh2d = fm.findMeshByDimension(2)
is_exterior = fm.createFieldIsExterior()
is_exterior_face_xi2_0 = fm.createFieldAnd(
is_exterior, fm.createFieldIsOnFace(Element.FACE_TYPE_XI2_0))
is_exterior_face_xi2_1 = fm.createFieldAnd(
is_exterior, fm.createFieldIsOnFace(Element.FACE_TYPE_XI2_1))
armTerms, faceTerms = getAutomaticArmFaceTerms(armCount)
armGroups = [
getAnnotationGroupForTerm(annotationGroups, armTerm)
for armTerm in armTerms
]
isArm = [
armGroup.getFieldElementGroup(mesh2d) for armGroup in armGroups
]
for arm in range(armCount):
is_face = fm.createFieldOr(
fm.createFieldAnd(isArm[arm - 1], is_exterior_face_xi2_1),
fm.createFieldAnd(isArm[arm], is_exterior_face_xi2_0))
faceGroup = findOrCreateAnnotationGroupForTerm(
annotationGroups, region, faceTerms[arm - 1])
faceGroup.getMeshGroup(mesh2d).addElementsConditional(is_face)
def defineFaceAnnotations(cls, region, options, annotationGroups):
'''
Add face annotation groups from the highest dimension mesh.
Must have defined faces and added subelements for highest dimension groups.
:param region: Zinc region containing model.
:param options: Dict containing options. See getDefaultOptions().
:param annotationGroups: List of annotation groups for top-level elements.
New face annotation groups are appended to this list.
'''
# Create 2d surface mesh groups
fm = region.getFieldmodule()
mesh2d = fm.findMeshByDimension(2)
colonGroup = getAnnotationGroupForTerm(annotationGroups, get_colon_term("colon"))
is_exterior = fm.createFieldIsExterior()
is_exterior_face_xi3_1 = fm.createFieldAnd(is_exterior, fm.createFieldIsOnFace(Element.FACE_TYPE_XI3_1))
is_exterior_face_xi3_0 = fm.createFieldAnd(is_exterior, fm.createFieldIsOnFace(Element.FACE_TYPE_XI3_0))
is_colon = colonGroup.getFieldElementGroup(mesh2d)
is_serosa = fm.createFieldAnd(is_colon, is_exterior_face_xi3_1)
serosa = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_colon_term("serosa of colon"))
serosa.getMeshGroup(mesh2d).addElementsConditional(is_serosa)
is_mucosaInnerSurface = fm.createFieldAnd(is_colon, is_exterior_face_xi3_0)
mucosaInnerSurface = findOrCreateAnnotationGroupForTerm(annotationGroups, region,
get_colon_term("luminal surface of the colonic mucosa"))
mucosaInnerSurface.getMeshGroup(mesh2d).addElementsConditional(is_mucosaInnerSurface)
def defineFaceAnnotations(cls, region, options, annotationGroups):
"""
Add face annotation groups from the highest dimension mesh.
Must have defined faces and added subelements for highest dimension groups.
:param region: Zinc region containing model.
:param options: Dict containing options. See getDefaultOptions().
:param annotationGroups: List of annotation groups for top-level elements.
New face annotation groups are appended to this list.
"""
# create 2d surface mesh groups
fm = region.getFieldmodule()
neckGroup = getAnnotationGroupForTerm(annotationGroups, get_bladder_term("neck of urinary bladder"))
bodyGroup = getAnnotationGroupForTerm(annotationGroups, get_bladder_term("dome of the bladder"))
urinaryBladderGroup = getAnnotationGroupForTerm(annotationGroups, get_bladder_term("urinary bladder"))
mesh2d = fm.findMeshByDimension(2)
is_exterior = fm.createFieldIsExterior()
is_exterior_face_xi3_1 = fm.createFieldAnd(is_exterior, fm.createFieldIsOnFace(Element.FACE_TYPE_XI3_1))
is_exterior_face_xi3_0 = fm.createFieldAnd(is_exterior, fm.createFieldIsOnFace(Element.FACE_TYPE_XI3_0))
is_body = bodyGroup.getFieldElementGroup(mesh2d)
is_body_serosa = fm.createFieldAnd(is_body, is_exterior_face_xi3_1)
is_body_lumen = fm.createFieldAnd(is_body, is_exterior_face_xi3_0)
is_neck = neckGroup.getFieldElementGroup(mesh2d)
is_neck_serosa = fm.createFieldAnd(is_neck, is_exterior_face_xi3_1)
is_neck_lumen = fm.createFieldAnd(is_neck, is_exterior_face_xi3_0)
serosaOfBody = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_bladder_term("serosa of body of urinary bladder"))
serosaOfBody.getMeshGroup(mesh2d).addElementsConditional(is_body_serosa)
lumenOfBody = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_bladder_term("lumen of body of urinary bladder"))
lumenOfBody.getMeshGroup(mesh2d).addElementsConditional(is_body_lumen)
SerosaOfNeck =findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_bladder_term("serosa of neck of urinary bladder"))
SerosaOfNeck.getMeshGroup(mesh2d).addElementsConditional(is_neck_serosa)
lumenOfNeck = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_bladder_term("lumen of neck of urinary bladder"))
lumenOfNeck.getMeshGroup(mesh2d).addElementsConditional(is_neck_lumen)
def test_sphere1(self):
"""
Test creation of Sphere scaffold.
"""
scaffold = MeshType_3d_solidsphere2
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default"])
options = scaffold.getDefaultOptions("Default")
self.assertEqual(16, len(options))
self.assertEqual(4, options.get("Number of elements across axis 1"))
self.assertEqual(4, options.get("Number of elements across axis 2"))
self.assertEqual(4, options.get("Number of elements across axis 3"))
self.assertEqual(0, options.get("Number of elements across shell"))
self.assertEqual(1,
options.get("Number of elements across transition"))
self.assertEqual(1.0, options.get("Radius1"))
self.assertEqual(1.0, options.get("Radius2"))
self.assertEqual(1.0, options.get("Radius3"))
self.assertEqual(1.0,
options.get("Shell element thickness proportion"))
self.assertEqual(
[0, 4], options.get("Range of elements required in direction 1"))
self.assertEqual(
[0, 4], options.get("Range of elements required in direction 2"))
self.assertEqual(
[0, 4], options.get("Range of elements required in direction 3"))
self.assertEqual([1, 2, 3], options.get("Box derivatives"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(2, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(32, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(108, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(128, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(53, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, sphere volume
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-1.0, -1.0, -1.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [1.0, 1.0, 1.0], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
surfaceGroup = AnnotationGroup(region, ("sphere surface", ""))
is_exterior = fieldmodule.createFieldIsExterior()
surfaceMeshGroup = surfaceGroup.getMeshGroup(mesh2d)
surfaceMeshGroup.addElementsConditional(is_exterior)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, surfaceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 12.460033954564986, delta=2.0E-1)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 4.132033912594377, delta=1.0E-3)
# check some annotationGroups:
expectedSizes3d = {
"box group": 8,
"transition group": 24,
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, (name, ''))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 8x8x8 and check result
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements'] = 2
meshrefinement = MeshRefinement(region, refineRegion, [])
scaffold.refineMesh(meshrefinement, options)
refineCoordinates = refineFieldmodule.findFieldByName(
"coordinates").castFiniteElement()
refineFieldmodule.defineAllFaces()
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(256, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(816, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(880, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(321, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# obtain surface area and volume again. If they are the same as previous, mesh is conform.
with ChangeManager(refineFieldmodule):
one = refineFieldmodule.createFieldConstant(1.0)
surfaceGroup = AnnotationGroup(refineRegion,
("sphere surface", ""))
is_exterior = refineFieldmodule.createFieldIsExterior()
surfaceMeshGroup = surfaceGroup.getMeshGroup(mesh2d)
surfaceMeshGroup.addElementsConditional(is_exterior)
surfaceAreaField = refineFieldmodule.createFieldMeshIntegral(
one, refineCoordinates, surfaceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = refineFieldmodule.createFieldMeshIntegral(
one, refineCoordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
refineFieldcache = refineFieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(
refineFieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 12.460033954564986, delta=5.0E-1)
result, volume = volumeField.evaluateReal(refineFieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 4.132033912594377, delta=3.0E-1)
# check ellipsoid.
scaffold1 = MeshType_3d_solidsphere2
parameterSetNames = scaffold1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default"])
options = scaffold1.getDefaultOptions("Default")
options['Number of elements across axis 1'] = 4
options['Number of elements across axis 2'] = 6
options['Number of elements across axis 3'] = 8
options['Range of elements required in direction 1'] = [0, 4]
options['Range of elements required in direction 2'] = [0, 6]
options['Range of elements required in direction 3'] = [0, 8]
options['Radius1'] = 0.5
options['Radius2'] = 0.8
options['Radius3'] = 1.0
context2 = Context("Test2")
region = context2.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold1.generateMesh(region, options)
self.assertEqual(2, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(136, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(452, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(510, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(195, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, sphere volume
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-0.5, -0.8, -1.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [0.5, 0.8, 1.0], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
surfaceGroup = AnnotationGroup(region, ("sphere surface", ""))
is_exterior = fieldmodule.createFieldIsExterior()
surfaceMeshGroup = surfaceGroup.getMeshGroup(mesh2d)
surfaceMeshGroup.addElementsConditional(is_exterior)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, surfaceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 7.3015173697377245, delta=2.0E-1)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 1.6741674010981926, delta=1.0E-3)
def test_heart1(self):
"""
Test creation of heart scaffold.
"""
scaffold = MeshType_3d_heart1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [
"Default", "Human 1", "Mouse 1", "Pig 1", "Rat 1", "Unit Human 1",
"Unit Mouse 1", "Unit Pig 1", "Unit Rat 1"
])
options = scaffold.getDefaultOptions("Human 1")
self.assertEqual(123, len(options))
self.assertEqual(0.9, options.get("LV outer height"))
self.assertEqual(80.0, options.get("Unit scale"))
self.assertEqual(7,
options.get("Number of elements around LV free wall"))
self.assertEqual(7,
options.get("Number of elements around RV free wall"))
# simplify atria
self.assertEqual(8, options.get("Number of elements over atria"))
options["Number of elements over atria"] = 6
self.assertEqual(
2, options.get("Number of elements radial pulmonary vein annuli"))
options["Number of elements radial pulmonary vein annuli"] = 1
self.assertFalse(scaffold.checkOptions(options))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(32, len(annotationGroups))
fieldmodule = region.getFieldmodule()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(332, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1287, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1567, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(614, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, epicardium surface area and volume
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums,
[-50.7876375290527, -58.42494589146976, -91.6],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[43.810947610743156, 39.03925080604259, 42.018608492002784],
1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
epicardiumGroup = fieldmodule.findFieldByName(
'epicardium').castGroup()
self.assertTrue(epicardiumGroup.isValid())
epicardiumMeshGroup = epicardiumGroup.getFieldElementGroup(
mesh2d).getMeshGroup()
self.assertTrue(epicardiumMeshGroup.isValid())
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, epicardiumMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 36541.36513577538, delta=1.0E-2)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 218014.81436425756, delta=1.0E-1)
# check some annotationGroups:
expectedSizes3d = {
"left ventricle myocardium": 110,
"right ventricle myocardium": 95,
"interventricular septum": 37,
"left atrium myocardium": 88,
"right atrium myocardium": 80,
"interatrial septum": 23
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
expectedSizes2d = {
"endocardium of left ventricle": 88,
"endocardium of right ventricle": 73,
"endocardium of left atrium": 82,
"endocardium of right atrium": 74,
"epicardium": 229
}
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name], size, name)
# test finding a marker in scaffold
markerGroup = fieldmodule.findFieldByName("marker").castGroup()
markerNodes = markerGroup.getFieldNodeGroup(nodes).getNodesetGroup()
self.assertEqual(7, markerNodes.getSize())
markerName = fieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = fieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = fieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of heart")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 1.0], 1.0E-10)
apexGroup = getAnnotationGroupForTerm(annotationGroups,
get_heart_term("apex of heart"))
self.assertTrue(apexGroup.getNodesetGroup(nodes).containsNode(node))
# refine 2x2x2 and check result
# first remove any face (but not point) annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (
annotationGroup.hasMeshGroup(mesh2d)
or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(23, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 2
options['Refine number of elements through LV wall'] = 2
options['Refine number of elements through wall'] = 2
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(32, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(2580, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(8872, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(9983, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(3693, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 8, size, name)
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
if name == "epicardium":
# fibrous ring is only refined by 1 through its thickness
fibrousRingReduction = (
options['Refine number of elements surface'] - 1
) * options['Refine number of elements surface'] * (
options['Number of elements around left atrium free wall']
+
options['Number of elements around right atrium free wall']
)
self.assertEqual(
expectedSizes2d[name] * 4 - fibrousRingReduction, size,
name)
else:
self.assertEqual(expectedSizes2d[name] * 4, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(7, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of heart")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(5, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 1.0], 1.0E-10)
apexGroup = getAnnotationGroupForTerm(annotationGroups,
get_heart_term("apex of heart"))
self.assertTrue(apexGroup.getNodesetGroup(nodes).containsNode(node))
def test_stomach1(self):
"""
Test creation of stomach scaffold.
"""
scaffold = MeshType_3d_stomach1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames,
["Default", "Human 1", "Mouse 1", "Rat 1"])
options = scaffold.getDefaultOptions("Rat 1")
self.assertEqual(19, len(options))
self.assertEqual(12,
options.get("Number of elements around esophagus"))
self.assertEqual(14, options.get("Number of elements around duodenum"))
self.assertEqual(
2, options.get("Number of elements between cardia and duodenum"))
self.assertEqual(1, options.get("Number of elements across cardia"))
self.assertEqual(0.5, options.get("Wall thickness"))
self.assertEqual(True, options.get("Limiting ridge"))
ostiumOptions = options['Gastro-esophagal junction']
ostiumSettings = ostiumOptions.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(
12, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(4,
ostiumSettings.get("Number of elements through wall"))
self.assertEqual(5.0, ostiumSettings.get("Ostium diameter"))
self.assertEqual(5.0, ostiumSettings.get("Ostium length"))
self.assertEqual(0.5, ostiumSettings.get("Ostium wall thickness"))
self.assertEqual(
[0.65, 0.12, 0.18, 0.05],
ostiumSettings.get("Ostium wall relative thicknesses"))
self.assertEqual(2.0, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(0.5, ostiumSettings.get("Vessel wall thickness"))
self.assertEqual(
[0.65, 0.12, 0.18, 0.05],
ostiumSettings.get("Vessel wall relative thicknesses"))
self.assertEqual(0.0, ostiumSettings.get("Vessel angle 1 degrees"))
self.assertEqual(
0.55,
options.get("Gastro-esophagal junction position along factor"))
self.assertEqual(0.2, options.get("Cardia derivative factor"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(37, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(582, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1965, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(2195, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(830, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(
self, minimums,
[-18.238549598577396, -16.033751319943754, -8.905924748773598],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[18.285156743233415, 15.214807824088728, 8.905433142848109],
1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(
fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 2557.832902256128, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 809.0349219398828, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"body of stomach": 112,
"cardia of stomach": 36,
"duodenum": 56,
"esophagus": 96,
"fundus of stomach": 114,
"pyloric antrum": 112,
"pyloric canal": 56,
"stomach": 582
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and \
(annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(37, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(68, len(annotationGroups))
#
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(37248, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(115248, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(118796, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(40814, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(18, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(
markerNodes, markerName,
"esophagogastric junction along the lesser curvature on serosa")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(5821, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 1.0, 1.0], 1.0E-10)
def test_lung1(self):
"""
Test creation of heart scaffold.
"""
scaffold = MeshType_3d_lung1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [ "Default", "Human 1", "Mouse 1", "Pig 1", "Rat 1" ])
options = scaffold.getDefaultOptions(["Human 1"])
self.assertEqual(3, len(options))
self.assertFalse(scaffold.checkOptions(options))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(20, len(annotationGroups))
fieldmodule = region.getFieldmodule()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(88, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(292, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(334, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(141, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, outside surface area and volume
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [ 14.153, 62.444, -353.40564 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 297.502, 245.3003, -23.486 ], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
upperRightFissureGroup = fieldmodule.findFieldByName('upper lobe of right lung').castGroup()
self.assertTrue(upperRightFissureGroup.isValid())
upperRightFissureMeshGroup = upperRightFissureGroup.getFieldElementGroup(mesh2d).getMeshGroup()
self.assertTrue(upperRightFissureMeshGroup.isValid())
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, upperRightFissureMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 138894.27893716586, delta=1.0E-2)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 7225489.982550352, delta=1.0E-2)
# check some annotationGroups:
expectedSizes3d = {
"lung": 88,
"left lung": 44,
"right lung": 44,
"upper lobe of left lung": 24,
"lower lobe of left lung": 20,
"upper lobe of right lung": 16,
"middle lobe of right lung": 8,
"lower lobe of right lung": 20,
# "right lung accessory lobe": 0
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
expectedSizes2d = {
"horizontal fissure of right lung": 4,
"oblique fissure of left lung": 8,
"oblique fissure of right lung": 8
}
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name], size, name)
# test finding a marker in scaffold
markerGroup = fieldmodule.findFieldByName("marker").castGroup()
markerNodes = markerGroup.getFieldNodeGroup(nodes).getNodesetGroup()
self.assertEqual(9, markerNodes.getSize())
markerName = fieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = fieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = fieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of left lung")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(37, element.getIdentifier())
assertAlmostEqualList(self, xi, [ 0.0, 0.0, 1.0 ], 1.0E-10)
# refine 4 and check result
# first remove any face (but not point) annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(17, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine'] = True
options['Refine number of elements'] = 4
refineNumberOfElements = options['Refine number of elements']
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(20, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(5632, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(17344, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(17848, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(6147, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name]*(refineNumberOfElements**3), size, name)
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name]*(refineNumberOfElements**2), size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(refinedNodes).getNodesetGroup()
self.assertEqual(9, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of left lung")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(2353, element.getIdentifier())
assertAlmostEqualList(self, xi, [ 0.0, 0.0, 1.0 ], 1.0E-10)
def defineFaceAnnotations(cls, region, options, annotationGroups):
"""
Add face annotation groups from the highest dimension mesh.
Must have defined faces and added subelements for highest dimension groups.
:param region: Zinc region containing model.
:param options: Dict containing options. See getDefaultOptions().
:param annotationGroups: List of annotation groups for top-level elements.
New face annotation groups are appended to this list.
"""
# create 2d surface mesh groups
fm = region.getFieldmodule()
mesh2d = fm.findMeshByDimension(2)
bodyGroup = getAnnotationGroupForTerm(annotationGroups, get_body_term("body"))
coreGroup = getAnnotationGroupForTerm(annotationGroups, get_body_term("core"))
non_coreGroup = getAnnotationGroupForTerm(annotationGroups, get_body_term("non core"))
abdomenGroup = getAnnotationGroupForTerm(annotationGroups, get_body_term("abdomen"))
thoraxGroup = getAnnotationGroupForTerm(annotationGroups, get_body_term("thorax"))
neckGroup = getAnnotationGroupForTerm(annotationGroups, get_body_term("neck core"))
skinGroup = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_body_term("skin epidermis"))
coreBoundaryGroup = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_body_term("core boundary"))
diaphragmGroup = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_body_term("diaphragm"))
spinalCordGroup = findOrCreateAnnotationGroupForTerm(annotationGroups, region, get_body_term("spinal cord"))
is_exterior = fm.createFieldIsExterior()
is_on_face_xi3_1 = fm.createFieldIsOnFace(Element.FACE_TYPE_XI3_1)
is_skin = fm.createFieldAnd(is_exterior, is_on_face_xi3_1)
skinMeshGroup = skinGroup.getMeshGroup(mesh2d)
skinMeshGroup.addElementsConditional(is_skin)
is_core_boundary = fm.createFieldAnd(coreGroup.getGroup(), non_coreGroup.getGroup())
coreBoundaryMeshGroup = coreBoundaryGroup.getMeshGroup(mesh2d)
coreBoundaryMeshGroup.addElementsConditional(is_core_boundary)
is_diaphragm = fm.createFieldAnd(abdomenGroup.getGroup(), thoraxGroup.getGroup())
diaphragmMeshGroup = diaphragmGroup.getMeshGroup(mesh2d)
diaphragmMeshGroup.addElementsConditional(is_diaphragm)
# spinal cord
coordinates = fm.findFieldByName('coordinates').castFiniteElement()
zero = fm.createFieldConstant(0)
zero_m = fm.createFieldConstant(-0.01)
zero_p = fm.createFieldConstant(0.01)
comp2 = cls.axis2.index(max(cls.axis2)) + 1
ax2_comp = fm.createFieldComponent(coordinates, comp2)
ax2_gt_zero_m = fm.createFieldGreaterThan(ax2_comp, zero_m)
ax2_lt_zero_p = fm.createFieldLessThan(ax2_comp, zero_p)
ax2_gt_zero_xi10 = fm.createFieldAnd(fm.createFieldIsOnFace(Element.FACE_TYPE_XI1_0), ax2_gt_zero_m)
ax2_lt_zero_xi10 = fm.createFieldAnd(fm.createFieldIsOnFace(Element.FACE_TYPE_XI1_0), ax2_lt_zero_p)
is_ax2_zero = fm.createFieldAnd(ax2_lt_zero_xi10, ax2_gt_zero_xi10)
comp3 = cls.axis3.index(max(cls.axis3)) + 1
ax3_comp = fm.createFieldComponent(coordinates, comp3)
ax3_positive = fm.createFieldGreaterThan(ax3_comp, zero)
is_ax2_zero_ax3_positive = fm.createFieldAnd(is_ax2_zero, ax3_positive)
is_abdomen_thorax = fm.createFieldAdd(abdomenGroup.getGroup(), thoraxGroup.getGroup())
is_abdomen_thorax_neck = fm.createFieldAdd(is_abdomen_thorax, neckGroup.getGroup())
is_abdomen_thorax_neck_boundary = fm.createFieldAnd(is_core_boundary, is_abdomen_thorax_neck)
is_spinal_cord = fm.createFieldAnd(is_ax2_zero_ax3_positive, is_abdomen_thorax_neck_boundary)
mesh1d = fm.findMeshByDimension(1)
spinalCordMeshGroup = spinalCordGroup.getMeshGroup(mesh1d)
spinalCordMeshGroup.addElementsConditional(is_spinal_cord)
def test_esophagus1(self):
"""
Test creation of esophagus scaffold.
"""
scaffold = MeshType_3d_esophagus1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Human 1"])
options = scaffold.getDefaultOptions("Human 1")
self.assertEqual(15, len(options))
self.assertEqual(8, options.get("Number of elements around"))
self.assertEqual(12, options.get("Number of elements along"))
self.assertEqual(4, options.get("Number of elements through wall"))
self.assertEqual(5.0, options.get("Wall thickness"))
self.assertEqual(0.35, options.get("Mucosa relative thickness"))
self.assertEqual(0.15, options.get("Submucosa relative thickness"))
self.assertEqual(
0.25, options.get("Circular muscle layer relative thickness"))
self.assertEqual(
0.25, options.get("Longitudinal muscle layer relative thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(12, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(384, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1280, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1416, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(524, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(
self, minimums,
[-17.57777917463216, -9.777573632674187, -14.999995678650333],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[40.16077850310996, 291.0400575669104, 14.999999571130854], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(
fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 27931.063402890817, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 116538.12918074048, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"abdominal part of esophagus": 64,
"cervical part of esophagus": 64,
"esophagus": 384,
"esophagus mucosa": 96,
"esophagus smooth muscle circular layer": 96,
"esophagus smooth muscle longitudinal layer": 96,
"submucosa of esophagus": 96,
"thoracic part of esophagus": 256
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_esophagus_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and \
(annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(12, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements around'] = 4
options['Refine number of elements along'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(13, len(annotationGroups))
#
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(24576, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(75776, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(77856, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(26660, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_esophagus_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(4, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(
markerNodes, markerName,
"distal point of lower esophageal sphincter serosa on the greater curvature of stomach"
)
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(24125, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 1.0, 1.0], 1.0E-10)
def test_bladderurethra1(self):
"""
Test creation of bladder scaffold.
"""
scaffold = MeshType_3d_bladderurethra1
parameterSetNames = MeshType_3d_bladderurethra1.getParameterSetNames()
self.assertEqual(parameterSetNames,
["Default", "Cat 1", "Rat 1", "Human 1"])
options = scaffold.getDefaultOptions("Cat 1")
self.assertEqual(26, len(options))
self.assertEqual(12, options.get("Number of elements along bladder"))
self.assertEqual(12, options.get("Number of elements around"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(0.5, options.get("Wall thickness"))
self.assertEqual(45, options.get("Neck angle degrees"))
ostiumOptions = options['Ureter']
ostiumSettings = ostiumOptions.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(
8, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(1,
ostiumSettings.get("Number of elements through wall"))
self.assertEqual(2.2, ostiumSettings.get("Ostium diameter"))
self.assertEqual(0.5, ostiumSettings.get("Ostium length"))
self.assertEqual(0.5, ostiumSettings.get("Ostium wall thickness"))
self.assertEqual(0.8, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(0.25, ostiumSettings.get("Vessel wall thickness"))
self.assertEqual(0.0, ostiumSettings.get("Vessel angle 1 degrees"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(13, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(240, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(960, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1201, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(487, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums,
[-15.48570141314588, -12.992184072505665, -0.5],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[15.485696373577879, 13.837600783918127, 127.68599990411343],
1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(
fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 5335.535739164492, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 2555.81694845211, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"dome of the bladder": 108,
"neck of urinary bladder": 36,
"urethra": 96,
"urinary bladder": 144
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_bladder_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# test finding a marker in scaffold
markerGroup = fieldmodule.findFieldByName("marker").castGroup()
markerNodes = markerGroup.getFieldNodeGroup(nodes).getNodesetGroup()
self.assertEqual(5, markerNodes.getSize())
markerName = fieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = fieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = fieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName,
"apex of urinary bladder")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 0.0], 1.0E-10)
apexGroup = getAnnotationGroupForTerm(
annotationGroups, get_bladder_term("apex of urinary bladder"))
self.assertTrue(apexGroup.getNodesetGroup(nodes).containsNode(node))
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (
annotationGroup.hasMeshGroup(mesh2d)
or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(13, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements along'] = 4
options['Refine number of elements around'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
del meshrefinement
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(37, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(15360, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(49920, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(53764, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(19210, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_bladder_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(5, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName,
"apex of urinary bladder")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 0.0], 1.0E-10)
def test_heart1(self):
"""
Test creation of heart scaffold.
"""
scaffold = MeshType_3d_heart1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [
"Default", "Human 1", "Mouse 1", "Pig 1", "Rat 1", "Unit Human 1",
"Unit Mouse 1", "Unit Pig 1", "Unit Rat 1"
])
options = scaffold.getDefaultOptions("Human 1")
self.assertEqual(117, len(options))
self.assertEqual(0.9, options.get("LV outer height"))
self.assertEqual(80.0, options.get("Unit scale"))
self.assertEqual(7,
options.get("Number of elements around LV free wall"))
self.assertEqual(7,
options.get("Number of elements around RV free wall"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(27, len(annotationGroups))
fieldmodule = region.getFieldmodule()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(289, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1117, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1356, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(528, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums,
[-50.7876375290527, -57.76590573823474, -91.6],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[43.81084359764995, 39.03925080604259, 40.71693637558552], 1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"left ventricle myocardium": 94,
"right ventricle myocardium": 79,
"interventricular septum": 30,
"left atrium myocardium": 88,
"right atrium myocardium": 62,
"interatrial septum": 17
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
expectedSizes2d = {
"endocardium of left ventricle": 74,
"endocardium of right ventricle": 59,
"endocardium of left atrium": 82,
"endocardium of right atrium": 56,
"epicardium": 197
}
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name], size, name)
# refine 2x2x2 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if annotationGroup.getMeshGroup(mesh3d).getSize() == 0:
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(18, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 2
options['Refine number of elements through LV wall'] = 2
options['Refine number of elements through wall'] = 2
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(27, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(2236, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(7676, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(8623, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(3183, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 8, size, name)
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
if name == "epicardium":
# fibrous ring is only refined by 1 through its thickness
fibrousRingReduction = (
options['Refine number of elements surface'] - 1
) * options['Refine number of elements surface'] * (
options['Number of elements around left atrium free wall']
+
options['Number of elements around right atrium free wall']
)
self.assertEqual(
expectedSizes2d[name] * 4 - fibrousRingReduction, size,
name)
else:
self.assertEqual(expectedSizes2d[name] * 4, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(5, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "APEX")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(5, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 1.0], 1.0E-10)
def test_stomach1(self):
"""
Test creation of stomach scaffold.
"""
scaffold = MeshType_3d_stomach1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [ "Default", "Human 1", "Rat 1" ])
options = scaffold.getDefaultOptions("Rat 1")
self.assertEqual(15, len(options))
self.assertEqual(12, options.get("Number of elements around esophagus"))
self.assertEqual(14, options.get("Number of elements around duodenum"))
self.assertEqual(2, options.get("Number of elements between cardia and duodenum"))
self.assertEqual(1, options.get("Number of elements across cardia"))
self.assertEqual(0.5, options.get("Wall thickness"))
self.assertEqual(True, options.get("Limiting ridge"))
ostiumOptions = options['Gastro-esophagal junction']
ostiumSettings = ostiumOptions.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(8, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(1, ostiumSettings.get("Number of elements through wall"))
self.assertEqual(4.0, ostiumSettings.get("Ostium diameter"))
self.assertEqual(3.5, ostiumSettings.get("Ostium length"))
self.assertEqual(0.5, ostiumSettings.get("Ostium wall thickness"))
self.assertEqual(1.25, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(0.5, ostiumSettings.get("Vessel wall thickness"))
self.assertEqual(0.0, ostiumSettings.get("Vessel angle 1 degrees"))
self.assertEqual(0.55, options.get("Gastro-esophagal junction position along factor"))
self.assertEqual(0.2, options.get("Cardia derivative factor"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(13, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(158, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(643, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(823, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(342, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-18.535034704449842, -14.989550140413265, -8.726949180639382], 1.0E-6)
assertAlmostEqualList(self, maximums, [18.39909561216101, 15.187335864125645, 8.727618869278126], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 2452.212186914634, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 1175.367658574881, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"body of stomach" : 28,
"cardia of stomach" : 12,
"duodenum" : 14,
"esophagus" : 24,
"fundus of stomach" : 38,
"pyloric antrum" : 28,
"pylorus": 14,
"stomach": 158
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(13, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(16, len(annotationGroups))
#
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(10112, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(33232, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(36028, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(12936, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name]*64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(refinedNodes).getNodesetGroup()
self.assertEqual(4, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "gastro-esophagal junction on lesser curvature")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1213, element.getIdentifier())
assertAlmostEqualList(self, xi, [ 0.0, 1.0, 1.0 ], 1.0E-10)
