Geometry Operations Enhancement (#122)

* updating exclusion domain
- update sample/ is_inside
- create tests

* difference fixes
- random iteration list for sample

* created Intersection

* created a Difference domain

* unittest

* docstrings and minor fixes

* Refacotring Geometries
- added OperationInterface
- redid test cases
- edited Union, Intersect, Exclusion, and Difference
to inherit from OperationInterface
- simplified Union, Intersect, Exclusion, and Difference

* rm lighting logs

---------

Co-authored-by: Dario Coscia <dariocoscia@cli-10-110-16-239.WIFIeduroamSTUD.units.it>

tests/test_geometry/test_cartesian.py

@@ -0,0 +1,37 @@
+import torch
+import pytest
+
+from pina import LabelTensor, Condition, CartesianDomain, PINN
+from pina.problem import SpatialProblem
+from pina.model import FeedForward
+from pina.operators import nabla
+
+
+
+def test_constructor():
+    CartesianDomain({'x': [0, 1], 'y': [0, 1]})
+
+
+def test_is_inside_check_border():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ['x', 'y'])
+    pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ['x', 'y'])
+    domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
+    for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, True, False]):
+        assert domain.is_inside(pt, check_border=True) == exp_result
+
+def test_is_inside_not_check_border():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ['x', 'y'])
+    pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ['x', 'y'])
+    domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
+    for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, False, False]):
+        assert domain.is_inside(pt, check_border=False) == exp_result
+
+def test_is_inside_fixed_variables():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ['x', 'y'])
+    pt_3 = LabelTensor(torch.tensor([[1.0, 1.5]]), ['x', 'y'])
+    domain = CartesianDomain({'x': 1, 'y': [0, 1]})
+    for pt, exp_result in zip([pt_1, pt_2, pt_3], [False, True, False]):
+        assert domain.is_inside(pt, check_border=False) == exp_result

tests/test_geometry/test_difference.py

@@ -0,0 +1,51 @@
+import torch
+
+from pina import LabelTensor
+from pina.geometry import Difference, EllipsoidDomain, CartesianDomain
+
+
+def test_constructor_two_CartesianDomains():
+    Difference([CartesianDomain({'x': [0, 2], 'y': [0, 2]}),
+               CartesianDomain({'x': [1, 3], 'y': [1, 3]})])
+
+
+def test_constructor_two_3DCartesianDomain():
+    Difference([CartesianDomain({'x': [0, 2], 'y': [0, 2], 'z': [0, 2]}),
+                CartesianDomain({'x': [1, 3], 'y': [1, 3], 'z': [1, 3]})])
+
+
+def test_constructor_three_CartesianDomains():
+    Difference([CartesianDomain({'x': [0, 2], 'y': [0, 2]}), CartesianDomain(
+        {'x': [1, 3], 'y': [1, 3]}), CartesianDomain({'x': [2, 4], 'y': [2, 4]})])
+
+
+def test_is_inside_two_CartesianDomains():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -0.5]]), ['x', 'y'])
+    domain = Difference([CartesianDomain({'x': [0, 2], 'y': [0, 2]}),
+                         CartesianDomain({'x': [1, 3], 'y': [1, 3]})])
+    assert domain.is_inside(pt_1) == True
+    assert domain.is_inside(pt_2) == False
+
+
+def test_is_inside_two_3DCartesianDomain():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ['x', 'y', 'z'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -0.5, -0.5]]), ['x', 'y', 'z'])
+    domain = Difference([CartesianDomain({'x': [0, 2], 'y': [0, 2], 'z': [
+                        0, 2]}), CartesianDomain({'x': [1, 3], 'y': [1, 3], 'z': [1, 3]})])
+    assert domain.is_inside(pt_1) == True
+    assert domain.is_inside(pt_2) == False
+
+
+def test_sample():
+    n = 100
+    domain = Difference([EllipsoidDomain(
+        {'x': [-1, 1], 'y': [-1, 1]}), CartesianDomain({'x': [-0.5, 0.5], 'y': [-0.5, 0.5]})])
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n
+
+    n = 105
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n

tests/test_geometry/test_ellipsoid.py

