Datasets:

introvoyz042
/

OpenPNM

License:

OpenPNM / data /scripts /example_new_solvers.py

Migrated from GitHub

f421c2e verified about 2 months ago

5.16 kB

# %% Initializations
import numpy as np
import openpnm as op
import matplotlib.pyplot as plt
from openpnm.utils import tic, toc
from openpnm.algorithms.legacy import TransientReactiveTransport

np.random.seed(10)
ws = op.Workspace()
ws.clear()
ws.settings["loglevel"] = 40

# %% Set the stage up for algorithms
Nx = 10
shape = [Nx, Nx, Nx]
spacing = 1/Nx
net = op.network.Cubic(shape=shape, spacing=spacing)
air = op.phase.Air(network=net)
air["throat.diffusive_conductance"] = np.random.rand(net.Nt)

# Add reactions
mod = op.models.physics.generic_source_term.standard_kinetics
k, n = -1e-1, 2
air["pore.k"], air["pore.n"] = k, n
air.add_model(
    X="pore.concentration",
    propname="pore.rxn",
    model=mod, prefactor="pore.k", exponent="pore.n",
    regen_mode="deferred"
)

alg_settings = {
    "conductance": "throat.diffusive_conductance",
    "quantity": "pore.concentration"
}
pardiso = op.solvers.PardisoSpsolve()
rk45 = op.integrators.ScipyRK45(verbose=True)

# %% Try w/ GenericTransport
print(f"\n{'+'*65}", "\n--> Using GenericTransport", f"\n{'+'*65}\n", flush=True)
gt = op.algorithms.GenericTransport(network=net, phase=air)
gt.settings._update(alg_settings)
gt.set_value_BC(net.pores("left"), 1.0)
gt.set_value_BC(net.pores("right"), 0.4)

gt.run(solver=pardiso)

print(gt["pore.concentration"].mean())

# %% Try w/ ReactiveTransport
print(f"\n{'+'*65}", "\n--> Using ReactiveTransport", f"\n{'+'*65}\n", flush=True)
rt = op.algorithms.ReactiveTransport(network=net, phase=air)
rt.settings._update(alg_settings)

rt.set_value_BC(net.pores("left"), 1.0)
rt.set_value_BC(net.pores("right"), 0.4)
rt.set_source(propname="pore.rxn", pores=net.pores("surface", mode="not"))

rt.run(solver=pardiso)

print(rt["pore.concentration"].mean())

# %% Try w/ FickianDiffusion
print(f"\n{'+'*65}", "\n--> Using FickianDiffusion", f"\n{'+'*65}\n", flush=True)

fd = op.algorithms.FickianDiffusion(network=net, phase=air)

fd.set_value_BC(net.pores("left"), 1.0)
fd.set_value_BC(net.pores("right"), 0.4)

fd.run(solver=pardiso)

print(fd["pore.concentration"].mean())

# %% Playing around w/ Transient stuff
print(f"\n{'+'*65}", "\n--> Using TransientReactiveTransport", f"\n{'+'*65}\n", flush=True)

# air["throat.diffusive_conductance"] = np.ones(net.Nt, dtype=float) * spacing
air["throat.diffusive_conductance"] = np.random.rand(net.Nt) * spacing
V = net["pore.volume"] = spacing**3

trt = op.algorithms.TransientReactiveTransport(network=net, phase=air)
trt.settings._update(alg_settings)
trt.set_value_BC(net.pores("left"), 1.0)
trt.set_value_BC(net.pores("right"), 0.4)
c0 = np.zeros(trt.Np)

tspan = [0, 0.4]
tout = np.linspace(tspan[0], tspan[1], 11)
dt = (tspan[1] - tspan[0]) / 200

# Adding source term
trt.set_source("pore.rxn", pores=net.pores("surface", mode="not"))
# air.remove_model("pore.rxn")

tic()
sol = trt.run(x0=c0, tspan=tspan, integrator=rk45, saveat=tout)
toc()

# %% Hardcoded solution using solve_ivp
# trt._build_A()
# trt._build_b()
# trt._apply_BCs()
# trt._apply_sources()
# A = trt.A.tocsc()
# b = trt.b

# from scipy.integrate import solve_ivp

# def ode_func(t, y, A, b, V):
#     return (-A.dot(y) + b) / V

# f = lambda t, y: ode_func(t, y, A, b, V)

# tic()
# # TODO: implicit methods: pass lband/uband for drastically better performance
# # TODO: lband/uband = 1 is probably wrong!
# sol = solve_ivp(fun=f, t_span=tspan, y0=c0, method="RK23", rtol=1e-5)
# toc()

