def force_diff(**params):
# for random walk (with pointsize force field, no current)
setup = Setup(create_geo=False, **params)
# DEBUG
#print "active params", setup.active_params
#print "inactive params", setup.inactive_params
F = force_pointsize(**params)
if setup.phys.posDTarget:
D = diffusivity_simple(**params)
name = "diffusivity_div_simple"
if not fields.exists(name, **params):
V = D.function_space()
divD = dolfin.project(
dolfin.as_vector([dolfin.grad(D[0])[0],
dolfin.grad(D[1])[1]]), V)
fields.save_functions(name, setup.active_params, divD=divD)
fields.update()
divD, = fields.get_functions(name, "divD", **params)
else:
D0 = setup.phys.DTargetBulk
D0a = np.array([D0, D0, D0])
divDa = np.array([0., 0., 0.])
D = lambda x: D0a
divD = lambda x: divDa
return F, D, divD
def cache_diffusivity(geoname="alphahem", mode="coupled", **params):
name = "D%s-%s" % (geoname, mode)
if not fields.exists(name, **params):
setup = nanopore.Setup(**params)
r = setup.geop.rMolecule
if mode == "coupled":
data_z = diff_profile_z_ahem(**params)
data_r = diff_profile_plane(r)
elif mode == "simple":
data_z = None
data_r = diff_profile_plane(r)
elif mode == "profile":
data_z = diff_profile_z_ahem(**params)
data_r = diff_profile_trivial(r)
else:
raise NotImplementedError
functions = diffusivity_field(setup,
r,
ddata_z=data_z,
ddata_r=data_r,
boundary="poresolidb",
poreregion="pore")
fields.save_functions(name, params, **functions)
fields.update()
return name
def cache_pugh_diffusivity(geoname="pugh2", mode="coupled", **params):
#name = "D%s-%s" % (geoname, mode)
name = "D%s" % (geoname, )
if not fields.exists(name, **params):
if not "cheapest" in params:
params["cheapest"] = True
setup = pugh.Setup(x0=None, **params)
r = setup.geop.rMolecule
diamPore = setup.geop.diamPore
if mode == "coupled":
data_z = diff_profile_z_pugh(diamPore=diamPore)
data_r = diff_profile_plane(r)
elif mode == "simple":
data_z = None
data_r = diff_profile_plane(r)
elif mode == "profile":
data_z = diff_profile_z_pugh(diamPore=diamPore)
data_r = diff_profile_trivial(r)
else:
raise NotImplementedError
functions = diffusivity_field(setup,
r,
ddata_z=data_z,
ddata_r=data_r,
boundary="dnab",
poreregion="poreregion")
fields.save_functions(name, params, **functions)
fields.update()
return name
def calculate_forcefield(name, X, calculate, params={}, default={}, nproc=1,
overwrite=False):
"assuming function calculate([x0], **params)"
save_params = dict(default, **params)
run_params = save_params
N = len(X)
if fields.exists(name, **save_params) and not overwrite:
Xdone = fields.get_field(name, "x", **save_params)
X = [x0 for x0 in X if x0 not in Xdone]
if len(X) > 0:
print "Existing force file found, %d/%d points remaining." % (
len(X), N)
iter_params = dict(x0=X)
def run(x0=None):
try:
result = calculate([x0], **run_params)
#result = {k: [v] for k, v in result.items()}
fields.save_fields(name, save_params, x=[x0], **result)
except: # Exception, RuntimeError:
print "x = %s: Error occured, continuing without saving." %x0
print traceback.print_exc()
result = None
return result
results, _ = iterate_in_parallel(run, nproc, **iter_params)
if len(X) > 0:
# if nproc == 1:
# print "%d of %d force calculations failed." % (len(Xfailed), len(X))
fields.update()
return results
def cache_diffusivity_simple(geoname="alphahem", **params):
name = "D%s" % (geoname, )
if not fields.exists(name, **params):
setup = nanopore.Setup(**params)
r = setup.geop.rMolecule
functions = diffusivity_field(setup, r, boundary="poresolidb")
fields.save_functions(name, params, **functions)
fields.update()
def maybe_calculate(overwrite=False, **newparams):
params.update(newparams)
if not overwrite and fields.exists(NAME, **params):
print "Existing 2D force field found."
else:
print "Calculating 2D force field."
save_forcefield_implicit(**params)
return load_forcefield_implicit(**params)
def distance_boundary():
h = up.h
geo = pughpore.get_geo(h)
y = distance_boundary_from_geo(geo)
print "Max distance:", y.vector().max()
if not fields.exists("pugh_distance", h=h):
fields.save_functions("pugh_distance", dict(h=h), y=y)
fields.update()
return y
def diffusivity_simple(**params):
from nanopores.models.diffusion_interpolation import diffusivity_field
name = "diffusivity_simple"
if not fields.exists(name, **params):
setup = Setup(**params)
dic = diffusivity_field(setup,
r=params["rMolecule"],
boundary="poresolidb")
fields.save_functions(name, setup.active_params, **dic)
fields.update()
D, = fields.get_functions(name, "D", **params)
return D
def cache_pugh_diffusivity_old(**params):
"the function above applied to the pugh pore"
if not fields.exists("Dpugh", **params):
setup_params = dict(params)
r = setup_params.pop("r")
ddata_z = fields.get_fields("pugh_diff2D", rMolecule=r)
ddata_r = fields.get_fields("pugh_diff3D", rMolecule=r, bulkbc=True)
if not "cheapest" in setup_params:
setup_params["cheapest"] = True
setup = pugh.Setup(x0=None, **setup_params)
functions = diffusivity_field(setup, r, ddata_r, ddata_z)
fields.save_functions("Dpugh", params, **functions)
fields.update()
def cache_pugh_diffusivity_alt(**params):
"the function above applied to the pugh pore"
if not fields.exists("Dpugh_alt", **params):
setup_params = dict(params)
r = setup_params.pop("r")
ddata_pore = fields.get_fields("pugh_diff_pore", rMolecule=r)
ddata_bulk = fields.get_fields("pugh_diff_bulk", rMolecule=r)
if not "cheapest" in setup_params:
setup_params["cheapest"] = True
setup = pugh.Setup(x0=None, **setup_params)
functions = diffusivity_field_alt(setup, r, ddata_pore, ddata_bulk)
fields.save_functions("Dpugh_alt", params, **functions)
fields.update()
def forcefieldS1_explicit(overwrite=False, **params):
# maybe interpolate and save force field
if not overwrite and fields.exists(NAME, **params):
print "Existing force field interpolation found."
else:
print "Interpolating 3D force field."
interpolate_forcefieldS1_explicit(**params)
# load force field
FNAME = fields.get_entry(NAME, "FNAME", **params)
forces, mesh, _ = nanopores.load_vector_functions(str(FNAME))
F = forces["F"]
return F
def get_results(NAME, params, calc=True):
# check existing saved rws
if fields.exists(NAME, **params):
data = load_results(NAME, **params)
N = len(data.times)
else:
N = 0
# determine number of missing rws and run
N_missing = params["N"] - N
if N_missing > 0 and calc:
new_params = Params(params, N=N_missing)
rw = setup_rw(new_params)
run(rw, NAME)
rw.save(NAME)
# return results
data = load_results(NAME, **params)
return data
def force_pointsize(**params):
name = "force_pointsize"
if not fields.exists(name, **params):
setup = Setup(**params)
#print setup.geo
#setup.geo.plot_boundaries(interactive=True)
_, pnps = solve(setup, True)
v, cp, cm, u, p = pnps.solutions()
F, Fel, Fdrag = setup.phys.ForceField(v, u, "fluid")
fields.save_functions(name,
setup.active_params,
F=F,
Fel=Fel,
Fdrag=Fdrag)
fields.update()
F, = fields.get_functions(name, "F", **params)
return F
def get_results(name, params, setup=setup_default, calc=True):
# setup is function rw = setup(params) that sets up rw
# check existing saved rws
data = None
if fields.exists(name, **params):
data = load_results(name, **params)
N = len(data.times)
else:
N = 0
# determine number of missing rws and run
N_missing = params["N"] - N
if N_missing > 0 and calc:
new_params = nanopores.Params(params, N=N_missing)
rw = setup(new_params)
run(rw, name)
rw.save(name)
data = load_results(name, **params)
# return results
elif data is None:
data = load_results(name, **params)
return data
def cache_diffusivity(mode="coupled", **params):
#name = "D%s-%s" % (geoname, mode)
name = "Diffusivity"
if not fields.exists(name, **params):
if not "cheapest" in params:
params["cheapest"] = True
# setup = pugh.Setup(x0=None, **params)
setup = nanopore.Setup(x0=None, **params)
r = params["r"]
#diamPore = setup.geo.params.diamPore
if mode == "coupled":
# TODO: make general
data_z = fields.get_fields("pugh_diff2D", rMolecule=r)
data_r = diff_profile_plane(r)
elif mode == "simple":
data_z = None
data_r = diff_profile_plane(r)
elif mode == "profile":
data_z = fields.get_fields("pugh_diff2D", rMolecule=r)
#data_z = diff_profile_z_pugh(diamPore=diamPore)
data_r = diff_profile_trivial(r)
else:
raise NotImplementedError
functions = diffusivity_field(setup,
r,
ddata_z=data_z,
ddata_r=data_r,
boundary="dnab",
poreregion="poreregion")
params["mode"] = mode
fields.save_functions(name, params, **functions)
fields.update()
return name
# (c) 2016 Gregor Mitscha-Baude
from dolfin import *
from nanopores.tools import fields
# set save/load directory
fields.set_dir("/tmp/nanopores/")
mesh = UnitSquareMesh(10, 10)
V = FunctionSpace(mesh, "CG", 1)
u = Function(V)
u.interpolate(Expression("sin(x[0]*x[1]*4*pi)"))
if not fields.exists("test_save"):
fields.save_functions("test_save", {}, utest=u)
fields.update()
functions, mesh = fields.get_functions("test_save")
u1 = functions["utest"]
plot(u1, interactive=True)
minus = lambda l: [[-x[0], x[1]] for x in l]
def plot_polygon(p, lw=1):
p.plot("-k", lw=lw)
Polygon(minus(p.nodes)).plot("-k", lw=lw)
params = dict(
h=0.5,
Nmax=3e4,
bV=0.0,
)
name = "pot-ahem"
if not fields.exists(name, **params):
setup = model.Setup(**params)
pb, pnps = model.solve(setup)
v = pnps.solutions()[0]
fields.save_functions(name, params, v=v)
fields.update()
fun, mesh = fields.get_functions(name, **params)
f = fun["v"]
def F(x, z):
if x >= 0:
return f([x, z])
else:
return f([-x, z])
# (c) 2016 Gregor Mitscha-Baude
import os
import sys
HOME = os.path.expanduser("~")
#PAPERDIR = os.path.join(HOME, "papers", "paper-howorka")
#FIGDIR = os.path.join(PAPERDIR, "figures", "")
FIGDIR = os.path.join(HOME, "Dropbox", "nanopores", "figures")
DATADIR = os.path.join(HOME, "Dropbox", "nanopores", "fields")
import nanopores.tools.fields as fields
fields.set_dir(DATADIR)
fieldsname=sys.argv[1]
if fields.exists(fieldsname):
a=raw_input('delete %s'%fieldsname+' ?')
if a=='y' or a=='Y':
fields.remove(fieldsname)
Dxx_ = [D[0][0] for D in data["D"]]
Dyy_ = [D[1][1] for D in data["D"]]
Dzz_ = [D[2][2] for D in data["D"]]
Dxx = smooth(smooth(Dxx_, 3), 5)
Dyy = smooth(smooth(Dyy_, 3), 5)
Dzz = smooth(smooth(Dzz_, 3), 5)
def matrix(d):
return [[d[0], 0., 0.], [0., d[1], 0.], [0., 0., d[2]]]
data = dict(x=x, D=map(matrix, zip(Dxx, Dyy, Dzz)))
if not fields.exists("pugh_diff_pore", rMolecule=rMolecule):
print "SAVING..."
fields.save_fields("pugh_diff_pore", dict(rMolecule=rMolecule), **data)
fields.update()
plt.figure()
plt.plot(x, Dxx_, "o:b")
plt.plot(x, Dxx, "-b", label=r"$D_x$")
plt.plot(x, Dyy_, "o:r")
plt.plot(x, Dyy, "-r", label=r"$D_y$")
plt.plot(x, Dzz_, "o:g")
plt.plot(x, Dzz, "-g", label=r"$D_z$")
plt.xlabel('x distance from pore wall [nm]')
plt.ylabel('diffusivity relative to bulk')
plt.legend(loc='lower right')
h=1.,
lcpore=0.1,
Nmax3D=2.5e4, # UMFPACK: max. ca. 3e4
Nmax=1e4,
stokesLU=True,
)
fields.update()
# TODO calculate in parallel
# TODO calculate current as well
# TODO retrieve x points based on a given model and save file link
# to data field
X = fields.get_entry("xforce", "X")
N = len(X)
if fields.exists("force3D", **params):
Xdone = fields.get_field("force3D", "x", **params)
X = [x0 for x0 in X if x0 not in Xdone]
print "Existing force file found, %d/%d points remaining." % (len(X), N)
Xfailed = []
for x in X:
x0 = [x[0], 0., x[1]]
try:
F, Fel, Fdrag = Howorka.F_explicit3D([x0], **solver_params)
fields.save_fields("force3D", params, x=[x], F=F, Fel=Fel, Fdrag=Fdrag)
except RuntimeError:
print "RuntimeError occured, continuing without saving."
Xfailed.append(x)
print "failed:"
