version 0.0.1

2022-02-11 16:44:37 +01:00
parent fa8ffd5042
commit 1483746b45
29 changed files with 416 additions and 559 deletions
--- a/examples/problems/burgers.py
+++ b/examples/problems/burgers.py
@@ -1,35 +1,26 @@
-import numpy as np
-import scipy.io
 import torch

-from pina.segment import Segment
-from pina.cube import Cube
-from pina.problem import TimeDependentProblem, Problem1D
+from pina.problem import TimeDependentProblem, SpatialProblem
 from pina.operators import grad
+from pina import Condition
+from pina.span import Span

-def tmp_grad(output_, input_):
-    return torch.autograd.grad(
-            output_,
-            input_.tensor,
-            grad_outputs=torch.ones(output_.size()).to(
-                dtype=input_.tensor.dtype,
-                device=input_.tensor.device),
-            create_graph=True, retain_graph=True, allow_unused=True)[0]

-class Burgers1D(TimeDependentProblem, Problem1D):
+class Burgers1D(TimeDependentProblem, SpatialProblem):

-    input_variables = ['x', 't']
+    spatial_variables = ['x']
+    temporal_variable = ['t']
    output_variables = ['u']
-    spatial_domain = Cube([[-1, 1]])
-    temporal_domain = Cube([[0, 1]])
+    domain = Span({'x': [-1, 1], 't': [0, 1]})

    def burger_equation(input_, output_):
        grad_u = grad(output_['u'], input_)
-        grad_x, grad_t = tmp_grad(output_['u'], input_).T
+        grad_x, grad_t = grad(output_['u'], input_).T
        gradgrad_u_x = grad(grad_u['x'], input_)
-        grad_xx = tmp_grad(grad_x, input_)[:, 0]
-        return grad_u['t'] + output_['u']*grad_u['x'] - (0.01/torch.pi)*gradgrad_u_x['x']
-
+        return (
+            grad_u['t'] + output_['u']*grad_u['x'] -
+            (0.01/torch.pi)*gradgrad_u_x['x']
+        )

    def nil_dirichlet(input_, output_):
        u_expected = 0.0
@@ -39,11 +30,9 @@ class Burgers1D(TimeDependentProblem, Problem1D):
        u_expected = -torch.sin(torch.pi*input_['x'])
        return output_['u'] - u_expected

-
-
    conditions = {
-        'gamma1': {'location': Segment((-1, 0), (-1, 1)), 'func': nil_dirichlet},
-        'gamma2': {'location': Segment(( 1, 0), ( 1, 1)), 'func': nil_dirichlet},
-        'initia': {'location': Segment((-1, 0), ( 1, 0)), 'func': initial_condition},
-        'D': {'location': Cube([[-1, 1],[0,1]]), 'func': burger_equation}
+        '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),
    }
--- a/examples/problems/parametric_poisson.py
+++ b/examples/problems/parametric_poisson.py
@@ -1,43 +1,41 @@
-import numpy as np
 import torch
-from pina.segment import Segment
-from pina.cube import Cube
-from pina.problem2d import Problem2D
-from pina.problem import Problem
+
+from pina.problem import SpatialProblem, ParametricProblem
+from pina.operators import nabla
+from pina import Span, Condition


-class ParametricPoisson2DProblem(Problem2D):
+class ParametricPoisson(SpatialProblem, ParametricProblem):

-    def __init__(self):
+    spatial_variables = ['x', 'y']
+    parameters = ['mu1', 'mu2']
+    output_variables = ['u']
+    domain = Span({'x': [-1, 1], 'y': [-1, 1]})

-        def laplace_equation(input_, param_, output_):
-            grad_u = self.grad(output_['u'], input_)
-            gradgrad_u_x = self.grad(grad_u['x'], input_)
-            gradgrad_u_y = self.grad(grad_u['y'], input_)
-            force_term = torch.exp(
-                    - 2*(input_['x'] - input_['mu1'])**2 -
-                    2*(input_['y'] - input_['mu2'])**2
-            )
-            return gradgrad_u_x['x'] + gradgrad_u_y['y'] - force_term
+    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

-        def nil_dirichlet(input_, param_, output_):
-            value = 0.0
-            return output_['u'] - value
+    def nil_dirichlet(input_, output_):
+        value = 0.0
+        return output_['u'] - value

