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_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 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 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 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 interpolate_forcefieldS1_explicit(**params):
# --- load force field and points
data = fields.get_fields("force3D", **params)
X = data["x"]
F = data["F"]
Fexp = [[1e-12 * f[0], 1e-12 * f[2]] for f in F]
Fimpl = forcefieldS1_implicit(**params)
# --- load geometry params
# TODO: not very general
xparams = fields.load_file("xforce")["params"]
Rx0, Ry0 = xparams["Rx"], xparams["Ry"]
Ry0 = 7. # FIXME bad hack
r = params["rMolecule"]
r0, l0, r1, l1 = (Howorka.params_geo.r0, Howorka.params_geo.l0,
Howorka.params_geo.r1, Howorka.params_geo.l1)
Rx, Ry = params["Rx"], params["Ry"]
# --- piece together data TODO
# additional points where implicit model will be used
hadd = 0.8
Xadd = uniform_grid([r1+r, Rx], [-Ry, -l1/2-r], hadd) + \
uniform_grid([r1+r, Rx], [l1/2+r, Ry], hadd) + \
uniform_grid([0, r1], [Ry0, Ry], hadd) + \
uniform_grid([0, r1], [-Ry, -Ry0], hadd)
# points where force is zero
hdna = 0.4
Xdna = uniform_grid([r0-r+.01, r1+r-.01], [-l0/2-r, l0/2+r], hdna) + \
uniform_grid([r1+r, Rx], [-l1/2-r, l1/2+r], hdna)
Fexpadd = [Fimpl(x) for x in Xadd]
X += Xadd
Fexp += Fexpadd
Fimp = [Fimpl(x0) for x0 in X]
X += Xdna
Fdna = [[0., 0.] for x in Xdna]
Fexp += Fdna
Fimp += Fdna
Fexp = np.array(Fexp)
Fimp = np.array(Fimp)
x = np.array([t[0] for t in X])
y = np.array([t[1] for t in X])
# overwrite explicit calculation far from pore # FIXME bad hack
yfar = abs(y) > Ry0
Fexp[yfar, :] = Fimp[yfar, :]
# --- obtain S1 functions
mesh = Fimpl.function_space().mesh()
F = data_to_S1(x, y, mesh, Fexp=Fexp)
# --- save functions
uid = fields._unique_id()
FNAME = NAME + uid
nanopores.save_functions(FNAME, mesh, meta=params, F=F)
fields.save_entries(NAME, params, FNAME=FNAME)
fields.update()
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_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 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 save_forcefield_implicit(**params):
F, Fel, Fdrag = Howorka.F_field_implicit(**params)
mesh = Howorka.geo.mesh
uid = fields._unique_id()
FNAME = NAME + uid
nanopores.save_functions(FNAME,
mesh,
meta=params,
F=F,
Fel=Fel,
Fdrag=Fdrag)
fields.save_entries(NAME, params, FNAME=FNAME)
fields.update()
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 save(self, name="rw"):
if "N" in self.params:
self.params.pop("N")
optional = dict()
if self.record_positions:
optional.update(positions=self.positions,
timetraces=self.timetraces)
if hasattr(self, "binding_zone_forces"):
optional.update(binding_zone_forces=self.binding_zone_forces)
fields.save_fields(name,
self.params,
times=self.times,
success=self.success,
fail=self.fail,
bind_times=self.bind_times,
attempts=self.attempts,
bindings=self.bindings,
attempt_times=self.attempt_times,
**optional)
fields.update()
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)
# (c) 2016 Gregor Mitscha-Baude
import nanopores.tools.fields as f
import matplotlib.pyplot as plot
import folders
f.update()
for h in [2., 4.]:
field = f.get_fields("pughcenter", bulkcon=1e3, Qmol=8, h=h)
z = [x[2] for x in field["x"]]
J = [j * 1e12 for j in field["J"]]
I = sorted(range(len(z)), key=lambda k: z[k])
z1 = [z[i] for i in I]
J1 = [J[i] for i in I]
for i in I:
print z[i], J[i]
plot.plot(z1, J1, "s-", label="molecule, h=%s" % h)
plot.xlabel("z position of molecule [nm]")
plot.ylabel("current [pA]")
plot.title("current at -100mV for molecule along pore center")
for h in []: #[1., 2., 3., 4.]:
Jopen = f.get_fields("pughopen", Qmol=8, h=h)["J"][0]
plot.plot(z1, [2. * Jopen * 1e12] * len(z1), "--", label="open, h=%s" % h)
plot.legend()
plot.show()