@@ -0,0 +1,30 @@
+import torch
+import pytest
+
+from pina import LabelTensor
+from pina.geometry import EllipsoidDomain
+
+
+
+def test_constructor():
+    EllipsoidDomain({'x': [0, 1], 'y': [0, 1]})
+    EllipsoidDomain({'x': [0, 1], 'y':[0, 1]}, sample_surface=True)
+
+
+def test_is_inside_sample_surface_false():
+    domain = EllipsoidDomain({'x': [0, 1], 'y':[0, 1]}, sample_surface=False)
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ['x', 'y'])
+    pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ['x', 'y'])
+    for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, False, False]):
+        assert domain.is_inside(pt) == exp_result
+    for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, True, False]):
+        assert domain.is_inside(pt, check_border=True) == exp_result
+
+def test_is_inside_sample_surface_true():
+    domain = EllipsoidDomain({'x': [0, 1], 'y':[0, 1]}, sample_surface=True)
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ['x', 'y'])
+    pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ['x', 'y'])
+    for pt, exp_result in zip([pt_1, pt_2, pt_3], [False, True, False]):
+        assert domain.is_inside(pt) == exp_result

tests/test_geometry/test_exclusion.py

@@ -0,0 +1,51 @@
+import torch
+
+from pina import LabelTensor
+from pina.geometry import Exclusion, EllipsoidDomain, CartesianDomain
+
+
+def test_constructor_two_CartesianDomains():
+    Exclusion([CartesianDomain({'x': [0, 2], 'y': [0, 2]}),
+               CartesianDomain({'x': [1, 3], 'y': [1, 3]})])
+
+
+def test_constructor_two_3DCartesianDomain():
+    Exclusion([CartesianDomain({'x': [0, 2], 'y': [0, 2], 'z': [0, 2]}),
+               CartesianDomain({'x': [1, 3], 'y': [1, 3], 'z': [1, 3]})])
+
+
+def test_constructor_three_CartesianDomains():
+    Exclusion([CartesianDomain({'x': [0, 2], 'y': [0, 2]}), CartesianDomain(
+        {'x': [1, 3], 'y': [1, 3]}), CartesianDomain({'x': [2, 4], 'y': [2, 4]})])
+
+
+def test_is_inside_two_CartesianDomains():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -0.5]]), ['x', 'y'])
+    domain = Exclusion([CartesianDomain({'x': [0, 2], 'y': [0, 2]}),
+                        CartesianDomain({'x': [1, 3], 'y': [1, 3]})])
+    assert domain.is_inside(pt_1) == True
+    assert domain.is_inside(pt_2) == False
+
+
+def test_is_inside_two_3DCartesianDomain():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ['x', 'y', 'z'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -0.5, -0.5]]), ['x', 'y', 'z'])
+    domain = Exclusion([CartesianDomain({'x': [0, 2], 'y': [0, 2], 'z': [
+                        0, 2]}), CartesianDomain({'x': [1, 3], 'y': [1, 3], 'z': [1, 3]})])
+    assert domain.is_inside(pt_1) == True
+    assert domain.is_inside(pt_2) == False
+
+
+def test_sample():
+    n = 100
+    domain = Exclusion([EllipsoidDomain(
+        {'x': [-1, 1], 'y': [-1, 1]}), CartesianDomain({'x': [0.3, 1.5], 'y': [0.3, 1.5]})])
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n
+
+    n = 105
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n

tests/test_geometry/test_intersection.py

