def run(self, globdat): # ADVANCE logging.info("Advancing to the next load step") globdat.i += 1 ndof = globdat.get("ndof") globdat.set("fext", np.zeros(ndof)) globdat.set("loadScale", globdat.i) globdat.model.takeAction(Action.ADVANCE, globdat) globdat.model.takeAction(Action.GET_MATRIX_0, globdat) globdat.model.takeAction(Action.GET_EXT_VECTOR, globdat) globdat.model.takeAction(Action.GET_CONSTRAINTS, globdat) # INITIAL RESIDUAL mbuild = globdat.get("mbuild") fext = globdat.get("fext") cons = globdat.get("cons") disp = globdat.get("solu") ndof = globdat.get("ndof") old_disp = deepcopy(disp) cons.updateSolution(disp) Du = globdat.set("Du", disp - old_disp) K = mbuild.getDenseMatrix() r = fext - np.array(K).dot(Du) solver = Solver(self.type, cons) solver.solve(K, disp, r, mbuild.hbw) return Status.EXIT
def calculation(self): while True: try: calculator = Solver(self.type_method, self.xy, self.x) calculator.solve() del calculator break except TypeError: break except ValueError: break
def p_convergence(config: ConfigParser, solver: Solver, sol: GridFunction, var: str) -> None: """ Function to check p (interpolat polynomial order) convergence and print results. Args: config: Config file from which to grab solver: The solver used sol: Gridfunction that contains the current solution var: The variable of interest. """ num_refinements = config.get_item(['ERROR ANALYSIS', 'num_refinements'], int) average_lst = config.get_list(['ERROR ANALYSIS', 'error_average'], str, quiet=True) component = solver.model.model_components[var] average = component in average_lst # Reload the model's mesh and finite element space so convergence tests can be chained and don't affect each other. solver.model.load_mesh_fes(mesh=True, fes=True) # First solve used the default settings. if component is None: err = norm('l2_norm', sol, solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes, average) else: err = norm('l2_norm', sol.components[component], solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes.components[component], average) # Track the convergence information. num_dofs_lst = [solver.model.fes.ndof] interp_ord_lst = [solver.model.interp_ord[var]] error_lst = [err] # Then run through a series of interpolant refinements. for n in range(num_refinements): solver.model.interp_ord = {key: val + 1 for key, val in solver.model.interp_ord.items()} solver.model.load_mesh_fes(mesh=False, fes=True) solver.reset_model() sol = solver.solve() if component is None: err = norm('l2_norm', sol, solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes, average) else: err = norm('l2_norm', sol.components[component], solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes.components[component], average) num_dofs_lst.append(solver.model.fes.ndof) interp_ord_lst.append(solver.model.interp_ord[var]) error_lst.append(err) print('L2 norm at refinement {0}: {1}'.format(n, err)) # Display the results nicely. convergence_table = [['Interpolant Order', 'DOFs', 'Error', 'Convergence Rate']] convergence_table.append([interp_ord_lst[0], num_dofs_lst[0], error_lst[0], 0]) for n in range(num_refinements): # TODO: Not sure if this is the correct equation for p-convergence. convergence_rate = math.log(error_lst[n] / error_lst[n + 1]) / math.log(num_dofs_lst[n + 1] / num_dofs_lst[n]) convergence_table.append([interp_ord_lst[n + 1], num_dofs_lst[n + 1], error_lst[n + 1], convergence_rate]) print(tabulate.tabulate(convergence_table, headers='firstrow', floatfmt=['.1f', '.1f', '.3e', '.2f']))
def solve(solver_name, problem_name, options): 'Solve the problem by solver with options.' # Set cpp_compiler options parameters["form_compiler"]["cpp_optimize"] = True # Set debug level set_log_active(options['debug']) # Set refinement level options['N'] = mesh_sizes[options['refinement_level']] # Create problem and solver problem = Problem(problem_name, options) solver = Solver(solver_name, options) time_step = solver.get_timestep(problem)[0] if MPI.process_number() == 0 and options['verbose']: print 'Problem: ' + str(problem) print 'Solver: ' + str(solver) # Solve problem with solver wct = time.time() u, p = solver.solve(problem) # Compute elapsed time wct = time.time() - wct # Compute number of degrees of freedom num_dofs = u.vector().size() + p.vector().size() # Get the mesh size mesh_size = u.function_space().mesh().hmin() # Get functional value and error functional, error = solver.eval() # Save results cpu_time = solver.cputime() save_results(problem, solver, num_dofs, mesh_size, time_step, functional, error) return 0
def h_convergence(config: ConfigParser, solver: Solver, sol: GridFunction, var: str) -> None: """ Function to check h (mesh element size) convergence and print results. Args: config: Config file from which to grab solver: The solver used sol: Gridfunction that contains the current solution var: The variable of interest. """ num_refinements = config.get_item(['ERROR ANALYSIS', 'num_refinements'], int) average_lst = config.get_list(['ERROR ANALYSIS', 'error_average'], str, quiet=True) component = solver.model.model_components[var] average = component in average_lst # Reload the model's mesh and finite element space so convergence tests can be chained and don't affect each other. solver.model.load_mesh_fes(mesh=True, fes=True) # First solve used the default settings. if component is None: err = norm('l2_norm', sol, solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes, average) else: err = norm('l2_norm', sol.components[component], solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes.components[component], average) # Track the convergence information. num_dofs_lst = [solver.model.fes.ndof] error_lst = [err] # Then run through a series of mesh refinements and resolve on each # refined mesh. for n in range(num_refinements): solver.model.mesh.Refine() solver.model.fes.Update() solver.reset_model() sol = solver.solve() if component is None: err = norm('l2_norm', sol, solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes, average) else: err = norm('l2_norm', sol.components[component], solver.model.ref_sol['ref_sols'][var], solver.model.mesh, solver.model.fes.components[component], average) num_dofs_lst.append(solver.model.fes.ndof) error_lst.append(err) print('L2 norm at refinement {0}: {1}'.format(n, err)) # Display the results nicely. convergence_table = [['Refinement Level', 'DOFs', 'Error', 'Convergence Rate']] convergence_table.append([1, num_dofs_lst[0], error_lst[0], 0]) for n in range(num_refinements): ref_level = '1/{}'.format(int(2 ** (n + 1))) convergence_rate = math.log(error_lst[n] / error_lst[n + 1]) / \ (math.log(num_dofs_lst[n + 1] / (num_dofs_lst[n] * 2.0 ** (solver.model.mesh.dim - 1)))) convergence_table.append([ref_level, num_dofs_lst[n + 1], error_lst[n + 1], convergence_rate]) print(tabulate.tabulate(convergence_table, headers='firstrow', floatfmt=('.1f', '.1f', '.3e', '.2f')))
def run(self, globdat): # ADVANCE logging.info("Advancing to the next load step") globdat.i += 1 ndof = globdat.get("ndof") globdat.set("fext", np.zeros(ndof)) globdat.set("loadScale", globdat.i) globdat.model.takeAction(Action.ADVANCE, globdat) globdat.model.takeAction(Action.GET_MATRIX_0, globdat) globdat.model.takeAction(Action.GET_EXT_VECTOR, globdat) globdat.model.takeAction(Action.GET_CONSTRAINTS, globdat) mbuild = globdat.get("mbuild") fext = globdat.get("fext") fint = globdat.get("fint") cons = globdat.get("cons") disp = globdat.get("solu") old_disp = deepcopy(disp) cons.updateSolution(disp) du = disp - old_disp K = mbuild.getDenseMatrix() r = fext - fint - np.array(K).dot(du) solver = Solver(self.type, cons) fdof = cons.getFdof() for iter in range(self.niter): # Update displacement vector solver.solve(K, du, r, mbuild.hbw) disp[fdof] += du[fdof] # Find interal force vector globdat.set("fint", np.zeros(ndof)) if self.nrkey == "full": globdat.model.takeAction(Action.GET_MATRIX_0, globdat) elif self.nrkey == "mod" or self.nrkey == "LE": globdat.model.takeAction(Action.GET_INT_VECTOR, globdat) else: raise ValueError("{} not implemented !".format(self.nrkey)) # Find out-of-balance force vector r = fext - globdat.get("fint") nrm = norm(r[fdof]) logging.info(" Iteration {}: norm = {:.10f} ".format(iter, nrm)) # Check convergence in first iteration if iter == 0 and nrm <= self.tiny: logging.info(" Converged in {} iterations".format(iter + 1)) return Status.OK elif iter == 0 and nrm > self.tiny: nrm1 = deepcopy(nrm) # Check convergence in later iterations if nrm < self.tol * nrm1: logging.info(" Converged in {} iterations".format(iter + 1)) return Status.OK
def run(self, globdat): # ADVANCE logging.info("Advancing to the next load step") globdat.i += 1 ndof = globdat.get("ndof") globdat.set("du", np.zeros(ndof)) globdat.set("Du", np.zeros(ndof)) globdat.set("fext", np.zeros(ndof)) globdat.set("fint", np.zeros(ndof)) globdat.set("loadScale", globdat.i) globdat.model.takeAction(Action.ADVANCE, globdat) globdat.model.takeAction(Action.GET_MATRIX_0, globdat) globdat.model.takeAction(Action.GET_EXT_VECTOR, globdat) globdat.model.takeAction(Action.GET_CONSTRAINTS, globdat) mbuild = globdat.get("mbuild") fext = globdat.get("fext") fint = globdat.get("fint") cons = globdat.get("cons") disp = globdat.get("solu") old_disp = deepcopy(disp) cons.updateSolution(disp) du = globdat.set("du", disp - old_disp) Du = globdat.set("Du", deepcopy(du)) K = mbuild.getDenseMatrix() r = fext - fint - np.array(K).dot(Du) solver = Solver(self.type, cons) fdof = cons.getFdof() nrm1 = 0.0 for iter in range(self.niter): # Update displacement vector solver.solve(K, du, r, mbuild.hbw) disp[fdof] += du[fdof] Du[fdof] += du[fdof] # Find interal force vector globdat.set("fint", np.zeros(ndof)) globdat.model.takeAction(self.action, globdat) # Find out-of-balance force vector r = fext - globdat.get("fint") nrm = norm(r[fdof]) logging.info(" Iteration {}: norm = {:.10f} ".format(iter, nrm)) # Check convergence if (iter == 0 and nrm <= self.tiny) or (iter > 0 and nrm < self.tol * nrm1): logging.info(" Converged in {} iterations".format(iter + 1)) globdat.model.takeAction(Action.COMMIT, globdat) return Status.OK elif iter == 0 and nrm > self.tiny: nrm1 = deepcopy(nrm) return Status.EXIT