def experiment(P, opt, expname): # First run with regular refinement opt["meshRefinement"] = 1 df_uniform = solveProblem(P, opt) if WRITE_CSV: hlp.writeOutputToCsv(df_uniform, opt, opt['id'] + expname + '_uniform', df_uniform)
def experiment(P, opt, expname): # First run with regular refinement opt["meshRefinement"] = 1 df_uniform = solveProblem(P, opt) if WRITE_CSV: fname = '{}_{}_uniform'.format(opt['id'], expname) hlp.writeOutputToCsv(df_uniform, opt, fname)
def degreeStudy(P, opt, minDegree=1, maxDegree=4, filename=None): out = [] for deg in range(minDegree, maxDegree + 1): opt["p"] = deg opt["q"] = deg df = solveProblem(P, opt) out.append(df) if WRITE_CSV: fname = '{}_degree_study_{}_deg_{}'.format(opt['id'], filename, deg) hlp.writeOutputToCsv(df, opt, fname) return out
def experiment(P, opt, expname): # First run with regular refinement opt["meshRefinement"] = 1 df_uniform = solveProblem(P, opt) if WRITE_CSV: fname = '{}_{}_uniform'.format(opt['id'], expname) hlp.writeOutputToCsv(df_uniform, opt, fname) # Second run with adaptive refinement opt["meshRefinement"] = 2 opt["refinementThreshold"] = 0.9 df_adaptive = solveProblem(P, opt) if WRITE_CSV: fname = '{}_{}_adaptive'.format(opt['id'], expname) hlp.writeOutputToCsv(df_adaptive, opt, fname)
def experiment(P, opt, expname): # First run with regular refinement opt["meshRefinement"] = 1 df_uniform = solveProblem(P, opt) if WRITE_CSV: hlp.writeOutputToCsv(CSV_DIR + opt['id'] + expname + '_uniform.csv', df_uniform) # Second run with adaptive refinement opt["meshRefinement"] = 2 opt["refinementThreshold"] = 0.95 opt["plotMesh"] = 1 opt["saveMesh"] = 1 opt["plotSolution"] = 1 df_adaptive = solveProblem(P, opt) if WRITE_CSV: hlp.writeOutputToCsv(CSV_DIR + opt['id'] + expname + '_adaptive.csv', df_adaptive)
dg1stab = degreeStudy(P, hlp.opt_Own_DG_1_stab(global_opt), minDegree, maxDegree, 'dg1stab') # Set up one large dataframe to store relevant output dfs = [] keys = [ 'L2_error', 'H1_error', 'H2_error', 'H2h_error', 'L2_eoc', 'H1_eoc', 'H2_eoc', 'H2h_eoc' ] for deg in range(maxDegree): df = pd.DataFrame(columns=['Ndofs', 'hmax'], dtype=float) df['Ndofs'] = Neilan[deg]['Ndofs'] df['hmax'] = Neilan[deg]['hmax'] for key in keys: df['neilan_' + key] = Neilan[deg][key] df['nsz_' + key] = NSZ[deg][key] df['cg0stab_' + key] = cg0stab[deg][key] df['cg1stab_' + key] = cg1stab[deg][key] df['cg2stab_' + key] = cg2stab[deg][key] df['dg0stab_' + key] = dg0stab[deg][key] df['dg1stab_' + key] = dg1stab[deg][key] dfs.append(df) if WRITE_CSV: fname = global_opt['id'] + '_deg_{}'.format(deg + 1) hlp.writeOutputToCsv(df, global_opt, fname)
opt["NdofsThreshold"] = 70000 # Don't write all the information opt["writeToCsv"] = 0 # Set tolerance to 10^-8 opt["gmresTolRes"] = 1e-8 opt["gmresWarmStart"] = False # Prepare dataframe for results out = pd.DataFrame() # First experiment: Without stabilization for i, kappa in enumerate(kappa_list): for j, eta in enumerate(eta_list): opt["stabilizationFlag"] = 0 if eta < 1e-15 else 1 opt["stabilizationConstant1"] = eta opt["stabilizationConstant2"] = 0 opt["id"] = "Cinfty_eta_{}_kappa_{}_".format(eta, kappa) P = Cinfty(kappa) df = solveProblem(P, opt) if i == 0 and j == 0: out['h'] = [ '2^{{-{}}}'.format(j + 3) for j in range(df.shape[0]) ] out['eta_{}_kappa_{}'.format( eta, kappa)] = df.loc[:, 'N_iter'].astype('int') # Write csv file if WRITE_CSV: opt['id'] = 'gmres_iter' writeOutputToCsv(out, opt) print(out)
def solveProblem(P, opt): set_log_level(opt['dolfinLogLevel']) # parameters["reorder_dofs_serial"] = False # parameters['form_compiler']['quadrature_rule'] = 'vertex' parameters["form_compiler"]["quadrature_degree"] = 15 # parameters['ghost_mode'] = 'shared_facet' parameters['krylov_solver']['absolute_tolerance'] = 1e-10 parameters['krylov_solver']['relative_tolerance'] = 1e-10 parameters['krylov_solver']['maximum_iterations'] = 1000 parameters['krylov_solver']['monitor_convergence'] = True df = hlp.initDataframe() if opt["meshRefinement"]: n_range = range(opt["numberMeshLevels"]) else: n_range = [opt["initialMeshResolution"]] print('-' * 50 + '\n') n = opt["initialMeshResolution"] # Initialize mesh P.initMesh(n) P.meshLevel = 1 for (k, n) in enumerate(n_range): # updateFunctionSpaces also, since it depends on the mesh P.updateFunctionSpaces(opt) if P.getType().find('HJB') > -1: # initControl has to be run on each mesh once P.initControl() # update Coefficients needs control, therefore after initControl P.updateCoefficients() # checkVariables sets things like hasSolution, hasDrift etc. P.checkVariables() h = P.mesh.hmax() ndofs = P.solDofs(opt) ndofsMixed = P.totalDofs(opt) if k == 0: print(hlp.getSummary(P, opt)) print("Solve problem with %d (%d) dofs." % (ndofs, ndofsMixed)) if opt["printCordesInfo"]: P.printCordesInfo() N_iter = P.solve(opt) # Save solution as uold P.uold = P.u.copy() P.doPlots(opt) df.loc[k, ['hmax', 'Ndofs', 'NdofsMixed', 'N_iter']] = (h, ndofs, ndofsMixed, N_iter) # Check error estimation option during the first iteration if k == 0 and not P.hasSolution and opt["errorEstimationMethod"] == 1: print("""WARNING: Switch to errorEstimationMethod 2; no explicit solution is available.""") opt["errorEstimationMethod"] = 2 if k == 0 and opt["errorEstimationMethod"] == 2: # Initialize list to store all solutions U = [] if isinstance(P, PNVP.PNVP_WorstOfTwoAssetsPut): if k == 0: qoi_val_list = [] qoi_val = P.u([40, 40]) qoi_val_list.append(qoi_val) print('--------------------------------------------------\n') print('Value at qoi: %10.8f\n' % qoi_val) print('--------------------------------------------------\n') # Method 1: Determine norms of residual on current mesh if opt["errorEstimationMethod"] == 1: # Expression for difference between discrete # and analytical solution if hasattr(P, 'loc'): u_diff = (P.u - P.u_) * P.loc else: u_diff = P.u - P.u_ # Determine error norms l2err = L2_norm(u_diff) h1semierr = H10_norm(u_diff) h2semierr = H20_norm(u_diff) jumperr = EdgeJump_norm(u_diff, P.hE, P.nE) # Write errors to dataframe df.loc[k, 'L2_error'] = l2err df.loc[k, 'H1_error'] = h1semierr df.loc[k, 'H2_error'] = h2semierr df.loc[k, 'EdgeJump_error'] = jumperr df.loc[k, 'H2h_error'] = np.sqrt(pow(h2semierr, 2) + pow(jumperr, 2)) # Method 2: Collect the current solution, # compute the norms of residual on finest mesh if opt["errorEstimationMethod"] == 2: uerr = Function(P.V) assign(uerr, P.u) U.append(uerr) if opt["plotSolution"]: P.plotSolution() # Determine error estimates print('WARNING: Introduce flag to estimate errors') print('Estimate errors') eta = P.determineErrorEstimates(opt) eta_est = np.sum(np.power(eta, 2)) df.loc[k, 'Eta_global'] = eta_est # Mesh refinement if opt["meshRefinement"] > 0: if ndofs < opt["NdofsThreshold"]: P.meshLevel += 1 # Refine mesh depending on the strategy if opt["meshRefinement"] == 1: print('Refine mesh uniformly') P.refineMesh() elif opt["meshRefinement"] == 2: print("Refine mesh adaptively") cell_markers = P.markCells(opt, eta) P.refineMesh(cell_markers) else: print("Reached maximum number of dofs") break if opt["holdOn"]: inp = input('Press enter to continue, "x" to abort: ') if inp == 'x': break if opt["errorEstimationMethod"] == 2: """ This method computes the error norms all on the finest mesh. Since the errornorm command is not available for the H^2_h norm, we compute the respective norms directly. """ u_exact = P.u_ if P.hasSolution else interpolate(P.u, P.V) for (k, u) in enumerate(U): print("Compute errors on mesh level %i / %i" % (k + 1, len(U))) # Interpolate u_k on the finest mesh u = interpolate(u, P.V) if hasattr(P, 'loc'): u_diff = (u - u_exact) * P.loc else: u_diff = u - u_exact # Determine norms of residual EdgeJumperr = EdgeJump_norm(u_diff, P.hE, P.nE) L2err = L2_norm(u_diff) H1err = H10_norm(u_diff) H2err = H20_norm(u_diff) H2herr = np.sqrt(pow(H2err, 2) + pow(EdgeJumperr, 2)) # Write errors to dataframe df.loc[k, 'L2_error'] = L2err df.loc[k, 'H1_error'] = H1err df.loc[k, 'H2_error'] = H2err df.loc[k, 'H2h_error'] = H2herr df.loc[k, 'EdgeJump_error'] = EdgeJumperr if len(n_range) > 1: df = hlp.determineEOCforDataframe(P.dim(), df) if opt["plotConvergenceRates"]: hlp.plotConvergenceRates(df) if isinstance(P, PNVP.PNVP_WorstOfTwoAssetsPut): df['qoi_val'] = qoi_val_list if opt["writeToCsv"]: hlp.writeOutputToCsv(df, opt) # xf = XDMFFile("mesh.xdmf") # xf.write(P.u) return df
# Threshold for dofs opt["NdofsThreshold"] = 50000 opt["initialMeshResolution"] = 10 opt["timeSteps"] = 10 opt["timeStepFactor"] = 2 # Fix polynomial degree opt["p"] = 2 opt["q"] = 2 opt["plotSolution"] = 0 opt["plotErrorEstimates"] = 0 opt["plotConvergenceRates"] = 0 opt["plotMesh"] = 0 opt["meshRefinement"] = 1 # Uniform refinement opt["stabilizationFlag"] = 1 # Stability constant for first-order term opt["stabilityConstant1"] = 2 # Stability constant for second-order term opt["stabilityConstant2"] = 0 opt["solutionMethod"] = 'NeilanSalgadoZhang' df = solveProblem(P, opt) # Determine method to estimate error norms opt["errorEstimationMethod"] = 1 if WRITE_CSV: hlp.writeOutputToCsv(df, opt, opt['id'])