def getthecoeffs(N=None, Re=None, scheme='CR', inivp='Stokes', inifemp=None): femp, stokesmatsc, rhsmomcont \ = dnsps.get_sysmats(problem='cylinderwake', N=N, Re=Re, scheme=scheme, mergerhs=True) fp = rhsmomcont['fp'] fv = rhsmomcont['fv'] # stokesmatsc.update(rhsmomcont) J, MP = stokesmatsc['J'], stokesmatsc['MP'] NV, NP = J.T.shape # Nv = J.shape[1] # Mpfac = spsla.splu(MP) if inivp is 'Stokes': inivp = lau.solve_sadpnt_smw(amat=stokesmatsc['A'], jmat=J, jmatT=-J.T, rhsv=fv, rhsp=fp) iniv = inivp[:NV] inip = snu.get_pfromv(v=iniv, V=femp['V'], M=stokesmatsc['M'], A=stokesmatsc['A'], J=J, fv=fv, fp=fp, diribcs=femp['diribcs'], invinds=femp['invinds']) else: inv, inp = dts.expand_vp_dolfunc(vp=inivp, **inifemp) # interpolate on new mesh and extract the invinds getconvvec = getconvvecfun(**femp) return dict(A=stokesmatsc['A'], M=stokesmatsc['M'], J=J, JT=J.T, MP=MP, fp=fp, fv=fv, getconvvec=getconvvec, iniv=iniv, inip=inip, V=femp['V'], Q=femp['Q'], invinds=femp['invinds'], diribcs=femp['diribcs'], ppin=femp['ppin'], femp=femp)
def compvperror(reffemp=None, vref=None, pref=None, curfemp=None, vcur=None, pcur=None): try: verf, perf = dts.expand_vp_dolfunc(vc=vref-vcur, pc=pref-pcur, zerodiribcs=True, **reffemp) verr = dolfin.norm(verf) perr = dolfin.norm(perf) # vreff, preff = dts.expand_vp_dolfunc(vc=vref, pc=pref, **reffemp) # vcurf, pcurf = dts.expand_vp_dolfunc(vc=vcur, pc=pcur, **curfemp) # verr = dolfin.norm(vreff - vcurf) # perr = dolfin.norm(preff - pcurf) except ValueError: # obviously not the same FEM spaces vreff, preff = dts.expand_vp_dolfunc(vc=vref, pc=pref, **reffemp) vcurf, pcurf = dts.expand_vp_dolfunc(vc=vcur, pc=pcur, **curfemp) verr = dolfin.errornorm(vreff, vcurf) perr = dolfin.errornorm(preff, pcurf) return verr, perr
def plotit(vp, t): if plotplease: v, p = dts.expand_vp_dolfunc(vp=vp, **femp) v.rename('v', 'velocity') p.rename('p', 'pressure') vfile << v, t pfile << p, t else: return
def test_expand_condense_vfuncs(self): """check the expansion of vectors to dolfin funcs """ from dolfin_navier_scipy.dolfin_to_sparrays import expand_vp_dolfunc u = dolfin.Expression(('x[1]', '0'), element=self.V.ufl_element()) ufun = dolfin.project(u, self.V, solver_type='lu') uvec = ufun.vector().get_local().reshape(len(ufun.vector()), 1) # Boundaries def top(x, on_boundary): return x[1] > 1.0 - dolfin.DOLFIN_EPS def leftbotright(x, on_boundary): return (x[0] > 1.0 - dolfin.DOLFIN_EPS or x[1] < dolfin.DOLFIN_EPS or x[0] < dolfin.DOLFIN_EPS) # No-slip boundary condition for velocity noslip = u bc0 = dolfin.DirichletBC(self.V, noslip, leftbotright) # Boundary condition for velocity at the lid lid = u bc1 = dolfin.DirichletBC(self.V, lid, top) # Collect boundary conditions diribcs = [bc0, bc1] bcinds = [] for bc in diribcs: bcdict = bc.get_boundary_values() bcinds.extend(bcdict.keys()) # indices of the innernodes innerinds = np.setdiff1d(range(self.V.dim()), bcinds).astype(np.int32) # take only the inner nodes uvec_condensed = uvec[innerinds, ] v, p = expand_vp_dolfunc(V=self.V, vc=uvec_condensed, invinds=innerinds, diribcs=diribcs) vvec = v.vector().get_local().reshape(len(v.vector()), 1) self.assertTrue(np.allclose(uvec, vvec))
def record_ldt(t, vel=None, p=None, memory={}, mode='abtwo'): rotval = 0. if mode == 'stokes': memory.update(dict(lastt=t)) return rotval, memory if mode == 'init': memory.update(dict(lastt=t)) return rotval, memory vfun, pfun = dts.expand_vp_dolfunc(vc=vel, pc=p, **femp) if mode == 'heunpred' or mode == 'heuncorr': curdt = t - memory['lastt'] if mode == 'heunpred': memory.update(dict(lastv=vel)) pass elif mode == 'heuncorr': lvfun = dts.expand_vp_dolfunc(vc=memory['lastv'], **femp)[0] trqe = euleres(vfun, pfun, curdt, lastvel=lvfun, phi=phitwo) lift = euleres(vfun, pfun, curdt, lastvel=lvfun, phi=poy) drag = euleres(vfun, pfun, curdt, lastvel=lvfun, phi=pox) memory.update(dict(lastt=t, lastdt=curdt, heunpred=vel)) memory['trqs'].append(trqe) memory['lfts'].append(lift) memory['drgs'].append(drag) memory['tims'].append(t) elif mode == 'abtwo': lvfun = dts.expand_vp_dolfunc(vc=memory['lastv'], **femp)[0] curdt = t - memory['lastt'] try: ovfn = dts.expand_vp_dolfunc(vc=memory['lastlastv'], **femp)[0] modres = abtwres except KeyError: # no lastlastv yet -- we can check the Heun res ovfn = dts.expand_vp_dolfunc(vc=memory['heunpred'], **femp)[0] modres = heunres trqe = modres(vfun, pfun, curdt, lastvel=lvfun, othervel=ovfn, phi=phitwo) lift = modres(vfun, pfun, curdt, lastvel=lvfun, othervel=ovfn, phi=poy) drag = modres(vfun, pfun, curdt, lastvel=lvfun, othervel=ovfn, phi=pox) memory.update(dict(lastlastv=np.copy(memory['lastv']))) memory.update(dict(lastv=vel)) memory['trqs'].append(trqe) memory['lfts'].append(lift) memory['drgs'].append(drag) memory['tims'].append(t) memory.update(dict(lastt=t, lastdt=curdt)) deltap = pfun(a_1) - pfun(a_2) memory['dtps'].append(deltap) return rotval, memory
def test_residuals(self): femp, stokesmatsc, rhsd = \ dnsps.get_sysmats(problem=self.problem, nu=self.nu, bccontrol=False, charvel=self.charvel, scheme=self.scheme, mergerhs=True, meshparams=self.meshparams) # setting some parameters t0 = 0.0 tE = .1 Nts = 2 tips = dict(t0=t0, tE=tE, Nts=Nts) soldict = stokesmatsc # containing A, J, JT soldict.update(femp) # adding V, Q, invinds, diribcs soldict.update(tips) # adding time integration params soldict.update(fv=rhsd['fv'], fp=rhsd['fp'], treat_nonl_explct=True, return_vp_dict=True, no_data_caching=True, start_ssstokes=True) vpdct = snu.solve_nse(**soldict) M, A, JT = stokesmatsc['M'], stokesmatsc['A'], stokesmatsc['JT'] fv = rhsd['fv'] V, invinds = femp['V'], femp['invinds'] dt = (tE - t0) / Nts tm = (tE - t0) / 2 reschkdict = dict(V=V, nu=self.nu, gradvsymmtrc=True, outflowds=femp['outflowds']) euleres = get_imex_res(explscheme='eule', **reschkdict) heunres = get_imex_res(explscheme='heun', **reschkdict) crnires = get_imex_res(explscheme='abtw', **reschkdict) # the initial value inivwbcs = vpdct[t0]['v'] iniv = inivwbcs[invinds] iniconvvec = dts.get_convvec(V=V, u0_vec=inivwbcs, invinds=invinds) inivelfun = dts.expand_vp_dolfunc(vc=inivwbcs, **femp)[0] # the Heun prediction step cneevwbcs = vpdct[(tm, 'heunpred')]['v'] cneev = cneevwbcs[invinds] cneep = vpdct[(tm, 'heunpred')]['p'] # the Heun step cnhevwbcs = vpdct[tm]['v'] cnhev = cnhevwbcs[invinds] cnhep = vpdct[tm]['p'] hpconvvec = dts.get_convvec(V=V, u0_vec=cneevwbcs, invinds=invinds) hpvelfun = dts.expand_vp_dolfunc(vc=cneevwbcs, **femp)[0] # the AB2 step cnabvwbcs = vpdct[tE]['v'] cnabv = cnabvwbcs[invinds] cnabp = vpdct[tE]['p'] hcconvvec = dts.get_convvec(V=V, u0_vec=cnhevwbcs, invinds=invinds) hcvelfun = dts.expand_vp_dolfunc(vc=cnhevwbcs, **femp)[0] print('Heun-Prediction: one step of Euler') resvec = (1. / dt * M * (cneev - iniv) + .5 * A * (iniv + cneev) + iniconvvec - JT * cneep - fv) hpscres = np.linalg.norm(resvec) print('Scipy residual: ', hpscres) curv, curp = dts.expand_vp_dolfunc(vc=cneevwbcs, pc=cneep, **femp) res = euleres(curv, curp, dt, lastvel=inivelfun) hpfnres = np.linalg.norm(res.get_local()[invinds]) print('dolfin residua: ', hpfnres) self.assertTrue(np.allclose(hpfnres, 0.)) self.assertTrue(np.allclose(hpscres, 0.)) print('\nHeun-Step:') heunrhs = M * iniv - .5 * dt * \ (A * iniv + iniconvvec + hpconvvec) + dt * fv matvp = M * cnhev + .5 * dt * A * cnhev - dt * JT * cnhep hcscres = np.linalg.norm(matvp - heunrhs) print('Scipy residual: ', hcscres) # import ipdb; ipdb.set_trace() curv, curp = dts.expand_vp_dolfunc(vc=cnhevwbcs, pc=cnhep, **femp) heunres = heunres(curv, curp, dt, lastvel=inivelfun, othervel=hpvelfun) hcfnres = np.linalg.norm(heunres.get_local()[invinds]) print('dolfin residua: ', hcfnres) self.assertTrue(np.allclose(hcfnres, 0.)) self.assertTrue(np.allclose(hcscres, 0.)) print('\nAB2-Step:') abtrhs = M * cnhev - .5 * dt * \ (A * cnhev + -iniconvvec + 3. * hcconvvec) + dt * fv matvp = M * cnabv + .5 * dt * A * cnabv - dt * JT * cnabp abscres = np.linalg.norm(matvp - abtrhs) print('Scipy residual: ', abscres) # import ipdb; ipdb.set_trace() curv, curp = dts.expand_vp_dolfunc(vc=cnabvwbcs, pc=cnabp, **femp) crnires = crnires(curv, curp, dt, lastvel=hcvelfun, othervel=inivelfun) abfnres = np.linalg.norm(crnires.get_local()[invinds]) print('dolfin residua: ', abfnres) self.assertTrue(np.allclose(abfnres, 0.)) self.assertTrue(np.allclose(abscres, 0.))
problemname = 'cylinderwake' N = 2 Nref = 3 Re = 10 femp, stokesmatsc, rhsd = dnsps.get_sysmats(problem=problemname, N=N, Re=Re, mergerhs=True) soldict = stokesmatsc # containing A, J, JT soldict.update(femp) # adding V, Q, invinds, diribcs soldict.update(rhsd) # adding the discrete rhs v_ss_nse, list_norm_nwtnupd = snu.solve_steadystate_nse(N=N, **soldict) vwbc = dts.append_bcs_vec(v_ss_nse, **femp) vwbcf, _ = dts.expand_vp_dolfunc(vc=vwbc, V=femp['V']) fempref, stokesmatsc, rhsd = dnsps.get_sysmats(problem=problemname, N=Nref, Re=Re, mergerhs=True) Vref = fempref['V'] class ExtFunZero(dolfin.Expression): def __init__(self, vfun=None): self.vfun = vfun def eval(self, value, x): try: self.vfun.eval(value, x) except RuntimeError: value[0] = 0.0
def testit(problem=None, nu=None, charvel=None, Re=None, meshlvl=1, rho=1., t0=0.0, tE=1.0, Nts=1e2+1, ParaviewOutput=False, scheme='TH'): meshfile = 'mesh/karman2D-rotcyl_lvl{0}.xml.gz'.format(meshlvl) physregs = 'mesh/karman2D-rotcyl_lvl{0}_facet_region.xml.gz'.\ format(meshlvl) femp, stokesmatsc, rhsd = \ dnsps.get_sysmats(problem='cylinder_rot', nu=nu, bccontrol=False, charvel=charvel, scheme=scheme, mergerhs=True, meshparams=dict(strtomeshfile=meshfile, strtophysicalregions=physregs, strtobcsobs=geodata)) ddir = 'data/' data_prfx = problem + '{4}_mesh{0}_Re{1}_Nts{2}_tE{3}'.\ format(meshlvl, femp['Re'], Nts, tE, scheme) tips = dict(t0=t0, tE=tE, Nts=Nts) # ## Parameters for the benchmark values Um = charvel # (we alread scale the inflow parabola accordingly) L = femp['charlen'] # characteristic length NP, NV = stokesmatsc['J'].shape print('NV + NP : {0} + {1} = {2}'.format(NV, NP, NV+NP)) def rotcont(t, vel): return 0. dircntdict = dict(diricontbcinds=[femp['mvwbcinds']], diricontbcvals=[femp['mvwbcvals']], diricontfuncs=[rotcont]) soldict = stokesmatsc # containing A, J, JT soldict.update(femp) # adding V, Q, invinds, diribcs soldict.update(tips) # adding time integration params soldict.update(dircntdict) soldict.update(fv=rhsd['fv'], fp=rhsd['fp'], N=meshlvl, nu=nu, # start_ssstokes=True, verbose=True, return_vp=True, iniv=0*rhsd['fv'], get_datastring=None, comp_nonl_semexp=True, dbcinds=femp['dbcinds'], dbcvals=femp['dbcvals'], data_prfx=ddir+data_prfx, paraviewoutput=ParaviewOutput, vfileprfx=proutdir+'vel_', pfileprfx=proutdir+'p_') # # compute the uncontrolled steady state Navier-Stokes solution # vp_ss_nse = snu.solve_steadystate_nse(**soldict) vss, dynpss = dts.expand_vp_dolfunc(vc=vp_ss_nse[0], pc=vp_ss_nse[1], **femp) realpss = rho*dynpss # Um**2*rho*dynpss realvss = vss # Um*vss getld = dnsps.LiftDragSurfForce(V=femp['V'], nu=nu, ldds=femp['liftdragds']) clift, cdrag = getld.evaliftdragforce(u=realvss, p=realpss) cdclfac = 2./(rho*L*Um**2) print('Cl: {0}'.format(cdclfac*clift)) print('Cd: {0}'.format(cdclfac*cdrag)) import dolfin a_1 = dolfin.Point(0.15, 0.2) a_2 = dolfin.Point(0.25, 0.2) pdiff = realpss(a_1) - realpss(a_2) print('Delta P: {0}'.format(pdiff)) print('\n values from Schaefer/Turek as in') print('www.featflow.de/en/benchmarks/cfdbenchmarking/flow/' + 'dfg_benchmark1_re20.html:') print('Cl: {0}'.format(0.010618948146)) print('Cd: {0}'.format(5.57953523384)) print('Delta P: {0}'.format(0.11752016697))
def testit(problem=None, nu=None, charvel=None, Re=None, meshlvl=1, gradvsymmtrc=True, rho=1., ParaviewOutput=False, scheme='TH'): meshfile = 'mesh/karman2D-rotcyl_lvl{0}.xml.gz'.format(meshlvl) physregs = 'mesh/karman2D-rotcyl_lvl{0}_facet_region.xml.gz'.\ format(meshlvl) femp, stokesmatsc, rhsd = \ dnsps.get_sysmats(problem=problem, nu=nu, charvel=charvel, gradvsymmtrc=gradvsymmtrc, scheme=scheme, mergerhs=True, meshparams=dict(strtomeshfile=meshfile, movingwallcntrl=False, strtophysicalregions=physregs, strtobcsobs=geodata)) ddir = 'data/' data_prfx = problem + '{2}_mesh{0}_Re{1}'.format(meshlvl, femp['Re'], scheme) # ## Parameters for the benchmark values Um = charvel # (we alread scale the inflow parabola accordingly) L = femp['charlen'] # characteristic length NP, NV = stokesmatsc['J'].shape print('NV + NP : {0} + {1} = {2}'.format(NV, NP, NV + NP)) soldict = stokesmatsc # containing A, J, JT # soldict.update(femp) # adding V, Q, invinds, diribcs soldict.update(invinds=femp['invinds'], V=femp['V'], Q=femp['Q']) soldict.update(fv=rhsd['fv'], fp=rhsd['fp'], N=meshlvl, nu=nu, verbose=True, return_vp=True, get_datastring=None, dbcinds=femp['dbcinds'], dbcvals=femp['dbcvals'], data_prfx=ddir + data_prfx, paraviewoutput=ParaviewOutput, vfileprfx=proutdir + 'vel_', pfileprfx=proutdir + 'p_') # # compute the uncontrolled steady state Navier-Stokes solution # vp_ss_nse = snu.solve_steadystate_nse(**soldict) vss, dynpss = dts.expand_vp_dolfunc(vc=vp_ss_nse[0], pc=vp_ss_nse[1], **femp) steady_state_res = \ get_steady_state_res(V=femp['V'], gradvsymmtrc=True, outflowds=femp['outflowds'], nu=nu) res = steady_state_res(vss, rho * dynpss) auxvec = np.zeros((femp['V'].dim(), )) invinds = femp['invinds'] auxvec[invinds] = res.get_local()[invinds] print('two norm of the res: {0}'.format(np.linalg.norm(auxvec))) phionevec = np.zeros((femp['V'].dim(), 1)) phionevec[femp['ldsbcinds'], :] = 1. phione = dolfin.Function(femp['V']) phione.vector().set_local(phionevec) pickx = dolfin.as_matrix([[1., 0.], [0., 0.]]) picky = dolfin.as_matrix([[0., 0.], [0., 1.]]) pox = pickx * phione poy = picky * phione drag = steady_state_res(vss, rho * dynpss, phi=pox) lift = steady_state_res(vss, rho * dynpss, phi=poy) cdclfac = 2. / (rho * L * Um**2) print('Computed via testing the residual: ') print('Cl: {0}'.format(cdclfac * lift)) print('Cd: {0}'.format(cdclfac * drag)) phionevec = np.zeros((femp['V'].dim(), 1)) phionevec[femp['ldsbcinds'], :] = 1. phione = dolfin.Function(femp['V']) phione.vector().set_local(phionevec) # phionex = phione.sub(0) print('Computed via `dnsps.LiftDragSurfForce`:') realpss = rho * dynpss # Um**2*rho*dynpss realvss = vss # Um*vss getld = dnsps.LiftDragSurfForce(V=femp['V'], nu=nu, ldds=femp['liftdragds'], outflowds=femp['outflowds'], phione=phione) clift, cdrag = getld.evaliftdragforce(u=realvss, p=realpss) print('Cl: {0}'.format(cdclfac * clift)) print('Cd: {0}'.format(cdclfac * cdrag)) a_1 = dolfin.Point(0.15, 0.2) a_2 = dolfin.Point(0.25, 0.2) pdiff = realpss(a_1) - realpss(a_2) print('Delta P: {0}'.format(pdiff)) print('\n values from Schaefer/Turek as in') print('www.featflow.de/en/benchmarks/cfdbenchmarking/flow/' + 'dfg_benchmark1_re20.html:') print('Cl: {0}'.format(0.010618948146)) print('Cd: {0}'.format(5.57953523384)) print('Delta P: {0}'.format(0.11752016697))