def run(rw, name="rw", plot=False, a=-3, b=3, **aniparams):
params = nanopores.user_params(video=False, save=False, cyl=False)
if params.video:
ani = video(rw, cyl=params.cyl, **aniparams)
if params.save:
save(ani, name=name)
else:
plt.show()
else:
for t in rw.walk():
pass
if plot and ((not params.video) or (not params.save)):
histogram(rw, a, b)
#plt.figure()
#hist_poisson(rw, "attempts")
#plt.figure()
#hist_poisson(rw, "bindings")
plt.show()
# MEMBRANE |DDDDD| |DDDDD| . H
# | |DDDDD| |DDDDD| . .
# | |DDDDD| |DDDDD|....h4 . .
#______V_________|DDD| |DDD|_____.________ .___ .......
#MMMMMMMMMMMMMMMM|DDD| |DDD|MMMMM.MMMMMMMMM.MMMM. hmem
#MMMMMMMMMMMMMMMM|DDD|_______|DDD|MMMMM.MMMMMMMMM.MMMM.......
# . . .
# .......l4........ .
# .
# .
# .
#......................................................
if __name__ == "__main__":
from nanopores import user_params
up = user_params(dim=2, h=1., Nmax=1e5, x0=[0.,0.,0.], bV=-0.08,
diffusivity="Dpugh2", diamPore=6.)
setup = Setup(**up)
#setup.geo.plot_boundaries()
_, pnps = solve(setup, True)
print get_forces(setup, pnps)
plotter = Plotter(setup)
v, cp, cm, u, p = pnps.solutions()
plotter.plot_vector(u, "velocity")
plotter.plot(cm, "cm")
plotter.plot(cp, "cp")
plotter.plot(p, "p")
dolfin.interactive()
from scipy import ndimage
import nanopores.geometries.pughpore as pughpore
import nanopores
import numpy as np
import matplotlib.pyplot as plt
up = nanopores.user_params(pughpore.params, k=3)
R = up.R
H = up.H
def z_func(x, y):
return (1 - (x ** 2 + y ** 3)) * np.exp(-(x ** 2 + y ** 2) / 2)
X, Y, Z = np.load('X.npy'), np.load('Y.npy'), np.load('ZJ4.npy')
Z=ndimage.rotate(Z,0)
im = plt.imshow(Z, cmap=plt.cm.viridis, extent=(-R/2., R/2., H/2., -H/2.))
plt.colorbar(im)
plt.tight_layout()
plt.show()
"solve eikonal equation to get distance to boundary"
"TODO: implement also in 2D"
from dolfin import *
from nanopores.tools import fields
import nanopores.geometries.pughpore as pughpore
import nanopores.models.pughpore as pughm
import nanopores as nano
import folders
up = nano.user_params(h=8.0)
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 distance_boundary_from_geo(geo):
mesh = geo.mesh
V = FunctionSpace(mesh, "CG", 1)
v = TestFunction(V)
u = TrialFunction(V)
f = Constant(1.0)
y = Function(V)
params = nanopores.user_params(
# general params
geoname="wei",
dim=2,
rMolecule=1.25, # 6.
h=5.,
Nmax=1e5,
Qmol=2., #15.,
bV=-0.2,
dp=26.,
geop=dict(dp=26.),
posDTarget=True,
# random walk params
N=100000, # number of (simultaneous) random walks
dt=.5, # time step [ns]
walldist=2., # in multiples of radius, should be >= 1
margtop=60.,
margbot=0.,
#zstart = 46.5, # 46.5
#xstart = 0., # 42.
rstart=30,
initial="sphere",
# receptor params
tbind=40e9, # from Lata, = 1/kd = 1/(25e-3)s [ns]
# tbind = 286e9, from Wei, = 1/kd = 1/(3.5e-3)s [ns]
ka=1.5e5,
zreceptor=.95, # receptor location relative to pore length (1 = top)
)
##### what to do
)
domain.params = dict(
_params,
name="pughpore",
dim=1,
nm=1.,
lscale=1e9,
)
geo = domain.create_geometry(lc=lc)
return geo
if __name__ == "__main__":
import dolfin
from nanopores import plot_sliced, user_params
up = user_params(params, h=4.)
geo2D = get_geo_cyl(lc=1., **up)
dolfin.plot(geo2D.subdomains, title="subdomains")
dolfin.plot(geo2D.boundaries, title="boundaries")
print geo2D
domain = get_domain(**up)
membrane = domain.getsubdomain("membrane")
dna = domain.getsubdomain("dna")
molecule = domain.getsubdomain("molecule")
solid = membrane | dna | molecule
solid.addsubdomains(dna=dna, membrane=membrane)
solid.addball(molecule, "molecule", "moleculeb")
solid.addboundaries(
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 get_pugh_diffusivity_alt(**params):
cache_pugh_diffusivity_alt(**params)
functions, mesh = fields.get_functions("Dpugh_alt", **params)
return functions, mesh
if __name__ == "__main__":
params = nanopores.user_params(dim=2, r=0.11, h=1., Nmax=1e5)
functions = get_pugh_diffusivity(**params)
D = functions["D"]
D = dolfin.as_matrix(np.diag([D[i] for i in range(params.dim)]))
dolfin.plot(functions["D"][0], title="Dx")
dolfin.plot(functions["D"][1], title="Dz")
dolfin.plot(functions["dist"], title="dist")
dolfin.interactive()
i.e current and release time series for specific molecule."""
from nanopores.tools.fields import cache
import nanopores
import dolfin
import matplotlib.pyplot as plt
from nanopores.physics.convdiff import ConvectionDiffusion
import forcefields
from eikonal import boundary_force
p = nanopores.user_params(
overwrite=False,
bforce=True,
levels=12,
t=1e-8,
steps=20,
Qmol=-1,
rMolecule=0.5,
implicit=False,
R=100.,
h=4.,
Nmax=1e5,
dnaqsdamp=1.,
)
# force field parameters
f_params = dict(
Qmol=p.Qmol,
rMolecule=p.rMolecule,
implicit=p.implicit,
Ry=p.R,
Rx=p.R,
Nmax=p.Nmax,
default = dict(
dim = 2,
geoname = "alphahem",
porename = "alphahem",
Htop = 7.,
Hbot = 15.,
R = 10.,
cs = [-3, -6],
zmem = -7.625,
proteincs = [-2.3, -4.6, -7.2],
)
def get_pore(**params):
params = dict(default, **params)
pore = Pore(poly, **params)
pore.build_polygons()
pore.build_boundaries()
return pore
def get_geo(h=1., recreate=False, **params):
params = dict(default, **params)
geo = get_geo_generic(poly, h=h, recreate=recreate, **params)
return geo
if __name__ == "__main__":
from nanopores import user_params
params = user_params(default, x0=None, h=1.)
geo = get_geo(reconstruct=True, **params)
geo.plot_subdomains()
geo.plot_boundaries(interactive=True)
i0 = V.index(0.)
F[i0] = velo2force_2D(0., setup)
F0 = F[i0]
print "F(0)", F0
for i, v in enumerate(V):
if not i == i0:
print "\n--- Velocity %d ---" %(i+1,)
F[i] = velo2force_2D(v, setup)
print "Velocity", v
print "Force (exact)", F[i]
print "Force (linear)", F0 - gamma*v
return F, gamma, F0
params = user_params(dim=3, Nmax=1.5e5, h=1., dnaqsdamp=0.25,
x0=[0.2,0.,4.01], Qmol=-1., bulkcon=300.)
setup = Howorka.Setup(**params)
setup.prerefine()
velo2force_3D([0., 0.1, 0.2], setup)
do_v2f = False
redo_v2f = False
if do_v2f:
if redo_v2f:
params = user_params(dim=2, Nmax=2e4, h=.5, dnaqsdamp=0.25,
x0=[0.,0.,4.5], Qmol=-1., bulkcon=300.)
V = list(np.linspace(-1., 1., 3))
F, gamma, F0 = nonzero_velocities_2D(V, **params)
fields.save_entries("howorka_velo2force_3", params, V=V, F=F, gamma=gamma, F0=F0)
fields.update()
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 get_pugh_diffusivity_alt(**params):
cache_pugh_diffusivity_alt(**params)
functions, mesh = fields.get_functions("Dpugh_alt", **params)
return functions, mesh
if __name__ == "__main__":
params = nanopores.user_params(geoname="pughcyl",
dim=2,
r=0.11,
h=1.,
Nmax=1e4)
functions, mesh = get_diffusivity(**params)
D = functions["D"]
D = dolfin.as_matrix(np.diag([D[i] for i in range(params.dim)]))
dolfin.plot(functions["D"][0], title="Dx")
dolfin.plot(functions["D"][1], title="Dz")
dolfin.plot(functions["dist"], title="dist")
dolfin.interactive()
# (c) 2016 Gregor Mitscha-Baude
import diffusion
import nanopores.tools.solvers as solvers
import nanopores.models.pughpore as pugh
import numpy as np
from folders import fields
import nanopores as nano
import dolfin
def tolist(array):
return [list(a) for a in array]
up = nano.user_params(h=1., Nmax=2e5, H=10., R=3.1)
params = dict(
H=up.H,
R=up.R,
center_z_at_x0=True, #False, #True,
dim=3,
h=up.h,
Nmax=up.Nmax,
rMolecule=2.0779,
bulkbc=True,
)
@solvers.cache_forcefield("pugh_diff3D", {})
def D_tensor(X, **params):
x0 = X[0]
print
import dolfin
import matplotlib.pyplot as plt
from nanopores.geometries.pughpore import (params, get_geo_cyl, get_domain,
get_geo)
from nanopores import plot_sliced, user_params
from nanopores.tools.balls import Box, Ball, EmptySet, set_tol, union
up = user_params(params, h=1.)
r = up.rMolecule
lc = up.lcMolecule
positions = [
[3., 0., 26.],
[-0.9, .9, 2.],
[0.1, .8, -24.],
]
molecules = [Ball(x0, r=r, lc=lc) for x0 in positions]
#geo2D = get_geo_cyl(lc=1., **up)
#dolfin.plot(geo2D.subdomains, title="subdomains", backend="matplotlib")
#dolfin.plot(geo2D.boundaries, title="boundaries", backend="matplotlib")
#dolfin.plot(geo2D.mesh, backend="matplotlib")
#print geo2D
#dolfin.interactive()
domain = get_domain(**up)
membrane = domain.getsubdomain("membrane")
dna = domain.getsubdomain("dna")
molecule = domain.getsubdomain("molecule")
name = params["geoname"] if params is not None else "cylpore"
try:
geo = reconstructgeo(name=name, params=dict(params))
except EnvironmentError as e:
print e.message
geo = None
return geo
if __name__ == "__main__":
from nanopores import user_params, showplots
params = user_params(
h=1.,
porename="dna",
H=20.,
R=10.,
x0=[0., 0., 0.],
dim=2,
subs=None,
)
dnapolygon = [[1, -5], [1, 5], [3, 5], [3, -5]]
# --- TEST
p = MultiPore(dict(dna=dnapolygon), **params)
p.build_polygons()
p.build_boundaries()
#print p.polygons.keys()
#print p.boundaries.keys()
p.protein.plot(".k", zorder=100)
# (c) 2017 Gregor Mitscha-Baude
import numpy as np
from matplotlib import pyplot as plt
from nanopores import fields, user_params
up = user_params(diamPore=7.)
data = fields.get_fields("diffz_pugh", **up)
z = map(lambda x: x[2], data["x"])
data, z = fields._sorted(data, z)
plt.plot(z, data["D"], "o-")
plt.ylim(0, 1)
@solvers.cache_forcefield("pugh_diffusivity", default)
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)
@solvers.cache_forcefield("pugh_diffusivity2D", default)
def calculate_diffusivity2D(X, **params):
_params = dict(default, frac=.5, **params)
_params["dim"] = 2
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)
if __name__ == "__main__":
up = nano.user_params(h=.1, H=8., R=4., Nmax=4e4)
print calculate_diffusivity2D([[0., 0., 0.]], cache=False, **up)
#print calculate_diffusivity([[0.,0.,0.], [0.,0.,30.]], nproc=2)
"harmonic interpolation -- proof of concept."
import numpy as np
import dolfin
import nanopores.geometries.pughpore as pughpore
from nanopores.models.pughpore import Plotter
from nanopores import user_params, Log
#import nanopores.py4gmsh as gmsh
from nanopores.tools.interpolation import harmonic_interpolation
import nanopores.tools.box as box
h = 2.
box.set_tol(None)
domain = pughpore.get_domain(h, x0=None)
# create random points
N = user_params(N=1000).N
R, H = domain.params["R"], domain.params["H"]
px = 2*R*np.random.random(N) - R
py = 2*R*np.random.random(N) - R
pz = H*np.random.random(N) - H/2.
points = zip(px, py, pz)
# prepare mesh containing points
domain.write_gmsh_code(h)
domain.insert_points(points, h, forbidden=["dna", "membrane"])
geo = domain.code_to_mesh()
mesh = geo.mesh
with Log("harmonic interpolation..."):
# interpolate function from point values
values = np.sin(np.array(points)[:,2]/5.)
from nanopores.tools.solvers import cache_forcefield
fields.set_dir_dropbox()
params = nanopores.user_params(
# general params
geoname="wei",
dim=2,
rMolecule=1.25, # 6.
h=5.,
Nmax=1e5,
Qmol=2., #15.,
bV=-0.2,
dp=23.,
# random walk params
N=1000, # number of (simultaneous) random walks
dt=1., # time step [ns]
walldist=2., # in multiples of radius, should be >= 1
margtop=50.,
margbot=0.,
zstart=46.5, # 46.5
xstart=0., # 42.
rstart=None,
# receptor params
rec_t=3.7e9,
rec_p=0.01763,
rec_eps=0.1,
)
receptor = randomwalk.Ball([8.5 - 3. + 2., 0., 40.5], 0.5) # ztop 46.5
receptor_params = dict(
# (c) 2017 Gregor Mitscha-Baude
import dolfin
import nanopores as nano
from nanopores.tools import fields
from nanopores.models import nanopore
from nanopores.tools.poreplots import streamlines
from nanopores.geometries.allpores import WeiPore
from nanopores.tools.polygons import MultiPolygon, Polygon
from nanopores.models.diffusion_interpolation import diffusivity_field
params = nano.user_params(
geoname="wei",
h=5.,
Nmax=4e4,
dim=2,
x0=None,
rMolecule=6.,
Qmol=-1.,
bV=-0.5,
)
fields.set_dir_dropbox()
name = "wei_force_ps"
if not fields.exists(name, **params):
setup = nanopore.Setup(**params)
_, pnps = nanopore.solve(setup, True)
v, cp, cm, u, p = pnps.solutions()
F, Fel, Fdrag = setup.phys.ForceField(v, u, "fluid")
fields.save_functions(name, params, F=F, Fel=Fel, Fdrag=Fdrag)
fields.update()
# (c) 2017 Gregor Mitscha-Baude
import dolfin
import os, sys
import numpy as np
from nanopores.models.pughpore import *
from nanopores import user_params
setup = Setup(**user_params(dim=3,
h=2.,
Nmax=5e5,
x0=[0., 0., 0.],
diffusivity="Dpugh2",
cheapest=True,
diamPore=6.))
setup.prerefine()
set_D(setup)
dim = setup.phys.dim
setup.plot(setup.phys.Dp[dim - 1, dim - 1], interactive=True)
import numpy
import nanopores
import matplotlib.pyplot as plt
from selectivity import selectivity, default
Qs = [-1., -3.]
label = r"$Q = %.0f$"
default = nanopores.user_params(**default)
def avg(J):
n = len(J)
J0 = list(numpy.array(J)[n * 0.2:n * 0.5])
return sum(J0) / len(J0)
Javg = []
for Q in Qs:
params = dict(default)
params["Qmol"] = Q
results = selectivity(**params)
t = results["time"]
J = results["current"]
rel = results["release"]
params0 = results["params"]
plt.figure(0)
plt.semilogx(t, rel, "x-", label=label % Q)
plt.xlabel("time [s]")
from nanopores.models import nanopore
from nanopores.tools.poreplots import streamlines
from nanopores.tools import fields
dolfin.parameters["allow_extrapolation"] = True #False #TODO:
params = nanopores.user_params(
# general params
geoname="wei",
dim=2,
rMolecule=6.,
h=5.,
Nmax=4e4,
Qmol=-1.,
bV=-0.2,
posDTarget=True,
x0=None,
# random walk params
N=100, # number of (simultaneous) random walks
dt=10., # time step [ns]
walldist=1., # in multiples of radius, should be >= 1
margtop=40.,
margbot=20.,
initial="disc", # oder "sphere"
)
# domains are places where molecule can bind
# and/or be reflected after collision
domain_params = dict(
cyl=False, # determines whether rz or xyz coordinates are passed to .inside
walldist=1., # multiple of radius that determines what counts as collision
# (c) 2016 Gregor Mitscha-Baude
import dolfin
import nanopores as nano
import nanopores.tools.box as box
import nanopores.geometries.pughpore as pughpore
from nanopores.geometries.curved import Sphere
#from nanopores.models.mysolve import pbpnps
import nanopores.physics.simplepnps as simplepnps
import solvers
up = nano.user_params(
#up = nano.Params( # for iPython
h=2.,
Qmol=-1.,
Nmax=1e5,
R=30.,
)
geop = nano.Params(R=up.R, H=80., x0=[0., 0., 15.])
physp = nano.Params(
Qmol=up.Qmol,
bulkcon=300.,
dnaqsdamp=.5,
bV=-0.1,
)
solverp = nano.Params(
h=up.h,
frac=0.2,
Nmax=up.Nmax,
imax=30,
tol=1e-2,
params = nanopores.user_params(
# general params
# geo
geoname="pughcyl",
dim=2,
diamPore=6.,
rMolecule=2.0779,
R=40.,
Htop=60.,
Hbot=35.,
geop=dict(R=40., Htop=60., Hbot=35.),
x0=None,
# physics
Qmol=5.,
bulkcon=1000.,
dnaqsdamp=0.7353,
bV=-0.1,
posDTarget=True,
# solver
h=2.,
frac=0.5,
Nmax=5e4,
imax=30,
tol=1e-3,
cheapest=False,
stokesiter=False, #True
hybrid=True,
reconstruct=False,
# random walk params
N=100, # number of (simultaneous) random walks
dt=.2, # time step [ns]
walldist=1., # in multiples of radius, should be >= 1
margtop=15., # 35 is about the maximum
margbot=0.,
rstart=5.,
initial="sphere",
# receptor params
bind_everywhere=False,
lbind=8., # length of binding zone for long binding [nm]
ra=.2, # binding zone radius [nm] (1nm means whole channel)
collect_stats_mode=True,
)
params = nanopores.user_params(
# general params
# geo
geoname="pughcyl",
dim=2,
diamPore=6.,
rMolecule=2.0779,
R=40.,
Htop=60.,
Hbot=35.,
geop=dict(R=40., Htop=60., Hbot=35.),
x0=None,
# physics
Qmol=5.,
bulkcon=1000.,
dnaqsdamp=0.7353,
bV=-0.1,
posDTarget=True,
# solver
h=2.,
frac=0.5,
Nmax=5e4,
imax=30,
tol=1e-3,
cheapest=False,
stokesiter=False, #True
hybrid=True,
reconstruct=False,
# random walk params
N=100, # number of (simultaneous) random walks
dt=.3, # time step [ns]
walldist=1.2, # in multiples of radius, should be >= 1
margtop=35.,
margbot=0.,
rstart=5.,
initial="sphere",
# receptor params
lbind=4., # length of binding zone for long binding [nm]
)
#from nanopores.geometries import pughpore
import numpy as np
from nanopores.models import pughpore as pugh
from nanopores.tools.interpolation import harmonic_interpolation
from eikonal import distance_boundary_from_geo
from scipy.interpolate import interp1d
from folders import fields as f
import dolfin
import nanopores
# read user parameters
params = nanopores.user_params(
# dim = 3,
# h = 2.,
# Nmax = 2e6,
dim=2,
h=1.,
Nmax=1e5,
r=2.0779,
)
print "params", params
if not f.exists("Dpugh", **params):
# build 1D interpolations from data
data = f.get_fields("pugh_diff2D", rMolecule=params.r)
z = [x[2] for x in data["x"]]
data, z = f._sorted(data, z)
Dz = data["D"]
data = f.get_fields("pugh_diff3D", rMolecule=params.r, bulkbc=True)
x = [x[0] for x in data["x"]]
# (c) 2017 Gregor Mitscha-Baude
import numpy as np
from nanopores.tools.polygons import Ball, Polygon, MultiPolygon, MultiPolygonPore
from nanopores.geometries.cylpore import MultiPore
from nanopores import user_params
params = user_params(
R = 100.,
R0 = 60.,
H0 = 70.,
H = 150.,
x0 = [0, 0, 46],
rMolecule = 2.1,
dim = 3,
no_membrane = True,
r0 = 13, # pore radius
angle = 40, # aperture angle in degrees
lcCenter = 0.3,
lcMolecule = 0.1,
h = 10.,
subs = "solid",
reconstruct = False,
poreregion = True,
)
# SiN membrane thickness (in vertical direction)
lsin = 50.
# Au membrane thickness (in vertical direction)
lau = 40.
# Au thickness in radial direction
rlau = 10.
# SAM layer thickness (in vertical direction)
# (c) 2017 Gregor Mitscha-Baude
import numpy as np
import dolfin, os
import nanopores
from nanopores.models.pughpore import Plotter
from nanopores.models.diffusion_interpolation import get_pugh_diffusivity_alt
from nanopores.tools import fields
fields.set_dir(os.path.expanduser("~") + "/Dropbox/nanopores/fields")
params = nanopores.user_params(dim=3, r=2.0779, h=1., Nmax=.5e6)
functions = get_pugh_diffusivity_alt(**params)
D = functions["D"]
print D([0.,0.,0.])
#D = dolfin.as_matrix(np.diag([D[i] for i in range(params.dim)]))
plotter = Plotter()
plotter.plot(functions["D"][0], title="Dx")
plotter.plot(functions["D"][1], title="Dz")
plotter.plot(functions["dist"], title="dist")
dolfin.interactive()
3: dict(name="Dpugh", Nmax=2e6, dim=3, r=0.11, h=2.0)
}
physp = dict(
bV=-0.08,
Qmol=5.,
bulkcon=1000.,
dnaqsdamp=0.5882,
)
default = {
2:
dict(physp, dim=2, h=.75, Nmax=1e5, diffusivity_data=ddata[2]),
3:
dict(physp,
dim=3,
h=1.25,
Nmax=7e5,
diffusivity_data=ddata[3],
stokesiter=True)
}
dim = 3
params = user_params(default[dim])
ran = np.linspace(-30, 30, 10)
X = [[0., 0., t] for t in ran]
result = pugh.F_explicit(X, name="pugh_test", **params)
print result
print result["J"]
# (c) 2017 Gregor Mitscha-Baude
import nanopores
from nanopores.models.randomwalk import (get_pore, RandomWalk, Ball, run)
params = nanopores.user_params(
# general params
geoname = "alphahem",
dim = 2,
rMolecule = .25,
h = 1.,
Nmax = 4e4,
Qmol = 1.,
bV = -0.4,
# random walk params
N = 100, # number of (simultaneous) random walks
dt = 1e-2, # time step [ns]
walldist = 2., # in multiples of radius, should be >= 1
margtop = 2.,
margbot = .5,
rstart = 0.1,
zstart = -5.,
)
pore = get_pore(**params)
rw = RandomWalk(pore, **params)
#receptor = Ball([1., 0., -30.], 8.)
#rw.add_domain(receptor, exclusion=True, walldist=1.,
# binding=True, eps=1., t=1e6, p=0.1)
rw.add_wall_binding(t=1e4, p=0.1, eps=0.1)
run(rw, "rw_ahem", a=-9, b=3, save_count=1000)
