def do_demo(): """ show examples of the patch methods / classes """ import util.io as io # illustrate basic mesh operations myg = Grid2d(8, 16, xmax=1.0, ymax=2.0) mydata = CellCenterData2d(myg) bc = bnd.BC() mydata.register_var("a", bc) mydata.create() a = mydata.get_var("a") a[:, :] = np.exp(-(myg.x2d - 0.5)**2 - (myg.y2d - 1.0)**2) print(mydata) # output print("writing\n") mydata.write("mesh_test") print("reading\n") myd2 = io.read("mesh_test") print(myd2) mydata.pretty_print("a")
def do_demo(): """ show examples of the patch methods / classes """ import util.io as io # illustrate basic mesh operations myg = Grid2d(8, 16, xmax=1.0, ymax=2.0) mydata = CellCenterData2d(myg) bc = bnd.BC() mydata.register_var("a", bc) mydata.create() a = mydata.get_var("a") a[:, :] = np.exp(-(myg.x2d - 0.5)**2 - (myg.y2d - 1.0)**2) print(mydata) # output print("writing\n") mydata.write("mesh_test") print("reading\n") myd2 = io.read("mesh_test") print(myd2) mydata.pretty_print("a")
def makeplot(plotfile, variable, outfile): sim = io.read(plotfile) myd = sim.cc_data myg = myd.grid if variable == "vort": vx = myd.get_var("x-velocity") vy = myd.get_var("y-velocity") v = myg.scratch_array() v[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \ 0.5*(vy[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] - vy[myg.ilo-1:myg.ihi,myg.jlo:myg.jhi+1])/myg.dx - \ 0.5*(vx[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] - vx[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi])/myg.dy else: v = myd.get_var(variable) plt.figure(num=1, figsize=(6.0, 6.0), dpi=100, facecolor='w') plt.imshow(np.transpose(v[myg.ilo:myg.ihi + 1, myg.jlo:myg.jhi + 1]), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax]) plt.axis("off") plt.subplots_adjust(bottom=0.0, top=1.0, left=0.0, right=1.0) plt.savefig(outfile)
def makeplot(plotfile_name, outfile, width, height): """ plot the data in a plotfile using the solver's vis() method """ sim = io.read(plotfile_name) plt.figure(num=1, figsize=(width, height), dpi=100, facecolor='w') sim.dovis() if outfile.endswith(".pdf"): plt.savefig(outfile, bbox_inches="tight") else: plt.savefig(outfile)
def makeplot(basename, outfile, width, height): """ plot the data in a plotfile using the solver's vis() method """ files = glob.glob(basename + '_[0-9]*_[1-9][0-9]*.h5') print(files) sim_average = io.read(files[0]) sim_average.cc_data.get_vars()[:, :, :] = 0 for f in files: print(f) s = io.read(f) sim_average.cc_data.get_vars( )[:, :, :] += s.cc_data.get_vars()[:, :, :] / len(files) plt.figure(num=1, figsize=(width, height), dpi=100, facecolor='w') sim_average.dovis() if outfile.endswith(".pdf"): plt.savefig(outfile, bbox_inches="tight") else: plt.savefig(outfile) plt.show()
def makeplot(plotfile_name, outfile, width, height): """ plot the data in a plotfile using the solver's vis() method """ sim = io.read(plotfile_name) plt.figure(num=1, figsize=(width, height), dpi=100, facecolor='w') sim.dovis() if outfile.endswith(".pdf"): plt.savefig(outfile, bbox_inches="tight") else: plt.savefig(outfile) plt.show()
def makeplot(plotfile, variable, outfile, width=6.5, height=5.25, log=False, compact=False, quiet=False): sim = io.read(plotfile) if isinstance(sim, patch.CellCenterData2d): myd = sim else: myd = sim.cc_data myg = myd.grid plt.figure(num=1, figsize=(width, height), dpi=100, facecolor='w') var = myd.get_var(variable) if log: var = np.log10(var) img = plt.imshow(np.transpose(var.v()), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax]) if not compact: plt.colorbar(img) plt.xlabel("x") plt.ylabel("y") if compact: plt.axis("off") plt.subplots_adjust(bottom=0.0, top=1.0, left=0.0, right=1.0) plt.savefig(outfile) else: plt.savefig(outfile, bbox_inches="tight") if not quiet: plt.show()
def compare_to_benchmark(self): """ Are we comparing to a benchmark? """ basename = self.rp.get_param("io.basename") compare_file = "{}/tests/{}{:04d}".format(self.solver_name, basename, self.sim.n) msg.warning("comparing to: {} ".format(compare_file)) try: sim_bench = io.read(compare_file) except IOError: msg.warning("ERROR openning compare file") return "ERROR openning compare file" result = compare.compare(self.sim.cc_data, sim_bench.cc_data) if result == 0: msg.success("results match benchmark\n") else: msg.warning("ERROR: " + compare.errors[result] + "\n") return result
def test_write_read(): myg = patch.Grid2d(8, 6, ng=2, xmax=1.0, ymax=1.0) myd = patch.CellCenterData2d(myg) bco = bnd.BC(xlb="outflow", xrb="outflow", ylb="outflow", yrb="outflow") myd.register_var("a", bco) myd.create() a = myd.get_var("a") a.v()[:, :] = np.arange(48).reshape(8, 6) myd.write("io_test") # now read it in nd = io.read("io_test") anew = nd.get_var("a") assert_array_equal(anew.v(), a.v())
def makeplot(plotfile, variable, outfile): sim = io.read(plotfile) myd = sim.cc_data myg = myd.grid plt.figure(num=1, figsize=(6.5,5.25), dpi=100, facecolor='w') var = myd.get_var(variable) img = plt.imshow(np.transpose(var.v()), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax]) plt.colorbar() plt.xlabel("x") plt.ylabel("y") plt.savefig(outfile, bbox_inches="tight") plt.show()
def compare_to_benchmark(self, rtol): """ Are we comparing to a benchmark? """ basename = self.rp.get_param("io.basename") compare_file = "{}/tests/{}{:04d}".format( self.solver_name, basename, self.sim.n) msg.warning("comparing to: {} ".format(compare_file)) try: sim_bench = io.read(compare_file) except IOError: msg.warning("ERROR opening compare file") return "ERROR opening compare file" result = compare.compare(self.sim.cc_data, sim_bench.cc_data, rtol) if result == 0: msg.success("results match benchmark to within relative tolerance of {}\n".format(rtol)) else: msg.warning("ERROR: " + compare.errors[result] + "\n") return result
def test_write_read(): myg = patch.Grid2d(8, 6, ng=2, xmax=1.0, ymax=1.0) myd = patch.CellCenterData2d(myg) bco = bnd.BC(xlb="outflow", xrb="outflow", ylb="outflow", yrb="outflow") myd.register_var("a", bco) myd.create() a = myd.get_var("a") a.v()[:, :] = np.arange(48).reshape(8, 6) myd.write("io_test") # now read it in nd = io.read("io_test") anew = nd.get_var("a") assert_array_equal(anew.v(), a.v())
def makeplot(plotfile, variable, outfile, width=6.5, height=5.25, log=False, compact=False, quiet=False): sim = io.read(plotfile) if isinstance(sim, patch.CellCenterData2d): myd = sim else: myd = sim.cc_data myg = myd.grid plt.figure(num=1, figsize=(width, height), dpi=100, facecolor='w') var = myd.get_var(variable) if log: var = np.log10(var) plt.imshow(np.transpose(var.v()), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax]) if not compact: plt.colorbar() plt.xlabel("x") plt.ylabel("y") if compact: plt.axis("off") plt.subplots_adjust(bottom=0.0, top=1.0, left=0.0, right=1.0) plt.savefig(outfile) else: plt.savefig(outfile, bbox_inches="tight") if not quiet: plt.show()
def makeplot(plotfile, variable, outfile, vmin=None, vmax=None): sim = io.read(plotfile) myd = sim.cc_data myg = myd.grid if variable == "vort": vx = myd.get_var("x-velocity") vy = myd.get_var("y-velocity") v = myg.scratch_array() v[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1] = \ 0.5*(vy[myg.ilo+1:myg.ihi+2, myg.jlo:myg.jhi+1] - vy[myg.ilo-1:myg.ihi, myg.jlo:myg.jhi+1])/myg.dx - \ 0.5*(vx[myg.ilo:myg.ihi+1, myg.jlo+1:myg.jhi+2] - vx[myg.ilo:myg.ihi+1, myg.jlo-1:myg.jhi])/myg.dy else: v = myd.get_var(variable) if vmin is None: vmin = v.v().min() if vmax is None: vmax = v.v().max() plt.figure(num=1, figsize=(6.0, 6.0), dpi=100, facecolor='w') plt.imshow(np.transpose(v[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1]), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax], vmin=vmin, vmax=vmax) plt.axis("off") plt.subplots_adjust(bottom=0.0, top=1.0, left=0.0, right=1.0) plt.savefig(outfile)
def process(file): # read the data and convert to the primitive variables (and # velocity magnitude) sim = io.read(file) myd = sim.cc_data myg = myd.grid phi_t = myd.get_var("phi") phi = phi_t[myg.ilo:myg.ihi + 1, myg.jlo:myg.jhi + 1] # get the problem parameters t_0 = myd.get_aux("t_0") phi_0 = myd.get_aux("phi_0") phi_max = myd.get_aux("phi_max") k = myd.get_aux("k") t = myd.t # radially bin # see http://code.google.com/p/agpy/source/browse/trunk/agpy/radialprofile.py?r=317 # for inspiration # first define the bins rmin = 0 rmax = np.sqrt(myg.xmax**2 + myg.ymax**2) nbins = np.int(np.sqrt(myg.nx**2 + myg.ny**2)) # bins holds the edges, so there is one more value than actual bin # bin_centers holds the center value of the bin bins = np.linspace(rmin, rmax, nbins + 1) bin_centers = 0.5 * (bins[1:] + bins[:-1]) # radius of each zone xcenter = 0.5 * (myg.xmin + myg.xmax) ycenter = 0.5 * (myg.ymin + myg.ymax) r = np.sqrt( (myg.x2d[myg.ilo:myg.ihi + 1, myg.jlo:myg.jhi + 1] - xcenter)**2 + (myg.y2d[myg.ilo:myg.ihi + 1, myg.jlo:myg.jhi + 1] - ycenter)**2) # bin the radii -- digitize returns an array with the same shape # as the input array but with elements of the array specifying # which bin that location belongs to. The value of whichbin will # be 1 if we are located in the bin defined by bins[0] to bins[1]. # This means that there will be no 0s whichbin = np.digitize(r.flat, bins) # bincount counts the number of occurrences of each non-negative # integer value in whichbin. Each entry in ncount gives the # number of occurrences of it in whichbin. The length of ncount # is set by the maximum value in whichbin ncount = np.bincount(whichbin) # now bin the associated data phi_bin = np.zeros(len(ncount) - 1, dtype=np.float64) for n in range(len(ncount)): # remember that there are no whichbin == 0, since that # corresponds to the left edge. So we want whichbin == 1 to # correspond to the first value of bin_centers # (bin_centers[0]) phi_bin[n - 1] = np.sum(phi.flat[whichbin == n]) / np.sum(ncount[n]) bin_centers = bin_centers[0:len(ncount) - 1] # get the analytic solution phi_exact = gaussian.phi_analytic(bin_centers, t, t_0, k, phi_0, phi_max) return bin_centers, phi_exact, phi_bin
def doit(solver_name, problem_name, param_file, other_commands=None, comp_bench=False, reset_bench_on_fail=False, make_bench=False): """The main driver to run pyro""" msg.bold('pyro ...') tc = profile.TimerCollection() tm_main = tc.timer("main") tm_main.begin() # import desired solver under "solver" namespace solver = importlib.import_module(solver_name) #------------------------------------------------------------------------- # runtime parameters #------------------------------------------------------------------------- # parameter defaults rp = runparams.RuntimeParameters() rp.load_params("_defaults") rp.load_params(solver_name + "/_defaults") # problem-specific runtime parameters rp.load_params(solver_name + "/problems/_" + problem_name + ".defaults") # now read in the inputs file if not os.path.isfile(param_file): # check if the param file lives in the solver's problems directory param_file = solver_name + "/problems/" + param_file if not os.path.isfile(param_file): msg.fail("ERROR: inputs file does not exist") rp.load_params(param_file, no_new=1) # and any commandline overrides if other_commands is not None: rp.command_line_params(other_commands) # write out the inputs.auto rp.print_paramfile() #------------------------------------------------------------------------- # initialization #------------------------------------------------------------------------- # initialize the Simulation object -- this will hold the grid and # data and know about the runtime parameters and which problem we # are running sim = solver.Simulation(solver_name, problem_name, rp, timers=tc) sim.initialize() sim.preevolve() #------------------------------------------------------------------------- # evolve #------------------------------------------------------------------------- verbose = rp.get_param("driver.verbose") plt.ion() sim.cc_data.t = 0.0 # output the 0th data basename = rp.get_param("io.basename") sim.write("{}{:04d}".format(basename, sim.n)) dovis = rp.get_param("vis.dovis") if dovis: plt.figure(num=1, figsize=(8, 6), dpi=100, facecolor='w') sim.dovis() while not sim.finished(): # fill boundary conditions sim.cc_data.fill_BC_all() # get the timestep sim.compute_timestep() # evolve for a single timestep sim.evolve() if verbose > 0: print("%5d %10.5f %10.5f" % (sim.n, sim.cc_data.t, sim.dt)) # output if sim.do_output(): if verbose > 0: msg.warning("outputting...") basename = rp.get_param("io.basename") sim.write("{}{:04d}".format(basename, sim.n)) # visualization if dovis: tm_vis = tc.timer("vis") tm_vis.begin() sim.dovis() store = rp.get_param("vis.store_images") if store == 1: basename = rp.get_param("io.basename") plt.savefig("{}{:04d}.png".format(basename, sim.n)) tm_vis.end() # final output if verbose > 0: msg.warning("outputting...") basename = rp.get_param("io.basename") sim.write("{}{:04d}".format(basename, sim.n)) tm_main.end() #------------------------------------------------------------------------- # benchmarks (for regression testing) #------------------------------------------------------------------------- result = 0 # are we comparing to a benchmark? if comp_bench: compare_file = "{}/tests/{}{:04d}".format( solver_name, basename, sim.n) msg.warning("comparing to: {} ".format(compare_file)) try: sim_bench = io.read(compare_file) except: msg.warning("ERROR openning compare file") return "ERROR openning compare file" result = compare.compare(sim.cc_data, sim_bench.cc_data) if result == 0: msg.success("results match benchmark\n") else: msg.warning("ERROR: " + compare.errors[result] + "\n") # are we storing a benchmark? if make_bench or (result != 0 and reset_bench_on_fail): if not os.path.isdir(solver_name + "/tests/"): try: os.mkdir(solver_name + "/tests/") except: msg.fail("ERROR: unable to create the solver's tests/ directory") bench_file = solver_name + "/tests/" + basename + "%4.4d" % (sim.n) msg.warning("storing new benchmark: {}\n".format(bench_file)) sim.write(bench_file) #------------------------------------------------------------------------- # final reports #------------------------------------------------------------------------- if verbose > 0: rp.print_unused_params() tc.report() sim.finalize() if comp_bench: return result
def test_poisson_dirichlet(N, store_bench=False, comp_bench=False, make_plot=False, verbose=1, rtol=1e-12): # test the multigrid solver nx = N ny = nx # create the multigrid object a = MG.CellCenterMG2d(nx, ny, xl_BC_type="dirichlet", yl_BC_type="dirichlet", xr_BC_type="dirichlet", yr_BC_type="dirichlet", verbose=verbose) # initialize the solution to 0 a.init_zeros() # initialize the RHS using the function f rhs = f(a.x2d, a.y2d) a.init_RHS(rhs) # solve to a relative tolerance of 1.e-11 a.solve(rtol=1.e-11) # alternately, we can just use smoothing by uncommenting the following # a.smooth(a.nlevels-1,50000) # get the solution v = a.get_solution() # compute the error from the analytic solution b = true(a.x2d, a.y2d) e = v - b print(" L2 error from true solution = %g\n rel. err from previous cycle = %g\n num. cycles = %d" % (e.norm(), a.relative_error, a.num_cycles)) # plot it if make_plot: plt.figure(num=1, figsize=(5.0, 5.0), dpi=100, facecolor='w') plt.imshow(np.transpose(v[a.ilo:a.ihi+1, a.jlo:a.jhi+1]), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") plt.savefig("mg_test.png") # store the output for later comparison bench = "mg_poisson_dirichlet" bench_dir = os.environ["PYRO_HOME"] + "/multigrid/tests/" my_data = a.get_solution_object() if store_bench: my_data.write("{}/{}".format(bench_dir, bench)) # do we do a comparison? if comp_bench: compare_file = "{}/{}".format(bench_dir, bench) msg.warning("comparing to: %s " % (compare_file)) bench_data = io.read(compare_file) result = compare.compare(my_data, bench_data, rtol) if result == 0: msg.success("results match benchmark to within relative tolerance of {}\n".format(rtol)) else: msg.warning("ERROR: " + compare.errors[result] + "\n") return result return None
usage = """ compare the output for a Sedov problem with the exact solution contained in cylindrical-sedov.out. To do this, we need to bin the Sedov data into radial bins.""" parser = argparse.ArgumentParser(description=usage) parser.add_argument("-o", type=str, default="sedov_compare.png", metavar="plot.png", help="output file name") parser.add_argument("plotfile", type=str, nargs=1, help="the plotfile you wish to plot") args = parser.parse_args() # read the data and convert to the primitive variables (and velocity # magnitude) sim = io.read(args.plotfile[0]) myd = sim.cc_data myg = myd.grid dens = myd.get_var("density") xmom = myd.get_var("x-momentum") ymom = myd.get_var("y-momentum") ener = myd.get_var("energy") rho = dens.v() u = np.sqrt(xmom.v()**2 + ymom.v()**2)/rho e = (ener.v() - 0.5*rho*u*u)/rho gamma = myd.get_aux("gamma") p = rho*e*(gamma - 1.0)
def test_poisson_dirichlet(N, store_bench=False, comp_bench=False, make_plot=False, verbose=1, rtol=1e-12): # test the multigrid solver nx = N ny = nx # create the multigrid object a = MG.CellCenterMG2d(nx, ny, xl_BC_type="dirichlet", yl_BC_type="dirichlet", xr_BC_type="dirichlet", yr_BC_type="dirichlet", verbose=verbose) # initialize the solution to 0 a.init_zeros() # initialize the RHS using the function f rhs = f(a.x2d, a.y2d) a.init_RHS(rhs) # solve to a relative tolerance of 1.e-11 a.solve(rtol=1.e-11) # alternately, we can just use smoothing by uncommenting the following # a.smooth(a.nlevels-1,50000) # get the solution v = a.get_solution() # compute the error from the analytic solution b = true(a.x2d, a.y2d) e = v - b print(" L2 error from true solution = %g\n rel. err from previous cycle = %g\n num. cycles = %d" % (e.norm(), a.relative_error, a.num_cycles)) # plot it if make_plot: plt.figure(num=1, figsize=(5.0, 5.0), dpi=100, facecolor='w') plt.imshow(np.transpose(v[a.ilo:a.ihi+1, a.jlo:a.jhi+1]), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") print("Saving figure to mg_test.png") plt.savefig("mg_test.png") # store the output for later comparison bench = "mg_poisson_dirichlet" bench_dir = os.environ["PYRO_HOME"] + "/multigrid/tests/" my_data = a.get_solution_object() if store_bench: my_data.write("{}/{}".format(bench_dir, bench)) # do we do a comparison? if comp_bench: compare_file = "{}/{}".format(bench_dir, bench) msg.warning("comparing to: %s " % (compare_file)) bench_data = io.read(compare_file) result = compare.compare(my_data, bench_data, rtol) if result == 0: msg.success("results match benchmark to within relative tolerance of {}\n".format(rtol)) else: msg.warning("ERROR: " + compare.errors[result] + "\n") return result return None
def abort(string): print(string) sys.exit(2) if not len(sys.argv) == 2: print(usage) sys.exit(2) try: file1 = sys.argv[1] except IndexError: print(usage) sys.exit(2) sim = io.read(file1) myd = sim.cc_data myg = myd.grid # time of file t = myd.t if myg.nx > myg.ny: # x-problem xmin = myg.xmin xmax = myg.xmax param_file = "inputs.dam.x" else: # y-problem xmin = myg.ymin xmax = myg.ymax param_file = "inputs.dam.y"
usage: ./convergence.py fine coarse """ def compare(fine, coarse): dens = coarse.get_var("density") dens_avg = fine.restrict("density", N=2) e = coarse.grid.scratch_array() e.v()[:, :] = dens.v() - dens_avg.v() return float(np.abs(e).max()), e.norm() if __name__ == "__main__": if not len(sys.argv) == 3: print(usage) sys.exit(2) fine = sys.argv[1] coarse = sys.argv[2] ff = io.read(fine) cc = io.read(coarse) result = compare(ff.cc_data, cc.cc_data) print("inf/L2 norm of density: ", result)
def process(file): # read the data and convert to the primitive variables (and # velocity magnitude) sim = io.read(file) myd = sim.cc_data myg = myd.grid phi_t = myd.get_var("phi") phi = phi_t[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1] # get the problem parameters t_0 = myd.get_aux("t_0") phi_0 = myd.get_aux("phi_0") phi_max = myd.get_aux("phi_max") k = myd.get_aux("k") t = myd.t # radially bin # see http://code.google.com/p/agpy/source/browse/trunk/agpy/radialprofile.py?r=317 # for inspiration # first define the bins rmin = 0 rmax = np.sqrt(myg.xmax**2 + myg.ymax**2) nbins = np.int(np.sqrt(myg.nx**2 + myg.ny**2)) # bins holds the edges, so there is one more value than actual bin # bin_centers holds the center value of the bin bins = np.linspace(rmin, rmax, nbins+1) bin_centers = 0.5*(bins[1:] + bins[:-1]) # radius of each zone xcenter = 0.5*(myg.xmin + myg.xmax) ycenter = 0.5*(myg.ymin + myg.ymax) r = np.sqrt((myg.x2d[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1] - xcenter)**2 + (myg.y2d[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1] - ycenter)**2) # bin the radii -- digitize returns an array with the same shape # as the input array but with elements of the array specifying # which bin that location belongs to. The value of whichbin will # be 1 if we are located in the bin defined by bins[0] to bins[1]. # This means that there will be no 0s whichbin = np.digitize(r.flat, bins) # bincount counts the number of occurrences of each non-negative # integer value in whichbin. Each entry in ncount gives the # number of occurrences of it in whichbin. The length of ncount # is set by the maximum value in whichbin ncount = np.bincount(whichbin) # now bin the associated data phi_bin = np.zeros(len(ncount)-1, dtype=np.float64) for n in range(len(ncount)): # remember that there are no whichbin == 0, since that # corresponds to the left edge. So we want whichbin == 1 to # correspond to the first value of bin_centers # (bin_centers[0]) phi_bin[n-1] = np.sum(phi.flat[whichbin == n])/np.sum(ncount[n]) bin_centers = bin_centers[0:len(ncount)-1] # get the analytic solution phi_exact = gaussian.phi_analytic(bin_centers, t, t_0, k, phi_0, phi_max) return bin_centers, phi_exact, phi_bin
else: print("{:20s} absolute error = {:10.10g}".format(name, abs_err)) if not np.allclose(d1.v(), d2.v(), rtol=rtol): result = "varerr" return result if __name__ == "__main__": if not (len(sys.argv) == 3 or len(sys.argv) == 4): print(usage) sys.exit(2) file1 = sys.argv[1] file2 = sys.argv[2] s1 = io.read(file1) s2 = io.read(file2) if len(sys.argv) == 3: result = compare(s1.cc_data, s2.cc_data) else: result = compare(s1.cc_data, s2.cc_data, rtol=float(sys.argv[3])) if result == 0: print("SUCCESS: files agree") else: print("ERROR: ", errors[result])
def test_general_poisson_dirichlet(N, store_bench=False, comp_bench=False, make_plot=False, verbose=1): """ test the general MG solver. The return value here is the error compared to the exact solution, UNLESS comp_bench=True, in which case the return value is the error compared to the stored benchmark """ # test the multigrid solver nx = N ny = nx # create the coefficient variable g = patch.Grid2d(nx, ny, ng=1) d = patch.CellCenterData2d(g) bc_c = bnd.BC(xlb="neumann", xrb="neumann", ylb="neumann", yrb="neumann") d.register_var("alpha", bc_c) d.register_var("beta", bc_c) d.register_var("gamma_x", bc_c) d.register_var("gamma_y", bc_c) d.create() a = d.get_var("alpha") a[:, :] = alpha(g.x2d, g.y2d) b = d.get_var("beta") b[:, :] = beta(g.x2d, g.y2d) gx = d.get_var("gamma_x") gx[:, :] = gamma_x(g.x2d, g.y2d) gy = d.get_var("gamma_y") gy[:, :] = gamma_y(g.x2d, g.y2d) # create the multigrid object a = MG.GeneralMG2d(nx, ny, xl_BC_type="dirichlet", yl_BC_type="dirichlet", xr_BC_type="dirichlet", yr_BC_type="dirichlet", coeffs=d, verbose=verbose, vis=0, true_function=true) # initialize the solution to 0 a.init_zeros() # initialize the RHS using the function f rhs = f(a.x2d, a.y2d) a.init_RHS(rhs) # solve to a relative tolerance of 1.e-11 a.solve(rtol=1.e-11) # alternately, we can just use smoothing by uncommenting the following # a.smooth(a.nlevels-1,50000) # get the solution v = a.get_solution() # compute the error from the analytic solution b = true(a.x2d, a.y2d) e = v - b enorm = e.norm() print( " L2 error from true solution = %g\n rel. err from previous cycle = %g\n num. cycles = %d" % (enorm, a.relative_error, a.num_cycles)) # plot the solution if make_plot: plt.clf() plt.figure(figsize=(10.0, 4.0), dpi=100, facecolor='w') plt.subplot(121) plt.imshow(np.transpose(v.v()), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") plt.title("nx = {}".format(nx)) plt.colorbar() plt.subplot(122) plt.imshow(np.transpose(e.v()), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") plt.title("error") plt.colorbar() plt.tight_layout() plt.savefig("mg_general_dirichlet_test.png") # store the output for later comparison bench = "mg_general_poisson_dirichlet" bench_dir = os.environ["PYRO_HOME"] + "/multigrid/tests/" my_data = a.get_solution_object() if store_bench: my_data.write("{}/{}".format(bench_dir, bench)) # do we do a comparison? if comp_bench: compare_file = "{}/{}".format(bench_dir, bench) msg.warning("comparing to: %s " % (compare_file)) bench = io.read(compare_file) result = compare.compare(my_data, bench) if result == 0: msg.success("results match benchmark\n") else: msg.warning("ERROR: " + compare.errors[result] + "\n") return result # normal return -- error wrt true solution return enorm
parser = argparse.ArgumentParser(description=usage) parser.add_argument("-o", type=str, default="sedov_compare.png", metavar="plot.png", help="output file name") parser.add_argument("plotfile", type=str, nargs=1, help="the plotfile you wish to plot") args = parser.parse_args() # read the data and convert to the primitive variables (and velocity # magnitude) sim = io.read(args.plotfile[0]) myd = sim.cc_data myg = myd.grid dens = myd.get_var("density") xmom = myd.get_var("x-momentum") ymom = myd.get_var("y-momentum") ener = myd.get_var("energy") rho = dens.v() u = np.sqrt(xmom.v()**2 + ymom.v()**2) / rho e = (ener.v() - 0.5 * rho * u * u) / rho gamma = myd.get_aux("gamma") p = rho * e * (gamma - 1.0)
usage: ./incomp_converge_error.py file """ if not len(sys.argv) == 2: print(usage) sys.exit(2) try: file1 = sys.argv[1] except IndexError: print(usage) sys.exit(2) sim = io.read(file1) myd = sim.cc_data myg = myd.grid # numerical solution u = myd.get_var("x-velocity") v = myd.get_var("y-velocity") t = myd.t # analytic solution u_exact = myg.scratch_array() u_exact[:, :] = 1.0 - 2.0*np.cos(2.0*math.pi*(myg.x2d-t))*np.sin(2.0*math.pi*(myg.y2d-t)) v_exact = myg.scratch_array() v_exact[:, :] = 1.0 + 2.0*np.sin(2.0*math.pi*(myg.x2d-t))*np.cos(2.0*math.pi*(myg.y2d-t))
else: print("{:20s} absolute error = {:10.10g}".format(name, abs_err)) if not np.allclose(d1.v(), d2.v(), rtol=rtol): result = "varerr" return result if __name__ == "__main__": if not (len(sys.argv) == 3 or len(sys.argv) == 4): print(usage) sys.exit(2) file1 = sys.argv[1] file2 = sys.argv[2] s1 = io.read(file1) s2 = io.read(file2) if len(sys.argv) == 3: result = compare(s1.cc_data, s2.cc_data) else: result = compare(s1.cc_data, s2.cc_data, rtol=float(sys.argv[3])) if result == 0: print("SUCCESS: files agree") else: print("ERROR: ", errors[result])
def test_vc_poisson_periodic(N, store_bench=False, comp_bench=False, make_plot=False, verbose=1): """ test the variable-coefficient MG solver. The return value here is the error compared to the exact solution, UNLESS comp_bench=True, in which case the return value is the error compared to the stored benchmark """ # test the multigrid solver nx = N ny = nx # create the coefficient variable g = patch.Grid2d(nx, ny, ng=1) d = patch.CellCenterData2d(g) bc_c = bnd.BC(xlb="periodic", xrb="periodic", ylb="periodic", yrb="periodic") d.register_var("c", bc_c) d.create() c = d.get_var("c") c[:, :] = alpha(g.x2d, g.y2d) # check whether the RHS sums to zero (necessary for periodic data) rhs = f(g.x2d, g.y2d) print("rhs sum: {}".format(np.sum(rhs[g.ilo:g.ihi + 1, g.jlo:g.jhi + 1]))) # create the multigrid object a = MG.VarCoeffCCMG2d(nx, ny, xl_BC_type="periodic", yl_BC_type="periodic", xr_BC_type="periodic", yr_BC_type="periodic", coeffs=c, coeffs_bc=bc_c, verbose=verbose, vis=0, true_function=true) # initialize the solution to 0 a.init_zeros() # initialize the RHS using the function f rhs = f(a.x2d, a.y2d) a.init_RHS(rhs) # solve to a relative tolerance of 1.e-11 a.solve(rtol=1.e-11) # alternately, we can just use smoothing by uncommenting the following # a.smooth(a.nlevels-1,10000) # get the solution v = a.get_solution() # get the true solution b = true(a.x2d, a.y2d) # compute the error from the analytic solution -- note that with # periodic BCs all around, there is nothing to normalize the # solution. We subtract off the average of phi from the MG # solution (we do the same for the true solution to put them on # the same footing) e = v - np.sum(v.v()) / (nx * ny) - ( b - np.sum(b[a.ilo:a.ihi + 1, a.jlo:a.jhi + 1]) / (nx * ny)) enorm = e.norm() print( " L2 error from true solution = %g\n rel. err from previous cycle = %g\n num. cycles = %d" % (enorm, a.relative_error, a.num_cycles)) # plot the solution if make_plot: plt.clf() plt.figure(figsize=(10.0, 4.0), dpi=100, facecolor='w') plt.subplot(121) plt.imshow(np.transpose(v.v()), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") plt.title("nx = {}".format(nx)) plt.colorbar() plt.subplot(122) plt.imshow(np.transpose(e.v()), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") plt.title("error") plt.colorbar() plt.tight_layout() plt.savefig("mg_vc_periodic_test.png") # store the output for later comparison bench = "mg_vc_poisson_periodic" bench_dir = os.environ["PYRO_HOME"] + "/multigrid/tests/" my_data = a.get_solution_object() if store_bench: my_data.write("{}/{}".format(bench_dir, bench)) # do we do a comparison? if comp_bench: compare_file = "{}/{}".format(bench_dir, bench) msg.warning("comparing to {}".format(compare_file)) bench = io.read(compare_file) result = compare.compare(my_data, bench) if result == 0: msg.success("results match benchmark\n") else: msg.warning("ERROR: {}\n".format(compare.errors[result])) return result # normal return -- error wrt true solution return enorm
def test_vc_poisson_dirichlet(N, store_bench=False, comp_bench=False, make_plot=False, verbose=1, rtol=1.e-12): """ test the variable-coefficient MG solver. The return value here is the error compared to the exact solution, UNLESS comp_bench=True, in which case the return value is the error compared to the stored benchmark """ # test the multigrid solver nx = N ny = nx # create the coefficient variable g = patch.Grid2d(nx, ny, ng=1) d = patch.CellCenterData2d(g) bc_c = bnd.BC(xlb="neumann", xrb="neumann", ylb="neumann", yrb="neumann") d.register_var("c", bc_c) d.create() c = d.get_var("c") c[:, :] = alpha(g.x2d, g.y2d) # create the multigrid object a = MG.VarCoeffCCMG2d(nx, ny, xl_BC_type="dirichlet", yl_BC_type="dirichlet", xr_BC_type="dirichlet", yr_BC_type="dirichlet", coeffs=c, coeffs_bc=bc_c, verbose=verbose, vis=0, true_function=true) # initialize the solution to 0 a.init_zeros() # initialize the RHS using the function f rhs = f(a.x2d, a.y2d) a.init_RHS(rhs) # solve to a relative tolerance of 1.e-11 a.solve(rtol=1.e-11) # alternately, we can just use smoothing by uncommenting the following # a.smooth(a.nlevels-1,50000) # get the solution v = a.get_solution() # compute the error from the analytic solution b = true(a.x2d, a.y2d) e = v - b enorm = e.norm() print(" L2 error from true solution = %g\n rel. err from previous cycle = %g\n num. cycles = %d" % (enorm, a.relative_error, a.num_cycles)) # plot the solution if make_plot: plt.clf() plt.figure(figsize=(10.0, 4.0), dpi=100, facecolor='w') plt.subplot(121) plt.imshow(np.transpose(v.v()), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") plt.title("nx = {}".format(nx)) plt.colorbar() plt.subplot(122) plt.imshow(np.transpose(e.v()), interpolation="nearest", origin="lower", extent=[a.xmin, a.xmax, a.ymin, a.ymax]) plt.xlabel("x") plt.ylabel("y") plt.title("error") plt.colorbar() plt.tight_layout() plt.savefig("mg_vc_dirichlet_test.png") # store the output for later comparison bench = "mg_vc_poisson_dirichlet" bench_dir = os.environ["PYRO_HOME"] + "/multigrid/tests/" my_data = a.get_solution_object() if store_bench: my_data.write("{}/{}".format(bench_dir, bench)) # do we do a comparison? if comp_bench: compare_file = "{}/{}".format(bench_dir, bench) msg.warning("comparing to: %s " % (compare_file)) bench = io.read(compare_file) result = compare.compare(my_data, bench, rtol) if result == 0: msg.success("results match benchmark to within relative tolerance of {}\n".format(rtol)) else: msg.warning("ERROR: " + compare.errors[result] + "\n") return result # normal return -- error wrt true solution return enorm