-        self.conditions = {
-            'gamma1': {'location': Segment((-1, -1), ( 1, -1)),'func': nil_dirichlet},
-            'gamma2': {'location': Segment(( 1, -1), ( 1,  1)),'func': nil_dirichlet},
-            'gamma3': {'location': Segment(( 1,  1), (-1,  1)),'func': nil_dirichlet},
-            'gamma4': {'location': Segment((-1,  1), (-1, -1)),'func': nil_dirichlet},
-            'D': {'location': Cube([[-1, 1], [-1, 1]]), 'func': laplace_equation}
-        }
-
-        self.input_variables = ['x', 'y']
-        self.output_variables = ['u']
-        self.parameters = ['mu1', 'mu2']
-        #self.truth_solution = poisson_sol
-        self.spatial_domain = Cube([[0, 1], [0, 1]])
-        self.parameter_domain = np.array([[-1, 1], [-1, 1]])
-
-
-        #self.check() # Check the problem is correctly set
+    conditions = {
+        'gamma1': Condition(
+            Span({'x': [-1, 1], 'y': 1, 'mu1': [-1, 1], 'mu2': [-1, 1]}),
+            nil_dirichlet),
+        'gamma2': Condition(
+            Span({'x': [-1, 1], 'y': -1, 'mu1': [-1, 1], 'mu2': [-1, 1]}),
+            nil_dirichlet),
+        'gamma3': Condition(
+            Span({'x': 1, 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
+            nil_dirichlet),
+        'gamma4': Condition(
+            Span({'x': -1, 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
+            nil_dirichlet),
+        'D': Condition(
+            Span({'x': [-1, 1], 'y': [-1, 1], 'mu1': [-1, 1], 'mu2': [-1, 1]}),
+            laplace_equation),
+    }
--- a/examples/problems/poisson.py
+++ b/examples/problems/poisson.py
@@ -0,0 +1,35 @@
+import numpy as np
+import torch
+
+from pina.problem import SpatialProblem
+from pina.operators import nabla
+from pina import Condition, Span
+
+
+class Poisson(SpatialProblem):
+
+    spatial_variables = ['x', 'y']
+    output_variables = ['u']
+    domain = Span({'x': [0, 1], 'y': [0, 1]})
+
+    def laplace_equation(input_, output_):
+        force_term = (torch.sin(input_['x']*torch.pi) *
+                      torch.sin(input_['y']*torch.pi))
+        return nabla(output_['u'], input_).flatten() - force_term
+
+    def nil_dirichlet(input_, output_):
+        value = 0.0
+        return output_['u'] - value
+
+    conditions = {
+        'gamma1': Condition(Span({'x': [-1, 1], 'y':  1}), nil_dirichlet),
+        'gamma2': Condition(Span({'x': [-1, 1], 'y': -1}), nil_dirichlet),
+        'gamma3': Condition(Span({'x':  1, 'y': [-1, 1]}), nil_dirichlet),
+        'gamma4': Condition(Span({'x': -1, 'y': [-1, 1]}), nil_dirichlet),
+        'D': Condition(Span({'x': [-1, 1], 'y': [-1, 1]}), laplace_equation),
+    }
+
+    def poisson_sol(self, x, y):
+        return -(np.sin(x*np.pi)*np.sin(y*np.pi))/(2*np.pi**2)
+
+    truth_solution = poisson_sol
--- a/examples/problems/poisson2D.py
+++ b/examples/problems/poisson2D.py
@@ -1,35 +0,0 @@
-import numpy as np
-import torch
-from pina.segment import Segment
-from pina.cube import Cube
-from pina.problem import Problem2D
-from pina.operators import grad, div, nabla
-
-
-class Poisson2D(Problem2D):
-
-    input_variables = ['x', 'y']
-    output_variables = ['u']
-    spatial_domain = Cube([[0, 1], [0, 1]])
-
-    def laplace_equation(input_, output_):
-        force_term = (torch.sin(input_['x']*torch.pi)
-                        * torch.sin(input_['y']*torch.pi))
-        return nabla(output_['u'], input_).flatten() - force_term
-
-    def nil_dirichlet(input_, output_):
-        value = 0.0
-        return output_['u'] - value
-
-    conditions = {
-        'gamma1': {'location': Segment((0, 0), (1, 0)), 'func': nil_dirichlet},
-        'gamma2': {'location': Segment((1, 0), (1, 1)), 'func': nil_dirichlet},
-        'gamma3': {'location': Segment((1, 1), (0, 1)), 'func': nil_dirichlet},
-        'gamma4': {'location': Segment((0, 1), (0, 0)), 'func': nil_dirichlet},
-        'D': {'location': Cube([[0, 1], [0, 1]]), 'func': laplace_equation}
-    }
-
-    def poisson_sol(self, x, y):
-        return -(np.sin(x*np.pi)*np.sin(y*np.pi))/(2*np.pi**2)
-
-    truth_solution = poisson_sol