def test_mesh_to_mesh_1d_dirichlet(): """ A simple test program to test dirichlet interpolation order in space """ # initialize problem parameters problem_params = {} problem_params['nu'] = 0.1 # diffusion coefficient problem_params['freq'] = 3 # frequency for the test value # initialize transfer parameters space_transfer_params = {} space_transfer_params['rorder'] = 2 iorder_list = [2,4,6,8] nvars_fine_list = [2**p-1 for p in range(5,9)] # set up dictionary to store results (plus lists) results = {} results['nvars_fine_list'] = nvars_fine_list results['iorder_list'] = iorder_list # loop over interpolation orders and number of DOFs for iorder in iorder_list: space_transfer_params['iorder'] = iorder for nvars_fine in nvars_fine_list: # instantiate fine problem problem_params['nvars'] = nvars_fine # number of degrees of freedom Pfine = heat1d(problem_params=problem_params, dtype_u=mesh, dtype_f=mesh) # instantiate coarse problem problem_params['nvars'] = int((nvars_fine + 1) / 2.0 - 1) Pcoarse = heat1d(problem_params=problem_params, dtype_u=mesh, dtype_f=mesh) # instantiate spatial interpolation T = mesh_to_mesh(fine_prob=Pfine, coarse_prob=Pcoarse, params=space_transfer_params) # set exact fine solution to compare with uexact_fine = Pfine.u_exact(t=0) # set exact coarse solution as source uexact_coarse = Pcoarse.u_exact(t=0) # do the interpolation/prolongation uinter = T.prolong(uexact_coarse) # compute error and store err = abs(uinter-uexact_fine) id = ID(nvars_fine=nvars_fine, iorder=iorder) results[id] = err orders = get_accuracy_orders(results) for p in range(len(orders)): # print(abs(orders[p][1]-orders[p][2])/orders[p][1]) assert abs(orders[p][1]-orders[p][2])/orders[p][1] < 0.151, 'ERROR: did not get expected orders for interpolation, got %s' %str(orders[p])
def run_accuracy_check(nvars_list, problem_params): """ Routine to check the error of the Laplacian vs. its FD discretization Args: nvars_list: list of nvars to do the testing with problem_params: dictionary containing the problem-dependent parameters Returns: a dictionary containing the errors and a header (with nvars_list) """ results = {} # loop over all nvars for nvars in nvars_list: # setup problem problem_params['nvars'] = nvars prob = heat1d(problem_params=problem_params, dtype_u=mesh, dtype_f=mesh) # create x values, use only inner points xvalues = np.array([(i + 1) * prob.dx for i in range(prob.params.nvars)]) # create a mesh instance and fill it with a sine wave u = prob.u_exact(t=0) # create a mesh instance and fill it with the Laplacian of the sine wave u_lap = prob.dtype_u(init=prob.init) u_lap.values = -(np.pi * prob.params.freq)**2 * prob.params.nu * np.sin( np.pi * prob.params.freq * xvalues) # compare analytic and computed solution using the eval_f routine of the problem class err = abs(prob.eval_f(u, 0) - u_lap) # get id for this nvars and put error into dictionary id = ID(nvars=nvars) results[id] = err # add nvars_list to dictionary for easier access later on results['nvars_list'] = nvars_list return results
def main(): """ A simple test program to compute the order of accuracy in time """ # initialize problem parameters problem_params = {} problem_params['nu'] = 0.1 # diffusion coefficient problem_params['freq'] = 4 # frequency for the test value problem_params['nvars'] = 16383 # number of DOFs in space # instantiate problem prob = heat1d(problem_params=problem_params, dtype_u=mesh, dtype_f=mesh) # instantiate collocation class, relative to the time interval [0,1] coll = CollGaussRadau_Right(num_nodes=3, tleft=0, tright=1) # assemble list of dt dt_list = [0.1 / 2**p for p in range(0, 4)] # run accuracy test for all dt results = run_accuracy_check(prob=prob, coll=coll, dt_list=dt_list) # get order of accuracy order = get_accuracy_order(results) f = open('step_1_D_out.txt', 'w') for l in range(len(order)): out = 'Expected order: %2i -- Computed order %4.3f' % (5, order[l]) f.write(out + '\n') print(out) f.close() # visualize results plot_accuracy(results) assert os.path.isfile('step_1_accuracy_test_coll.png') assert all( np.isclose(order, 2 * coll.num_nodes - 1, rtol=0.4) ), "ERROR: did not get order of accuracy as expected, got %s" % order
def main(): """ A simple test program to set up a spatial problem and play with it """ # initialize problem parameters problem_params = dict() problem_params['nu'] = 0.1 # diffusion coefficient problem_params['freq'] = 4 # frequency for the test value problem_params['nvars'] = 1023 # number of degrees of freedom # instantiate problem prob = heat1d(problem_params=problem_params, dtype_u=mesh, dtype_f=mesh) # run accuracy test, get error back err = run_accuracy_check(prob) f = open('step_1_A_out.txt', 'w') out = 'Error of the spatial accuracy test: %8.6e' % err f.write(out) print(out) f.close() assert err <= 2E-04, "ERROR: the spatial accuracy is higher than expected, got %s" % err
def main(): """ A simple test program to test interpolation order in space """ # initialize problem parameters problem_params = dict() problem_params['nu'] = 0.1 # diffusion coefficient problem_params['freq'] = 3 # frequency for the test value # initialize transfer parameters space_transfer_params = dict() space_transfer_params['rorder'] = 2 space_transfer_params['iorder'] = 4 nvars_fine_list = [2**p - 1 for p in range(5, 10)] # set up dictionary to store results (plus lists) results = dict() results['nvars_list'] = nvars_fine_list for nvars_fine in nvars_fine_list: print('Working on nvars_fine = %4i...' % nvars_fine) # instantiate fine problem problem_params['nvars'] = nvars_fine # number of degrees of freedom Pfine = heat1d(problem_params=problem_params, dtype_u=mesh, dtype_f=mesh) # instantiate coarse problem using half of the DOFs problem_params['nvars'] = int((nvars_fine + 1) / 2.0 - 1) Pcoarse = heat1d(problem_params=problem_params, dtype_u=mesh, dtype_f=mesh) # instantiate spatial interpolation T = mesh_to_mesh(fine_prob=Pfine, coarse_prob=Pcoarse, params=space_transfer_params) # set exact fine solution to compare with xvalues_fine = np.array([(i + 1) * Pfine.dx for i in range(Pfine.params.nvars)]) uexact_fine = Pfine.dtype_u(0) uexact_fine.values = np.sin(np.pi * Pfine.params.freq * xvalues_fine) # set exact coarse solution as source xvalues_coarse = np.array([(i + 1) * Pcoarse.dx for i in range(Pcoarse.params.nvars)]) uexact_coarse = Pfine.dtype_u(0) uexact_coarse.values = np.sin(np.pi * Pcoarse.params.freq * xvalues_coarse) # do the interpolation/prolongation uinter = T.prolong(uexact_coarse) # compute error and store id = ID(nvars_fine=nvars_fine) results[id] = abs(uinter - uexact_fine) # print out and check print('Running order checks...') orders = get_accuracy_order(results) f = open('step_4_A_out.txt', 'w') for p in range(len(orders)): out = 'Expected order %2i, got order %5.2f, deviation of %5.2f%%' \ % (space_transfer_params['iorder'], orders[p], 100 * abs(space_transfer_params['iorder'] - orders[p]) / space_transfer_params['iorder']) f.write(out + '\n') print(out) assert abs(space_transfer_params['iorder'] - orders[p]) / space_transfer_params['iorder'] < 0.05, \ 'ERROR: did not get expected orders for interpolation, got %s' % str(orders[p]) f.close() print('...got what we expected!')