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:"