sampling mode domain added

pina/domain/cartesian.py

@@ -21,6 +21,7 @@ class CartesianDomain(DomainInterface):
         """
         self.fixed_ = {}
         self.range_ = {}
+        self.sample_modes = ["random", "grid", "lh", "chebyshev", "latin"]
 
         for k, v in cartesian_dict.items():
             if isinstance(v, (int, float)):

pina/domain/difference_domain.py

@@ -77,7 +77,7 @@ class Difference(OperationInterface):
                 5
 
         """
-        if mode != "random":
+        if mode != self.sample_modes:
             raise NotImplementedError(
                 f"{mode} is not a valid mode for sampling."
             )

pina/domain/domain_interface.py

@@ -9,6 +9,30 @@ class DomainInterface(metaclass=ABCMeta):
     Any geometry entity should inherit from this class.
     """
 
+    __available_sampling_modes = ["random", "grid", "lh", "chebyshev", "latin"]
+
+    @property
+    @abstractmethod
+    def sample_modes(self):
+        """
+        Abstract method returing available samples modes for the Domain.
+        """
+        pass
+
+    @sample_modes.setter
+    def sample_modes(self, values):
+        """
+        TODO
+        """
+        if not isinstance(values, (list, tuple)):
+            values = [values]
+        for value in values:
+            if value not in DomainInterface.__available_sampling_modes:
+                raise TypeError(f"mode {value} not valid. Expected at least "
+                                "one in "
+                                f"{DomainInterface.__available_sampling_modes}."
+                                )
+
     @abstractmethod
     def sample(self):
         """

pina/domain/ellipsoid.py

@@ -39,6 +39,7 @@ class EllipsoidDomain(DomainInterface):
         self.range_ = {}
         self._centers = None
         self._axis = None
+        self.sample_modes = "random"
 
         # checking consistency
         check_consistency(sample_surface, bool)
@@ -286,7 +287,7 @@ class EllipsoidDomain(DomainInterface):
         if variables == "all":
             variables = self.variables
 
-        if mode in ["random"]:
+        if mode in self.sample_modes:
             return _Nd_sampler(n, mode, variables).extract(variables)
         else:
             raise NotImplementedError(f"mode={mode} is not implemented.")

pina/domain/exclusion_domain.py

@@ -76,7 +76,7 @@ class Exclusion(OperationInterface):
                 5
 
         """
-        if mode != "random":
+        if mode != self.sample_modes:
             raise NotImplementedError(
                 f"{mode} is not a valid mode for sampling."
             )

pina/domain/intersection_domain.py

@@ -78,7 +78,7 @@ class Intersection(OperationInterface):
                 5
 
         """
-        if mode != "random":
+        if mode != self.sample_modes:
             raise NotImplementedError(
                 f"{mode} is not a valid mode for sampling."
             )

pina/domain/operation_interface.py

@@ -24,6 +24,9 @@ class OperationInterface(DomainInterface, metaclass=ABCMeta):
         # assign geometries
         self._geometries = geometries
 
+        # sampling mode, for now random is the only available
+        self.sample_modes = "random"
+
     @property
     def geometries(self):
         """

pina/domain/simplex.py

@@ -74,6 +74,9 @@ class SimplexDomain(DomainInterface):
         # build cartesian_bound
         self._cartesian_bound = self._build_cartesian(self._vertices_matrix)
 
+        # sampling mode
+        self.sample_modes = "random"
+
     @property
     def variables(self):
         return sorted(self._vertices_matrix.labels)
@@ -231,12 +234,13 @@ class SimplexDomain(DomainInterface):
             in ``variables``.
         """
 
-        if variables == "all":
+        # if variables == "all": # TODO: check if this is necessary (from 0.1)
-            variables = self.variables
+        #     variables = self.variables
-        elif isinstance(variables, (list, tuple)):
+        # elif isinstance(variables, (list, tuple)):
-            variables = sorted(variables)
+        #     variables = sorted(variables)
 
-        if mode in ["random"]:
+        # if mode in ["random"]:
+        if mode in self.sample_modes:
             if self._sample_surface:
                 sample_pts = self._sample_boundary_randomly(n)
             else:

pina/domain/union_domain.py

@@ -32,6 +32,9 @@ class Union(OperationInterface):
 
         """
         super().__init__(geometries)
+        self.sample_modes = list(
+            set([geom.sample_modes for geom in geometries])
+            )
 
     def is_inside(self, point, check_border=False):
         """