def test__eq__(self):
a = np.linspace(0, 1, 11)
x = fields.Domain(a)
y = fields.Domain(a)
f0 = fields.Field1D('q0', x)
f1 = fields.Field1D('q1', x)
f2 = fields.Field1D('q2', y)
assert (f0 == f0)
assert (f0 != 0)
assert (f0 == f1)
assert (f0 != f2)
data = np.asarray(range(len(x.xp)))
f0.set_field(data)
assert (f0 != f1)
f1.set_field(data)
assert (f0 == f1)
bcp = fields.BoundaryCondition(name='periodic')
f0.add_boundary_condition(bcp)
assert (f0 != f1)
f1.add_boundary_condition(bcp)
assert (f0 == f1)
return
def test__eq__(self):
x = np.linspace(0, 1, 11)
y = fields.Domain(x)
x = fields.Domain(x)
name = ['q', 'q0', 'q1']
q0 = fields.VectorField1D(2, name, x)
q1 = fields.VectorField1D(2, name, x)
q2 = fields.VectorField1D(2, name, y)
assert (q0 == q0)
assert (q0 != 0)
assert (q0 == q1)
assert (q0 != q2)
q2 = q0.copy()
data1 = np.ones(q1.val.shape)
data1[1, :] *= 2
q0.set_field(data1)
q1.set_field(data1)
data2 = np.ones(q2.val.shape)
data2[0, :] *= 3
data2[1, :] *= 4
q2.set_field(data2)
assert (q0 == q1)
assert (q0 != q2)
q2 = q0.copy()
bc0 = general.fields.BoundaryCondition(name='periodic')
bc1 = general.fields.BoundaryCondition(name='neumann', indx=0, val=0)
assert (bc0 != bc1)
q0.add_boundary_condition(0, bc0)
q1.add_boundary_condition(0, bc0)
q2.add_boundary_condition(0, bc1)
assert (q0 == q1)
assert (q0 != q2)
q2 = q0.copy()
q2.add_boundary_condition(1, bc0)
assert (q0 != q2)
return
def test__div__(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
name = ['q', 'q0', 'q1']
q1 = fields.VectorField1D(2, name, x)
q2 = fields.VectorField1D(2, name, x)
data1 = np.ones(q1.val.shape)
data1[1, :] *= 2
q1.set_field(data1)
data2 = np.ones(q2.val.shape)
data2[0, :] *= 3
data2[1, :] *= 4
q2.set_field(data2)
q3 = q1 / q2
q4 = q1 / 2
assert q3 is not q1
assert q3 is not q2
assert np.all(q3.val == q1.val / q2.val)
assert np.all(q4.val == q1.val / 2)
return
def test_set_expansion(self):
mesh = np.linspace(-1.0, 1.0, 11)
d = fields.Domain(mesh)
o = 3
d.set_expansion(order=o)
assert d.p == o
assert np.all(d.zp == polys.Legendre.zeros[o])
assert np.all(d.wp == polys.Legendre.weights[o])
assert len(d.xp) == (len(mesh) - 1) * o
assert d.xp[-1] == 1.0 - (1.0 - polys.Legendre.zeros[o][-1]) * 0.1
assert len(d.dg) == len(mesh) - 1
assert d.dg[2] == 0.5 * d.dxh[2]
assert len(d.Lm1) == (len(mesh) - 1) * o
assert len(d.Lp1) == (len(mesh) - 1) * o
tm = [1.47883056, -0.666666667, 0.18783611]
tp = [0.18783611, -0.666666667, 1.47883056]
assert np.all(np.isclose(d.Lm1[:o], tm))
assert np.all(np.isclose(d.Lp1[:o], tp))
assert len(d.M) == d.p * d.nh
return
def test_copy(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
name = ['q', 'q0', 'q1']
q = fields.VectorField1D(2, name, x)
bc0 = general.fields.BoundaryCondition(name='periodic')
bc1 = general.fields.BoundaryCondition(name='periodic')
q.add_boundary_condition(0, bc0)
q.add_boundary_condition(1, bc1)
q2 = q.copy()
assert q2 is not q
assert q2.n == q.n
assert q2.name == q.name
assert q2.mesh == q.mesh
for i in range(q2.n):
assert q2.q[i] is not q.q[i]
assert q2.q[i] == q.q[i]
return
def test_init(self):
mesh = np.linspace(-1.0, 1.0, 11)
d = fields.Domain(xh=mesh)
assert np.all(d.dg == 0.5 * d.dxh)
return
def test_set_timestep(self):
mesh = np.linspace(-0.05, 1.05, 12)
d = fields.Domain(mesh)
f = fields.UnsteadyField1D('x', d)
f.set_timestep(0.1)
assert f.dt == 0.1
return
def test_init(self):
mesh = np.linspace(0.0, 1.0, 11)
d = fields.Domain(mesh)
assert d.xh is not mesh
assert np.all(d.xh == mesh)
assert np.all(d.dxh == np.diff(mesh))
assert d.nh == 10
return
def test_init(self):
mesh = np.linspace(0, 1.0, 11)
d = fields.Domain(mesh)
g = general.fields.Domain(mesh)
assert np.all(d.xp == 0.5 * (g.xh[:-1] + g.xh[1:]))
assert np.all(d.dxp == np.diff(d.xp))
return
def test__getitem__(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
f = fields.Field1D('q', x)
data = np.asarray(range(len(x.xp)))
f.set_field(data)
assert (np.all(f[:] == data))
return
def burgers( nt, dt=0.001, nx = 203, nu=0.27, save_interval=5 ):
ufunc = mth.BurgersWave1D()
#set up problem
L = 2.*np.pi
dx = L/(nx-1)
t = 0
x = np.linspace(-dx/2.0, L + dx/2.0, nx)
x = fields.Domain( x )
u = fields.UnsteadyField1D( 'u', x )
u.set_boundary_condition( name='periodic' )
u.set_timestep( dt )
u.set_save_interval( nt=5 )
#set initial solution
u_0 = np.asarray([ufunc(t, x0, nu) for x0 in x.x_noghost])
u.set_field( u_0 )
print('cfl =', max(u_0)*dt/dx)
print('dif# =', nu*dt/(dx*dx))
print('Pe =', max(u_0)*dx/nu)
fluxv = dfx.CDS2()
fluxi = afx.UDS1()
fluxi.set_variable( u )
fluxi.set_advection_velocity( u )
fluxv.set_variable( u )
fluxv.set_diffusion_coefficient( nu )
#--------------------------------------------------
flux_inv = np.empty(nx+1)
flux_vis = np.empty(nx+1)
flux = np.empty(nx+1)
# timestepping
for n in range(nt):
# calculate inviscid and viscous fluxes across each face
flux_vis = fluxv.apply()
flux_inv = fluxi.apply()
flux = flux_inv + flux_vis
dudt = -np.diff(flux)/dx
du = dudt*dt
u.update( du )
return u
def test_set_timestep(self):
mesh = np.linspace(-1.0, 1.0, 11)
mesh = fields.Domain(xh=mesh)
mesh.set_expansion(order=3)
f = fields.UnsteadyField1D('q', mesh)
f.set_timestep(0.1)
assert f.dt == 0.1
return
def test__getitem__(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
name = ['q', 'q0', 'q1']
q = fields.VectorField1D(2, name, x)
assert q[0] is q.q[0]
assert q[1] is q.q[1]
return
def test_set_field(self):
mesh = np.linspace(-1.0, 1.0, 11)
mesh = fields.Domain(xh=mesh)
mesh.set_expansion(order=3)
y = np.asarray(range(len(mesh.xp)))
f = fields.Field1D('q', mesh)
f.set_field(y)
assert np.all(f.val == y)
return
def test_set_field(self):
mesh = np.linspace(-0.05, 1.05, 12)
d = fields.Domain(mesh)
f = fields.UnsteadyField1D('x', d)
data = np.asarray(range(len(f.val)))
f.set_field(data)
assert np.all(f.history[:] == f.val[:])
return
def test_set_field(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
f = fields.Field1D('q', x)
data = np.asarray(range(len(x.xp)))
f.set_field(data)
assert np.all(f.val == data)
assert f.val is not data
return
def test_init(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
f = fields.Field1D('q', x)
assert f.mesh is x
assert f.name == 'q'
assert f.bconds == []
assert len(f.val) == len(f.mesh.xp)
assert np.all(f.val == 0)
return
def test_update(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
f = fields.Field1D('q', x)
data = np.asarray(range(len(x.xp)))
f.set_field(data)
f.update(data)
assert np.all(f.val == 2 * data)
return
def test_init(self):
mesh = np.linspace(0, 1.0, 11)
d = fields.Domain(mesh)
f = fields.UnsteadyField1D('q', d)
assert f.dt == None
assert f.nt == 0
assert f.t == 0
assert f.save_interval == 1
assert np.all(f.history == np.zeros((1, len(f.val))))
return
def test__sub__(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
f1 = fields.Field1D('q1', x)
f4 = fields.Field1D('q4', x)
f3 = fields.Field1D('q3', x)
data = np.asarray(range(len(x.xp)))
f1.set_field(data)
f4.set_field(4 * data)
f3.set_field(3 * data)
assert (f4 - f1 == f3)
return
def test__add__(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
f1 = fields.Field1D('q1', x)
f2 = fields.Field1D('q2', x)
f3 = fields.Field1D('q3', x)
data = np.asarray(range(len(x.xp)))
f1.set_field(data)
f2.set_field(2 * data)
f3.set_field(3 * data)
assert (f1 + f2 == f3)
return
def test_init(self):
mesh = np.linspace(-1.0, 1.0, 11)
mesh = fields.Domain(xh=mesh)
mesh.set_expansion(order=3)
f = fields.Field1D('q', mesh)
assert f.name == 'q'
assert f.mesh == mesh
assert len(f.val) == len(f.mesh.xp)
assert np.all(f.val == 0)
assert f.bconds == []
return
def test__div__(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
f2 = fields.Field1D('q2', x)
f3 = fields.Field1D('q6', x)
f6 = fields.Field1D('q3', x)
three = 3 * np.ones(len(x.xp))
data = np.asarray(range(len(x.xp)))
f2.set_field(2 * data)
f3.set_field(three)
f6.set_field(6 * data)
assert (f6 / f3 == f2)
return
def test_add_boundary_condition(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
name = ['q', 'q0', 'q1']
q = fields.VectorField1D(2, name, x)
bc0 = general.fields.BoundaryCondition(name='periodic')
bc1 = general.fields.BoundaryCondition(name='periodic')
q.add_boundary_condition(0, bc0)
assert bc0 in q.q[0].bconds
q.add_boundary_condition('q1', bc1)
assert bc1 in q.q[1].bconds
pass
def test_init(self):
mesh = np.linspace(-1.0, 1.0, 11)
mesh = fields.Domain(xh=mesh)
mesh.set_expansion(order=3)
y = np.asarray(range(len(mesh.xp)))
f = fields.UnsteadyField1D('q', mesh)
assert f.dt == None
assert f.nt == 0
assert f.t == 0
assert f.save_interval == 1
assert np.all(f.history == np.zeros((1, len(f.val))))
return
def test_update(self):
mesh = np.linspace(-0.05, 1.05, 12)
d = fields.Domain(mesh)
f = fields.UnsteadyField1D('x', d)
data = np.asarray(range(len(f.val)))
f.set_field(data)
f.set_timestep(0.1)
update = data[:]
f.update(update)
assert np.all(f.history[-1, :] == f.val[:])
assert f.t == 0.1
return
def test_update(self):
mesh = np.linspace(-1.0, 1.0, 11)
mesh = fields.Domain(xh=mesh)
mesh.set_expansion(order=3)
y = np.asarray(range(len(mesh.xp)))
f = fields.UnsteadyField1D('q', mesh)
f.set_field(y)
f.set_timestep(0.1)
f.update(y)
assert np.all(f.history[-1, :] == f.val)
assert f.t == 0.1
return
def test_set_field(self):
x = np.linspace(0, 1, 11)
x = fields.Domain(x)
name = ['q', 'q0', 'q1']
q = fields.VectorField1D(2, name, x)
assert np.all(q.val == 0)
data = np.ones(q.val.shape)
data[1, :] *= 2
q.set_field(data)
assert np.all(q.val == data)
assert np.all(q.q[0][:] == data[0, :])
assert np.all(q.q[1][:] == data[1, :])
return
def test_set_save_interval(self):
mesh = np.linspace(-0.05, 1.05, 12)
d = fields.Domain(mesh)
f = fields.UnsteadyField1D('x', d)
f.set_timestep(0.1)
f.set_save_interval()
assert f.save_interval == 1
f.set_save_interval(dt=0.1, nt=5)
assert f.save_interval == 1
f.set_save_interval(dt=0.3)
assert f.save_interval == 3
f.set_save_interval(nt=5)
assert f.save_interval == 5
return
def test_set_boundary_condition(self):
mesh = np.linspace(-0.05, 1.05, 12)
d = fields.Domain(mesh)
f = fields.Field1D('x', d)
f.set_boundary_condition('periodic')
assert type(f.bconds[0]) == fields.BoundaryCondition
assert f.bconds[0].name == 'periodic'
assert f.bconds[0].indx == None
assert f.bconds[0].val == None
f.set_boundary_condition(name='neumann', indx=0, val=1)
assert f.bconds[0].name == 'neumann'
assert f.bconds[0].indx == 0
assert f.bconds[0].val == 1
return
