folivo/PINA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

preliminary modifications for N-S

Browse Source
This commit is contained in:
Anna Ivagnes
2022-05-05 17:12:31 +02:00
parent d152fe67e3
commit 8130912926
13 changed files with 213 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
examples/problems/burgers.py
View File

@@ -14,22 +14,22 @@ class Burgers1D(TimeDependentProblem, SpatialProblem):
domain = Span({'x': [-1, 1], 't': [0, 1]})
def burger_equation(input_, output_):
grad_u = grad(output_['u'], input_)
grad_x = grad_u['x']
grad_t = grad_u['t']
gradgrad_u_x = grad(grad_u['x'], input_)
grad_u = grad(output_.extract(['u']), input_)
grad_x = grad_u.extract(['x'])
grad_t = grad_u.extract(['t'])
gradgrad_u_x = grad(grad_u.extract(['x']), input_)
return (
grad_u['t'] + output_['u']*grad_u['x'] -
(0.01/torch.pi)*gradgrad_u_x['x']
grad_u.extract(['t']) + output_.extract(['u'])*grad_u.extract(['x']) -
(0.01/torch.pi)*gradgrad_u_x.extract(['x'])
)
def nil_dirichlet(input_, output_):
u_expected = 0.0
return output_['u'] - u_expected
return output_.extract(['u']) - u_expected
def initial_condition(input_, output_):
u_expected = -torch.sin(torch.pi*input_['x'])
return output_['u'] - u_expected
u_expected = -torch.sin(torch.pi*input_.extract(['x']))
return output_.extract(['u']) - u_expected
conditions = {
'gamma1': Condition(Span({'x': -1, 't': [0, 1]}), nil_dirichlet),

20
examples/problems/elliptic_optimal_control.py
View File

@@ -12,26 +12,26 @@ class EllipticOptimalControl(Problem2D):
def __init__(self, alpha=1):
def term1(input_, 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_)
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_['y'] - yd - (gradgrad_p_x1['x1'] + gradgrad_p_x2['x2'])
return output_.extract(['y']) - yd - (gradgrad_p_x1.extract(['x1']) + gradgrad_p_x2.extract(['x2']))
def term2(input_, 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']
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_['p'] - output_['u']*alpha
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_['y'] - y_value) + torch.abs(output_['p'] - p_value)
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},

8
examples/problems/parametric_poisson.py
View File

@@ -14,13 +14,13 @@ class ParametricPoisson(SpatialProblem, ParametricProblem):
def laplace_equation(input_, output_):
force_term = torch.exp(
- 2*(input_['x'] - input_['mu1'])**2 - 2*(input_['y'] -
input_['mu2'])**2)
return nabla(output_['u'], input_) - force_term
- 2*(input_.extract(['x']) - input_.extract(['mu1']))**2 - 2*(input_.extract(['y']) -
input_.extract(['mu2']))**2)
return nabla(output_.extract(['u']), input_) - force_term
def nil_dirichlet(input_, output_):
value = 0.0
return output_['u'] - value
return output_.extract(['u']) - value
conditions = {
'gamma1': Condition(

20
examples/problems/stokes.py
View File

@@ -13,28 +13,24 @@ class Stokes(SpatialProblem):
domain = Span({'x': [-2, 2], 'y': [-1, 1]})
def momentum(input_, output_):
#print(nabla(output_['ux', 'uy'], input_))
#print(grad(output_['p'], input_))
nabla_ = LabelTensor.hstack([
LabelTensor(nabla(output_['ux'], input_), ['x']),
LabelTensor(nabla(output_['uy'], input_), ['y'])])
#return LabelTensor(nabla_.tensor + grad(output_['p'], input_).tensor, ['x', 'y'])
return nabla_.tensor + grad(output_['p'], input_).tensor
nabla_ = torch.hstack((LabelTensor(nabla(output_.extract(['ux']), input_), ['x']),
LabelTensor(nabla(output_.extract(['uy']), input_), ['y'])))
return - nabla_ + grad(output_.extract(['p']), input_)
def continuity(input_, output_):
return div(output_['ux', 'uy'], input_)
return div(output_.extract(['ux', 'uy']), input_)
def inlet(input_, output_):
value = 2.0
return output_['ux'] - value
value = 2 * (1 - input_.extract(['y'])**2)
return output_.extract(['ux']) - value
def outlet(input_, output_):
value = 0.0
return output_['p'] - value
return output_.extract(['p']) - value
def wall(input_, output_):
value = 0.0
return output_['ux', 'uy'].tensor - value
return output_.extract(['ux', 'uy']) - value
conditions = {
'gamma_top': Condition(Span({'x': [-2, 2], 'y': 1}), wall),