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()