Lattice Module

spatialpy/core/__init__.py

@@ -26,6 +26,7 @@
 from .datafunction import DataFunction
 from .domain import Domain
 from .geometry import (
+	CombinatoryGeometry,
 	Geometry,
 	GeometryAll,
 	GeometryExterior,
@@ -37,6 +38,14 @@
 	UniformInitialCondition,
 	ScatterInitialCondition
 )
+from .lattice import (
+	CartesianLattice,
+	SphericalLattice,
+	CylindricalLattice,
+	XMLMeshLattice,
+	MeshIOLattice,
+	StochSSLattice
+)
 from .model import Model, export_StochSS
 from .parameter import Parameter
 from .reaction import Reaction

spatialpy/core/domain.py

@@ -144,7 +144,7 @@ def compile_prep(self):
         self.listOfTypeIDs = list(self.typeNdxMapping.values())
         self._get_type_name_mapping()
 
-    def add_point(self, point, vol=0, mass=0, type_id=1, nu=0, fixed=False, rho=None, c=0):
+    def add_point(self, point, vol=1, mass=1, type_id=1, nu=0, fixed=False, rho=None, c=10):
         """
         Add a single point particle to the domain space.
 
@@ -492,22 +492,12 @@ def get_bounding_box(self):
         Get the bounding box of the entire domain.
 
         :returns: Limits of the bounding box.
-        :rtype: float | float | float | float | float | float
+        :rtype: tuple(float(2), float(2), float(2))
         """
-        for i in range(self.vertices.shape[0]):
-            if xhi < self.vertices[i, 0]:
-                xhi = self.vertices[i, 0]
-            if xlo > self.vertices[i, 0]:
-                xlo = self.vertices[i, 0]
-            if yhi < self.vertices[i, 1]:
-                yhi = self.vertices[i, 1]
-            if ylo > self.vertices[i, 1]:
-                ylo = self.vertices[i, 1]
-            if zhi < self.vertices[i, 2]:
-                zhi = self.vertices[i, 2]
-            if zlo > self.vertices[i, 2]:
-                zlo = self.vertices[i, 2]
-        return xhi, xlo, yhi, ylo, zhi, zlo
+        xlim = (min(self.vertices[:, 0]), max(self.vertices[:, 0]))
+        ylim = (min(self.vertices[:, 1]), max(self.vertices[:, 1]))
+        zlim = (min(self.vertices[:, 2]), max(self.vertices[:, 2]))
+        return xlim, ylim, zlim
 
     def get_vol(self):
         """

spatialpy/core/geometry.py

@@ -13,8 +13,67 @@
 
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import numpy
+
 from spatialpy.core.spatialpyerror import GeometryError
 
+class CombinatoryGeometry:
+    """
+    Combinatory Geometry class uses one or more Geometry class for inclusion or exclusion of
+    multiple geometric shapes.
+
+    :param formula: Boolean logic formula to be evaluated. Example use: "(geo1 or geo2) and not geo3".
+    :type formula: str
+
+    :param geo_namespace: Namespace used when evaluating the formula. Example use:
+        {'geo1': Geometry1(), 'geo2': Geometry2(), 'geo3': Geometry3()} where 'geo1',
+        'geo2', and 'geo3' are found in the formula.
+    :type geo_namespace: dict
+    """
+    def __init__(self, formula, geo_namespace):
+        self.formula = formula
+        self.geo_namespace = geo_namespace
+
+        self.validate()
+
+    def inside(self, point, on_boundary):
+        """
+        :param point: X, Y, Z coodinates for the particle.
+        :type point: float[3]
+
+        :param on_boundary: Indicates whether a particle is on the edge of the domain.
+        :type on_boundary: bool
+
+        :returns: True if the particle satisfies boolean condition for all geometies, else False.
+        :rtype: bool
+
+        :raises GeometryError: If any geometries inside method does not return a bool.
+        """
+        namespace = {}
+        for name, geometry in self.geo_namespace.items():
+            val = geometry.inside(point, on_boundary)
+            if not isinstance(val, (bool, numpy.bool_)):
+                errmsg = f"{name} is not a valid Geometry obj. Reason given: inside() method must return a bool"
+                raise GeometryError(errmsg)
+            namespace[name] = val
+        return eval(self.formula, {}, namespace)
+
+    def validate(self):
+        """
+        Validate the combinatory geometry object.
+        """
+        keys = list(self.geo_namespace.keys())
+        for name in keys:
+            if name not in self.formula:
+                raise GeometryError("geo_namespace entries must be in the formula.")
+        keys.extend(['and', 'or', 'not', '(', ')'])
+        formula = self.formula
+        for item in keys:
+            formula = formula.replace(item, "")
+        if formula.strip() != "":
+            errmsg = f"formula may only contain boolean operators or geometries in geo_namespace not {formula.split(' ')}"
+            raise GeometryError(errmsg)
+
 class Geometry:
     """
     Geometry class provides a method for tagging parts of the spatial domain as separate parts.