# %% TransientReactiveTransport (legacy)
trt_legacy = TransientReactiveTransport(network=net, phase=air)
dt_avg = np.diff(sol.t).mean()
t_settings = {
    "t_initial": tspan[0],
    "t_final": tspan[1],
    "t_scheme": "implicit",
    "t_step": dt,
    "t_output": tout.tolist()
}
trt_legacy.settings._update({**alg_settings, **t_settings})
trt_legacy.set_value_BC(net.pores("left"), 1.0)
trt_legacy.set_value_BC(net.pores("right"), 0.4)
trt_legacy.set_IC(0.0)

# Add source term
trt_legacy.set_source("pore.rxn", pores=net.pores("surface", mode="not"))

tic()
trt_legacy.run(solver=pardiso)
toc()

# %% Compare new implementation vs legacy
c_new = sol.reshape((*shape, sol.t.size))

c_legacy = np.zeros((trt_legacy.Np, tout.size))
for i, t in enumerate(tout):
    t_fmt = trt_legacy._nbr_to_str(t)
    c_legacy[..., i] = trt_legacy[f"pore.concentration@{t_fmt}"]
c_legacy = c_legacy.reshape((*shape, tout.size))

fig, ax = plt.subplots(ncols=2)
ax[0].imshow(c_new[..., -1].mean(axis=2))
ax[0].set_title("new implementation")
ax[1].set_title("legacy")
h = ax[1].imshow(c_legacy[..., -1].mean(axis=2))

fig, ax = plt.subplots()
ax.plot(sol.t, c_new.mean(axis=(0, 1, 2)), "g-", label="new implementation")
ax.plot(tout, c_legacy.mean(axis=(0, 1, 2)), "rx", label="legacy")
ax.legend()

# Ensure correctness
np.testing.assert_allclose(c_new[..., -1], c_legacy[..., -1], rtol=1e-3)

# %% Continue integration
# # Integrate from 0 to 0.2 at once
# sol1 = trt.run(x0=c0, tspan=[0, 0.2], solver=rk45)

# # Integrate from 0 to 0.1 and then from 0.1 to 0.2
# sol2 = trt.run(x0=c0, tspan=[0, 0.1], solver=rk45)
# sol3 = trt.run(x0=sol2(0.1), tspan=[0.1, 0.2], solver=rk45)

