update examples
This commit is contained in:
Dario Coscia
committed by
Nicola Demo
Nicola Demo
parent
37e9658211
commit
eb531747e5
@@ -5,13 +5,26 @@ from pina.operators import grad
|
||||
from pina import Condition
|
||||
from pina.span import Span
|
||||
|
||||
# ===================================================== #
|
||||
# #
|
||||
# This script implements the one dimensional Burger #
|
||||
# problem. The Burgers1D class is defined inheriting #
|
||||
# from TimeDependentProblem, SpatialProblem and we #
|
||||
# denote: #
|
||||
# u --> field variable #
|
||||
# x --> spatial variable #
|
||||
# t --> temporal variable #
|
||||
# #
|
||||
# ===================================================== #
|
||||
|
||||
class Burgers1D(TimeDependentProblem, SpatialProblem):
|
||||
|
||||
# assign output/ spatial and temporal variables
|
||||
output_variables = ['u']
|
||||
spatial_domain = Span({'x': [-1, 1]})
|
||||
temporal_domain = Span({'t': [0, 1]})
|
||||
|
||||
# define the burger equation
|
||||
def burger_equation(input_, output_):
|
||||
du = grad(output_, input_)
|
||||
ddu = grad(du, input_, components=['dudx'])
|
||||
@@ -21,17 +34,20 @@ class Burgers1D(TimeDependentProblem, SpatialProblem):
|
||||
(0.01/torch.pi)*ddu.extract(['ddudxdx'])
|
||||
)
|
||||
|
||||
# define nill dirichlet boundary conditions
|
||||
def nil_dirichlet(input_, output_):
|
||||
u_expected = 0.0
|
||||
return output_.extract(['u']) - u_expected
|
||||
|
||||
# define initial condition
|
||||
def initial_condition(input_, output_):
|
||||
u_expected = -torch.sin(torch.pi*input_.extract(['x']))
|
||||
return output_.extract(['u']) - u_expected
|
||||
|
||||
# problem condition statement
|
||||
conditions = {
|
||||
'gamma1': Condition(Span({'x': -1, 't': [0, 1]}), nil_dirichlet),
|
||||
'gamma2': Condition(Span({'x': 1, 't': [0, 1]}), nil_dirichlet),
|
||||
't0': Condition(Span({'x': [-1, 1], 't': 0}), initial_condition),
|
||||
'D': Condition(Span({'x': [-1, 1], 't': [0, 1]}), burger_equation),
|
||||
'gamma1': Condition(location=Span({'x': -1, 't': [0, 1]}), function=nil_dirichlet),
|
||||
'gamma2': Condition(location=Span({'x': 1, 't': [0, 1]}), function=nil_dirichlet),
|
||||
't0': Condition(location=Span({'x': [-1, 1], 't': 0}), function=initial_condition),
|
||||
'D': Condition(location=Span({'x': [-1, 1], 't': [0, 1]}), function=burger_equation),
|
||||
}
|
||||
|
||||
@@ -1,45 +1,47 @@
|
||||
import torch
|
||||
from pina.problem import Problem
|
||||
from pina.segment import Segment
|
||||
from pina.cube import Cube
|
||||
from pina.problem2d import Problem2D
|
||||
# import torch
|
||||
# from pina.problem import Problem
|
||||
# from pina.segment import Segment
|
||||
# from pina.cube import Cube
|
||||
# from pina.problem2d import Problem2D
|
||||
|
||||
xmin, xmax, ymin, ymax = -1, 1, -1, 1
|
||||
# xmin, xmax, ymin, ymax = -1, 1, -1, 1
|
||||
|
||||
class EllipticOptimalControl(Problem2D):
|
||||
# class EllipticOptimalControl(Problem2D):
|
||||
|
||||
def __init__(self, alpha=1):
|
||||
# def __init__(self, alpha=1):
|
||||
|
||||
def term1(input_, output_):
|
||||
grad_p = self.grad(output_.extract(['p']), input_)
|
||||
gradgrad_p_x1 = self.grad(grad_p.extract(['x1']), input_)
|
||||
gradgrad_p_x2 = self.grad(grad_p.extract(['x2']), input_)
|
||||
yd = 2.0
|
||||
return output_.extract(['y']) - yd - (gradgrad_p_x1.extract(['x1']) + gradgrad_p_x2.extract(['x2']))
|
||||
# def term1(input_, output_):
|
||||
# grad_p = self.grad(output_.extract(['p']), input_)
|
||||
# gradgrad_p_x1 = self.grad(grad_p.extract(['x1']), input_)
|
||||
# gradgrad_p_x2 = self.grad(grad_p.extract(['x2']), input_)
|
||||
# yd = 2.0
|
||||
# return output_.extract(['y']) - yd - (gradgrad_p_x1.extract(['x1']) + gradgrad_p_x2.extract(['x2']))
|
||||
|
||||
def term2(input_, output_):
|
||||
grad_y = self.grad(output_.extract(['y']), input_)
|
||||
gradgrad_y_x1 = self.grad(grad_y.extract(['x1']), input_)
|
||||
gradgrad_y_x2 = self.grad(grad_y.extract(['x2']), input_)
|
||||
return - (gradgrad_y_x1.extract(['x1']) + gradgrad_y_x2.extract(['x2'])) - output_.extract(['u'])
|
||||
# def term2(input_, output_):
|
||||
# grad_y = self.grad(output_.extract(['y']), input_)
|
||||
# gradgrad_y_x1 = self.grad(grad_y.extract(['x1']), input_)
|
||||
# gradgrad_y_x2 = self.grad(grad_y.extract(['x2']), input_)
|
||||
# return - (gradgrad_y_x1.extract(['x1']) + gradgrad_y_x2.extract(['x2'])) - output_.extract(['u'])
|
||||
|
||||
def term3(input_, output_):
|
||||
return output_.extract(['p']) - output_.extract(['u'])*alpha
|
||||
# def term3(input_, output_):
|
||||
# return output_.extract(['p']) - output_.extract(['u'])*alpha
|
||||
|
||||
|
||||
def nil_dirichlet(input_, output_):
|
||||
y_value = 0.0
|
||||
p_value = 0.0
|
||||
return torch.abs(output_.extract(['y']) - y_value) + torch.abs(output_.extract(['p']) - p_value)
|
||||
# def nil_dirichlet(input_, output_):
|
||||
# y_value = 0.0
|
||||
# p_value = 0.0
|
||||
# return torch.abs(output_.extract(['y']) - y_value) + torch.abs(output_.extract(['p']) - p_value)
|
||||
|
||||
self.conditions = {
|
||||
'gamma1': {'location': Segment((xmin, ymin), (xmax, ymin)), 'func': nil_dirichlet},
|
||||
'gamma2': {'location': Segment((xmax, ymin), (xmax, ymax)), 'func': nil_dirichlet},
|
||||
'gamma3': {'location': Segment((xmax, ymax), (xmin, ymax)), 'func': nil_dirichlet},
|
||||
'gamma4': {'location': Segment((xmin, ymax), (xmin, ymin)), 'func': nil_dirichlet},
|
||||
'D1': {'location': Cube([[xmin, xmax], [ymin, ymax]]), 'func': [term1, term2, term3]},
|
||||
}
|
||||
# self.conditions = {
|
||||
# 'gamma1': {'location': Segment((xmin, ymin), (xmax, ymin)), 'func': nil_dirichlet},
|
||||
# 'gamma2': {'location': Segment((xmax, ymin), (xmax, ymax)), 'func': nil_dirichlet},
|
||||
# 'gamma3': {'location': Segment((xmax, ymax), (xmin, ymax)), 'func': nil_dirichlet},
|
||||
# 'gamma4': {'location': Segment((xmin, ymax), (xmin, ymin)), 'func': nil_dirichlet},
|
||||
# 'D1': {'location': Cube([[xmin, xmax], [ymin, ymax]]), 'func': [term1, term2, term3]},
|
||||
# }
|
||||
|
||||
self.input_variables = ['x1', 'x2']
|
||||
self.output_variables = ['u', 'p', 'y']
|
||||
self.spatial_domain = Cube([[xmin, xmax], [xmin, xmax]])
|
||||
# self.input_variables = ['x1', 'x2']
|
||||
# self.output_variables = ['u', 'p', 'y']
|
||||
# self.spatial_domain = Cube([[xmin, xmax], [xmin, xmax]])
|
||||
|
||||
raise NotImplementedError('not available problem at the moment...')
|
||||
46
examples/problems/first_order_ode.py
Normal file
46
examples/problems/first_order_ode.py
Normal file
@@ -0,0 +1,46 @@
|
||||
from pina.problem import SpatialProblem
|
||||
from pina import Condition, Span
|
||||
from pina.operators import grad
|
||||
import torch
|
||||
|
||||
# ===================================================== #
|
||||
# #
|
||||
# This script implements a simple first order ode. #
|
||||
# The FirstOrderODE class is defined inheriting from #
|
||||
# SpatialProblem. We denote: #
|
||||
# y --> field variable #
|
||||
# x --> spatial variable #
|
||||
# #
|
||||
# ===================================================== #
|
||||
|
||||
class FirstOrderODE(SpatialProblem):
|
||||
|
||||
# variable domain range
|
||||
x_rng = [0, 5]
|
||||
# field variable
|
||||
output_variables = ['y']
|
||||
# create domain
|
||||
spatial_domain = Span({'x': x_rng})
|
||||
|
||||
# define the ode
|
||||
def ode(input_, output_):
|
||||
y = output_
|
||||
x = input_
|
||||
return grad(y, x) + y - x
|
||||
|
||||
# define initial conditions
|
||||
def fixed(input_, output_):
|
||||
exp_value = 1.
|
||||
return output_ - exp_value
|
||||
|
||||
# define real solution
|
||||
def solution(self, input_):
|
||||
x = input_
|
||||
return x - 1.0 + 2*torch.exp(-x)
|
||||
|
||||
# define problem conditions
|
||||
conditions = {
|
||||
'bc': Condition(location=Span({'x': x_rng[0]}), function=fixed),
|
||||
'dd': Condition(location=Span({'x': x_rng}), function=ode),
|
||||
}
|
||||
truth_solution = solution
|
||||
@@ -1,53 +1,53 @@
|
||||
import numpy as np
|
||||
import torch
|
||||
from pina.problem import Problem
|
||||
from pina.segment import Segment
|
||||
from pina.cube import Cube
|
||||
from pina.problem2d import Problem2D
|
||||
# import numpy as np
|
||||
# import torch
|
||||
# from pina.problem import Problem
|
||||
# from pina.segment import Segment
|
||||
# from pina.cube import Cube
|
||||
# from pina.problem2d import Problem2D
|
||||
|
||||
xmin, xmax, ymin, ymax = -1, 1, -1, 1
|
||||
# xmin, xmax, ymin, ymax = -1, 1, -1, 1
|
||||
|
||||
class ParametricEllipticOptimalControl(Problem2D):
|
||||
# class ParametricEllipticOptimalControl(Problem2D):
|
||||
|
||||
def __init__(self, alpha=1):
|
||||
# def __init__(self, alpha=1):
|
||||
|
||||
def term1(input_, param_, output_):
|
||||
grad_p = self.grad(output_['p'], input_)
|
||||
gradgrad_p_x1 = self.grad(grad_p['x1'], input_)
|
||||
gradgrad_p_x2 = self.grad(grad_p['x2'], input_)
|
||||
return output_['y'] - param_ - (gradgrad_p_x1['x1'] + gradgrad_p_x2['x2'])
|
||||
# def term1(input_, param_, output_):
|
||||
# grad_p = self.grad(output_['p'], input_)
|
||||
# gradgrad_p_x1 = self.grad(grad_p['x1'], input_)
|
||||
# gradgrad_p_x2 = self.grad(grad_p['x2'], input_)
|
||||
# return output_['y'] - param_ - (gradgrad_p_x1['x1'] + gradgrad_p_x2['x2'])
|
||||
|
||||
def term2(input_, param_, output_):
|
||||
grad_y = self.grad(output_['y'], input_)
|
||||
gradgrad_y_x1 = self.grad(grad_y['x1'], input_)
|
||||
gradgrad_y_x2 = self.grad(grad_y['x2'], input_)
|
||||
return - (gradgrad_y_x1['x1'] + gradgrad_y_x2['x2']) - output_['u_param']
|
||||
# def term2(input_, param_, output_):
|
||||
# grad_y = self.grad(output_['y'], input_)
|
||||
# gradgrad_y_x1 = self.grad(grad_y['x1'], input_)
|
||||
# gradgrad_y_x2 = self.grad(grad_y['x2'], input_)
|
||||
# return - (gradgrad_y_x1['x1'] + gradgrad_y_x2['x2']) - output_['u_param']
|
||||
|
||||
def term3(input_, param_, output_):
|
||||
return output_['p'] - output_['u_param']*alpha
|
||||
# def term3(input_, param_, output_):
|
||||
# return output_['p'] - output_['u_param']*alpha
|
||||
|
||||
|
||||
def term(input_, param_, output_):
|
||||
return term1( input_, param_, output_) +term2( input_, param_, output_) + term3( input_, param_, output_)
|
||||
# def term(input_, param_, output_):
|
||||
# return term1( input_, param_, output_) +term2( input_, param_, output_) + term3( input_, param_, output_)
|
||||
|
||||
def nil_dirichlet(input_, param_, output_):
|
||||
y_value = 0.0
|
||||
p_value = 0.0
|
||||
return torch.abs(output_['y'] - y_value) + torch.abs(output_['p'] - p_value)
|
||||
# def nil_dirichlet(input_, param_, output_):
|
||||
# y_value = 0.0
|
||||
# p_value = 0.0
|
||||
# return torch.abs(output_['y'] - y_value) + torch.abs(output_['p'] - p_value)
|
||||
|
||||
self.conditions = {
|
||||
'gamma1': {'location': Segment((xmin, ymin), (xmax, ymin)), 'func': nil_dirichlet},
|
||||
'gamma2': {'location': Segment((xmax, ymin), (xmax, ymax)), 'func': nil_dirichlet},
|
||||
'gamma3': {'location': Segment((xmax, ymax), (xmin, ymax)), 'func': nil_dirichlet},
|
||||
'gamma4': {'location': Segment((xmin, ymax), (xmin, ymin)), 'func': nil_dirichlet},
|
||||
'D1': {'location': Cube([[xmin, xmax], [ymin, ymax]]), 'func': term},
|
||||
#'D2': {'location': Cube([[0, 1], [0, 1]]), 'func': term2},
|
||||
#'D3': {'location': Cube([[0, 1], [0, 1]]), 'func': term3}
|
||||
}
|
||||
|
||||
self.input_variables = ['x1', 'x2']
|
||||
self.output_variables = ['u', 'p', 'y']
|
||||
self.parameters = ['mu']
|
||||
self.spatial_domain = Cube([[xmin, xmax], [xmin, xmax]])
|
||||
self.parameter_domain = np.array([[0.5, 3]])
|
||||
# self.conditions = {
|
||||
# 'gamma1': {'location': Segment((xmin, ymin), (xmax, ymin)), 'func': nil_dirichlet},
|
||||
# 'gamma2': {'location': Segment((xmax, ymin), (xmax, ymax)), 'func': nil_dirichlet},
|
||||
# 'gamma3': {'location': Segment((xmax, ymax), (xmin, ymax)), 'func': nil_dirichlet},
|
||||
# 'gamma4': {'location': Segment((xmin, ymax), (xmin, ymin)), 'func': nil_dirichlet},
|
||||
# 'D1': {'location': Cube([[xmin, xmax], [ymin, ymax]]), 'func': term},
|
||||
# #'D2': {'location': Cube([[0, 1], [0, 1]]), 'func': term2},
|
||||
# #'D3': {'location': Cube([[0, 1], [0, 1]]), 'func': term3}
|
||||
# }
|
||||
|
||||
# self.input_variables = ['x1', 'x2']
|
||||
# self.output_variables = ['u', 'p', 'y']
|
||||
# self.parameters = ['mu']
|
||||
# self.spatial_domain = Cube([[xmin, xmax], [xmin, xmax]])
|
||||
# self.parameter_domain = np.array([[0.5, 3]])
|
||||
raise NotImplementedError('not available problem at the moment...')
|
||||
|
||||
@@ -5,22 +5,42 @@ from pina import Span, Condition
|
||||
from pina.problem import SpatialProblem, ParametricProblem
|
||||
from pina.operators import grad, nabla
|
||||
|
||||
# ===================================================== #
|
||||
# #
|
||||
# This script implements the two dimensional #
|
||||
# Parametric Elliptic Optimal Control problem. #
|
||||
# The ParametricEllipticOptimalControl class is #
|
||||
# inherited from TimeDependentProblem, SpatialProblem #
|
||||
# and we denote: #
|
||||
# u --> field variable #
|
||||
# p --> field variable #
|
||||
# y --> field variable #
|
||||
# x1, x2 --> spatial variables #
|
||||
# mu, alpha --> problem parameters #
|
||||
# #
|
||||
# More info in https://arxiv.org/pdf/2110.13530.pdf #
|
||||
# Section 4.2 of the article #
|
||||
# ===================================================== #
|
||||
|
||||
|
||||
class ParametricEllipticOptimalControl(SpatialProblem, ParametricProblem):
|
||||
|
||||
# setting spatial variables ranges
|
||||
xmin, xmax, ymin, ymax = -1, 1, -1, 1
|
||||
x_range = [xmin, xmax]
|
||||
y_range = [ymin, ymax]
|
||||
# setting parameters range
|
||||
amin, amax = 0.0001, 1
|
||||
mumin, mumax = 0.5, 3
|
||||
mu_range = [mumin, mumax]
|
||||
a_range = [amin, amax]
|
||||
x_range = [xmin, xmax]
|
||||
y_range = [ymin, ymax]
|
||||
|
||||
# setting field variables
|
||||
output_variables = ['u', 'p', 'y']
|
||||
# setting spatial and parameter domain
|
||||
spatial_domain = Span({'x1': x_range, 'x2': y_range})
|
||||
parameter_domain = Span({'mu': mu_range, 'alpha': a_range})
|
||||
|
||||
|
||||
# equation terms as in https://arxiv.org/pdf/2110.13530.pdf
|
||||
def term1(input_, output_):
|
||||
laplace_p = nabla(output_, input_, components=['p'], d=['x1', 'x2'])
|
||||
return output_.extract(['y']) - input_.extract(['mu']) - laplace_p
|
||||
@@ -37,21 +57,22 @@ class ParametricEllipticOptimalControl(SpatialProblem, ParametricProblem):
|
||||
p_exp = 0.0
|
||||
return output_.extract(['p']) - p_exp
|
||||
|
||||
# setting problem condition formulation
|
||||
conditions = {
|
||||
'gamma1': Condition(
|
||||
Span({'x1': x_range, 'x2': 1, 'mu': mu_range, 'alpha': a_range}),
|
||||
[state_dirichlet, adj_dirichlet]),
|
||||
location=Span({'x1': x_range, 'x2': 1, 'mu': mu_range, 'alpha': a_range}),
|
||||
function=[state_dirichlet, adj_dirichlet]),
|
||||
'gamma2': Condition(
|
||||
Span({'x1': x_range, 'x2': -1, 'mu': mu_range, 'alpha': a_range}),
|
||||
[state_dirichlet, adj_dirichlet]),
|
||||
location=Span({'x1': x_range, 'x2': -1, 'mu': mu_range, 'alpha': a_range}),
|
||||
function=[state_dirichlet, adj_dirichlet]),
|
||||
'gamma3': Condition(
|
||||
Span({'x1': 1, 'x2': y_range, 'mu': mu_range, 'alpha': a_range}),
|
||||
[state_dirichlet, adj_dirichlet]),
|
||||
location=Span({'x1': 1, 'x2': y_range, 'mu': mu_range, 'alpha': a_range}),
|
||||
function=[state_dirichlet, adj_dirichlet]),
|
||||
'gamma4': Condition(
|
||||
Span({'x1': -1, 'x2': y_range, 'mu': mu_range, 'alpha': a_range}),
|
||||
[state_dirichlet, adj_dirichlet]),
|
||||
location=Span({'x1': -1, 'x2': y_range, 'mu': mu_range, 'alpha': a_range}),
|
||||
function=[state_dirichlet, adj_dirichlet]),
|
||||
'D': Condition(
|
||||
Span({'x1': x_range, 'x2': y_range,
|
||||
location=Span({'x1': x_range, 'x2': y_range,
|
||||
'mu': mu_range, 'alpha': a_range}),
|
||||
[term1, term2]),
|
||||
}
|
||||
function=[term1, term2]),
|
||||
}
|
||||
@@ -4,37 +4,52 @@ from pina.problem import SpatialProblem, ParametricProblem
|
||||
from pina.operators import nabla
|
||||
from pina import Span, Condition
|
||||
|
||||
# ===================================================== #
|
||||
# #
|
||||
# This script implements the two dimensional #
|
||||
# Parametric Poisson problem. The ParametricPoisson #
|
||||
# class is defined inheriting from SpatialProblem and #
|
||||
# ParametricProblem. We denote: #
|
||||
# u --> field variable #
|
||||
# x,y --> spatial variables #
|
||||
# mu1, mu2 --> parameter variables #
|
||||
# #
|
||||
# ===================================================== #
|
||||
|
||||
class ParametricPoisson(SpatialProblem, ParametricProblem):
|
||||
|
||||
# assign output/ spatial and parameter variables
|
||||
output_variables = ['u']
|
||||
spatial_domain = Span({'x': [-1, 1], 'y': [-1, 1]})
|
||||
parameter_domain = Span({'mu1': [-1, 1], 'mu2': [-1, 1]})
|
||||
|
||||
# define the laplace equation
|
||||
def laplace_equation(input_, output_):
|
||||
force_term = torch.exp(
|
||||
- 2*(input_.extract(['x']) - input_.extract(['mu1']))**2
|
||||
- 2*(input_.extract(['y']) - input_.extract(['mu2']))**2)
|
||||
return nabla(output_.extract(['u']), input_) - force_term
|
||||
|
||||
# define nill dirichlet boundary conditions
|
||||
def nil_dirichlet(input_, output_):
|
||||
value = 0.0
|
||||
return output_.extract(['u']) - value
|
||||
|
||||
# problem condition statement
|
||||
conditions = {
|
||||
'gamma1': Condition(
|
||||
Span({'x': [-1, 1], 'y': 1, 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
nil_dirichlet),
|
||||
location=Span({'x': [-1, 1], 'y': 1, 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
function=nil_dirichlet),
|
||||
'gamma2': Condition(
|
||||
Span({'x': [-1, 1], 'y': -1, 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
nil_dirichlet),
|
||||
location=Span({'x': [-1, 1], 'y': -1, 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
function=nil_dirichlet),
|
||||
'gamma3': Condition(
|
||||
Span({'x': 1, 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
nil_dirichlet),
|
||||
location=Span({'x': 1, 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
function=nil_dirichlet),
|
||||
'gamma4': Condition(
|
||||
Span({'x': -1, 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
nil_dirichlet),
|
||||
location=Span({'x': -1, 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
function=nil_dirichlet),
|
||||
'D': Condition(
|
||||
Span({'x': [-1, 1], 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
laplace_equation),
|
||||
location=Span({'x': [-1, 1], 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
|
||||
function=laplace_equation),
|
||||
}
|
||||
|
||||
@@ -5,35 +5,49 @@ from pina.problem import SpatialProblem
|
||||
from pina.operators import nabla
|
||||
from pina import Condition, Span
|
||||
|
||||
# ===================================================== #
|
||||
# #
|
||||
# This script implements the two dimensional #
|
||||
# Poisson problem. The Poisson class is defined #
|
||||
# inheriting from SpatialProblem. We denote: #
|
||||
# u --> field variable #
|
||||
# x,y --> spatial variables #
|
||||
# #
|
||||
# ===================================================== #
|
||||
|
||||
|
||||
class Poisson(SpatialProblem):
|
||||
|
||||
# assign output/ spatial variables
|
||||
output_variables = ['u']
|
||||
spatial_domain = Span({'x': [0, 1], 'y': [0, 1]})
|
||||
|
||||
# define the laplace equation
|
||||
def laplace_equation(input_, output_):
|
||||
force_term = (torch.sin(input_.extract(['x'])*torch.pi) *
|
||||
torch.sin(input_.extract(['y'])*torch.pi))
|
||||
nabla_u = nabla(output_.extract(['u']), input_)
|
||||
return nabla_u - force_term
|
||||
|
||||
# define nill dirichlet boundary conditions
|
||||
def nil_dirichlet(input_, output_):
|
||||
value = 0.0
|
||||
return output_.extract(['u']) - value
|
||||
|
||||
# problem condition statement
|
||||
conditions = {
|
||||
'gamma1': Condition(Span({'x': [0, 1], 'y': 1}), nil_dirichlet),
|
||||
'gamma2': Condition(Span({'x': [0, 1], 'y': 0}), nil_dirichlet),
|
||||
'gamma3': Condition(Span({'x': 1, 'y': [0, 1]}), nil_dirichlet),
|
||||
'gamma4': Condition(Span({'x': 0, 'y': [0, 1]}), nil_dirichlet),
|
||||
'D': Condition(Span({'x': [0, 1], 'y': [0, 1]}), laplace_equation),
|
||||
'gamma1': Condition(location=Span({'x': [0, 1], 'y': 1}), function=nil_dirichlet),
|
||||
'gamma2': Condition(location=Span({'x': [0, 1], 'y': 0}), function=nil_dirichlet),
|
||||
'gamma3': Condition(location=Span({'x': 1, 'y': [0, 1]}),function=nil_dirichlet),
|
||||
'gamma4': Condition(location=Span({'x': 0, 'y': [0, 1]}), function=nil_dirichlet),
|
||||
'D': Condition(location=Span({'x': [0, 1], 'y': [0, 1]}), function=laplace_equation),
|
||||
}
|
||||
|
||||
# real poisson solution
|
||||
def poisson_sol(self, pts):
|
||||
return -(
|
||||
torch.sin(pts.extract(['x'])*torch.pi)*
|
||||
torch.sin(pts.extract(['y'])*torch.pi)
|
||||
)/(2*torch.pi**2)
|
||||
#return -(np.sin(x*np.pi)*np.sin(y*np.pi))/(2*np.pi**2)
|
||||
|
||||
truth_solution = poisson_sol
|
||||
|
||||
@@ -5,36 +5,62 @@ from pina.problem import SpatialProblem
|
||||
from pina.operators import nabla, grad, div
|
||||
from pina import Condition, Span, LabelTensor
|
||||
|
||||
# ===================================================== #
|
||||
# #
|
||||
# This script implements the two dimensional #
|
||||
# Stokes problem. The Stokes class is defined #
|
||||
# inheriting from SpatialProblem. We denote: #
|
||||
# ux --> field variable velocity along x #
|
||||
# uy --> field variable velocity along y #
|
||||
# p --> field variable pressure #
|
||||
# x,y --> spatial variables #
|
||||
# #
|
||||
# ===================================================== #
|
||||
|
||||
class Stokes(SpatialProblem):
|
||||
|
||||
# assign output/ spatial variables
|
||||
output_variables = ['ux', 'uy', 'p']
|
||||
spatial_domain = Span({'x': [-2, 2], 'y': [-1, 1]})
|
||||
|
||||
# define the momentum equation
|
||||
def momentum(input_, output_):
|
||||
nabla_ = torch.hstack((LabelTensor(nabla(output_.extract(['ux']), input_), ['x']),
|
||||
LabelTensor(nabla(output_.extract(['uy']), input_), ['y'])))
|
||||
return - nabla_ + grad(output_.extract(['p']), input_)
|
||||
|
||||
|
||||
# define the continuity equation
|
||||
def continuity(input_, output_):
|
||||
return div(output_.extract(['ux', 'uy']), input_)
|
||||
|
||||
# define the inlet velocity
|
||||
def inlet(input_, output_):
|
||||
value = 2 * (1 - input_.extract(['y'])**2)
|
||||
return output_.extract(['ux']) - value
|
||||
|
||||
|
||||
# define the outlet pressure
|
||||
def outlet(input_, output_):
|
||||
value = 0.0
|
||||
return output_.extract(['p']) - value
|
||||
|
||||
# define the wall condition
|
||||
def wall(input_, output_):
|
||||
value = 0.0
|
||||
return output_.extract(['ux', 'uy']) - value
|
||||
|
||||
# problem condition statement
|
||||
conditions = {
|
||||
'gamma_top': Condition(Span({'x': [-2, 2], 'y': 1}), wall),
|
||||
'gamma_bot': Condition(Span({'x': [-2, 2], 'y': -1}), wall),
|
||||
'gamma_out': Condition(Span({'x': 2, 'y': [-1, 1]}), outlet),
|
||||
'gamma_in': Condition(Span({'x': -2, 'y': [-1, 1]}), inlet),
|
||||
'D': Condition(Span({'x': [-2, 2], 'y': [-1, 1]}), [momentum, continuity]),
|
||||
'gamma_top': Condition(location=Span({'x': [-2, 2], 'y': 1}), function=wall),
|
||||
'gamma_bot': Condition(location=Span({'x': [-2, 2], 'y': -1}), function=wall),
|
||||
'gamma_out': Condition(location=Span({'x': 2, 'y': [-1, 1]}), function=outlet),
|
||||
'gamma_in': Condition(location=Span({'x': -2, 'y': [-1, 1]}), function=inlet),
|
||||
'D1': Condition(location=Span({'x': [-2, 2], 'y': [-1, 1]}), function=momentum),
|
||||
'D2': Condition(location=Span({'x': [-2, 2], 'y': [-1, 1]}), function=continuity),
|
||||
}
|
||||
# conditions = {
|
||||
# 'gamma_top': Condition(location=Span({'x': [-2, 2], 'y': 1}), function=wall),
|
||||
# 'gamma_bot': Condition(location=Span({'x': [-2, 2], 'y': -1}), function=wall),
|
||||
# 'gamma_out': Condition(location=Span({'x': 2, 'y': [-1, 1]}), function=outlet),
|
||||
# 'gamma_in': Condition(location=Span({'x': -2, 'y': [-1, 1]}), function=inlet),
|
||||
# 'D': Condition(location=Span({'x': [-2, 2], 'y': [-1, 1]}), function=[momentum, continuity]),
|
||||
# }
|
||||
|
||||
Reference in New Issue
Block a user