def Idiam(diam, **params):
dim = params["dim"]
x0 = params.pop("x0")
params.pop("diamPore")
Jon = []
Joff = []
# TODO bad hack
if dim==3:
params.update(h=1.5, Nmax=7e5)
if dim==2:
params.update(h=0.75, Nmax=1e5)
for d in diam:
# get diffusivity interpolation
cache_pugh_diffusivity(diamPore=d, **dparams[dim])
ddata = dict(dparams[dim], name="Dpugh", diamPore=d)
# current WITHOUT molecule
setup = pugh.Setup(x0=None, diamPore=d, diffusivity_data=ddata, **params)
pb, pnps = pugh.solve(setup, visualize=True)
Jon.append(pnps.evaluate(setup.phys.CurrentPNPS)["J"])
# current WITH molecule
setup = pugh.Setup(x0=x0, diamPore=d, diffusivity_data=ddata, **params)
pb, pnps = pugh.solve(setup, visualize=True)
Joff.append(pnps.evaluate(setup.phys.CurrentPNPS)["J"])
return dict(Jon=Jon, Joff=Joff)
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 diff2D(X, **params):
for x, result in collect_dict(X):
params["x0"] = x
setup = pugh.Setup(**params)
D = diffusivity(setup)
result.new = dict(D=D)
return result
def IVDetail(V, **params):
params["x0"] = None
for bV, result in collect_dict(V):
params["bV"] = bV
setup = pugh.Setup(**params)
pb, pnps = pugh.solve(setup)
result.new = pnps.evaluate(setup.phys.CurrentPNPSDetail)
return result
def IrhoDetail(Rho, **params):
params["x0"] = None
for rho, result in collect_dict(Rho):
params["dnaqsdamp"] = rho
setup = pugh.Setup(**params)
pb, pnps = pugh.solve(setup, visualize=True)
result.new = pnps.evaluate(setup.phys.CurrentPNPSDetail)
return result
def IV(V, **params):
params["x0"] = None
J = []
for bV in V:
params["bV"] = bV
setup = pugh.Setup(**params)
pb, pnps = pugh.solve(setup)
J.append(pnps.evaluate(setup.phys.CurrentPNPS)["J"])
return dict(J=J)
def calculate_diffusivity(X, **params):
_params = dict(default, **params)
values = []
for x0 in X:
setup = pugh.Setup(x0=x0, **_params)
setup.physp["bulkbc"] = _params["bulkbc"]
D = diffusivity(setup)
values.append(D)
return dict(D=values)
def Irho(Rho, **params):
params["x0"] = None
bV = params["bV"]
J = []
for rho in Rho:
params["dnaqsdamp"] = rho
setup = pugh.Setup(**params)
pb, pnps = pugh.solve(setup, visualize=True)
J.append(pnps.evaluate(setup.phys.CurrentPNPS)["J"])
cond = [abs(j / bV) for j in J]
return dict(J=J, cond=cond)
def D_tensor(X, **params):
x0 = X[0]
print
print
print "MOLECULE: ", x0
setup = pugh.Setup(x0=x0, **params)
nano.plot_sliced(setup.geo)
#dolfin.plot(setup.geo.subdomains, elevate=-45., key="subdomains")
#dolfin.plot(setup.geo.subdomains, key="subdomains")
setup.physp["bulkbc"] = params["bulkbc"]
D = diffusion.diffusivity_tensor(setup)
return dict(D=[tolist(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 Idiam(diam, **params):
dim = params["dim"]
x0 = params.pop("x0")
params.pop("diamPore")
Jon = []
Joff = []
for d in diam:
# get diffusivity interpolation
cache_pugh_diffusivity(geoname="pugh2", diamPore=d, **dparams[dim])
# current WITHOUT molecule
setup = pugh.Setup(x0=None, diamPore=d, **params)
pb, pnps = pugh.solve(setup, visualize=True)
Jon.append(pnps.evaluate(setup.phys.CurrentPNPS)["J"])
# current WITH molecule
setup = pugh.Setup(x0=x0, diamPore=d, **params)
pb, pnps = pugh.solve(setup, visualize=True)
Joff.append(pnps.evaluate(setup.phys.CurrentPNPS)["J"])
return dict(Jon=Jon, Joff=Joff)
VVV = dolfin.TensorFunctionSpace(meshp, "CG", 1, shape=(dim, dim))
D = dolfin.Function(VVV)
v2d = dolfin.vertex_to_dof_map(VVV)
Dv = D.vector()
for k, (i, j) in enumerate(product(i3, i3)):
Dv[np.ascontiguousarray(v2d[k::dim**2])] = np.ascontiguousarray(Da[:,
i,
j])
setup.phys.update(Dp=D, Dm=D)
#embed()
return D
# set up domain with protein
ddata = dict(name="Dpugh", r=0.11, dim=2)
setup = pugh.Setup(x0=[0., 0., 10.],
dim=2,
h=1.,
Nmax=1e5,
diamPore=6. * np.sqrt(np.pi) / 2.,
cheapest=True,
diffusivity_data=ddata)
plotter = pugh.Plotter(setup)
pugh.prerefine(setup, True)
print "getting D"
D = set_D_with_protein(setup)
print "plotting"
plotter.plot(D[0, 0], title="Dxx")
dolfin.interactive()
Dn = [0., eps] + Dn + [1.]
Dt = [0., eps] + Dt + [1.]
fz = interp1d(z, Dz)
fn = interp1d(x, Dn)
ft = interp1d(x, Dt)
import matplotlib.pyplot as plt
plt.plot(z, fz(z), "s-")
plt.figure()
plt.plot(x, fn(x), "s-")
plt.plot(x, ft(x), "s-")
# get geometry, prerefine mesh, compute distance function
setup = pugh.Setup(dim=params.dim,
x0=None,
h=params.h,
Nmax=params.Nmax,
cheapest=True)
pugh.prerefine(setup, visualize=True)
dist = distance_boundary_from_geo(setup.geo)
VV = dolfin.VectorFunctionSpace(setup.geo.mesh, "CG", 1)
normal = dolfin.project(dolfin.grad(dist), VV)
plotter = pugh.Plotter(setup)
plotter.plot_vector(normal, "normal")
#functions, mesh = f.get_functions("pugh_distance", h=h)
#dist = functions["y"]
def transformation(n, Dn, Dt):
D = np.diag([Dn, Dt, Dt]) if len(n) == 3 else np.diag([Dn, Dt])
diamDNA=2.5,
Nmax=1.2e5,
dim=2,
r=0.11,
h=.75,
cheapest=False,
Membraneqs=-.5),
3:
dict(diamPore=6., Nmax=1e6, dim=3, r=0.11, h=2.0, cheapest=False)
}
# obtain diffusivity field and project to x-z plane
#functions = get_pugh_diffusivity(**dparams[2])
setup = pugh.Setup(dim=2,
h=1.,
Nmax=1e5,
x0=[0., 0., 0.],
diffusivity="Dpugh2")
setup.prerefine()
pugh.set_D(setup)
D3D = setup.phys.Dp[1, 1]
print D3D([0., 0.])
#D3D = functions["D"][2]
D0 = nanopores.D
def F(x, z):
if x >= 0:
return D3D([x, z]) / D0
else:
return D3D([-x, z]) / D0
while eps > 1e-4:
print "eps", eps, " ",
solver.solve()
u.assign(u + du)
eps *= epsfact
epsi.assign(eps)
return u
if __name__ == "__main__":
import nanopores.geometries.pughpore as pughpore
import nanopores.models.pughpore as pugh
from nanopores import user_param
setup = pugh.Setup(dim=3, h=2., x0=None, Nmax=6e5, cheapest=True)
setup.prerefine()
geo = setup.geo
#geo = pughpore.get_geo_cyl(lc=1., x0=None)
y = distance_boundary_from_geo(geo)
setup.plot(y, title="distance", interactive=True)
from numpy import linspace
from matplotlib.pyplot import plot, show
t = linspace(0., 20., 100)
def point(t):
x = [0.] * setup.geop.dim
x[0] = t
return x
plot(t, [y(point(t0)) for t0 in t], ".-")
