def get_conv_rates(init_cond, tf, N_steps = 100, s = 100, order = 1, dim = 1, n = 32, C1 = 1, C2 = 2, kmax = 6, thmin = 0, thmax = 1, **kwargs): print(order, dim, kwargs) CFL_zero_lim = kwargs['alpha_2']/(kwargs['alpha_1'] + kwargs['alpha_2']) CFL_inf_lim = kwargs['lambda_2']/(kwargs['lambda_1'] + kwargs['lambda_2']) results = {'updates': [], 'theta': list(np.linspace(thmin, thmax, s))} # prob = get_problem(dim = dim, n = n, **kwargs, len_1 = 2, len_2 = 3) prob = get_problem(dim = dim, n = n, **kwargs, len_1 = 9, len_2 = 1) solver = get_solver(prob, order = order, WR_type = 'DNWR') for th in results['theta']: print('theta', th) _, _, _, updates, _ = solver(tf, C1*N_steps, C2*N_steps, init_cond, th, TOL = 1e-13, maxiter = kmax) results['updates'].append(updates) ## calculate theta_opt for given setting p = Problem_FSI_1D(n, kwargs['lambda_1'], kwargs['lambda_2'], kwargs['alpha_1'], kwargs['alpha_2'], 'DNWR') dt1, dt2 = tf/(N_steps*C1), tf/(N_steps*C2) results['theta_opt'] = p.DNWR_theta_opt(dt1, dt2) results['theta_CFL_zero'] = CFL_zero_lim results['theta_CFL_inf'] = CFL_inf_lim results['theta_start'] = thmin results['theta_stop'] = thmax results['parameters'] = kwargs results['tf'] = tf results['n'] = n results['N_steps'] = N_steps return results
def verify_adaptive(init_cond, tf=1, k=10, WR_type='DNWR', order=-2, **kwargs): ## sum of splitting and time-integration order ## calculating time-integration error( + splitting error) for a small tolerance prob = get_problem(WR_type=WR_type, **kwargs) solver = get_solver(prob, order, WR_type) errs = {'u': [], 'it': [], 'timesteps': []} sols = [] tols = [10**(-i) for i in range(k + 1)] for tau in tols: u1, u2, ug, E, it, s = solver(tf, init_cond, TOL=tau) sols.append((u1, u2, ug)) errs['it'].append(it) errs['timesteps'].append(s) errs['tols'] = tols[:-1] u1_ref, u2_ref, ug_ref = sols[-1] for u in sols[:-1]: u1, u2, ug = u errs['u'].append(prob.norm_inner(u1_ref - u1, u2_ref - u2, ug_ref - ug)) del errs['it'][-1] del errs['timesteps'][-1] errs['tf'] = tf return errs
def verify_comb_error(init_cond, tf=1, k=10, kmin=0, C1=1, C2=1, theta=None, WR_type='DNWR', order=1, TOL=1e-13, **kwargs): ## sum of splitting and time-integration order ## calculating time-integration error( + splitting error) for a small tolerance prob = get_problem(WR_type=WR_type, **kwargs) solver = get_solver(prob, order, WR_type) u1_ref, u2_ref, ug_ref, _, prob_mono = solve_monolithic( tf, int(max(C1, C2)) * 2**(k + 1), init_cond, order, **kwargs) errs = {'u': [], 'it': [], 'dts': []} for n_steps in [2**i for i in range(kmin, k)]: errs['dts'].append(tf / n_steps) u1, u2, ug, E, it = solver(tf, C1 * n_steps, C2 * n_steps, init_cond, theta, TOL=TOL) errs['u'].append( prob_mono.norm_inner(u1_ref - u1, u2_ref - u2, ug_ref - ug)) errs['it'].append(it) return errs
def verify_comb_error(init_cond, tf=1, k=10, kmin=0, C1=1, C2=1, theta=None, WR_type='NNWR', order=1, TOL=1e-13, **kwargs): comm = MPI.COMM_WORLD if comm.size != 2: raise ValueError( 'incorrect number of processes, needs to be exactly 2') ID_SELF = comm.rank ## sum of splitting and time-integration order ## calculating time-integration error( + splitting error) for a small tolerance prob = get_problem( WR_type=WR_type, **kwargs, ) solver = get_solver(prob, order, WR_type) if ID_SELF == 0: u1_ref, u2_ref, ug_ref, _, prob_mono = solve_monolithic( tf, int(max(C1, C2)) * 2**(k + 1), init_cond, order, **kwargs) elif ID_SELF == 1: pass if ID_SELF == 0: errs = {'u': [], 'it': [], 'dts': []} for n_steps in [2**i for i in range(kmin, k)]: errs['dts'].append(tf / n_steps) u1, u2, ug, E, it = solver(tf, C1 * n_steps, C2 * n_steps, init_cond, theta, TOL=TOL) errs['u'].append( prob_mono.norm_inner(u1_ref - u1, u2_ref - u2, ug_ref - ug)) errs['it'].append(it) elif ID_SELF == 1: for n_steps in [2**i for i in range(kmin, k)]: solver(tf, C1 * n_steps, C2 * n_steps, init_cond, theta, TOL=TOL) return None return errs
def get_conv_rates(tf, s = 10, n = 199, C1 = 1, C2 = 10, kmax = 6, **kwargs): init_cond = get_init_cond(1) results = {} prob = get_problem(dim = 1, n = n, **kwargs) solver = get_solver(prob, order = 1, WR_type = 'DNWR') nn = np.array([2**i for i in range(s)]) results['para'] = [kwargs['alpha_1'], kwargs['alpha_2'], kwargs['lambda_1'], kwargs['lambda_2']] results['n'] = n results['tf'] = tf results['cfl'] = [] theta_min, theta_max, theta_actual, theta_avg = [], [], [], [] dx = 1/(n+1) for n in nn: dt = tf/n results['cfl'].append(dt/(dx**2)) dt1, dt2 = dt/C1, dt/C2 th_min = prob.DNWR_theta_opt_test(min(dt1, dt2), min(dt1, dt2)) _, _, _, updates, _ = solver(dt, C1, C2, init_cond, th_min, TOL = 1e-13, maxiter = kmax) theta_min.append(updates) th_max = prob.DNWR_theta_opt_test(max(dt1, dt2), max(dt1, dt2)) _, _, _, updates, _ = solver(dt, C1, C2, init_cond, th_max, TOL = 1e-13, maxiter = kmax) theta_max.append(updates) th_act = prob.DNWR_theta_opt_test(dt1, dt2) _, _, _, updates, _ = solver(dt, C1, C2, init_cond, th_act, TOL = 1e-13, maxiter = kmax) theta_actual.append(updates) th_avg = prob.DNWR_theta_opt_test((dt1 + dt2)/2, (dt1 + dt2)/2) _, _, _, updates, _ = solver(dt, C1, C2, init_cond, th_avg, TOL = 1e-13, maxiter = kmax) theta_avg.append(updates) results['min'] = theta_min results['max'] = theta_max results['actual'] = theta_actual results['avg'] = theta_avg results['parameters'] = kwargs return results
def verify_adaptive(init_cond, tf = 1, k = 10, WR_type = 'NNWR', order = -1, **kwargs): ## sum of splitting and time-integration order ## calculating time-integration error( + splitting error) for a small tolerance if WR_type == 'NNWR': from mpi4py import MPI comm = MPI.COMM_WORLD if comm.size != 2: raise ValueError('incorrect number of processes, needs to be exactly 2') ID_SELF = comm.rank prob = get_problem(WR_type = WR_type, **kwargs) solver = get_solver(prob, order, WR_type) if ID_SELF == 0: ## problem object for correct error computation prob_norm = get_problem(WR_type = 'MONOLITHIC', **kwargs) tols = [10**(-i) for i in range(k + 1)] if ID_SELF == 1: for tol in tols: solver(tf, init_cond, TOL = tol) return None # process 1 quits errs = {'u': [], 'it': [], 'timesteps': []} sols = [] for tau in tols: print(tau) u1, u2, ug, E, it, s = solver(tf, init_cond, TOL = tau) sols.append((u1, u2, ug)) errs['it'].append(it) errs['timesteps'].append(s) errs['tols'] = tols[:-1] u1_ref, u2_ref, ug_ref = sols[-1] for u in sols[:-1]: u1, u2, ug = u errs['u'].append(prob_norm.norm_inner(u1_ref - u1, u2_ref - u2, ug_ref - ug)) del errs['it'][-1]; del errs['timesteps'][-1] errs['tf'] = tf return errs
def get_conv_rates(init_cond, tf, N_steps=100, s=100, order=1, dim=1, n=32, C1=1, C2=2, kmax=6, thmin=0, thmax=1, **kwargs): comm = MPI.COMM_WORLD if comm.size != 2: raise ValueError( 'incorrect number of processes, needs to be exactly 2') ID_SELF = comm.rank print(order, dim, kwargs) CFL_zero_lim = kwargs['alpha_2'] * kwargs['alpha_1'] / ( kwargs['alpha_1'] + kwargs['alpha_2'])**2 CFL_inf_lim = kwargs['lambda_2'] * kwargs['lambda_1'] / ( kwargs['lambda_1'] + kwargs['lambda_2'])**2 results = {'updates': [], 'theta': list(np.linspace(thmin, thmax, s))} prob = get_problem(dim=dim, n=n, WR_type='NNWR', **kwargs) solver = get_solver(prob, order=order, WR_type='NNWR') if ID_SELF == 0: for th in results['theta']: print('theta', th) _, _, _, updates, _ = solver(tf, C1 * N_steps, C2 * N_steps, init_cond, th, TOL=1e-13, maxiter=kmax) results['updates'].append(updates) elif ID_SELF == 1: for th in results['theta']: solver(tf, C1 * N_steps, C2 * N_steps, init_cond, th, TOL=1e-13, maxiter=kmax) return None ## process 2 quitting ## calculate theta_opt for given setting dt1, dt2 = tf / (N_steps * C1), tf / (N_steps * C2) results['theta_opt'] = prob.NNWR_theta_opt(dt1, dt2) results['theta_CFL_zero'] = CFL_zero_lim results['theta_CFL_inf'] = CFL_inf_lim results['theta_start'] = thmin results['theta_stop'] = thmax results['parameters'] = kwargs results['tf'] = tf results['n'] = n results['N_steps'] = N_steps return results
def get_err_work(output_file, init_cond, tf, C1=1, C2=1, n=99, k_mr=6, k_adaptive=6, **kwargs): results = kwargs.copy() results['C1'] = C1 results['C2'] = C2 results['tf'] = tf results['n'] = n ## step 1, calculate MR time-integration errors # a) get MR solutions with small tolerance prob = get_problem(dim=2, n=n, WR_type='DNWR', **kwargs) solver_MR = get_solver(prob, order=2, WR_type='DNWR') steps_list = [2**i for i in range(k_mr)] sols = [] for s in steps_list: u1, u2, ug, _, _ = solver_MR(tf, s * C1, s * C2, init_cond, TOL=1e-12) sols.append((u1, u2, ug)) results['MR_base_sols'] = [(list(i[0]), list(i[1]), list(i[2])) for i in sols] ## b) get monolithic reference sol with even smaller dt u1ref, u2ref, ugref, _, prob_mono = solve_monolithic(tf, max(C1, C2) * 2**k_mr, init_cond, 2, dim=2, n=n, **kwargs) results['MR_ref'] = (list(u1ref), list(u2ref), list(ugref)) ## c) calculate errors errs = [] for u in sols: u1, u2, ug = u errs.append(prob_mono.norm_inner(u1 - u1ref, u2 - u2ref, ug - ugref)) results['errs_for_tols'] = errs ## step 2, compute new, proper MR solutions sols_MR_new, steps_MR_new, iters_MR_new = [], [], [] for s, e in zip(steps_list, errs): print(s, steps_list) tol = e / 5 u1, u2, ug, _, iters = solver_MR(tf, s * C1, s * C2, init_cond, TOL=tol) sols_MR_new.append((u1, u2, ug)) steps_MR_new.append(iters * (s * C1 + s * C2)) iters_MR_new.append(iters) results['sols_MR_new'] = [(list(u[0]), list(u[1]), list(u[2])) for u in sols_MR_new] results['steps_MR_new'] = steps_MR_new results['iters_MR_new'] = iters_MR_new ## step 3, compute adaptive solutions solver_adaptive = get_solver(prob, order=-2, WR_type='DNWR') sols_adaptive, steps_adaptive, iters_adaptive = [], [], [] tols_list = [10**(-i) for i in range(k_adaptive)] for tol in tols_list: u1, u2, ug, _, iters, ss = solver_adaptive(tf, init_cond, TOL=tol) sols_adaptive.append((u1, u2, ug)) steps_adaptive.append(ss) iters_adaptive.append(iters) results['sols_adaptive'] = [(list(u[0]), list(u[1]), list(u[2])) for u in sols_adaptive] results['steps_adaptive'] = steps_adaptive results['iters_adaptive'] = iters_adaptive ## step 4, reference solution for error computation, here: use adaptive for one tol further u1ref, u2ref, ugref, _, _, _ = solver_adaptive(tf, init_cond, TOL=10**(-k_adaptive)) results['err_ref'] = (list(u1ref), list(u2ref), list(ugref)) ## step 5, compute errors errs_MR = [] for u in sols_MR_new: u1, u2, ug = u errs_MR.append(prob_mono.norm_inner(u1 - u1ref, u2 - u2ref, ug - ugref)) errs_adaptive = [] for u in sols_adaptive: u1, u2, ug = u errs_adaptive.append( prob_mono.norm_inner(u1 - u1ref, u2 - u2ref, ug - ugref)) results['errs_MR'] = errs_MR results['errs_adaptive'] = errs_adaptive with open(output_file, 'w') as myfile: myfile.write(json.dumps(results, indent=2, sort_keys=True))