# # Ensure correctness
# np.testing.assert_allclose(sol1(0.2), sol3(0.2), rtol=1e-5)

	# %% Initializations
	import numpy as np
	import openpnm as op
	import matplotlib.pyplot as plt
	from openpnm.utils import tic, toc
	from openpnm.algorithms.legacy import TransientReactiveTransport

	np.random.seed(10)
	ws = op.Workspace()
	ws.clear()
	ws.settings["loglevel"] = 40

	# %% Set the stage up for algorithms
	Nx = 10
	shape = [Nx, Nx, Nx]
	spacing = 1/Nx
	net = op.network.Cubic(shape=shape, spacing=spacing)
	air = op.phase.Air(network=net)
	air["throat.diffusive_conductance"] = np.random.rand(net.Nt)

	# Add reactions
	mod = op.models.physics.generic_source_term.standard_kinetics
	k, n = -1e-1, 2
	air["pore.k"], air["pore.n"] = k, n
	air.add_model(
	X="pore.concentration",
	propname="pore.rxn",
	model=mod, prefactor="pore.k", exponent="pore.n",
	regen_mode="deferred"
	)

	alg_settings = {
	"conductance": "throat.diffusive_conductance",
	"quantity": "pore.concentration"
	}
	pardiso = op.solvers.PardisoSpsolve()
	rk45 = op.integrators.ScipyRK45(verbose=True)

	# %% Try w/ GenericTransport
	print(f"\n{'+'65}", "\n--> Using GenericTransport", f"\n{'+'65}\n", flush=True)
	gt = op.algorithms.GenericTransport(network=net, phase=air)
	gt.settings._update(alg_settings)
	gt.set_value_BC(net.pores("left"), 1.0)
	gt.set_value_BC(net.pores("right"), 0.4)

	gt.run(solver=pardiso)

	print(gt["pore.concentration"].mean())

	# %% Try w/ ReactiveTransport
	print(f"\n{'+'65}", "\n--> Using ReactiveTransport", f"\n{'+'65}\n", flush=True)
	rt = op.algorithms.ReactiveTransport(network=net, phase=air)
	rt.settings._update(alg_settings)

	rt.set_value_BC(net.pores("left"), 1.0)
	rt.set_value_BC(net.pores("right"), 0.4)
	rt.set_source(propname="pore.rxn", pores=net.pores("surface", mode="not"))

	rt.run(solver=pardiso)

	print(rt["pore.concentration"].mean())

	# %% Try w/ FickianDiffusion
	print(f"\n{'+'65}", "\n--> Using FickianDiffusion", f"\n{'+'65}\n", flush=True)

	fd = op.algorithms.FickianDiffusion(network=net, phase=air)

	fd.set_value_BC(net.pores("left"), 1.0)
	fd.set_value_BC(net.pores("right"), 0.4)

	fd.run(solver=pardiso)

	print(fd["pore.concentration"].mean())

	# %% Playing around w/ Transient stuff
	print(f"\n{'+'65}", "\n--> Using TransientReactiveTransport", f"\n{'+'65}\n", flush=True)

	# air["throat.diffusive_conductance"] = np.ones(net.Nt, dtype=float) * spacing
	air["throat.diffusive_conductance"] = np.random.rand(net.Nt) * spacing
	V = net["pore.volume"] = spacing**3

	trt = op.algorithms.TransientReactiveTransport(network=net, phase=air)
	trt.settings._update(alg_settings)
	trt.set_value_BC(net.pores("left"), 1.0)
	trt.set_value_BC(net.pores("right"), 0.4)
	c0 = np.zeros(trt.Np)

	tspan = [0, 0.4]
	tout = np.linspace(tspan[0], tspan[1], 11)
	dt = (tspan[1] - tspan[0]) / 200

	# Adding source term
	trt.set_source("pore.rxn", pores=net.pores("surface", mode="not"))
	# air.remove_model("pore.rxn")

	tic()
	sol = trt.run(x0=c0, tspan=tspan, integrator=rk45, saveat=tout)
	toc()

	# %% Hardcoded solution using solve_ivp
	# trt._build_A()
	# trt._build_b()
	# trt._apply_BCs()
	# trt._apply_sources()
	# A = trt.A.tocsc()
	# b = trt.b

	# from scipy.integrate import solve_ivp

	# def ode_func(t, y, A, b, V):
	# return (-A.dot(y) + b) / V

	# f = lambda t, y: ode_func(t, y, A, b, V)

	# tic()
	# # TODO: implicit methods: pass lband/uband for drastically better performance
	# # TODO: lband/uband = 1 is probably wrong!
	# sol = solve_ivp(fun=f, t_span=tspan, y0=c0, method="RK23", rtol=1e-5)
	# toc()

	# %% TransientReactiveTransport (legacy)
	trt_legacy = TransientReactiveTransport(network=net, phase=air)
	dt_avg = np.diff(sol.t).mean()
	t_settings = {
	"t_initial": tspan[0],
	"t_final": tspan[1],
	"t_scheme": "implicit",
	"t_step": dt,
	"t_output": tout.tolist()
	}
	trt_legacy.settings._update({alg_settings, t_settings})
	trt_legacy.set_value_BC(net.pores("left"), 1.0)
	trt_legacy.set_value_BC(net.pores("right"), 0.4)
	trt_legacy.set_IC(0.0)

	# Add source term
	trt_legacy.set_source("pore.rxn", pores=net.pores("surface", mode="not"))

	tic()
	trt_legacy.run(solver=pardiso)
	toc()

	# %% Compare new implementation vs legacy
	c_new = sol.reshape((*shape, sol.t.size))

	c_legacy = np.zeros((trt_legacy.Np, tout.size))
	for i, t in enumerate(tout):
	t_fmt = trt_legacy._nbr_to_str(t)
	c_legacy[..., i] = trt_legacy[f"pore.concentration@{t_fmt}"]
	c_legacy = c_legacy.reshape((*shape, tout.size))

	fig, ax = plt.subplots(ncols=2)
	ax[0].imshow(c_new[..., -1].mean(axis=2))
	ax[0].set_title("new implementation")
	ax[1].set_title("legacy")
	h = ax[1].imshow(c_legacy[..., -1].mean(axis=2))

	fig, ax = plt.subplots()
	ax.plot(sol.t, c_new.mean(axis=(0, 1, 2)), "g-", label="new implementation")
	ax.plot(tout, c_legacy.mean(axis=(0, 1, 2)), "rx", label="legacy")
	ax.legend()

	# Ensure correctness
	np.testing.assert_allclose(c_new[..., -1], c_legacy[..., -1], rtol=1e-3)

	# %% Continue integration
	# # Integrate from 0 to 0.2 at once
	# sol1 = trt.run(x0=c0, tspan=[0, 0.2], solver=rk45)

	# # Integrate from 0 to 0.1 and then from 0.1 to 0.2
	# sol2 = trt.run(x0=c0, tspan=[0, 0.1], solver=rk45)
	# sol3 = trt.run(x0=sol2(0.1), tspan=[0.1, 0.2], solver=rk45)

	# # Ensure correctness
	# np.testing.assert_allclose(sol1(0.2), sol3(0.2), rtol=1e-5)