def elliptic_demo(args): args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER']) assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError('Invalid problem number') args['DIRICHLET-NUMBER'] = int(args['DIRICHLET-NUMBER']) assert 0 <= args['DIRICHLET-NUMBER'] <= 2, ValueError('Invalid Dirichlet boundary number.') args['NEUMANN-NUMBER'] = int(args['NEUMANN-NUMBER']) assert 0 <= args['NEUMANN-NUMBER'] <= 2, ValueError('Invalid Neumann boundary number.') args['NEUMANN-COUNT'] = int(args['NEUMANN-COUNT']) assert 0 <= args['NEUMANN-COUNT'] <= 3, ValueError('Invalid Neumann boundary count.') rhss = [ExpressionFunction('ones(x.shape[:-1]) * 10', 2, ()), ExpressionFunction('(x[..., 0] - 0.5) ** 2 * 1000', 2, ())] dirichlets = [ExpressionFunction('zeros(x.shape[:-1])', 2, ()), ExpressionFunction('ones(x.shape[:-1])', 2, ()), ExpressionFunction('x[..., 0]', 2, ())] neumanns = [None, ConstantFunction(3., dim_domain=2), ExpressionFunction('50*(0.1 <= x[..., 1]) * (x[..., 1] <= 0.2)' '+50*(0.8 <= x[..., 1]) * (x[..., 1] <= 0.9)', 2, ())] domains = [RectDomain(), RectDomain(right='neumann'), RectDomain(right='neumann', top='neumann'), RectDomain(right='neumann', top='neumann', bottom='neumann')] rhs = rhss[args['PROBLEM-NUMBER']] dirichlet = dirichlets[args['DIRICHLET-NUMBER']] neumann = neumanns[args['NEUMANN-NUMBER']] domain = domains[args['NEUMANN-COUNT']] problem = StationaryProblem( domain=domain, diffusion=ConstantFunction(1, dim_domain=2), rhs=rhs, dirichlet_data=dirichlet, neumann_data=neumann ) for n in [32, 128]: print('Discretize ...') discretizer = discretize_stationary_fv if args['--fv'] else discretize_stationary_cg m, data = discretizer( analytical_problem=problem, grid_type=RectGrid if args['--rect'] else TriaGrid, diameter=np.sqrt(2) / n if args['--rect'] else 1. / n ) grid = data['grid'] print(grid) print() print('Solve ...') U = m.solve() m.visualize(U, title=repr(grid)) print()
def elliptic_demo(args): args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER']) assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError('Invalid problem number') args['DIRICHLET-NUMBER'] = int(args['DIRICHLET-NUMBER']) assert 0 <= args['DIRICHLET-NUMBER'] <= 2, ValueError('Invalid Dirichlet boundary number.') args['NEUMANN-NUMBER'] = int(args['NEUMANN-NUMBER']) assert 0 <= args['NEUMANN-NUMBER'] <= 2, ValueError('Invalid Neumann boundary number.') args['NEUMANN-COUNT'] = int(args['NEUMANN-COUNT']) assert 0 <= args['NEUMANN-COUNT'] <= 3, ValueError('Invalid Neumann boundary count.') rhss = [GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, 2), GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, 2)] dirichlets = [GenericFunction(lambda X: np.zeros(X.shape[:-1]), 2), GenericFunction(lambda X: np.ones(X.shape[:-1]), 2), GenericFunction(lambda X: X[..., 0], 2)] neumanns = [None, ConstantFunction(3., dim_domain=2), GenericFunction(lambda X: 50*(0.1 <= X[..., 1]) * (X[..., 1] <= 0.2) +50*(0.8 <= X[..., 1]) * (X[..., 1] <= 0.9), 2)] domains = [RectDomain(), RectDomain(right=BoundaryType('neumann')), RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann')), RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann'), bottom=BoundaryType('neumann'))] rhs = rhss[args['PROBLEM-NUMBER']] dirichlet = dirichlets[args['DIRICHLET-NUMBER']] neumann = neumanns[args['NEUMANN-NUMBER']] domain = domains[args['NEUMANN-COUNT']] for n in [32, 128]: grid_name = '{1}(({0},{0}))'.format(n, 'RectGrid' if args['--rect'] else 'TriaGrid') print('Solving on {0}'.format(grid_name)) print('Setup problem ...') problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet, neumann_data=neumann) print('Discretize ...') if args['--rect']: grid, bi = discretize_domain_default(problem.domain, diameter=m.sqrt(2) / n, grid_type=RectGrid) else: grid, bi = discretize_domain_default(problem.domain, diameter=1. / n, grid_type=TriaGrid) discretizer = discretize_elliptic_fv if args['--fv'] else discretize_elliptic_cg discretization, _ = discretizer(analytical_problem=problem, grid=grid, boundary_info=bi) print('Solve ...') U = discretization.solve() print('Plot ...') discretization.visualize(U, title=grid_name) print('')
def __init__(self, num_blocks=(3, 3), parameter_range=(0.1, 1), rhs=ConstantFunction(dim_domain=2)): domain = RectDomain() parameter_space = CubicParameterSpace( {'diffusion': (num_blocks[1], num_blocks[0])}, *parameter_range) def parameter_functional_factory(x, y): return ProjectionParameterFunctional( component_name='diffusion', component_shape=(num_blocks[1], num_blocks[0]), coordinates=(num_blocks[1] - y - 1, x), name='diffusion_{}_{}'.format(x, y)) diffusion_functions = tuple( ThermalBlockDiffusionFunction(x, y, num_blocks[0], num_blocks[1]) for x, y in product(xrange(num_blocks[0]), xrange(num_blocks[1]))) parameter_functionals = tuple( parameter_functional_factory(x, y) for x, y in product(xrange(num_blocks[0]), xrange(num_blocks[1]))) super(ThermalBlockProblem, self).__init__(domain, rhs, diffusion_functions, parameter_functionals, name='ThermalBlock') self.parameter_space = parameter_space self.parameter_range = parameter_range self.num_blocks = num_blocks
def __init__(self, domain=RectDomain(), rhs=ConstantFunction(dim_domain=2), diffusion_functions=(ConstantFunction(dim_domain=2), ), diffusion_functionals=None, dirichlet_data=None, neumann_data=None, initial_data=ConstantFunction(dim_domain=2), T=1, parameter_space=None, name=None): assert isinstance(diffusion_functions, (tuple, list)) assert diffusion_functionals is None and len(diffusion_functions) == 1 \ or len(diffusion_functionals) == len(diffusion_functions) assert rhs.dim_domain == diffusion_functions[0].dim_domain assert dirichlet_data is None or dirichlet_data.dim_domain == diffusion_functions[ 0].dim_domain assert neumann_data is None or neumann_data.dim_domain == diffusion_functions[ 0].dim_domain assert initial_data is None or initial_data.dim_domain == diffusion_functions[ 0].dim_domain self.domain = domain self.rhs = rhs self.diffusion_functions = diffusion_functions self.diffusion_functionals = diffusion_functionals self.dirichlet_data = dirichlet_data self.neumann_data = neumann_data self.initial_data = initial_data self.T = T self.parameter_space = parameter_space self.name = name
def burgers_problem_2d(vx=1., vy=1., torus=True, initial_data_type='sin', parameter_range=(1., 2.)): """Two-dimensional Burgers-type problem. The problem is to solve :: ∂_t u(x, t, μ) + ∇ ⋅ (v * u(x, t, μ)^μ) = 0 u(x, 0, μ) = u_0(x) for u with t in [0, 0.3], x in [0, 2] x [0, 1]. Parameters ---------- vx The x component of the velocity vector v. vy The y component of the velocity vector v. torus If `True`, impose periodic boundary conditions. Otherwise, Dirichlet left and bottom, outflow top and right. initial_data_type Type of initial data (`'sin'` or `'bump'`). parameter_range The interval in which μ is allowed to vary. """ assert initial_data_type in ('sin', 'bump') if initial_data_type == 'sin': initial_data = ExpressionFunction( "0.5 * (sin(2 * pi * x[..., 0]) * sin(2 * pi * x[..., 1]) + 1.)", 2, ()) dirichlet_data = ConstantFunction(dim_domain=2, value=0.5) else: initial_data = ExpressionFunction( "(x[..., 0] >= 0.5) * (x[..., 0] <= 1) * 1", 2, ()) dirichlet_data = ConstantFunction(dim_domain=2, value=0.) return InstationaryProblem( StationaryProblem( domain=TorusDomain([[0, 0], [2, 1]]) if torus else RectDomain([[0, 0], [2, 1]], right=None, top=None), dirichlet_data=dirichlet_data, rhs=None, nonlinear_advection=ExpressionFunction("abs(x)**exponent * v", 1, (2, ), {'exponent': ()}, {'v': np.array([vx, vy])}), nonlinear_advection_derivative=ExpressionFunction( "exponent * abs(x)**(exponent-1) * sign(x) * v", 1, (2, ), {'exponent': ()}, {'v': np.array([vx, vy])}), ), initial_data=initial_data, T=0.3, parameter_space=CubicParameterSpace({'exponent': 0}, *parameter_range), name="burgers_problem_2d({}, {}, {}, '{}')".format( vx, vy, torus, initial_data_type))
def __init__(self, domain=RectDomain(), rhs=ConstantFunction(dim_domain=2), flux_function=ConstantFunction(value=np.array([0, 0]), dim_domain=1), flux_function_derivative=ConstantFunction(value=np.array([0, 0]), dim_domain=1), dirichlet_data=ConstantFunction(value=0, dim_domain=2), initial_data=ConstantFunction(value=1, dim_domain=2), T=1, name=None): self.domain = domain self.rhs = rhs self.flux_function = flux_function self.flux_function_derivative = flux_function_derivative self.dirichlet_data = dirichlet_data self.initial_data = initial_data self.T = T self.name = name
def __init__(self, domain=RectDomain(), rhs=None, parameter_range=(0., 100.), dirichlet_data=None, neumann_data=None): self.parameter_range = parameter_range # needed for with_ parameter_space = CubicParameterSpace({'k': ()}, *parameter_range) super().__init__( diffusion_functions=[ConstantFunction(1., dim_domain=domain.dim)], diffusion_functionals=[1.], reaction_functions=[ConstantFunction(1., dim_domain=domain.dim)], reaction_functionals=[ExpressionParameterFunctional('-k**2', {'k': ()})], domain=domain, rhs=rhs or ConstantFunction(1., dim_domain=domain.dim), parameter_space=parameter_space, dirichlet_data=dirichlet_data, neumann_data=neumann_data)
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 = StationaryProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet, diffusion=diffusion) grid, bi = discretize_domain_default(problem.domain, grid_type=gridtype) m, data = discretize_stationary_cg(analytical_problem=problem, grid=grid, boundary_info=bi) U = m.solve() try: visualize_patch(data['grid'], U=U, backend=backend) except QtMissing as ie: pytest.xfail("Qt missing") finally: stop_gui_processes()
def helmholtz_problem(domain=RectDomain(), rhs=None, parameter_range=(0., 100.), dirichlet_data=None, neumann_data=None): """Helmholtz equation problem. This problem is to solve the Helmholtz equation :: - ∆ u(x, k) - k^2 u(x, k) = f(x, k) on a given domain. Parameters ---------- domain A |DomainDescription| of the domain the problem is posed on. rhs The |Function| f(x, μ). parameter_range A tuple `(k_min, k_max)` describing the interval in which k is allowd to vary. dirichlet_data |Function| providing the Dirichlet boundary values. neumann_data |Function| providing the Neumann boundary values. """ return StationaryProblem( domain=domain, rhs=rhs or ConstantFunction(1., dim_domain=domain.dim), dirichlet_data=dirichlet_data, neumann_data=neumann_data, diffusion=ConstantFunction(1., dim_domain=domain.dim), reaction=LincombFunction([ConstantFunction(1., dim_domain=domain.dim)], [ExpressionParameterFunctional('-k**2', {'k': ()})]), parameter_space=CubicParameterSpace({'k': ()}, *parameter_range), name='helmholtz_problem' )
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 elliptic2_demo(args): args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER']) assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError( 'Invalid problem number.') args['N'] = int(args['N']) rhss = [ GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim_domain=2), GenericFunction(lambda X: (X[..., 0] - 0.5)**2 * 1000, dim_domain=2) ] rhs = rhss[args['PROBLEM-NUMBER']] 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(args['N'])) print('Setup Problem ...') problem = EllipticProblem(domain=RectDomain(), rhs=rhs, diffusion_functions=(d0, d1), diffusion_functionals=(f0, f1), name='2DProblem') print('Discretize ...') discretizer = discretize_elliptic_fv if args[ '--fv'] else discretize_elliptic_cg discretization, _ = discretizer(problem, diameter=1. / args['N']) print('The parameter type is {}'.format(discretization.parameter_type)) U = discretization.solution_space.empty() for mu in parameter_space.sample_uniformly(10): U.append(discretization.solve(mu)) print('Plot ...') discretization.visualize(U, title='Solution for diffusionl in [0.1, 1]')
def __init__(self, vx=1., vy=1., torus=True, initial_data_type='sin', parameter_range=(1., 2.)): assert initial_data_type in ('sin', 'bump') flux_function = Burgers2DFlux(vx, vy) flux_function_derivative = Burgers2DFluxDerivative(vx, vy) if initial_data_type == 'sin': initial_data = Burgers2DSinInitialData() dirichlet_data = ConstantFunction(dim_domain=2, value=0.5) else: initial_data = Burgers2DBumpInitialData() dirichlet_data = ConstantFunction(dim_domain=2, value=0) domain = TorusDomain([[0, 0], [2, 1]]) if torus else RectDomain( [[0, 0], [2, 1]], right=None, top=None) super(Burgers2DProblem, self).__init__(domain=domain, rhs=None, flux_function=flux_function, flux_function_derivative=flux_function_derivative, initial_data=initial_data, dirichlet_data=dirichlet_data, T=0.3, name='Burgers2DProblem') self.parameter_space = CubicParameterSpace({'exponent': 0}, *parameter_range) self.parameter_range = parameter_range self.initial_data_type = initial_data_type self.torus = torus self.vx = vx self.vy = vy
def elliptic2_demo(args): args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER']) assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError( 'Invalid problem number.') args['N'] = int(args['N']) rhss = [ ExpressionFunction('ones(x.shape[:-1]) * 10', 2, ()), ExpressionFunction('(x[..., 0] - 0.5)**2 * 1000', 2, ()) ] rhs = rhss[args['PROBLEM-NUMBER']] problem = StationaryProblem( domain=RectDomain(), rhs=rhs, diffusion=LincombFunction([ ExpressionFunction('1 - x[..., 0]', 2, ()), ExpressionFunction('x[..., 0]', 2, ()) ], [ ProjectionParameterFunctional('diffusionl', 0), ExpressionParameterFunctional('1', {}) ]), parameter_space=CubicParameterSpace({'diffusionl': 0}, 0.1, 1), name='2DProblem') print('Discretize ...') discretizer = discretize_stationary_fv if args[ '--fv'] else discretize_stationary_cg m, data = discretizer(problem, diameter=1. / args['N']) print(data['grid']) print() print('Solve ...') U = m.solution_space.empty() for mu in m.parameter_space.sample_uniformly(10): U.append(m.solve(mu)) m.visualize(U, title='Solution for diffusionl in [0.1, 1]')
def thermal_block_problem(num_blocks=(3, 3), parameter_range=(0.1, 1)): """Analytical description of a 2D 'thermal block' diffusion problem. The problem is to solve the elliptic equation :: - ∇ ⋅ [ d(x, μ) ∇ u(x, μ) ] = f(x, μ) on the domain [0,1]^2 with Dirichlet zero boundary values. The domain is partitioned into nx x ny blocks and the diffusion function d(x, μ) is constant on each such block (i,j) with value μ_ij. :: ---------------------------- | | | | | μ_11 | μ_12 | μ_13 | | | | | |--------------------------- | | | | | μ_21 | μ_22 | μ_23 | | | | | ---------------------------- Parameters ---------- num_blocks The tuple `(nx, ny)` parameter_range A tuple `(μ_min, μ_max)`. Each |Parameter| component μ_ij is allowed to lie in the interval [μ_min, μ_max]. """ def parameter_functional_factory(ix, iy): return ProjectionParameterFunctional(component_name='diffusion', component_shape=(num_blocks[1], num_blocks[0]), index=(num_blocks[1] - iy - 1, ix), name=f'diffusion_{ix}_{iy}') def diffusion_function_factory(ix, iy): if ix + 1 < num_blocks[0]: X = '(x[..., 0] >= ix * dx) * (x[..., 0] < (ix + 1) * dx)' else: X = '(x[..., 0] >= ix * dx)' if iy + 1 < num_blocks[1]: Y = '(x[..., 1] >= iy * dy) * (x[..., 1] < (iy + 1) * dy)' else: Y = '(x[..., 1] >= iy * dy)' return ExpressionFunction(f'{X} * {Y} * 1.', 2, (), {}, {'ix': ix, 'iy': iy, 'dx': 1. / num_blocks[0], 'dy': 1. / num_blocks[1]}, name=f'diffusion_{ix}_{iy}') return StationaryProblem( domain=RectDomain(), rhs=ConstantFunction(dim_domain=2, value=1.), diffusion=LincombFunction([diffusion_function_factory(ix, iy) for ix, iy in product(range(num_blocks[0]), range(num_blocks[1]))], [parameter_functional_factory(ix, iy) for ix, iy in product(range(num_blocks[0]), range(num_blocks[1]))], name='diffusion'), parameter_space=CubicParameterSpace({'diffusion': (num_blocks[1], num_blocks[0])}, *parameter_range), name=f'ThermalBlock({num_blocks})' )
def elliptic2_demo(args): args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER']) assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError( 'Invalid problem number.') args['N'] = int(args['N']) rhss = [ ExpressionFunction('ones(x.shape[:-1]) * 10', 2, ()), LincombFunction([ ExpressionFunction('ones(x.shape[:-1]) * 10', 2, ()), ConstantFunction(1., 2) ], [ ProjectionParameterFunctional('mu', 0), ExpressionParameterFunctional('0.1', {}) ]) ] dirichlets = [ ExpressionFunction('zeros(x.shape[:-1])', 2, ()), LincombFunction([ ExpressionFunction('2 * x[..., 0]', 2, ()), ConstantFunction(1., 2) ], [ ProjectionParameterFunctional('mu', 0), ExpressionParameterFunctional('0.5', {}) ]) ] neumanns = [ None, LincombFunction([ ExpressionFunction('1 - x[..., 1]', 2, ()), ConstantFunction(1., 2) ], [ ProjectionParameterFunctional('mu', 0), ExpressionParameterFunctional('0.5**2', {}) ]) ] robins = [ None, (LincombFunction( [ExpressionFunction('x[..., 1]', 2, ()), ConstantFunction(1., 2)], [ ProjectionParameterFunctional('mu', 0), ExpressionParameterFunctional('1', {}) ]), ConstantFunction(1., 2)) ] domains = [ RectDomain(), RectDomain(right='neumann', top='dirichlet', bottom='robin') ] rhs = rhss[args['PROBLEM-NUMBER']] dirichlet = dirichlets[args['PROBLEM-NUMBER']] neumann = neumanns[args['PROBLEM-NUMBER']] domain = domains[args['PROBLEM-NUMBER']] robin = robins[args['PROBLEM-NUMBER']] problem = StationaryProblem(domain=RectDomain(), rhs=rhs, diffusion=LincombFunction([ ExpressionFunction('1 - x[..., 0]', 2, ()), ExpressionFunction('x[..., 0]', 2, ()) ], [ ProjectionParameterFunctional('mu', 0), ExpressionParameterFunctional('1', {}) ]), dirichlet_data=dirichlet, neumann_data=neumann, robin_data=robin, parameter_space=CubicParameterSpace({'mu': 0}, 0.1, 1), name='2DProblem') print('Discretize ...') discretizer = discretize_stationary_fv if args[ '--fv'] else discretize_stationary_cg m, data = discretizer(problem, diameter=1. / args['N']) print(data['grid']) print() print('Solve ...') U = m.solution_space.empty() for mu in m.parameter_space.sample_uniformly(10): U.append(m.solve(mu)) m.visualize(U, title='Solution for mu in [0.1, 1]')
def text_problem(text='pyMOR', font_name=None): import numpy as np from PIL import Image, ImageDraw, ImageFont from tempfile import NamedTemporaryFile font_list = [font_name] if font_name else [ 'DejaVuSansMono.ttf', 'VeraMono.ttf', 'UbuntuMono-R.ttf', 'Arial.ttf' ] font = None for filename in font_list: try: font = ImageFont.truetype( filename, 64) # load some font from file of given size except (OSError, IOError): pass if font is None: raise ValueError('Could not load TrueType font') size = font.getsize(text) # compute width and height of rendered text size = (size[0] + 20, size[1] + 20 ) # add a border of 10 pixels around the text def make_bitmap_function( char_num ): # we need to genereate a BitmapFunction for each character img = Image.new('L', size) # create new Image object of given dimensions d = ImageDraw.Draw(img) # create ImageDraw object for the given Image # in order to position the character correctly, we first draw all characters from the first # up to the wanted character d.text((10, 10), text[:char_num + 1], font=font, fill=255) # next we erase all previous character by drawing a black rectangle if char_num > 0: d.rectangle( ((0, 0), (font.getsize(text[:char_num])[0] + 10, size[1])), fill=0, outline=0) # open a new temporary file with NamedTemporaryFile( suffix='.png' ) as f: # after leaving this 'with' block, the temporary # file is automatically deleted img.save(f, format='png') return BitmapFunction(f.name, bounding_box=[(0, 0), size], range=[0., 1.]) # create BitmapFunctions for each character dfs = [make_bitmap_function(n) for n in range(len(text))] # create an indicator function for the background background = ConstantFunction(1., 2) - LincombFunction( dfs, np.ones(len(dfs))) # form the linear combination dfs = [background] + dfs coefficients = [1] + [ ProjectionParameterFunctional('diffusion', (len(text), ), (i, )) for i in range(len(text)) ] diffusion = LincombFunction(dfs, coefficients) return StationaryProblem(domain=RectDomain(dfs[1].bounding_box, bottom='neumann'), neumann_data=ConstantFunction(-1., 2), diffusion=diffusion, parameter_space=CubicParameterSpace( diffusion.parameter_type, 0.1, 1.))
from src.base import plot2d import logging logging.getLogger('matplotlib').setLevel(logging.ERROR) if __name__ == '__main__': argvs = sys.argv parser = OptionParser() parser.add_option("--dir", dest="dir", default="./") opt, argc = parser.parse_args(argvs) print(opt, argc) rhs = ExpressionFunction('(x[..., 0] - 0.5)**2 * 1000', 2, ()) problem = StationaryProblem( domain=RectDomain(), rhs=rhs, diffusion=LincombFunction( [ExpressionFunction('1 - x[..., 0]', 2, ()), ExpressionFunction('x[..., 0]', 2, ())], [ProjectionParameterFunctional( 'diffusionl', 0), ExpressionParameterFunctional('1', {})] ), parameter_space=CubicParameterSpace({'diffusionl': 0}, 0.01, 0.1), name='2DProblem' ) args = {'N': 100, 'samples': 10} m, data = discretize_stationary_cg(problem, diameter=1. / args['N']) U = m.solution_space.empty() for mu in m.parameter_space.sample_uniformly(args['samples']):
result[space] = myfunction return result if __name__ == "__main__": from pymor.analyticalproblems.elliptic import EllipticProblem from pymor.domaindescriptions.basic import RectDomain from pymor.functions.basic import ConstantFunction from my_discretize_elliptic_cg import discretize_elliptic_cg from lmor.localizer import NumpyLocalizer from lmor.partitioner import build_subspaces, partition_any_grid coarse_grid_resolution = 10 p = EllipticProblem(domain=RectDomain([[0, 0], [1, 1]]), diffusion_functions=(ConstantFunction(1., dim_domain=2), ), diffusion_functionals=(1., ), rhs=ConstantFunction(1., dim_domain=2)) d, data = discretize_elliptic_cg(p, diameter=0.01) grid = data["grid"] subspaces, subspaces_per_codim = build_subspaces(*partition_any_grid( grid, num_intervals=(coarse_grid_resolution, coarse_grid_resolution))) localizer = NumpyLocalizer(d.solution_space, subspaces['dofs']) images = d.solution_space.empty() fdict = localized_pou(subspaces, subspaces_per_codim, localizer, coarse_grid_resolution, grid)
rhs=GenericFunction(dim_domain=2, mapping=lambda X: X[..., 0] + X[..., 1]))] thermalblock_problems = picklable_thermalblock_problems + non_picklable_thermalblock_problems burgers_problems = \ [burgers_problem(), burgers_problem(v=0.2, circle=False), burgers_problem(v=0.4, initial_data_type='bump'), burgers_problem(parameter_range=(1., 1.3)), burgers_problem_2d(), burgers_problem_2d(torus=False, initial_data_type='bump', parameter_range=(1.3, 1.5))] picklable_elliptic_problems = \ [StationaryProblem(domain=RectDomain(), rhs=ConstantFunction(dim_domain=2, value=1.)), helmholtz_problem()] non_picklable_elliptic_problems = \ [StationaryProblem(domain=RectDomain(), rhs=ConstantFunction(dim_domain=2, value=21.), diffusion=LincombFunction( [GenericFunction(dim_domain=2, mapping=lambda X, p=p: X[..., 0]**p) for p in range(5)], [ExpressionParameterFunctional('max(mu["exp"], {})'.format(m), parameter_type={'exp': ()}) for m in range(5)] ))] elliptic_problems = picklable_thermalblock_problems + non_picklable_elliptic_problems
def __init__(self, domain=RectDomain(), rhs=ConstantFunction(dim_domain=2), diffusion_functions=None, diffusion_functionals=None, advection_functions=None, advection_functionals=None, reaction_functions=None, reaction_functionals=None, dirichlet_data=None, neumann_data=None, robin_data=None, parameter_space=None, name=None): assert diffusion_functions is None or isinstance( diffusion_functions, (tuple, list)) assert advection_functions is None or isinstance( advection_functions, (tuple, list)) assert reaction_functions is None or isinstance( reaction_functions, (tuple, list)) assert diffusion_functionals is None and diffusion_functions is None \ or diffusion_functionals is None and len(diffusion_functions) == 1 \ or len(diffusion_functionals) == len(diffusion_functions) assert advection_functionals is None and advection_functions is None \ or advection_functionals is None and len(advection_functions) == 1 \ or len(advection_functionals) == len(advection_functions) assert reaction_functionals is None and reaction_functions is None \ or reaction_functionals is None and len(reaction_functions) == 1 \ or len(reaction_functionals) == len(reaction_functions) # for backward compatibility: if (diffusion_functions is None and advection_functions is None and reaction_functions is None): diffusion_functions = (ConstantFunction(dim_domain=2), ) # dim_domain: if diffusion_functions is not None: dim_domain = diffusion_functions[0].dim_domain assert rhs.dim_domain == dim_domain if diffusion_functions is not None: for f in diffusion_functions: assert f.dim_domain == dim_domain if advection_functions is not None: for f in advection_functions: assert f.dim_domain == dim_domain if reaction_functions is not None: for f in reaction_functions: assert f.dim_domain == dim_domain assert dirichlet_data is None or dirichlet_data.dim_domain == dim_domain assert neumann_data is None or neumann_data.dim_domain == dim_domain assert robin_data is None or (isinstance(robin_data, tuple) and len(robin_data) == 2) assert robin_data is None or np.all( [f.dim_domain == dim_domain for f in robin_data]) self.domain = domain self.rhs = rhs self.diffusion_functions = diffusion_functions self.diffusion_functionals = diffusion_functionals self.advection_functions = advection_functions self.advection_functionals = advection_functionals self.reaction_functions = reaction_functions self.reaction_functionals = reaction_functionals self.dirichlet_data = dirichlet_data self.neumann_data = neumann_data self.robin_data = robin_data self.parameter_space = parameter_space self.name = name