def test_clear_dofs(self):
# Define new dofhandler
mesh = Mesh2D(resolution=(1,1))
cell = mesh.cells.get_child(0)
element = QuadFE(2, 'Q2')
dofhandler = DofHandler(mesh, element)
# Fill dofs
dofhandler.fill_dofs(cell)
# Clear dofs
dofhandler.clear_dofs()
# Check that there are no dofs
self.assertIsNone(dofhandler.get_cell_dofs(cell))
def test_get_local_dofs(self):
"""
Extract local dofs from a corner vertex, halfEdge or cell
"""
local_dofs = {1: {'DQ0': [[0], [], [0]],
'DQ1': [[0,1], [1], []],
'DQ2': [[0,1,2], [1], [2]],
'DQ3': [[0,1,2,3], [1], [2,3]]
},
2: {'DQ0': [[0], [], [], [0]],
'DQ1': [[0,1,2,3], [1], [], []],
'DQ2': [[0,1,2,3,4,5,6,7,8], [1], [6], [8]],
'DQ3': [[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15], [1], [8,9], [12,13,14,15]]
}
}
etypes = ['DQ' + i for i in '0123']
for dim in range(1,3):
if dim==1:
mesh = Mesh1D(box=[2,4], resolution=(1,))
cell = mesh.cells.get_child(0)
vertex = cell.get_vertex(1)
entities = [None, vertex, cell]
elif dim==2:
mesh = QuadMesh(box = [0,2,0,2], resolution=(2,2))
cell = mesh.cells.get_child(1)
vertex = cell.get_vertex(1)
half_edge = cell.get_half_edge(2)
entities = [None, vertex, half_edge, cell]
for etype in etypes:
element = QuadFE(dim, etype)
dofhandler = DofHandler(mesh, element)
for i_entity in range(len(entities)):
entity = entities[i_entity]
dofs = dofhandler.get_cell_dofs(cell, entity=entity,
doftype='local', interior=True)
self.assertEqual(local_dofs[dim][etype][i_entity], dofs)
def test_set_hanging_nodes(self):
"""
Check that functions in the finite element space can be interpolated
by linear combinations of shape functions at supporting nodes.
TODO: Move this test to tests for system
"""
#
# Define QuadMesh with hanging node
#
mesh = QuadMesh(resolution=(1,1))
mesh.cells.refine()
mesh.cells.get_child(0).get_child(0).mark(flag=0)
mesh.cells.refine(refinement_flag=0)
c_00 = mesh.cells.get_child(0).get_child(0)
#
# Define test functions to interpolate
#
test_functions = {'Q1': lambda x,y: x + y, \
'Q2': lambda x,y: x**2 + y**2,\
'Q3': lambda x,y: x**3*y + y**2*x**2}
etypes = ['Q1', 'Q2', 'Q3']
plot = Plot()
for etype in etypes:
#print(etype)
# Define new element
element = QuadFE(2,etype)
# Distribute dofs and set vertices
dofhandler = DofHandler(mesh, element)
dofhandler.distribute_dofs()
dofhandler.set_dof_vertices()
# Determine hanging nodes
dofhandler.set_hanging_nodes()
hanging_nodes = dofhandler.get_hanging_nodes()
for dof, support in hanging_nodes.items():
# Get hanging node vertex
x_hgnd = dofhandler.get_dof_vertices(dof)
# Extract support indices and weights
js, ws = support
# Extract
dofs_glb = dofhandler.get_cell_dofs(c_00)
#print(dof, js)
# Local dof numbers for supporting nodes
dofs_loc_supp = [i for i in range(element.n_dofs()) if dofs_glb[i] in js]
#x_dofs = c_00.reference_map(element.reference_nodes())
#phi_supp = element.shape(x_hgnd, cell=c_00, local_dofs=dofs_loc_supp)
#print(phi_supp, js)
# Evaluate test function at hanging node
#f_hgnd = test_functions[etype](x_hgnd[0],x_hgnd[1])
#print('Weighted sum of support function', np.dot(phi_supp,ws))
#print(f_hgnd - np.dot(phi_supp, ws))
#phi_hgnd = element.shape(x_dofs, cell=c_00, local_dofs=dofs_loc_hgnd)
#print(phi_supp)
#print(phi_hgnd)
#plot.mesh(mesh, dofhandler=dofhandler, dofs=True)
# Evaluate
c_01 = mesh.cells.get_child(0).get_child(1)
c_022 = mesh.cells.get_child(0).get_child(2).get_child(2)
#print(dofhandler.get_global_dofs(c_022))
x_ref = element.reference_nodes()
#print(dofhandler.get_global_dofs(c_01))
#print(dofhandler.get_hanging_nodes())
x = c_01.reference_map(x_ref)
def test_share_dofs_with_children(self):
#
# 1D Test
#
mesh = Mesh1D(resolution=(1,))
mesh.cells.refine()
for etype in ['DQ0','DQ1', 'DQ2', 'DQ3', 'Q1', 'Q2', 'Q3']:
# New DofHandler
element = QuadFE(1, etype)
dh = DofHandler(mesh, element)
# Fill in parent dofs and share with children
cell = mesh.cells.get_child(0)
dh.fill_dofs(cell)
dh.share_dofs_with_children(cell)
# Expected dofs for children
left_child_dofs = {'DQ0': [None],
'DQ1': [0, None],
'DQ2': [0, 2, None],
'DQ3': [0, None, None, 2],
'Q1': [0, None],
'Q2': [0, 2, None],
'Q3': [0, None, None, 2]}
right_child_dofs = {'DQ0': [None],
'DQ1': [None, 1],
'DQ2': [None, 1, None],
'DQ3': [None, 1, 3, None],
'Q1':[None, 1],
'Q2': [2, 1, None],
'Q3': [None, 1, 3, None]}
left_child = cell.get_child(0)
right_child = cell.get_child(1)
#
# Check whether shared dofs are as expected.
#
self.assertEqual(dh.get_cell_dofs(left_child), left_child_dofs[etype])
self.assertEqual(dh.get_cell_dofs(right_child), right_child_dofs[etype])
#
# 2D Test
#
mesh = QuadMesh(resolution=(1,1))
mesh.cells.refine()
for etype in ['DQ0','DQ1', 'DQ2', 'DQ3', 'Q1', 'Q2', 'Q3']:
# New dofhandler
element = QuadFE(2, etype)
dh = DofHandler(mesh, element)
# Fill in parent dofs and share with children
cell = mesh.cells.get_child(0)
dh.fill_dofs(cell)
dh.share_dofs_with_children(cell)
# Expected dofs for children
child_dofs = {0: {'DQ0': [None],
'DQ1': [0, None, None, None],
'DQ2': [0, 4, 8, 7, None, None, None, None, None],
'DQ3': [0, None, None, None, None, 4, None, None,
None, None, 11, None, None, None, None, 12],
'Q1': [0, None, None, None],
'Q2': [0, 4, 8, 7, None, None, None, None, None],
'Q3': [0, None, None, None, None, 4, None, None,
None, None, 11, None, None, None, None, 12]},
1: {'DQ0': [None],
'DQ1': [None, 1, None, None],
'DQ2': [None, 1, 5, None, None, None, None, None, None],
'DQ3': [None, 1, None, None, 5, None, None, 6,
None, None, None, None, None, None, 13, None],
'Q1': [None, 1, None, None],
'Q2': [4, 1, 5, 8, None, None, None, None, None],
'Q3': [None, 1, None, None, 5, None, None, 6,
None, None, None, None, None, None, 13, None]},
2: {'DQ0': [None],
'DQ1': [None, None, 2, None],
'DQ2': [None, None, 2, 6, None, None, None, None, None],
'DQ3': [None, None, 2, None, None, None, 7, None,
None, 8, None, None, 15, None, None, None],
'Q1': [None, None, 2, None],
'Q2': [8, 5, 2, 6, None, None, None, None, None],
'Q3': [None, None, 2, None, None, None, 7, None,
None, 8, None, None, 15, None, None, None]},
3: {'DQ0': [None],
'DQ1': [None, None, None, 3],
'DQ2': [None, None, None, 3, None, None, None, None, None],
'DQ3': [None, None, None, 3, None, None, None,
None, 9, None, None, 10, None, 14, None, None],
'Q1': [None, None, None, 3],
'Q2': [7, 8, 6, 3, None, None, None, None, None],
'Q3': [None, None, None, 3, None, None, None,
None, 9, None, None, 10, None, 14, None, None]}}
for i in range(4):
child = cell.get_child(i)
#
# Check whether shared dofs are as expected
#
self.assertEqual(dh.get_cell_dofs(child), child_dofs[i][etype])
def test_share_dofs_with_neighbors(self):
# =====================================================================
# 1D
# =====================================================================
#
# Non-Periodic
#
# Define new mesh
mesh = Mesh1D(resolution=(2,))
lcell = mesh.cells.get_child(0)
rcell = mesh.cells.get_child(1)
etypes = ['DQ0','DQ1', 'DQ2', 'DQ3', 'Q1', 'Q2', 'Q3']
# Specify expected dofs
edofs = dict.fromkeys(etypes)
edofs['DQ0'] = None
edofs['DQ1'] = None
edofs['DQ2'] = None
edofs['DQ3'] = None
edofs['Q1'] = [1, None]
edofs['Q2'] = [1, None, None]
edofs['Q3'] = [1, None, None, None]
for etype in etypes:
# New Dofhandler
element = QuadFE(1,etype)
dh = DofHandler(mesh, element)
# Fill left dofs and share with right neighbor
dh.fill_dofs(lcell)
dh.share_dofs_with_neighbors(lcell, lcell.get_vertex(1))
self.assertEqual(dh.get_cell_dofs(rcell), edofs[etype])
dh.clear_dofs()
# Fill left dofs and share with all neighbors
dh.fill_dofs(lcell)
dh.share_dofs_with_neighbors(lcell)
self.assertEqual(dh.get_cell_dofs(rcell), edofs[etype])
#
# Periodic
#
# Define new mesh
mesh = Mesh1D(resolution=(2,), periodic=True)
lcell = mesh.cells.get_child(0)
rcell = mesh.cells.get_child(1)
# Specify expected dofs
edofs = dict.fromkeys(etypes)
edofs['DQ0'] = {'right': None, 'all': None}
edofs['DQ1'] = {'right': None, 'all': None}
edofs['DQ2'] = {'right': None, 'all': None}
edofs['DQ3'] = {'right': None, 'all': None}
edofs['Q1'] = {'right': [1, None], 'all': [1, 0]}
edofs['Q2'] = {'right': [1, None, None], 'all': [1, 0, None]}
edofs['Q3'] = {'right': [1, None, None, None],
'all': [1, 0, None, None]}
for etype in etypes:
# New Dofhandler
element = QuadFE(1,etype)
dh = DofHandler(mesh, element)
# Fill left dofs and share with right neighbor
dh.fill_dofs(lcell)
dh.share_dofs_with_neighbors(lcell, lcell.get_vertex(1))
self.assertEqual(dh.get_cell_dofs(rcell), edofs[etype]['right'])
dh.clear_dofs()
# Fill left dofs and share with all neighbors
dh.fill_dofs(lcell)
dh.share_dofs_with_neighbors(lcell)
self.assertEqual(dh.get_cell_dofs(rcell), edofs[etype]['all'])
# =====================================================================
# 2D
# =====================================================================
#
# Non-periodic
#
mesh = Mesh2D(resolution=(2,2))
c00 = mesh.cells.get_child(0)
c10 = mesh.cells.get_child(1)
c11 = mesh.cells.get_child(3)
edofs = dict.fromkeys(etypes)
edofs['DQ0'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['DQ1'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['DQ2'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['DQ3'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['Q1'] = {'vertex': {c10: [2], c11: [2]},
'edge': {c10: None, c11: None},
'all': {c10: [1,None, None, 2],
c11: [2, None, None, None]}}
edofs['Q2'] = {'vertex': {c10: [2], c11: [2]},
'edge': {c10: [5], c11: None},
'all': {c10: [1, None, None, 2, None, None, None, 5, None],
c11: [2] + [None]*8}}
edofs['Q3'] = {'vertex': {c10: [2], c11: [2]},
'edge': {c10: [7,6], c11: None},
'all': {c10: [1, None, None, 2, None, None, None, None,
None, None, 7, 6, None, None, None, None],
c11: [2] + [None]*15}}
for etype in etypes:
# New element
element = QuadFE(2, etype)
# New dofhandler
dh = DofHandler(mesh, element)
# ***************************
# Share dofs accross vertex 2
# ***************************
# Fill
dh.fill_dofs(c00)
# Share
vertex = c00.get_vertex(2)
dh.share_dofs_with_neighbors(c00, vertex)
# Check
self.assertEqual(dh.get_cell_dofs(c10, vertex), edofs[etype]['vertex'][c10])
self.assertEqual(dh.get_cell_dofs(c11, vertex), edofs[etype]['vertex'][c11])
# Clear
dh.clear_dofs()
# *****************************
# Share dofs across half_edge 1
# *****************************
# Fill
dh.fill_dofs(c00)
# Share
edge = c00.get_half_edge(1)
twin = edge.twin()
dh.share_dofs_with_neighbors(c00, edge)
# Check
self.assertEqual(dh.get_cell_dofs(c10, twin, interior=True), edofs[etype]['edge'][c10])
self.assertEqual(dh.get_cell_dofs(c11, twin, interior=True), edofs[etype]['edge'][c11])
# Clear
dh.clear_dofs()
# *****************************
# Share dofs with all neighbors
# *****************************
# Fill
dh.fill_dofs(c00)
# Share
dh.share_dofs_with_neighbors(c00)
# Check
self.assertEqual(dh.get_cell_dofs(c10), edofs[etype]['all'][c10])
self.assertEqual(dh.get_cell_dofs(c11), edofs[etype]['all'][c11])
#
# Periodic in both directions
#
mesh = Mesh2D(resolution=(2,2), periodic={0,1})
c00 = mesh.cells.get_child(0)
c10 = mesh.cells.get_child(1)
c11 = mesh.cells.get_child(3)
edofs = dict.fromkeys(etypes)
edofs['DQ0'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['DQ1'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['DQ2'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['DQ3'] = {'vertex': {c10: None, c11: None},
'edge': {c10: None, c11: None},
'all': {c10: None, c11: None}}
edofs['Q1'] = {'vertex': {c10: [0], c11: [0]},
'edge': {c10: None, c11: None},
'all': {c10: [1,0, 3, 2],
c11: [2, 3, 0, 1]}}
edofs['Q2'] = {'vertex': {c10: [0], c11: [0]},
'edge': {c10: [7], c11: None},
'all': {c10: [1, 0, 3, 2, None, 7, None, 5, None],
c11: [2,3,0,1] + [None]*5}}
edofs['Q3'] = {'vertex': {c10: [0], c11: [0]},
'edge': {c10: [11,10], c11: None},
'all': {c10: [1, 0, 3, 2, None, None, 11, 10,
None, None, 7, 6, None, None, None, None],
c11: [2,3,0,1] + [None]*12}}
for etype in etypes:
# New element
element = QuadFE(2, etype)
# New dofhandler
dh = DofHandler(mesh, element)
# ***************************
# Share dofs accross vertex 0
# ***************************
# Fill
dh.fill_dofs(c00)
# Share
vertex = c00.get_vertex(0)
self.assertTrue(vertex.is_periodic())
dh.share_dofs_with_neighbors(c00, vertex)
# Check
c10_vertex = vertex.get_periodic_pair(c10)[0]
self.assertEqual(dh.get_cell_dofs(c10, c10_vertex), edofs[etype]['vertex'][c10])
c11_vertex = vertex.get_periodic_pair(c11)[0]
self.assertEqual(dh.get_cell_dofs(c11, c11_vertex), edofs[etype]['vertex'][c11])
# Clear
dh.clear_dofs()
# *****************************
# Share dofs across half_edge 3
# *****************************
# Fill
dh.fill_dofs(c00)
# Share
edge = c00.get_half_edge(3)
twin = edge.twin()
dh.share_dofs_with_neighbors(c00, edge)
# Check
self.assertEqual(dh.get_cell_dofs(c10, twin, interior=True), edofs[etype]['edge'][c10])
self.assertEqual(dh.get_cell_dofs(c11, twin, interior=True), edofs[etype]['edge'][c11])
# Clear
dh.clear_dofs()
# *****************************
# Share dofs with all neighbors
# *****************************
# Fill
dh.fill_dofs(c00)
# Share
dh.share_dofs_with_neighbors(c00)
# Check
self.assertEqual(dh.get_cell_dofs(c10), edofs[etype]['all'][c10])
self.assertEqual(dh.get_cell_dofs(c11), edofs[etype]['all'][c11])
def test_assign_get_global_dofs(self):
#
# Assigning Dofs to entities within cell
#
# =====================================================================
# 1D
# =====================================================================
mesh = Mesh1D(resolution=(1,))
cell = mesh.cells.get_child(0)
etypes = ['DQ0', 'DQ1', 'DQ2', 'DQ3']
#
# Expected Dofs
#
edofs = dict.fromkeys(etypes)
edofs['DQ0'] = {'all': [0], 'pos': ([0], [2]), 'vertex': None, 'edge': None}
edofs['DQ1'] = {'all': [0,1], 'pos': ([1], [3]), 'vertex': (1, [1]), 'edge': None}
edofs['DQ2'] = {'all': [0,1,2], 'pos': ([2], [6]), 'vertex': (1, [1]), 'edge': [3]}
edofs['DQ3'] = {'all': [0,1,2,3], 'pos': ([3], [6]), 'vertex': (1, [1]), 'edge': [3,4]}
for etype in etypes:
#
# New Dofhandler
#
element = QuadFE(1,etype)
dh = DofHandler(mesh, element)
for key in edofs[etype].keys():
#
# Assign all dofs
#
if key=='all':
dh.assign_dofs(edofs[etype][key], cell)
self.assertEqual(dh.get_cell_dofs(cell), edofs[etype][key])
#
# Assign dofs at given positions
#
elif key=='pos':
pos, dofs = edofs[etype]['pos']
dh.assign_dofs(dofs, cell, pos=pos)
self.assertEqual(dh.get_cell_dofs(cell)[pos[0]], dofs[0])
#
# Assign dofs to given vertex
#
elif key=='vertex':
if edofs[etype]['vertex'] is not None:
v_num, dofs = edofs[etype]['vertex']
vertex = cell.get_vertex(v_num)
dh.assign_dofs(dofs, cell, vertex)
self.assertEqual(dh.get_cell_dofs(cell, vertex), dofs)
#
# Assign dofs to interval
#
elif key=='edge':
if edofs[etype][key] is not None:
dofs = edofs[etype][key]
dh.assign_dofs(dofs, cell, cell)
self.assertEqual(dh.get_cell_dofs(cell, cell, interior=True), dofs)
#
# Clear dofs to reuse DofHandler
#
dh.clear_dofs()
# =====================================================================
# 2D
# =====================================================================
# New mesh
mesh = Mesh2D(resolution=(1,1))
cell = mesh.cells.get_child(0)
etypes = ['DQ0', 'Q1', 'Q2', 'Q3']
#
# List of dofs to assign and check
#
edofs = dict.fromkeys(etypes)
edofs['DQ0'] = {'all': [0], 'pos': ([0],[2]) ,
'vertex': None, 'edge': None, 'cell': [0] }
edofs['Q1'] = {'all': [0,1,2,3], 'pos': ([1],[2]),
'vertex': (1,[2]), 'edge': None, 'cell': None }
edofs['Q2'] = {'all': [0,1,2,3,4,5,6,7,8], 'pos': ([5],[7]) ,
'vertex': (3,[4]), 'edge': (2, [1]), 'cell': [1] }
edofs['Q3'] = {'all': [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15], 'pos': ([11],[111]),
'vertex': (3,[1]), 'edge': (3,[2,3]), 'cell': [1,2,3,4]}
for etype in etypes:
# New element adn Dofhandler
element = QuadFE(2, etype)
dh = DofHandler(mesh, element)
for key in edofs[etype].keys():
#
# Assign all dofs
#
if key=='all':
dh.assign_dofs(edofs[etype][key], cell)
self.assertEqual(dh.get_cell_dofs(cell), edofs[etype][key])
#
# Assign dofs to specific position
#
elif key=='pos':
pos, dofs = edofs[etype][key]
dh.assign_dofs(dofs, cell, pos=pos)
self.assertEqual(dh.get_cell_dofs(cell)[pos[0]],dofs[0])
#
# Assign dof to specific vertex
#
elif key=='vertex':
if edofs[etype][key] is not None:
v_num, dofs = edofs[etype][key]
vertex = cell.get_vertex(v_num)
dh.assign_dofs(dofs, cell, vertex)
self.assertEqual(dh.get_cell_dofs(cell, vertex), dofs)
#
# Assign dofs to specific edge
#
elif key=='edge':
if edofs[etype][key] is not None:
e_num, dofs = edofs[etype][key]
he = cell.get_half_edge(e_num)
dh.assign_dofs(dofs, cell, he)
self.assertEqual(dh.get_cell_dofs(cell, he, interior=True),dofs)
#
# Assign dofs to cell interior
#
elif key=='cell':
if edofs[etype][key] is not None:
dofs = edofs[etype][key]
dh.assign_dofs(dofs, cell, cell)
self.assertEqual(dh.get_cell_dofs(cell, cell, interior=True), dofs)
#
# Clear dofs to re-use DofHandler
#
dh.clear_dofs()
def test_fill_dofs(self):
etypes = ['DQ0', 'DQ1','DQ2', 'DQ3', 'Q1', 'Q2', 'Q3']
# =====================================================================
# 1D
# =====================================================================
#
# Non-periodic
#
mesh = Mesh1D(resolution=(1,))
expected_dofs = {'DQ0': [0],
'DQ1': [0,1],
'DQ2': [0,1,2],
'DQ3': [0,1,2,3],
'Q1': [0,1],
'Q2': [0,1,2],
'Q3': [0,1,2,3]}
cell = mesh.cells.get_child(0)
for etype in etypes:
element = QuadFE(1, etype)
dofhandler = DofHandler(mesh, element)
dofhandler.fill_dofs(cell)
dofs = dofhandler.get_cell_dofs(cell)
self.assertEqual(expected_dofs[etype], dofs)
#
# Periodic
#
mesh = Mesh1D(resolution=(1,), periodic=True)
expected_dofs = {'DQ0': [0],
'DQ1': [0,1],
'DQ2': [0,1,2],
'DQ3': [0,1,2,3],
'Q1': [0,0],
'Q2': [0,0,1],
'Q3': [0,0,1,2]}
cell = mesh.cells.get_child(0)
for etype in etypes:
element = QuadFE(1, etype)
dofhandler = DofHandler(mesh, element)
dofhandler.fill_dofs(cell)
dofs = dofhandler.get_cell_dofs(cell)
self.assertEqual(dofs, expected_dofs[etype])
# =====================================================================
# 2D
# =====================================================================
#
# Non-periodic
#
mesh = Mesh2D(resolution=(1,1))
cell = mesh.cells.get_child(0)
expected_dofs = {'DQ0': [0],
'DQ1': [0,1,2,3],
'DQ2': [0,1,2,3,4,5,6,7,8],
'DQ3': [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],
'Q0': [0],
'Q1': [0,1,2,3],
'Q2': [0,1,2,3,4,5,6,7,8],
'Q3': [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]}
for etype in etypes:
element = QuadFE(2, etype)
dofhandler = DofHandler(mesh, element)
dofhandler.fill_dofs(cell)
dofs = dofhandler.get_cell_dofs(cell)
self.assertEqual(dofs, expected_dofs[etype])
#
# Periodic x direction
#
mesh = Mesh2D(resolution=(1,1), periodic={0})
cell = mesh.cells.get_child(0)
expected_dofs = {'DQ0': [0],
'DQ1': [0,1,2,3],
'DQ2': [0,1,2,3,4,5,6,7,8],
'DQ3': [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],
'Q0': [0],
'Q1': [0,0,1,1],
'Q2': [0,0,1,1,2,3,4,3,5],
'Q3': [0,0,1,1,2,3,4,5,6,7,5,4,8,9,10,11]}
for etype in etypes:
element = QuadFE(2, etype)
dofhandler = DofHandler(mesh, element)
dofhandler.fill_dofs(cell)
dofs = dofhandler.get_cell_dofs(cell)
self.assertEqual(dofs, expected_dofs[etype])
#
# Periodic in both directions
#
mesh = Mesh2D(resolution=(1,1), periodic={0,1})
cell = mesh.cells.get_child(0)
expected_dofs = {'DQ0': [0],
'DQ1': [0,1,2,3],
'DQ2': [0,1,2,3,4,5,6,7,8],
'DQ3': [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],
'Q0': [0],
'Q1': [0,0,0,0],
'Q2': [0,0,0,0,1,2,1,2,3],
'Q3': [0,0,0,0,1,2,3,4,2,1,4,3,5,6,7,8]}
for etype in etypes:
element = QuadFE(2, etype)
dofhandler = DofHandler(mesh, element)
dofhandler.fill_dofs(cell)
dofs = dofhandler.get_cell_dofs(cell)
self.assertEqual(dofs, expected_dofs[etype])
from mpl_toolkits.mplot3d import Axes3D
# TODO: Add global dofs to
mesh = QuadMesh(resolution=(2, 1))
mesh.cells.get_child(1).mark('refine')
mesh.cells.refine(refinement_flag='refine')
Q = QuadFE(2, 'Q1')
dofhandler = DofHandler(mesh, Q)
dofhandler.distribute_dofs()
l2g = dict.fromkeys(mesh.cells.get_leaves())
for cell in mesh.cells.get_leaves():
n_dofs = Q.n_dofs()
gdofs = dofhandler.get_cell_dofs(cell)
#
# Initialize local-to-global map
#
if l2g[cell] is None:
#
# Dictionary keys are global dofs in cell
#
l2g[cell] = dict.fromkeys(gdofs)
#
# Values are expansion coefficients ito local basis
#
I = np.identity(n_dofs)
for i in range(n_dofs):
l2g[cell][gdofs[i]] = I[i, :]
plot = Plot(time=0.1)
plot.mesh(mesh, regions=[('integrate', 'cell')])
# Finite Element Space
DQ0 = QuadFE(1, 'DQ0')
dh_0 = DofHandler(mesh, DQ0)
dh_0.distribute_dofs()
n = dh_0.n_dofs()
leaves = mesh.cells.get_leaves()
print(len(leaves))
for cell in mesh.cells.get_leaves():
#print(cell.get_root().info())
#print(cell.get_parent().is_marked(l_max-1))
c_dof = dh_0.get_cell_dofs(cell)[0]
#print(c_dof)
phi_0 = Basis(dh_0)
psi_0 = Basis(dh_0, subforest_flag=l_max - 1)
#plot.mesh(mesh, dofhandler=dh)
C = Covariance(dh_0, name='gaussian', parameters={'l': 0.05})
eta = GaussianField(n, K=C)
eta_path = Nodal(data=eta.sample(), basis=phi_0)
assembler = Assembler(Form(1, test=phi_0, flag='integrate'))
assembler.assemble()
L = assembler.get_vector()
print(L)
#
dhQ1.distribute_dofs()
dhQ0 = DofHandler(mesh, Q0)
dhQ0.distribute_dofs()
phi_0 = Basis(dhQ1)
print(phi_0.subforest_flag())
phi_1 = Basis(dhQ1, subforest_flag='coarse')
cell = mesh.cells.get_leaves(subforest_flag='coarse')[0]
cell.info()
print(mesh.cells.is_contained_in('fine', 'coarse'))
# Evaluate phi_1 on cell
sub_dofs = []
for child in cell.get_leaves(flag='fine'):
sub_dofs.extend(dhQ1.get_cell_dofs(child))
sub_dofs = list(set(sub_dofs))
print(sub_dofs)
x = dhQ1.get_dof_vertices(dofs=sub_dofs)
x_ref = cell.reference_map(x, mapsto='reference')
print(x_ref)
data = phi_1.eval(x_ref, cell)
fig = plt.figure()
ax = plt.axes(projection='3d')
print(data.shape, x.shape)
ax.scatter3D(x[:, 0], x[:, 1], data[:, 0])
plt.show()
