def test_mousecolonsegment1(self):
"""
Test creation of mouse colon segment scaffold.
"""
options = MeshType_3d_colonsegment1.getDefaultOptions("Mouse 1")
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_colonsegment1.generateBaseMesh(region, options)
self.assertEqual(7, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(160, mesh3d.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
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)
flatSurfaceAreaField = fieldmodule.createFieldMeshIntegral(one, flatCoordinates, faceMeshGroup)
flatSurfaceAreaField.setNumbersOfPoints(4)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 468.17062489996886, delta=1.0E-6)
result, flatSurfaceArea = flatSurfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(flatSurfaceArea, surfaceArea, delta=1.0E-3)
def test_mousecolon1(self):
"""
Test creation of mouse colon scaffold.
"""
options = MeshType_3d_colon1.getDefaultOptions("Mouse 2")
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_colon1.generateBaseMesh(region, options)
self.assertEqual(10, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(1600, mesh3d.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
colonCoordinates = fieldmodule.findFieldByName("colon coordinates").castFiniteElement()
self.assertTrue(colonCoordinates.isValid())
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(fieldmodule, Element.FACE_TYPE_XI3_1)
flatSurfaceAreaField = fieldmodule.createFieldMeshIntegral(one, flatCoordinates, faceMeshGroup)
flatSurfaceAreaField.setNumbersOfPoints(4)
colonSurfaceAreaField = fieldmodule.createFieldMeshIntegral(one, colonCoordinates, faceMeshGroup)
colonSurfaceAreaField.setNumbersOfPoints(4)
colonVolumeField = fieldmodule.createFieldMeshIntegral(one, colonCoordinates, mesh3d)
colonVolumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, flatSurfaceArea = flatSurfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(flatSurfaceArea, 629.4883774904393, delta=1.0E-6)
result, colonSurfaceArea = colonSurfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(colonSurfaceArea, 90.4578820802557, delta=1.0E-6)
result, colonVolume = colonVolumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(colonVolume, 8.290058800222006, delta=1.0E-6)
def test_humancolonsegment1(self):
"""
Test creation of human colon segment scaffold.
"""
parameterSetNames = MeshType_3d_colonsegment1.getParameterSetNames()
self.assertEqual(parameterSetNames,
["Default", "Human 1", "Mouse 1", "Pig 1"])
options = MeshType_3d_colonsegment1.getDefaultOptions("Human 1")
self.assertEqual(27, len(options))
self.assertEqual(0.0, options.get("Start phase"))
self.assertEqual(2,
options.get("Number of elements around tenia coli"))
self.assertEqual(4, options.get("Number of elements along segment"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(43.5, options.get("Start inner radius"))
self.assertEqual(0.0, options.get("Start inner radius derivative"))
self.assertEqual(33.0, options.get("End inner radius"))
self.assertEqual(0.0, options.get("End inner radius derivative"))
self.assertEqual(3.0,
options.get("Segment length mid derivative factor"))
self.assertEqual(50.0, options.get("Segment length"))
self.assertEqual(3, options.get("Number of tenia coli"))
self.assertEqual(10.0, options.get("Start tenia coli width"))
self.assertEqual(0.0, options.get("End tenia coli width derivative"))
self.assertEqual(1.6, options.get("Wall thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_colonsegment1.generateBaseMesh(
region, options)
self.assertEqual(3, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(144, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(576, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(747, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(315, 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,
[-2.172286248499807e-15, -58.968781863998764, -55.55863337757897],
1.0E-6)
assertAlmostEqualList(self, maximums,
[50.0, 50.53111767614515, 55.55863271778078],
1.0E-6)
flatCoordinates = fieldmodule.findFieldByName(
"flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [0.0, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums,
[397.26513766571264, 50.0, 3.2000000000000006],
1.0E-6)
textureCoordinates = fieldmodule.findFieldByName(
"texture coordinates").castFiniteElement()
minimums, maximums = evaluateFieldNodesetRange(textureCoordinates,
nodes)
assertAlmostEqualList(self, minimums, [0.0, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [0.9887754554800083, 1.0, 2.0],
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, 20849.829586166292, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 35626.9300655261, delta=1.0E-6)
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_smallintestine1(self):
"""
Test creation of small intestine scaffold.
"""
parameterSetNames = MeshType_3d_smallintestine1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Cattle 1", "Mouse 1"])
centralPathDefaultScaffoldPackages = {
'Test line': ScaffoldPackage(MeshType_1d_path1, {
'scaffoldSettings': {
'D2 derivatives': True,
'Coordinate dimensions': 3,
'Length': 1.0,
'Number of elements': 3
},
'meshEdits': exnodeStringFromNodeValues(
[Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D2_DS1DS2], [
[[-2.3, 18.5, -4.4], [-4.2, -0.8, 3.7], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]],
[[-8.6, 16.3, -0.4], [-7.1, -2.7, 1.6], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]],
[[-18.3, 12.6, -1.5], [-6.4, -1.7, -3.8], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]],
[[-15.6, 13.7, -6.1], [7.0, 2.1, -1.8], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]]])
})
}
centralPathOption = centralPathDefaultScaffoldPackages['Test line']
options = MeshType_3d_smallintestine1.getDefaultOptions("Mouse 1")
options['Central path'] = copy.deepcopy(centralPathOption)
options['Number of segments'] = 4
options['Duodenum length'] = 5.0
options['Jejunum length'] = 15.0
options['Ileum length'] = 5.0
self.assertEqual(19, len(options))
centralPath = options['Central path']
self.assertEqual(4, options.get("Number of segments"))
self.assertEqual(8, options.get("Number of elements around"))
self.assertEqual(4, options.get("Number of elements along segment"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(5.0, options.get("Duodenum length"))
self.assertEqual(5.0, options.get("Ileum length"))
self.assertEqual(0.6, options.get("Duodenum inner radius"))
self.assertEqual(1.0, options.get("Jejunum-ileum inner radius"))
self.assertEqual(0.1, options.get("Wall thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
tmpRegion = region.createRegion()
centralPath.generate(tmpRegion)
cx = extractPathParametersFromRegion(tmpRegion, [Node.VALUE_LABEL_VALUE])[0]
self.assertEqual(4, len(cx))
assertAlmostEqualList(self, cx[0], [-2.3, 18.5, -4.4], 1.0E-6)
assertAlmostEqualList(self, cx[2], [-18.3, 12.6, -1.5], 1.0E-6)
del tmpRegion
annotationGroups = MeshType_3d_smallintestine1.generateBaseMesh(region, options)
self.assertEqual(4, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(128, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(520, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(664, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(272, 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, [-20.06978981419564, 11.406595205949705, -7.1653294859433965], 1.0E-6)
assertAlmostEqualList(self, maximums, [-1.8300388314851923, 19.193885338090105, 0.9772071374844936], 1.0E-6)
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [-1.39038154442654, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [4.891237158967401, 25.293706698841913, 0.1], 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)
flatSurfaceAreaField = fieldmodule.createFieldMeshIntegral(one, flatCoordinates, faceMeshGroup)
flatSurfaceAreaField.setNumbersOfPoints(4)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 171.27464080337143, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 16.35219225882822, delta=1.0E-6)
result, flatSurfaceArea = flatSurfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(flatSurfaceArea, 171.37026123844635, delta=1.0E-3)
def test_cecum1(self):
"""
Test creation of cecum scaffold.
"""
parameterSetNames = MeshType_3d_cecum1.getParameterSetNames()
self.assertEqual(parameterSetNames, [ "Default", "Pig 1" ])
options = MeshType_3d_cecum1.getDefaultOptions("Pig 1")
self.assertEqual(30, len(options))
self.assertEqual(5, options.get("Number of segments"))
self.assertEqual(2, options.get("Number of elements around tenia coli"))
self.assertEqual(8, options.get("Number of elements along segment"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(35.0, options.get("Start inner radius"))
self.assertEqual(3.0, options.get("Start inner radius derivative"))
self.assertEqual(38.0, options.get("End inner radius"))
self.assertEqual(3.0, options.get("End inner radius derivative"))
self.assertEqual(0.5, options.get("Corner inner radius factor"))
self.assertEqual(0.25, options.get("Haustrum inner radius factor"))
self.assertEqual(4.0, options.get("Segment length mid derivative factor"))
self.assertEqual(3, options.get("Number of tenia coli"))
self.assertEqual(5.0, options.get("Start tenia coli width"))
self.assertEqual(0.0, options.get("End tenia coli width derivative"))
self.assertEqual(2.0, options.get("Wall thickness"))
ostiumOptions = options['Ileocecal 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(20.0, ostiumSettings.get("Ostium diameter"))
self.assertEqual(10.0, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(60, options.get("Ileocecal junction angular position degrees"))
self.assertEqual(0.5, options.get("Ileocecal junction position along factor"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_cecum1.generateBaseMesh(region, options)
self.assertEqual(2, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(1492, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(5617, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(6767, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(2642, 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, [-49.01658984455258, -46.89686037622053, -2.343256155753525], 1.0E-6)
assertAlmostEqualList(self, maximums, [42.18085849205387, 54.89264119402881, 180.0], 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, 65960.02821062482, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 127893.74708048582, delta=1.0E-6)
def test_colon1(self):
"""
Test creation of colon scaffold.
"""
parameterSetNames = MeshType_3d_colon1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Human 1", "Human 2", "Mouse 1", "Mouse 2", "Pig 1", "Pig 2"])
centralPathDefaultScaffoldPackages = {
'Test line': ScaffoldPackage(MeshType_1d_path1, {
'scaffoldSettings': {
'Coordinate dimensions': 3,
'Length': 1.0,
'Number of elements': 1
},
'meshEdits': exnodeStringFromNodeValues(
[Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D2_DS1DS2], [
[[163.7, -25.2, 12.2], [-21.7, 50.1, -18.1], [0.0, 0.0, 5.0], [0.0, 0.0, 0.5]],
[[117.2, 32.8, -2.6], [-64.3, 34.4, -3.9], [0.0, 0.0, 5.0], [0.0, 0.0, 0.5]]])
})
}
centralPathOption = centralPathDefaultScaffoldPackages['Test line']
segmentProfileOption = ScaffoldPackage(MeshType_3d_colonsegment1, defaultParameterSetName='Human 1')
options = {
'Central path': copy.deepcopy(centralPathOption),
'Segment profile': segmentProfileOption,
'Number of segments': 3,
'Start phase': 0.0,
'Proximal length': 25.0,
'Transverse length': 25.0,
'Distal length': 25.0,
'Proximal inner radius': 20.0,
'Proximal tenia coli width': 8.0,
'Proximal-transverse inner radius': 18.0,
'Proximal-transverse tenia coli width': 6.0,
'Transverse-distal inner radius': 16.0,
'Transverse-distal tenia coli width': 5.0,
'Distal inner radius': 15.0,
'Distal tenia coli width': 5.0,
'Refine': False,
'Refine number of elements around': 1,
'Refine number of elements along': 1,
'Refine number of elements through wall': 1
}
self.assertEqual(19, len(options))
centralPath = options['Central path']
segmentProfile = options.get("Segment profile")
segmentSettings = segmentProfile.getScaffoldSettings()
self.assertEqual(8, segmentSettings.get("Number of elements around haustrum"))
self.assertEqual(0.5, segmentSettings.get("Corner inner radius factor"))
self.assertEqual(0.5, segmentSettings.get("Haustrum inner radius factor"))
self.assertEqual(0.5, segmentSettings.get("Segment length end derivative factor"))
self.assertEqual(3, segmentSettings.get("Number of tenia coli"))
self.assertEqual(1.6, segmentSettings.get("Tenia coli thickness"))
self.assertEqual(3, options.get("Number of segments"))
self.assertEqual(0.0, options.get("Start phase"))
self.assertEqual(25.0, options.get("Transverse length"))
self.assertEqual(20.0, options.get("Proximal inner radius"))
self.assertEqual(6.0, options.get("Proximal-transverse tenia coli width"))
self.assertEqual(16.0, options.get("Transverse-distal inner radius"))
self.assertEqual(5.0, options.get("Distal tenia coli width"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
tmpRegion = region.createRegion()
centralPath.generate(tmpRegion)
cx = extractPathParametersFromRegion(tmpRegion)[0]
self.assertEqual(2, len(cx))
assertAlmostEqualList(self, cx[0], [ 163.7, -25.2, 12.2 ], 1.0E-6)
assertAlmostEqualList(self, cx[1], [ 117.2, 32.8, -2.6 ], 1.0E-6)
del tmpRegion
annotationGroups = MeshType_3d_colon1.generateBaseMesh(region, options)
self.assertEqual(7, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
if annotationGroups is not None:
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(432, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1656, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(2043, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(819, 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, [ 108.0250647983898, -36.876103983560014, -25.89741158325083 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 185.46457506220003, 48.101157490744, 34.995316052158934 ], 1.0E-6)
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [ 0.0, 0.0, 0.0 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 186.72988844629867, 77.4178187926561, 3.2000000000000006 ], 1.0E-6)
textureCoordinates = fieldmodule.findFieldByName("texture coordinates").castFiniteElement()
minimums, maximums = evaluateFieldNodesetRange(textureCoordinates, nodes)
assertAlmostEqualList(self, minimums, [ 0.0, 0.0, 0.0 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 0.9812471574796385, 1.0, 2.0 ], 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, 14612.416788520026, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 26826.069540921028, delta=1.0E-6)
def test_humancolonsegment1(self):
"""
Test creation of human colon segment scaffold.
"""
parameterSetNames = MeshType_3d_colonsegment1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Cattle 1", "Human 1", "Mouse 1", "Pig 1"])
options = MeshType_3d_colonsegment1.getDefaultOptions("Human 1")
self.assertEqual(31, len(options))
self.assertEqual(0.0, options.get("Start phase"))
self.assertEqual(2, options.get("Number of elements around tenia coli"))
self.assertEqual(4, options.get("Number of elements along segment"))
self.assertEqual(4, options.get("Number of elements through wall"))
self.assertEqual(43.5, options.get("Start inner radius"))
self.assertEqual(0.0, options.get("Start inner radius derivative"))
self.assertEqual(33.0, options.get("End inner radius"))
self.assertEqual(0.0, options.get("End inner radius derivative"))
self.assertEqual(3.0, options.get("Segment length mid derivative factor"))
self.assertEqual(50.0, options.get("Segment length"))
self.assertEqual(3, options.get("Number of tenia coli"))
self.assertEqual(10.0, options.get("Start tenia coli width"))
self.assertEqual(0.0, options.get("End tenia coli width derivative"))
self.assertEqual(1.6, options.get("Wall thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_colonsegment1.generateBaseMesh(region, options)
self.assertEqual(8, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(504, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1746, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(2007, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(765, 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, [-2.172286248499807e-15, -58.95670186936737, -55.54662267827035], 1.0E-6)
assertAlmostEqualList(self, maximums, [50.0, 50.52621132610023, 55.54662267827035], 1.0E-6)
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [0.0, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [397.2736607240895, 50.0, 2.2], 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, 21035.8818469729, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 39781.704358310606, delta=1.0E-6)
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_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)
