def setUp(self):
self.doms = list()
data2D = {'lower': [0, 0], 'upper': [0.6, 0.8], "nelem": [2, 3]}
for ngl in range(2, 10, 2):
dm = DMPlexDom(boxMesh=data2D)
dm.setFemIndexing(ngl)
self.doms.append(dm)
def setUp(self):
data3D = {
'lower': [0, 0, 0],
'upper': [0.6, 0.8, 1],
"nelem": [3, 4, 5]
}
self.dom = DMPlexDom(boxMesh=data3D)
self.dom.setFemIndexing(3)
def test_get_all_global_nodes_ngls(self):
data2D = {'lower': [0, 0], 'upper': [0.6, 0.8], "nelem": [2, 3]}
for ngl in range(2, 14):
dom = DMPlexDom(boxMesh=data2D)
dom.setFemIndexing(ngl)
allNodes = dom.getAllNodes()
total = 12 + 17 * (ngl - 2) + 6 * ((ngl - 2)**2)
assert len(allNodes) == total
del dom
def setUp(self):
ngl = 2
data2D = {'lower': [0, 0], 'upper': [1, 1], "nelem": [2, 2]}
self.dom = DMPlexDom(boxMesh=data2D)
self.dom.setFemIndexing(ngl)
dim = self.dom.getDimension()
spectral2D = Spectral(ngl, dim)
self.dom.computeFullCoordinates(spectral2D)
self.testVelVec = self.dom.createGlobalVec()
class BaseProblem(object):
def __init__(self, comm=MPI.COMM_WORLD):
"""
comm: MPI Communicator
"""
self.comm = comm
self.logger = logging.getLogger("Setting Up Base Problem")
def setUpDomain(self):
self.dom = DMPlexDom(self.lower, self.upper, self.nelem)
self.logger.debug("DMPlex dom intialized")
def setUpHighOrderIndexing(self):
self.dom.setFemIndexing(self.ngl)
def setUpElement(self):
self.elemType = Spectral2D(self.ngl, self.dim)
def setUpWithInputData(self, inputData):
self.dim = len(inputData['nelem'])
self.dim_w = 1 if self.dim == 2 else 3
self.dim_s = 3 if self.dim == 2 else 6
self.ngl = inputData['ngl']
self.lower = inputData['lower']
self.upper = inputData['upper']
self.nelem = inputData['nelem']
def createMesh(self):
self.dom.computeFullCoordinates(self.elemType)
self.viewer = Paraviewer(self.dim ,self.comm)
self.viewer.saveMesh(self.dom.fullCoordVec)
def setUpGeneral(self, inputData):
self.setUpWithInputData(inputData)
self.setUpDomain()
self.setUpHighOrderIndexing()
self.setUpElement()
self.createMesh()
def setUp(self):
self.dom_list_2d = list()
dim = 2
for ngl in range(2,4):
dm = DMPlexDom([0]*dim, [1]*dim, [2]*dim)
dm.setFemIndexing(ngl)
self.dom_list_2d.append(dm)
self.dom_list_3d = list()
dim = 3
for ngl in range(2,4):
dm = DMPlexDom([0]*dim, [1]*dim, [2]*dim)
dm.setFemIndexing(ngl)
self.dom_list_3d.append(dm)
class TestBoxDMPLEX2D(unittest.TestCase):
# Test Roadmap
## 1. Separate dmplex from indicesmanager
def setUp(self):
data2D = {'lower': [0, 0], 'upper': [0.6, 0.8], "nelem": [3, 4]}
self.dom = DMPlexDom(boxMesh=data2D)
self.dom.setFemIndexing(3)
def test_generate_dmplex(self):
assert self.dom.getDimension() == 2
def test_cell_start_end(self):
self.assertEqual(self.dom.cellStart, 0)
self.assertEqual(self.dom.cellEnd, 12)
def test_cell_corners_coords(self):
coords_cell_0 = np.array([[0, 0], [0.2, 0], [0.2, 0.2], [0, 0.2]])
coords_cell_0.shape = 8
coord = self.dom.getCellCornersCoords(0)
np_test.assert_array_almost_equal(coords_cell_0, coord, decimal=13)
def test_borders_nodes(self):
total = 28
bordersNodes = self.dom.getBordersNodes()
bordersNodes_alt = self.dom.getNodesFromLabel("External Boundary")
assert type(bordersNodes) == set
assert len(bordersNodes) == total
assert type(bordersNodes_alt) == set
assert len(bordersNodes_alt) == total
np_test.assert_equal(bordersNodes, bordersNodes_alt)
def test_border_nodes(self):
borderNames = self.dom.getBordersNames()
for b in borderNames:
if b in ['up', 'down']:
assert len(self.dom.getBorderNodes(b)) == 7
else:
assert len(self.dom.getBorderNodes(b)) == 9
class TestBoxDMPLEX3D(unittest.TestCase):
def setUp(self):
data3D = {
'lower': [0, 0, 0],
'upper': [0.6, 0.8, 1],
"nelem": [3, 4, 5]
}
self.dom = DMPlexDom(boxMesh=data3D)
self.dom.setFemIndexing(3)
def test_generate_dmplex(self):
assert self.dom.getDimension() == 3
def test_cell_start_end(self):
self.assertEqual(self.dom.cellStart, 0)
self.assertEqual(self.dom.cellEnd, 3 * 4 * 5)
def test_cell_corners_coords(self):
coords_cell_0 = np.array([[0, 0, 0], [0, 0.2, 0], [0.2, 0.2, 0],
[0.2, 0, 0], [0, 0, 0.2], [0.2, 0, 0.2],
[0.2, 0.2, 0.2], [0, 0.2, 0.2]])
coords_cell_0.shape = 8 * 3
coord = self.dom.getCellCornersCoords(0)
np_test.assert_array_almost_equal(coords_cell_0, coord, decimal=13)
def test_border_names(self):
borderNames = self.dom.getBordersNames()
assert len(borderNames) == 6
for b in borderNames:
assert b in ['up', 'down', 'left', 'right', 'front', 'back']
def test_borders_nodes(self):
totalArc = 28 * 11
totalFace = 35 * 2
total = totalArc + totalFace
bordersNodes = self.dom.getBordersNodes()
bordersNodes_alt = self.dom.getNodesFromLabel("External Boundary")
assert type(bordersNodes) == set
assert len(bordersNodes) == total
assert type(bordersNodes_alt) == set
assert len(bordersNodes_alt) == total
np_test.assert_equal(bordersNodes, bordersNodes_alt)
def test_border_nodes(self):
borderNames = self.dom.getBordersNames()
for b in borderNames:
if b in ['up', 'down']:
assert len(self.dom.getBorderNodes(b)) == 7 * 11
elif b in ['left', 'right']:
assert len(self.dom.getBorderNodes(b)) == 9 * 11
else:
assert len(self.dom.getBorderNodes(b)) == 7 * 9
class DomainModTests2D(unittest.TestCase):
def setUp(self):
ngl = 2
data2D = {'lower': [0, 0], 'upper': [1, 1], "nelem": [2, 2]}
self.dom = DMPlexDom(boxMesh=data2D)
self.dom.setFemIndexing(ngl)
dim = self.dom.getDimension()
spectral2D = Spectral(ngl, dim)
self.dom.computeFullCoordinates(spectral2D)
self.testVelVec = self.dom.createGlobalVec()
def test_get_all_global_nodes_ngls(self):
data2D = {'lower': [0, 0], 'upper': [0.6, 0.8], "nelem": [2, 3]}
for ngl in range(2, 14):
dom = DMPlexDom(boxMesh=data2D)
dom.setFemIndexing(ngl)
allNodes = dom.getAllNodes()
total = 12 + 17 * (ngl - 2) + 6 * ((ngl - 2)**2)
assert len(allNodes) == total
del dom
def test_get_nodes_coordinates_2D(self):
allNodes = self.dom.getAllNodes()
coords = [[0., 0.], [0.5, 0.], [1., 0.], [0., 0.5], [0.5, 0.5],
[1., 0.5], [0., 1.], [0.5, 1.], [1., 1.]]
test_coords = self.dom.getNodesCoordinates(allNodes)
np_test.assert_array_almost_equal(coords, test_coords)
# # TODO: implement 3D tests
def test_set_function_vec_to_vec_2D(self):
np_coords = np.array([[0., 0.], [0.5, 0.], [1., 0.], [0., 0.5],
[0.5, 0.5], [1., 0.5], [0., 1.], [0.5, 1.],
[1., 1.]])
result = np.sqrt(np_coords)
allNodes = self.dom.getAllNodes()
f = lambda coords: (sqrt(coords[0]), sqrt(coords[1]))
dim = self.dom.getDimension()
self.dom.applyFunctionVecToVec(allNodes, f, self.testVelVec, dim)
test_result = self.testVelVec.getArray().reshape(9, 2)
np_test.assert_array_almost_equal(result, test_result, decimal=12)
def test_set_function_vec_to_vec_2D_some_nodes(self):
np_coords = np.array([[0., 0.], [1, 1.], [1., 1.], [0., 0.5], [1., 1.],
[1., 1.], [1., 1.], [0.5, 1.], [1., 1.]])
result = np.sqrt(np_coords)
self.testVelVec.set(1.0)
someNodes = [0, 3, 7]
f = lambda coords: (sqrt(coords[0]), sqrt(coords[1]))
dim = self.dom.getDimension()
self.dom.applyFunctionVecToVec(someNodes, f, self.testVelVec, dim)
test_result = self.testVelVec.getArray().reshape(9, 2)
np_test.assert_array_almost_equal(result, test_result, decimal=12)
def test_set_function_scalar_to_vec_2D(self):
vecScalar = PETSc.Vec().createSeq(9)
result = np.array([0, 0.5, 1, 0.5, 1., 1.5, 1, 1.5, 2])
allNodes = self.dom.getAllNodes()
f = lambda coord: (coord[0] + coord[1])
self.dom.applyFunctionScalarToVec(allNodes, f, vecScalar)
test_result = vecScalar.getArray()
np_test.assert_array_almost_equal(result, test_result, decimal=12)
def test_set_constant_to_vec_2D(self):
cteValue = [3, 5]
result = np.array([3, 5] * 9).reshape(9, 2)
vec = PETSc.Vec().createSeq(18)
self.dom.applyValuesToVec(self.dom.getAllNodes(), cteValue, vec)
test_result = vec.getArray().reshape(9, 2)
np_test.assert_array_almost_equal(result, test_result, decimal=12)
def setUpDomain(self):
self.dom = DMPlexDom(self.lower, self.upper, self.nelem)
self.logger.debug("DMPlex dom intialized")
norm = vec.index(1.0)
return norm
else:
return 2
class Vertex:
def __init__(self, pointCoords):
self.data = pointCoords
self.next = None
def __repr__(self):
return str(self.data)
def getCoordinates(self):
return np.array(self.data)
if __name__ == "__main__":
lower = [0, 0]
upper = [1, 1]
plex = DMPlexDom(lower=lower, upper=upper, faces=[3, 3])
ns = NoSlipWalls(lower, upper)
ns.setWallVelocity("left", [3, 5])
ns.setWallVelocity("up", [34, 12])
vel, velDofs = ns.getWallVelocity("up")
dim = 2
nodesSet = [3, 5, 9]
dofVelToSet = [node * dim + dof for node in nodesSet for dof in velDofs]
# print(ns)
# plex.getFaceEntities("left")