def cg2_demo(nrhs, n, plot): rhs0 = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim_domain=2) # NOQA rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, dim_domain=2) # NOQA assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.') rhs = eval('rhs{}'.format(nrhs)) d0 = GenericFunction(lambda X: 1 - X[..., 0], dim_domain=2) d1 = GenericFunction(lambda X: X[..., 0], dim_domain=2) parameter_space = CubicParameterSpace({'diffusionl': 0}, 0.1, 1) f0 = ProjectionParameterFunctional('diffusionl', 0) f1 = GenericParameterFunctional(lambda mu: 1, {}) print('Solving on TriaGrid(({0},{0}))'.format(n)) print('Setup Problem ...') problem = EllipticProblem(domain=RectDomain(), rhs=rhs, diffusion_functions=(d0, d1), diffusion_functionals=(f0, f1), name='2DProblem') print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / n) print('The parameter type is {}'.format(discretization.parameter_type)) U = discretization.type_solution.empty(discretization.dim_solution) for mu in parameter_space.sample_uniformly(10): U.append(discretization.solve(mu)) if plot: print('Plot ...') discretization.visualize(U, title='Solution for diffusionl in [0.1, 1]')
def __init__(self, args): self.args = args self.first = True self.problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS']), parameter_range=(PARAM_MIN, PARAM_MAX)) self.discretization, pack = discretize_elliptic_cg(self.problem, diameter=m.sqrt(2) / args['--grid']) self.grid = pack['grid']
def cg_oned_demo(nrhs, n, plot): rhs0 = GenericFunction(lambda X: np.ones(X.shape) * 10, dim_domain=1) rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, dim_domain=1) assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.') rhs = eval('rhs{}'.format(nrhs)) d0 = GenericFunction(lambda X: 1 - X[..., 0], dim_domain=1) d1 = GenericFunction(lambda X: X[..., 0], dim_domain=1) parameter_space = CubicParameterSpace({'diffusionl': 1}, 0.1, 1) f0 = ProjectionParameterFunctional(parameter_space, 'diffusionl') f1 = GenericParameterFunctional(parameter_space, lambda mu: 1) print('Solving on OnedGrid(({0},{0}))'.format(n)) print('Setup Problem ...') problem = EllipticProblem(domain=LineDomain(), rhs=rhs, diffusion_functions=(d0, d1), diffusion_functionals=(f0, f1), dirichlet_data=ConstantFunction(value=0, dim_domain=1)) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=1 / n) print(discretization.parameter_info()) for mu in parameter_space.sample_uniformly(4): print('Solving for mu = {} ...'.format(mu)) U = discretization.solve(mu) if plot: print('Plot ...') discretization.visualize(U) print('')
def parabolic_demo(): p = ThermalBlockProblem(parameter_range=(0.01, 1)) d, d_data = discretize_elliptic_cg(p, diameter=1./100) mu = next(d.parameter_space.sample_randomly(1)) U0 = NumpyVectorArray(np.zeros(d.operator.dim_source)) R = implicit_euler(d.operator, d.rhs, d.l2_product, U0, 0, 1, 10, mu) visualize_glumpy_patch(d.rhs.grid, R)
def parabolic_demo(): p = ThermalBlockProblem(parameter_range=(0.01, 1)) d_stat, d_data = discretize_elliptic_cg(p, diameter=1./100) U0 = NumpyVectorArray(np.zeros(d_stat.operator.source.dim)) time_stepper = ImplicitEulerTimeStepper(50) d = InstationaryDiscretization(operator=d_stat.operator, rhs=d_stat.rhs, mass=d_stat.l2_product, initial_data=U0, T=1, products=d_stat.products, time_stepper=time_stepper, parameter_space=d_stat.parameter_space, visualizer=d_stat.visualizer) mu = next(d.parameter_space.sample_randomly(1)) R = d.solve(mu) d.visualize(R)
def test_visualize_patch(backend_gridtype): backend, gridtype = backend_gridtype domain = LineDomain() if gridtype is OnedGrid else RectDomain() dim = 1 if gridtype is OnedGrid else 2 rhs = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim) # NOQA dirichlet = GenericFunction(lambda X: np.zeros(X.shape[:-1]), dim) # NOQA diffusion = GenericFunction(lambda X: np.ones(X.shape[:-1]), dim) # NOQA problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet, diffusion_functions=(diffusion,)) grid, bi = discretize_domain_default(problem.domain, grid_type=gridtype) discretization, data = discretize_elliptic_cg(analytical_problem=problem, grid=grid, boundary_info=bi) U = discretization.solve() visualize_patch(data['grid'], U=U, backend=backend) sleep(2) # so gui has a chance to popup for child in multiprocessing.active_children(): child.terminate()
def cg_demo(nrhs, ndirichlet, nneumann, rect_grid=False): rhs0 = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, 2) # NOQA rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, 2) # NOQA dirichlet0 = GenericFunction(lambda X: np.zeros(X.shape[:-1]), 2) # NOQA dirichlet1 = GenericFunction(lambda X: np.ones(X.shape[:-1]), 2) # NOQA dirichlet2 = GenericFunction(lambda X: X[..., 0], 2) # NOQA domain0 = RectDomain() # NOQA domain1 = RectDomain(right=BoundaryType('neumann')) # NOQA domain2 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann')) # NOQA domain3 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann'), bottom=BoundaryType('neumann')) # NOQA assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.') rhs = eval('rhs{}'.format(nrhs)) assert 0 <= ndirichlet <= 2, ValueError('Invalid boundary number.') dirichlet = eval('dirichlet{}'.format(ndirichlet)) assert 0 <= nneumann <= 3, ValueError('Invalid neumann boundary count.') domain = eval('domain{}'.format(nneumann)) for n in [32, 128]: grid_name = '{1}(({0},{0}))'.format(n, 'RectGrid' if rect_grid else 'TriaGrid' ) print('Solving on {0}'.format(grid_name)) print('Setup problem ...') problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet) print('Discretize ...') grid, bi = discretize_domain_default(problem.domain, diameter=m.sqrt(2) / n, grid_type=RectGrid if rect_grid else TriaGrid) discretization, _ = discretize_elliptic_cg(analytical_problem=problem, grid=grid, boundary_info=bi) print('Solve ...') U = discretization.solve() print('Plot ...') discretization.visualize(U, title=grid_name) print('')
def cg_demo(nrhs, ndirichlet, nneumann): rhs0 = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, 2) # NOQA rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, 2) # NOQA dirichlet0 = GenericFunction(lambda X: np.zeros(X.shape[:-1]), 2) # NOQA dirichlet1 = GenericFunction(lambda X: np.ones(X.shape[:-1]), 2) # NOQA dirichlet2 = GenericFunction(lambda X: X[..., 0], 2) # NOQA domain0 = RectDomain() # NOQA domain1 = RectDomain(right=BoundaryType('neumann')) # NOQA domain2 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann')) # NOQA domain3 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann'), bottom=BoundaryType('neumann')) # NOQA assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.') rhs = eval('rhs{}'.format(nrhs)) assert 0 <= ndirichlet <= 2, ValueError('Invalid boundary number.') dirichlet = eval('dirichlet{}'.format(ndirichlet)) assert 0 <= nneumann <= 3, ValueError('Invalid neumann boundary count.') domain = eval('domain{}'.format(nneumann)) for n in [32, 128]: print('Solving on TriaGrid(({0},{0}))'.format(n)) print('Setup problem ...') problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / n) print('Solve ...') U = discretization.solve() print('Plot ...') discretization.visualize(U, title='Triagrid(({0},{0}))'.format(n)) print('')
def thermalblock_demo(args): args['XBLOCKS'] = int(args['XBLOCKS']) args['YBLOCKS'] = int(args['YBLOCKS']) args['--grid'] = int(args['--grid']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--pod-norm'] = args['--pod-norm'].lower() assert args['--pod-norm'] in {'trivial', 'h1'} print('Solving on TriaGrid(({0},{0}))'.format(args['--grid'])) print('Setup Problem ...') problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS'])) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid']) print('The parameter type is {}'.format(discretization.parameter_type)) if args['--plot-solutions']: print('Showing some solutions') Us = tuple() legend = tuple() for mu in discretization.parameter_space.sample_randomly(2): print('Solving for diffusion = \n{} ... '.format(mu['diffusion'])) sys.stdout.flush() Us = Us + (discretization.solve(mu),) legend = legend + (str(mu['diffusion']),) discretization.visualize(Us, legend=legend, title='Detailed Solutions for different parameters', block=True) print('RB generation ...') tic = time.time() print('Solving on training set ...') S_train = list(discretization.parameter_space.sample_uniformly(args['SNAPSHOTS'])) snapshots = discretization.operator.type_source.empty(discretization.operator.dim_source, reserve=len(S_train)) for mu in S_train: snapshots.append(discretization.solve(mu)) print('Performing POD ...') pod_product = discretization.h1_product if args['--pod-norm'] == 'h1' else None rb = pod(snapshots, modes=args['RBSIZE'], product=pod_product)[0] print('Reducing ...') reductor = reduce_generic_rb rb_discretization, reconstructor, _ = reductor(discretization, rb) toc = time.time() t_offline = toc - tic print('\nSearching for maximum error on random snapshots ...') tic = time.time() h1_err_max = -1 cond_max = -1 for mu in discretization.parameter_space.sample_randomly(args['--test']): print('Solving RB-Scheme for mu = {} ... '.format(mu), end='') URB = reconstructor.reconstruct(rb_discretization.solve(mu)) U = discretization.solve(mu) h1_err = discretization.h1_norm(U - URB)[0] cond = np.linalg.cond(rb_discretization.operator.assemble(mu)._matrix) if h1_err > h1_err_max: h1_err_max = h1_err Umax = U URBmax = URB mumax = mu if cond > cond_max: cond_max = cond cond_max_mu = mu print('H1-error = {}, condition = {}'.format(h1_err, cond)) toc = time.time() t_est = toc - tic real_rb_size = len(rb) print(''' *** RESULTS *** Problem: number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]} h: sqrt(2)/{args[--grid]} POD basis generation: number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]}) pod norm: {args[--pod-norm]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {t_offline} Stochastic error estimation: number of samples: {args[--test]} maximal H1-error: {h1_err_max} (mu = {mumax}) maximal condition of system matrix: {cond_max} (mu = {cond_max_mu}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-err']: discretization.visualize((U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'), title='Maximum Error Solution', separate_colorbars=True, block=True)
def thermalblock_demo(args): args['XBLOCKS'] = int(args['XBLOCKS']) args['YBLOCKS'] = int(args['YBLOCKS']) args['--grid'] = int(args['--grid']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--estimator-norm'] = args['--estimator-norm'].lower() assert args['--estimator-norm'] in {'trivial', 'h1'} args['--extension-alg'] = args['--extension-alg'].lower() assert args['--extension-alg'] in {'trivial', 'gram_schmidt', 'h1_gram_schmidt'} print('Solving on TriaGrid(({0},{0}))'.format(args['--grid'])) print('Setup Problem ...') problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS'])) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid']) print('The parameter type is {}'.format(discretization.parameter_type)) if args['--plot-solutions']: print('Showing some solutions') Us = tuple() legend = tuple() for mu in discretization.parameter_space.sample_randomly(2): print('Solving for diffusion = \n{} ... '.format(mu['diffusion'])) sys.stdout.flush() Us = Us + (discretization.solve(mu),) legend = legend + (str(mu['diffusion']),) discretization.visualize(Us, legend=legend, title='Detailed Solutions for different parameters', block=True) print('RB generation ...') error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None reductor = partial(reduce_stationary_affine_linear, error_product=error_product) extension_algorithms = {'trivial': trivial_basis_extension, 'gram_schmidt': gram_schmidt_basis_extension, 'h1_gram_schmidt': partial(gram_schmidt_basis_extension, product=discretization.h1_product)} extension_algorithm = extension_algorithms[args['--extension-alg']] greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm, extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] print('\nSearching for maximum error on random snapshots ...') def error_analysis(d, rd, rc, mus): print('N = {}: '.format(rd.operator.dim_source), end='') h1_err_max = -1 h1_est_max = -1 cond_max = -1 for mu in mus: print('.', end='') u = rd.solve(mu) URB = rc.reconstruct(u) U = d.solve(mu) h1_err = d.h1_norm(U - URB)[0] h1_est = rd.estimate(u, mu=mu) cond = np.linalg.cond(rd.operator.assemble(mu)._matrix) if h1_err > h1_err_max: h1_err_max = h1_err mumax = mu if h1_est > h1_est_max: h1_est_max = h1_est mu_est_max = mu if cond > cond_max: cond_max = cond cond_max_mu = mu print() return h1_err_max, mumax, h1_est_max, mu_est_max, cond_max, cond_max_mu tic = time.time() real_rb_size = len(greedy_data['basis']) if args['--plot-error-sequence']: N_count = min(real_rb_size - 1, 25) Ns = np.linspace(1, real_rb_size, N_count).astype(np.int) else: Ns = np.array([real_rb_size]) rd_rcs = [reduce_to_subbasis(rb_discretization, N, reconstructor)[:2] for N in Ns] mus = list(discretization.parameter_space.sample_randomly(args['--test'])) errs, err_mus, ests, est_mus, conds, cond_mus = zip(*(error_analysis(discretization, rd, rc, mus) for rd, rc in rd_rcs)) h1_err_max = errs[-1] mumax = err_mus[-1] cond_max = conds[-1] cond_max_mu = cond_mus[-1] toc = time.time() t_est = toc - tic print(''' *** RESULTS *** Problem: number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]} h: sqrt(2)/{args[--grid]} Greedy basis generation: number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]}) used estimator: {args[--with-estimator]} estimator norm: {args[--estimator-norm]} extension method: {args[--extension-alg]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal H1-error: {h1_err_max} (mu = {mumax}) maximal condition of system matrix: {cond_max} (mu = {cond_max_mu}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-error-sequence']: plt.semilogy(Ns, errs, Ns, ests) plt.legend(('error', 'estimator')) plt.show() if args['--plot-err']: U = discretization.solve(mumax) URB = reconstructor.reconstruct(rb_discretization.solve(mumax)) discretization.visualize((U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'), title='Maximum Error Solution', separate_colorbars=True, block=True)
def thermalblock_demo(args): args['XBLOCKS'] = int(args['XBLOCKS']) args['YBLOCKS'] = int(args['YBLOCKS']) args['--grid'] = int(args['--grid']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--estimator-norm'] = args['--estimator-norm'].lower() assert args['--estimator-norm'] in {'trivial', 'h1'} args['--extension-alg'] = args['--extension-alg'].lower() assert args['--extension-alg'] in {'trivial', 'gram_schmidt', 'h1_gram_schmidt', 'numpy_trivial', 'numpy_gram_schmidt'} args['--reductor'] = args['--reductor'].lower() assert args['--reductor'] in {'default', 'numpy_default'} print('Solving on TriaGrid(({0},{0}))'.format(args['--grid'])) print('Setup Problem ...') problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS'])) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid']) print(discretization.parameter_info()) if args['--plot-solutions']: print('Showing some solutions') for mu in discretization.parameter_space.sample_randomly(2): print('Solving for diffusion = \n{} ... '.format(mu['diffusion'])) sys.stdout.flush() U = discretization.solve(mu) discretization.visualize(U) print('RB generation ...') error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None reductors = {'default': partial(reduce_stationary_affine_linear, error_product=error_product), 'numpy_default': partial(numpy_reduce_stationary_affine_linear, error_product=error_product)} reductor = reductors[args['--reductor']] extension_algorithms = {'trivial': trivial_basis_extension, 'gram_schmidt': gram_schmidt_basis_extension, 'h1_gram_schmidt': partial(gram_schmidt_basis_extension, product=discretization.h1_product), 'numpy_trivial': numpy_trivial_basis_extension, 'numpy_gram_schmidt': numpy_gram_schmidt_basis_extension} extension_algorithm = extension_algorithms[args['--extension-alg']] greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm, extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] print('\nSearching for maximum error on random snapshots ...') tic = time.time() h1_err_max = -1 cond_max = -1 for mu in discretization.parameter_space.sample_randomly(args['--test']): print('Solving RB-Scheme for mu = {} ... '.format(mu), end='') URB = reconstructor.reconstruct(rb_discretization.solve(mu)) U = discretization.solve(mu) h1_err = discretization.h1_norm(U - URB)[0] cond = np.linalg.cond(rb_discretization.operator.assemble(mu)._matrix) if h1_err > h1_err_max: h1_err_max = h1_err Umax = U URBmax = URB mumax = mu if cond > cond_max: cond_max = cond cond_max_mu = mu print('H1-error = {}, condition = {}'.format(h1_err, cond)) toc = time.time() t_est = toc - tic real_rb_size = len(greedy_data['data']) print(''' *** RESULTS *** Problem: number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]} h: sqrt(2)/{args[--grid]} Greedy basis generation: number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]}) used estimator: {args[--with-estimator]} estimator norm: {args[--estimator-norm]} extension method: {args[--extension-alg]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal H1-error: {h1_err_max} (mu = {mumax}) maximal condition of system matrix: {cond_max} (mu = {cond_max_mu}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-err']: discretization.visualize(U - URB)