def test_init_empty(self):
f = field.fdata(self.convmodel, self.curmesh, [])
assert f.time == 0. # default value
assert f.it == -1 # default value
assert f.data == []
f.set_time(10.)
assert f.time == 10.
def fdata(self, mesh, t=None):
if t == None:
xot = np.where(mesh.centers() < 0., -1e6, 1e6)
else:
xot = mesh.centers() / t
q = self.riempb.qsol(xot)
qcons = self.model.prim2cons([q.rho, q.u, q.p])
return field.fdata(self.model, mesh, qcons)
def test_plotdata_sca(self):
def fn(x):
return np.exp(-2 * np.square(x - .5)) * np.sin(20 * (x - .5))
f = field.fdata(self.convmodel, self.curmesh,
[fn(self.curmesh.centers())])
fig, ax = plt.subplots(1, 1)
f.plot('q')
return fig
def test_reset(self):
f = field.fdata(self.convmodel, self.curmesh, [])
f.set_time(10.)
f.reset(t=5.)
assert f.time == 5.
assert f.it == -1 # default value
f.reset(it=20)
assert f.time == 0. # default value
assert f.it == 20
def fdata(self, mesh, t=None):
"""
:param mesh:
:param t: (Default value = None)
"""
qcons = self.consdata(mesh, t)
return field.fdata(self.model, mesh, qcons)
def test_plot2dcontourf(self):
xc, yc = self.mesh2d.centers()
f = field.fdata(self.model, self.mesh2d, [
1.,
euler.datavector(0., 0.),
self.fn(np.sqrt(np.square(xc - 8) + np.square(yc - 4)))
])
fig, ax = plt.subplots(1, 1)
f.contourf('pressure', axes=ax, style='r-')
return fig
def test_append_scalararray(self):
flist = field.fieldlist()
f1 = field.fdata(self.convmodel, self.curmesh, [1.])
flist.append(f1)
f2 = f1.copy()
f2.set_time(10.)
flist.append(f2)
assert len(flist) == 2
assert flist[0].time == 0.
assert flist[-1].time == 10.
assert flist.time_array() == [0., 10.]
def test_numscheme():
curmesh = mesh50
endtime = 1
cfl = .5
tnum = rk3ssp
for xnum in [ extrapol1(), extrapol2(), extrapol3(), muscl(minmod), muscl(vanalbada) ]:
finit = field.fdata(mymodel, curmesh, [ init_sinperk(curmesh, k=5) ] )
rhs = modeldisc.fvm(mymodel, curmesh, xnum)
solver = tnum(curmesh, rhs)
solver.solve(finit, cfl, [endtime])
assert 1
def test_checkend_maxit_noendtime(self):
endtime = 5.
cfl = .5
maxit = 100
stop_directive = {'maxit': maxit}
finit = field.fdata(self.convmodel, self.curmesh,
[self.init_sinperk(self.curmesh, k=4)])
rhs = modeldisc.fvm(self.convmodel, self.curmesh, self.xsch)
solver = tnum.rk4(self.curmesh, rhs)
fsol = solver.solve(finit, cfl, stop=stop_directive)
assert len(fsol) == 1 # end before expected by tsave
assert not fsol[-1].isnan()
assert solver.nit() == 100
def test_mesh_refined(lratio):
lmesh = mesh.refinedmesh(ncell=50, length=1., ratio=2., nratioa=lratio)
endtime = 5
cfl = 1.
# extrapol1(), extrapol2()=extrapolk(1), centered=extrapolk(-1), extrapol3=extrapolk(1./3.)
xnum = extrapol3()
# explicit, rk2, rk3ssp, rk4, implicit, trapezoidal=cranknicolson
tnum = rk3ssp
finit = field.fdata(mymodel, lmesh, [init_sinperk(lmesh, k=2)])
rhs = modeldisc.fvm(mymodel, lmesh, xnum)
solver = tnum(lmesh, rhs)
fsol = solver.solve(finit, cfl, [endtime])
assert not fsol[-1].isnan()
def test_integrators(tnum):
curmesh = mesh50
endtime = 1
cfl = .8
# extrapol1(), extrapol2()=extrapolk(1), centered=extrapolk(-1), extrapol3=extrapolk(1./3.)
xnum = extrapol1()
# explicit, rk2, rk3ssp, rk4, implicit, trapezoidal=cranknicolson
finit = field.fdata(mymodel, curmesh, [ init_sinperk(curmesh, k=2) ] )
rhs = modeldisc.fvm(mymodel, curmesh, xnum)
solver = tnum(curmesh, rhs)
fsol = solver.solve(finit, cfl, [endtime])
assert not fsol[-1].isnan()
assert fsol[-1].average('q') < 1.e-12
def test_integrators():
curmesh = mesh50
endtime = 1
cfl = .8
# extrapol1(), extrapol2()=extrapolk(1), centered=extrapolk(-1), extrapol3=extrapolk(1./3.)
xnum = extrapol1()
# explicit, rk2, rk3ssp, rk4, implicit, trapezoidal=cranknicolson
for tnum in [ explicit,rk2, rk3ssp, implicit, cranknicolson ]:
finit = field.fdata(mymodel, curmesh, [ init_sinperk(curmesh, k=2) ] )
rhs = modeldisc.fvm(mymodel, curmesh, xnum)
solver = tnum(curmesh, rhs)
solver.solve(finit, cfl, [endtime])
assert 1
def test_wavelength(k):
curmesh = mesh50
endtime = 5
cfl = .8
# extrapol1(), extrapol2()=extrapolk(1), centered=extrapolk(-1), extrapol3=extrapolk(1./3.)
xnum = extrapol1()
# explicit, rk2, rk3ssp, rk4, implicit, trapezoidal=cranknicolson
tnum = explicit
finit = field.fdata(mymodel, curmesh, [ init_sinperk(curmesh, k=k) ] )
rhs = modeldisc.fvm(mymodel, curmesh, xnum)
solver = tnum(curmesh, rhs)
fsol = solver.solve(finit, cfl, [endtime])
assert not fsol[-1].isnan()
def test_sin_bcper(self):
endtime = 2.
cfl = 0.5
xnum = muscl(minmod)
tnum = integ.rk3ssp
thismesh = self.mesh100
thisprim = [ self.init_sin(thismesh) ]
thiscons = field.fdata(self.mymodel, thismesh, thisprim)
bcL = { 'type': 'per' }
bcR = { 'type': 'per' }
rhs = modeldisc.fvm(self.mymodel, thismesh, xnum, bcL=bcL, bcR=bcR)
solver = tnum(thismesh, rhs)
fsol = solver.solve(thiscons, cfl, [endtime])
assert not fsol[-1].isnan()
def test_expansion(self):
endtime = 2.
cfl = 0.5
xnum = muscl(minmod)
tnum = integ.rk3ssp
thismesh = self.mesh100
thisprim = [self.init_step(thismesh, 1., 2.)]
thiscons = field.fdata(self.mymodel, thismesh, thisprim)
bcL = { 'type': 'dirichlet', 'prim': thisprim[0] }
bcR = { 'type': 'dirichlet', 'prim': thisprim[-1] }
rhs = modeldisc.fvm(self.mymodel, thismesh, xnum, bcL=bcL, bcR=bcR)
solver = tnum(thismesh, rhs)
fsol = solver.solve(thiscons, cfl, [endtime])
assert not fsol[-1].isnan()
def test_compression_centered():
endtime = 2.
cfl = .5
xnum = muscl(minmod)
tnum = integ.rk3ssp
thismesh = mesh100
thisprim = [init_step(thismesh, 2, -1.)]
thiscons = field.fdata(mymodel, thismesh, thisprim)
bcL = { 'type': 'dirichlet', 'prim': thisprim[0] }
bcR = { 'type': 'dirichlet', 'prim': thisprim[-1] }
rhs = modeldisc.fvm(mymodel, thismesh, xnum, bcL=bcL, bcR=bcR)
solver = tnum(thismesh, rhs)
solver.solve(thiscons, cfl, [endtime])
assert 1
def test_checkend_tottime(self):
endtime = 5.
cfl = .5
stop_directive = {'tottime': endtime}
finit = field.fdata(self.convmodel, self.curmesh,
[self.init_sinperk(self.curmesh, k=4)])
rhs = modeldisc.fvm(self.convmodel, self.curmesh, self.xsch)
solver = tnum.rk4(self.curmesh, rhs)
nsol = 11
tsave = np.linspace(0, 2 * endtime, nsol, endpoint=True)
fsol = solver.solve(finit, cfl, tsave, stop=stop_directive)
assert len(fsol) < nsol # end before expected by tsave
assert not fsol[-1].isnan()
assert fsol[-1].time < 2 * endtime
def test_conv_it_perf(self, tmeth):
endtime = 5
cfl = .8
xsch = xnum.extrapol3()
finit = field.fdata(self.convmodel, self.curmesh,
[self.init_sinperk(self.curmesh, k=4)])
rhs = modeldisc.fvm(self.convmodel, self.curmesh, xsch)
solver = tmeth(self.curmesh, rhs)
fsol = solver.solve(finit, cfl, [endtime])
assert solver.nit() > 300
assert solver.nit() < 400
maxperf = 40. if tmeth in tnum.List_Explicit_Integrators else 100.
assert solver.perf_micros() < maxperf
assert not fsol[-1].isnan()
def test_sin_bcper():
endtime = 2.
cfl = 0.5
xnum = muscl(minmod)
tnum = integ.rk3ssp
thismesh = mesh100
thisprim = [ init_sin(thismesh) ]
thiscons = field.fdata(mymodel, thismesh, thisprim)
bcL = { 'type': 'per' }
bcR = { 'type': 'per' }
rhs = modeldisc.fvm(mymodel, thismesh, xnum, bcL=bcL, bcR=bcR)
solver = tnum(thismesh, rhs)
solver.solve(thiscons, cfl, [endtime])
assert 1
def test_flist_plotxtcontourf(self):
def fn(x, t):
return np.exp(-2 * np.square(x - .5 + .2 * np.sin(10 * t)))
times = np.linspace(0., 5., 11, endpoint=True)
flist = field.fieldlist()
for t in times:
f = field.fdata(self.convmodel, self.curmesh,
[fn(self.curmesh.centers(), t)])
f.set_time(t)
flist.append(f)
fig, ax = plt.subplots(1, 1)
flist.xtcontourf('q')
return fig
def test_muscl_limiters(self, limiter):
curmesh = self.mesh50
endtime = 5
cfl = .8
# extrapol1(), extrapol2()=extrapolk(1), centered=extrapolk(-1), extrapol3=extrapolk(1./3.)
xnum = muscl(limiter)
finit = field.fdata(self.mymodel, curmesh,
[self.init_sinperk(curmesh, k=4)])
rhs = modeldisc.fvm(self.mymodel, curmesh, xnum)
solver = rk3ssp(curmesh, rhs)
fsol = solver.solve(finit, cfl, [endtime])
assert not fsol[-1].isnan()
avg, var = fsol[-1].stats('q')
#varref = { }
assert avg == pytest.approx(0., abs=1.e-12)
def test_interpol_t(self):
endtime = 1. / self.curmesh.ncell
cfl = 5. # unstable but no risk with 1 it
maxit = 1
stop_directive = {'maxit': maxit}
finit = field.fdata(self.convmodel, self.curmesh,
[self.init_sinperk(self.curmesh, k=4)])
rhs = modeldisc.fvm(self.convmodel, self.curmesh, self.xsch)
solver = tnum.explicit(self.curmesh, rhs)
fsol2 = solver.solve(finit, cfl, [2 * endtime], stop=stop_directive)
fsol1 = solver.solve(finit, cfl, [endtime], stop=stop_directive)
assert not fsol2[-1].isnan()
assert 2 * fsol1[-1].time == pytest.approx(fsol2[-1].time, abs=1.e-12)
fi = finit.interpol_t(fsol2[-1], endtime)
diff = fi.diff(fsol1[-1])
for d in diff.data:
assert np.average(np.abs(d)) == pytest.approx(0., abs=1.e-6)
def test_extend_scalararray(self):
flist = field.fieldlist()
f1 = field.fdata(self.convmodel, self.curmesh, [1.])
flist.append(f1)
f2 = f1.copy()
f2.set_time(10.)
flist.append(f2)
newlist = field.fieldlist()
f3 = f2.copy()
newlist.append(f3)
f3.set_time(20.)
newlist.append(f2)
flist.extend(newlist)
f2.reset(t=100., it=5)
assert len(flist) == 4 # f1, f2, f3, f2
assert flist.time_array() == [0., 100., 20., 100.]
assert flist.it_array() == [-1, 5, -1, 5]
def propagator(self, z):
"""computes scalar complex propagator of one time step
Args:
z:
Returns:
"""
# save actual modeldisc
saved_model = self.modeldisc
self.modeldisc = fakedisc(z)
# make virtual field
f = field.fdata(fakemodel(), fakemesh(), [0 * z + 1.0])
self.step(f, dtloc=1.0) # one step with normalized time step
# get back actual modeldisc
self.modeldisc = saved_model
return f.data[0]
def test_interpolation_regression(self):
endtime = 5
cfl = .5
finit = field.fdata(self.convmodel, self.curmesh,
[self.init_sinperk(self.curmesh, k=4)])
rhs = modeldisc.fvm(self.convmodel, self.curmesh, self.xsch)
solver = tnum.rk4(self.curmesh, rhs)
nsol = 5
tsave = np.linspace(0, endtime, nsol, endpoint=True)
fsol = solver.solve(finit, cfl, tsave)
fleg = solver.solve_legacy(finit, cfl, tsave)
assert len(fsol) == nsol
assert len(fleg) == nsol
for fs, fl in zip(fsol, fleg):
assert not fs.isnan()
diff = fs.diff(fl)
assert diff.time == pytest.approx(0., abs=1.e-12)
for d in diff.data:
assert np.average(np.abs(d)) == pytest.approx(0., abs=1.e-6)
def test_frequency(self, montype):
endtime = 5.
cfl = .5
finit = field.fdata(self.convmodel, self.mesh50,
[self.init_sinperk(self.mesh50, k=4)])
rhs = modeldisc.fvm(self.convmodel, self.mesh50, self.xsch)
maxit = 500
stop_directive = {'maxit': maxit}
solver = tnum.rk4(self.mesh50, rhs)
mondict = {}
for f in 1, 2, 10, 50, 100:
monitors = {montype: {'frequency': f}}
fsol = solver.solve(finit,
cfl, [endtime],
stop=stop_directive,
monitors=monitors)
mondict[f] = monitors[montype]['output']
assert not fsol[-1].isnan()
assert mondict[f]._it[-1] == maxit
assert (len(mondict[f]._it) - 1) * f == maxit
def test_restart(self):
tottime = 10.
breaktime = 5.
cfl = .5
finit = field.fdata(self.convmodel, self.curmesh,
[self.init_sinperk(self.curmesh, k=4)])
rhs = modeldisc.fvm(self.convmodel, self.curmesh, self.xsch)
solver = tnum.rk4(self.curmesh, rhs)
nsol = 10 + 1 # every second
tsave = np.linspace(0, tottime, nsol, endpoint=True)
#
stop_directive = {'tottime': breaktime}
fsol0 = solver.solve(finit, cfl, tsave, stop=stop_directive)
assert len(fsol0) == 6 # end before expected by tsave
assert not fsol0[-1].isnan()
assert fsol0[-1].time == breaktime
#
fsol = solver.restart(fsol0[-1], cfl, tsave)
assert len(fsol) == 6 # only last snapshots ; time 5. is saved again
assert not fsol[-1].isnan()
assert fsol[-1].time == tottime
def fdata_fromprim(self, data):
f = field.fdata(self.model, self.mesh, data)
return field.fdata(self.model, self.mesh, self.model.prim2cons(f.data))
def fdata(self, mesh, t=None):
qcons = self.model.prim2cons([q.rho, q.u, q.p])
return field.fdata(self.model, mesh, qcons)
def fdata(self, mesh):
"""
"""
qcons = self.consdata()
return field.fdata(self.model, mesh, qcons)
