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=1. / args['--grid']) self.grid = pack['grid']
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 stop_gui_processes()
def thermalblock_factory(xblocks, yblocks, diameter, seed): from pymor.analyticalproblems.thermalblock import ThermalBlockProblem from pymor.discretizers.elliptic import discretize_elliptic_cg from pymor.functions.basic import GenericFunction from pymor.operators.cg import InterpolationOperator p = ThermalBlockProblem((xblocks, yblocks)) d, d_data = discretize_elliptic_cg(p, diameter) f = GenericFunction(lambda X, mu: X[..., 0]**mu['exp'] + X[..., 1], dim_domain=2, parameter_type={'exp': ()}) iop = InterpolationOperator(d_data['grid'], f) U = d.operator.source.empty() V = d.operator.range.empty() np.random.seed(seed) for exp in np.random.random(5): U.append(iop.as_vector(exp)) for exp in np.random.random(6): V.append(iop.as_vector(exp)) return d.operator, d.parameter_space.sample_randomly(1, seed=seed)[0], U, V, d.h1_product, d.l2_product
def thermalblock_factory(xblocks, yblocks, diameter, seed): from pymor.analyticalproblems.thermalblock import ThermalBlockProblem from pymor.discretizers.elliptic import discretize_elliptic_cg from pymor.functions.basic import GenericFunction from pymor.operators.cg import InterpolationOperator p = ThermalBlockProblem((xblocks, yblocks)) d, d_data = discretize_elliptic_cg(p, diameter) f = GenericFunction(lambda X, mu: X[..., 0]**mu['exp'] + X[..., 1], dim_domain=2, parameter_type={'exp': tuple()}) iop = InterpolationOperator(d_data['grid'], f) U = d.operator.source.empty() V = d.operator.range.empty() np.random.seed(seed) for exp in np.random.random(5): U.append(iop.as_vector(exp)) for exp in np.random.random(6): V.append(iop.as_vector(exp)) return d.operator, d.parameter_space.sample_randomly(1, seed=seed)[0], U, V, d.h1_product, d.l2_product
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 parabolic_demo(): p = ThermalBlockProblem(parameter_range=(0.01, 1)) d_stat, d_data = discretize_elliptic_cg(p, diameter=1.0 / 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() try: visualize_patch(data['grid'], U=U, backend=backend) except PySideMissing as ie: pytest.xfail("PySide missing") finally: stop_gui_processes()
def discretize_pymor(xblocks, yblocks, grid_num_intervals, use_list_vector_array): from pymor.analyticalproblems.thermalblock import ThermalBlockProblem from pymor.discretizers.elliptic import discretize_elliptic_cg from pymor.playground.discretizers.numpylistvectorarray import convert_to_numpy_list_vector_array print('Discretize ...') # setup analytical problem problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS'])) # discretize using continuous finite elements d, _ = discretize_elliptic_cg(problem, diameter=1. / args['--grid']) if use_list_vector_array: d = convert_to_numpy_list_vector_array(d) summary = '''pyMOR discretization: number of blocks: {xblocks}x{yblocks} grid intervals: {grid_num_intervals} ListVectorArray: {use_list_vector_array} '''.format(**locals()) return d, summary
def discretize_pymor(xblocks, yblocks, grid_num_intervals, use_list_vector_array): from pymor.analyticalproblems.thermalblock import ThermalBlockProblem from pymor.discretizers.elliptic import discretize_elliptic_cg from pymor.playground.discretizers.numpylistvectorarray import convert_to_numpy_list_vector_array print('Discretize ...') # setup analytical problem problem = ThermalBlockProblem(num_blocks=(xblocks, yblocks)) # discretize using continuous finite elements d, _ = discretize_elliptic_cg(problem, diameter=1. / grid_num_intervals) if use_list_vector_array: d = convert_to_numpy_list_vector_array(d) summary = '''pyMOR discretization: number of blocks: {xblocks}x{yblocks} grid intervals: {grid_num_intervals} ListVectorArray: {use_list_vector_array} '''.format(**locals()) return d, summary
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=1. / 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.source.empty(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 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 discretize_parabolic_cg(analytical_problem, diameter=None, domain_discretizer=None, grid=None, boundary_info=None, num_values=None, time_stepper=None, nt=None): """Discretizes an |ParabolicProblem| using finite elements. Parameters ---------- analytical_problem The |ParabolicProblem| to discretize. diameter If not `None`, `diameter` is passed to the `domain_discretizer`. domain_discretizer Discretizer to be used for discretizing the analytical domain. This has to be a function `domain_discretizer(domain_description, diameter, ...)`. If further arguments should be passed to the discretizer, use :func:`functools.partial`. If `None`, |discretize_domain_default| is used. grid Instead of using a domain discretizer, the |Grid| can also be passed directly using this parameter. boundary_info A |BoundaryInfo| specifying the boundary types of the grid boundary entities. Must be provided if `grid` is specified. num_values The number of returned vectors of the solution trajectory. If `None`, each intermediate vector that is calculated is returned. time_stepper The time-stepper to be used by :class:`~pymor.discretizations.basic.InstationaryDiscretization.solve`. Has to satisfy the :class:`~pymor.algorithms.timestepping.TimeStepperInterface`. nt The number of time-steps. If provided implicit euler time-stepping is used. Returns ------- discretization The |Discretization| that has been generated. data Dictionary with the following entries: :grid: The generated |Grid|. :boundary_info: The generated |BoundaryInfo|. """ assert isinstance(analytical_problem, ParabolicProblem) assert grid is None or boundary_info is not None assert boundary_info is None or grid is not None assert grid is None or domain_discretizer is None assert time_stepper is None or nt is None p = analytical_problem d, data = discretize_elliptic_cg(p.elliptic_part(), diameter=diameter, domain_discretizer=domain_discretizer, grid=grid, boundary_info=boundary_info) if p.initial_data.parametric: I = InterpolationOperator(data['grid'], p.initial_data) else: I = p.initial_data.evaluate(data['grid'].centers(data['grid'].dim)) I = NumpyVectorArray(I, copy=False) if time_stepper is None: time_stepper = ImplicitEulerTimeStepper(nt=nt) mass = d.l2_product if isinstance(time_stepper, ImplicitEulerTimeStepper) else None discretization = InstationaryDiscretization(operator=d.operator, rhs=d.rhs, mass=mass, initial_data=I, T=p.T, products=d.products, time_stepper=time_stepper, parameter_space=d.parameter_space, visualizer=d.visualizer, num_values=num_values, name='{}_CG'.format(p.name)) return discretization, data
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' } args['--reductor'] = args['--reductor'].lower() assert args['--reductor'] in {'traditional', 'residual_basis'} 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=1. / 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 coercivity_estimator = ExpressionParameterFunctional( 'min(diffusion)', discretization.parameter_type) reductors = { 'residual_basis': partial(reduce_stationary_coercive, error_product=error_product, coercivity_estimator=coercivity_estimator), 'traditional': partial(reduce_stationary_affine_linear, error_product=error_product, coercivity_estimator=coercivity_estimator) } 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) } 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'] if args['--pickle']: print('\nWriting reduced discretization to file {} ...'.format( args['--pickle'] + '_reduced')) with open(args['--pickle'] + '_reduced', 'w') as f: dump(rb_discretization, f) print( 'Writing detailed discretization and reconstructor to file {} ...'. format(args['--pickle'] + '_detailed')) with open(args['--pickle'] + '_detailed', 'w') as f: dump((discretization, reconstructor), f) print('\nSearching for maximum error on random snapshots ...') def error_analysis(d, rd, rc, mus): print('N = {}: '.format(rd.operator.source.dim), end='') h1_err_max = -1 h1_est_max = -1 cond_max = -1 for mu in mus: print('.', end='') sys.stdout.flush() 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['--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=1. / 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.source.empty(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 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 discretize_parabolic_cg(analytical_problem, diameter=None, domain_discretizer=None, grid=None, boundary_info=None, num_values=None, time_stepper=None, nt=None): """Discretizes an |ParabolicProblem| using finite elements. Parameters ---------- analytical_problem The |ParabolicProblem| to discretize. diameter If not `None`, `diameter` is passed to the `domain_discretizer`. domain_discretizer Discretizer to be used for discretizing the analytical domain. This has to be a function `domain_discretizer(domain_description, diameter, ...)`. If further arguments should be passed to the discretizer, use :func:`functools.partial`. If `None`, |discretize_domain_default| is used. grid Instead of using a domain discretizer, the |Grid| can also be passed directly using this parameter. boundary_info A |BoundaryInfo| specifying the boundary types of the grid boundary entities. Must be provided if `grid` is specified. num_values The number of returned vectors of the solution trajectory. If `None`, each intermediate vector that is calculated is returned. time_stepper The time-stepper to be used by :class:`~pymor.discretizations.basic.InstationaryDiscretization.solve`. Has to satisfy the :class:`~pymor.algorithms.timestepping.TimeStepperInterface`. nt The number of time-steps. If provided implicit euler time-stepping is used. Returns ------- discretization The |Discretization| that has been generated. data Dictionary with the following entries: :grid: The generated |Grid|. :boundary_info: The generated |BoundaryInfo|. """ assert isinstance(analytical_problem, ParabolicProblem) assert grid is None or boundary_info is not None assert boundary_info is None or grid is not None assert grid is None or domain_discretizer is None assert time_stepper is None or nt is None p = analytical_problem d, data = discretize_elliptic_cg(p.elliptic_part(), diameter=diameter, domain_discretizer=domain_discretizer, grid=grid, boundary_info=boundary_info) if p.initial_data.parametric: I = InterpolationOperator(data['grid'], p.initial_data) else: I = p.initial_data.evaluate(data['grid'].centers(data['grid'].dim)) I = NumpyVectorArray(I, copy=False) if time_stepper is None: time_stepper = ImplicitEulerTimeStepper(nt=nt) mass = d.l2_0_product discretization = InstationaryDiscretization(operator=d.operator, rhs=d.rhs, mass=mass, initial_data=I, T=p.T, products=d.products, time_stepper=time_stepper, parameter_space=d.parameter_space, visualizer=d.visualizer, num_values=num_values, name='{}_CG'.format(p.name)) return discretization, data
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause) from itertools import product import pytest import os from pymor.discretizers.advection import discretize_nonlinear_instationary_advection_fv from pymor.discretizers.disk import discretize_stationary_from_disk, discretize_instationary_from_disk from pymor.discretizers.elliptic import discretize_elliptic_cg from pymortests.fixtures.analyticalproblem import (picklable_thermalblock_problems, non_picklable_thermalblock_problems, burgers_problems) picklable_discretizaion_generators = \ [lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0] for p, d in product(picklable_thermalblock_problems, [1./50., 1./100.])] + \ [lambda p=p,d=d: discretize_nonlinear_instationary_advection_fv(p, diameter=d)[0] for p, d in product(burgers_problems, [1./10., 1./15.])] + \ [lambda p=p: discretize_stationary_from_disk(parameter_file=p) for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_stationary.ini'),)] + \ [lambda p=p: discretize_instationary_from_disk(parameter_file=p) for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_instationary.ini'),)] non_picklable_discretization_generators = \ [lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0] for p, d in product(non_picklable_thermalblock_problems, [1./20., 1./30.])] discretization_generators = picklable_discretizaion_generators + non_picklable_discretization_generators
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'} args['--reductor'] = args['--reductor'].lower() assert args['--reductor'] in {'traditional', 'residual_basis'} 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=1. / 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 coercivity_estimator=ExpressionParameterFunctional('min(diffusion)', discretization.parameter_type) reductors = {'residual_basis': partial(reduce_stationary_coercive, error_product=error_product, coercivity_estimator=coercivity_estimator), 'traditional': partial(reduce_stationary_affine_linear, error_product=error_product, coercivity_estimator=coercivity_estimator)} 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)} 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'] if args['--pickle']: print('\nWriting reduced discretization to file {} ...'.format(args['--pickle'] + '_reduced')) with open(args['--pickle'] + '_reduced', 'w') as f: dump(rb_discretization, f) print('Writing detailed discretization and reconstructor to file {} ...'.format(args['--pickle'] + '_detailed')) with open(args['--pickle'] + '_detailed', 'w') as f: dump((discretization, reconstructor), f) print('\nSearching for maximum error on random snapshots ...') def error_analysis(d, rd, rc, mus): print('N = {}: '.format(rd.operator.source.dim), end='') h1_err_max = -1 h1_est_max = -1 cond_max = -1 for mu in mus: print('.', end='') sys.stdout.flush() 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['--grid'] = int(args['--grid']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--ipython-engines'] = int(args['--ipython-engines']) 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'} args['--reductor'] = args['--reductor'].lower() assert args['--reductor'] in {'traditional', 'residual_basis'} args['--cache-region'] = args['--cache-region'].lower() args['--validation-mus'] = int(args['--validation-mus']) args['--rho'] = float(args['--rho']) args['--gamma'] = float(args['--gamma']) args['--theta'] = float(args['--theta']) print('Solving on TriaGrid(({0},{0}))'.format(args['--grid'])) print('Setup Problem ...') problem = ThermalBlockProblem(num_blocks=(2, 2)) functionals = [ExpressionParameterFunctional('diffusion[0]', {'diffusion': (2,)}), ExpressionParameterFunctional('diffusion[1]**2', {'diffusion': (2,)}), ExpressionParameterFunctional('diffusion[0]', {'diffusion': (2,)}), ExpressionParameterFunctional('diffusion[1]', {'diffusion': (2,)})] problem = EllipticProblem(domain=problem.domain, diffusion_functions=problem.diffusion_functions, diffusion_functionals=functionals, rhs=problem.rhs, parameter_space=CubicParameterSpace({'diffusion': (2,)}, 0.1, 1.)) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=1. / args['--grid']) if args['--list-vector-array']: from pymor.playground.discretizers.numpylistvectorarray import convert_to_numpy_list_vector_array discretization = convert_to_numpy_list_vector_array(discretization) if args['--cache-region'] != 'none': discretization.enable_caching(args['--cache-region']) print('The parameter type is {}'.format(discretization.parameter_type)) if args['--plot-solutions']: print('Showing some solutions') Us = () legend = () 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 ...') product = discretization.h1_0_semi_product if args['--estimator-norm'] == 'h1' else None coercivity_estimator=ExpressionParameterFunctional('min([diffusion[0], diffusion[1]**2])', discretization.parameter_type) reductors = {'residual_basis': partial(reduce_coercive, product=product, coercivity_estimator=coercivity_estimator), 'traditional': partial(reduce_coercive_simple, product=product, coercivity_estimator=coercivity_estimator)} 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_0_semi_product)} extension_algorithm = extension_algorithms[args['--extension-alg']] pool = new_parallel_pool(ipython_num_engines=args['--ipython-engines'], ipython_profile=args['--ipython-profile']) greedy_data = adaptive_greedy(discretization, reductor, validation_mus=args['--validation-mus'], rho=args['--rho'], gamma=args['--gamma'], theta=args['--theta'], use_estimator=not args['--without-estimator'], error_norm=discretization.h1_0_semi_norm, extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE'], visualize=args['--visualize-refinement']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] if args['--pickle']: print('\nWriting reduced discretization to file {} ...'.format(args['--pickle'] + '_reduced')) with open(args['--pickle'] + '_reduced', 'wb') as f: dump(rb_discretization, f) print('Writing detailed discretization and reconstructor to file {} ...'.format(args['--pickle'] + '_detailed')) with open(args['--pickle'] + '_detailed', 'wb') as f: dump((discretization, reconstructor), f) print('\nSearching for maximum error on random snapshots ...') results = reduction_error_analysis(rb_discretization, discretization=discretization, reconstructor=reconstructor, estimator=True, error_norms=(discretization.h1_0_semi_norm,), condition=True, test_mus=args['--test'], basis_sizes=25 if args['--plot-error-sequence'] else 1, plot=True, pool=pool) real_rb_size = rb_discretization.solution_space.dim print(''' *** RESULTS *** Problem: number of blocks: 2x2 h: sqrt(2)/{args[--grid]} Greedy basis generation: estimator disabled: {args[--without-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]} '''.format(**locals())) print(results['summary']) sys.stdout.flush() if args['--plot-error-sequence']: from matplotlib import pyplot as plt plt.show(results['figure']) if args['--plot-err']: mumax = results['max_error_mus'][0, -1] 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)
from itertools import product import pytest import os from pymor.discretizers.advection import discretize_nonlinear_instationary_advection_fv from pymor.discretizers.disk import discretize_stationary_from_disk, discretize_instationary_from_disk from pymor.discretizers.elliptic import discretize_elliptic_cg from pymortests.fixtures.analyticalproblem import ( picklable_thermalblock_problems, non_picklable_thermalblock_problems, burgers_problems) picklable_discretizaion_generators = \ [lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0] for p, d in product(picklable_thermalblock_problems, [1./50., 1./100.])] + \ [lambda p=p,d=d: discretize_nonlinear_instationary_advection_fv(p, diameter=d)[0] for p, d in product(burgers_problems, [1./10., 1./15.])] + \ [lambda p=p: discretize_stationary_from_disk(parameter_file=p) for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_stationary.ini'),)] + \ [lambda p=p: discretize_instationary_from_disk(parameter_file=p) for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_instationary.ini'),)] non_picklable_discretization_generators = \ [lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0] for p, d in product(non_picklable_thermalblock_problems, [1./20., 1./30.])] discretization_generators = picklable_discretizaion_generators + non_picklable_discretization_generators