@@ -0,0 +1,56 @@
+import torch
+
+from pina import LabelTensor
+from pina.geometry import Intersection, EllipsoidDomain, CartesianDomain
+
+
+def test_constructor_two_CartesianDomains():
+    Intersection([CartesianDomain({'x': [0, 2], 'y': [0, 2]}),
+                  CartesianDomain({'x': [1, 3], 'y': [1, 3]})])
+
+
+def test_constructor_two_3DCartesianDomain():
+    Intersection([CartesianDomain({'x': [0, 2], 'y': [0, 2], 'z': [0, 2]}),
+                  CartesianDomain({'x': [1, 3], 'y': [1, 3], 'z': [1, 3]})])
+
+
+def test_constructor_three_CartesianDomains():
+    Intersection([CartesianDomain({'x': [0, 2], 'y': [0, 2]}), CartesianDomain(
+        {'x': [1, 3], 'y': [1, 3]}), CartesianDomain({'x': [2, 4], 'y': [2, 4]})])
+
+
+def test_is_inside_two_CartesianDomains():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -0.5]]), ['x', 'y'])
+    pt_3 = LabelTensor(torch.tensor([[1.5, 1.5]]), ['x', 'y'])
+
+    domain = Intersection([CartesianDomain({'x': [0, 2], 'y': [0, 2]}),
+                           CartesianDomain({'x': [1, 3], 'y': [1, 3]})])
+    assert domain.is_inside(pt_1) == False
+    assert domain.is_inside(pt_2) == False
+    assert domain.is_inside(pt_3) == True
+
+
+def test_is_inside_two_3DCartesianDomain():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ['x', 'y', 'z'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -0.5, -0.5]]), ['x', 'y', 'z'])
+    pt_3 = LabelTensor(torch.tensor([[1.5, 1.5, 1.5]]), ['x', 'y', 'z'])
+    domain = Intersection([CartesianDomain({'x': [0, 2], 'y': [0, 2], 'z': [
+        0, 2]}), CartesianDomain({'x': [1, 3], 'y': [1, 3], 'z': [1, 3]})])
+    assert domain.is_inside(pt_1) == False
+    assert domain.is_inside(pt_2) == False
+    assert domain.is_inside(pt_3) == True
+
+
+def test_sample():
+    n = 100
+    domain = Intersection([EllipsoidDomain(
+        {'x': [-1, 1], 'y': [-1, 1]}), CartesianDomain({'x': [-0.5, 0.5], 'y': [-0.5, 0.5]})])
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n
+
+    n = 105
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n

tests/test_geometry/test_union.py

@@ -0,0 +1,60 @@
+import torch
+
+from pina import LabelTensor
+from pina.geometry import Union, EllipsoidDomain, CartesianDomain
+
+
+def test_constructor_two_CartesianDomains():
+    Union([CartesianDomain({'x': [0, 1], 'y': [0, 1]}),
+           CartesianDomain({'x': [0.5, 2], 'y': [-1, 0.1]})])
+
+
+def test_constructor_two_EllipsoidDomains():
+    Union([EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1], 'z': [-1, 1]}),
+           EllipsoidDomain({'x': [-0.5, 0.5], 'y': [-0.5, 0.5], 'z': [-0.5, 0.5]})])
+
+
+def test_constructor_EllipsoidDomain_CartesianDomain():
+    Union([EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1]}),
+           CartesianDomain({'x': [-0.5, 0.5], 'y': [-0.5, 0.5]})])
+
+
+def test_is_inside_two_CartesianDomains():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -1]]), ['x', 'y'])
+    domain = Union([CartesianDomain({'x': [0, 1], 'y': [0, 1]}),
+                    CartesianDomain({'x': [0.5, 2], 'y': [-1, 0.1]})])
+    assert domain.is_inside(pt_1) == True
+    assert domain.is_inside(pt_2) == False
+
+
+def test_is_inside_two_EllipsoidDomains():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ['x', 'y', 'z'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -1, -1]]), ['x', 'y', 'z'])
+    domain = Union([EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1], 'z': [-1, 1]}),
+                    EllipsoidDomain({'x': [-0.5, 0.5], 'y': [-0.5, 0.5], 'z': [-0.5, 0.5]})])
+    assert domain.is_inside(pt_1) == True
+    assert domain.is_inside(pt_2) == False
+
+
+def test_is_inside_EllipsoidDomain_CartesianDomain():
+    pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ['x', 'y'])
+    pt_2 = LabelTensor(torch.tensor([[-1, -1]]), ['x', 'y'])
+    domain = Union([EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1], }),
+                    CartesianDomain({'x': [0.6, 1.5], 'y': [-2, 0]})])
+    assert domain.is_inside(pt_1) == True
+    assert domain.is_inside(pt_2) == False
+
+
+def test_sample():
+    n = 100
+    domain = Union([EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1]}),
+                    CartesianDomain({'x': [-0.5, 0.5], 'y': [-0.5, 0.5]})])
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n
+
+    n = 105
+    pts = domain.sample(n)
+    assert isinstance(pts, LabelTensor)
+    assert pts.shape[0] == n