Objects can now be removed from the grid (#4).

The following methods are tested to work:
```
    grid.objects.pop(idx)
    del grid.objects[idx]
    del grid.object_name
```

Author: flaport

fdtd/boundaries.py

@@ -17,7 +17,7 @@
 
 
 ## Boundary Conditions [base class]
-class _Boundary:
+class Boundary:
     """ an FDTD Boundary [base class] """
 
     def __init__(self, name: str = None):
@@ -128,7 +128,7 @@ def _handle_slice(s):
 
 
 ## Periodic Boundaries
-class PeriodicBoundary(_Boundary):
+class PeriodicBoundary(Boundary):
     """ An FDTD Periodic Boundary
 
     Note:
@@ -211,7 +211,7 @@ def update_H(self):
 ## Perfectly Matched Layer (PML)
 
 
-class PML(_Boundary):
+class PML(Boundary):
     """ A perfectly matched layer (PML)
 
     a PML is an impedence-matched area at the boundary of the grid for which

fdtd/detectors.py

@@ -15,6 +15,11 @@
 from .grid import Grid
 from .backend import backend as bd
 
+## Base detector class:
+class Detector:
+    """ an FDTD Detector [base class] """
+
+
 ## Detector
 class LineDetector:
     """ A detector along a line in the FDTD grid """

fdtd/grid.py

@@ -71,6 +71,20 @@ def curl_H(H: Tensorlike) -> Tensorlike:
     return curl
 
 
+class GridList(list):
+    """ Special list that removes item from grid when deleted from list """
+
+    def __init__(self, grid):
+        super().__init__([])
+        self.grid = grid
+
+    def __delitem__(self, i):
+        item = self[i]
+        super().__delitem__(i)
+        if hasattr(item, "name") and hasattr(self.grid, item.name):
+            delattr(self.grid, item.name)
+
+
 ## FDTD Grid Class
 class Grid:
     """ The FDTD Grid
@@ -149,16 +163,16 @@ def __init__(
         self.time_steps_passed = 0
 
         # dictionary containing the sources:
-        self.sources = []
+        self.sources = GridList(self)
 
         # dictionary containing the boundaries
-        self.boundaries = []
+        self.boundaries = GridList(self)
 
         # dictionary containing the detectors
-        self.detectors = []
+        self.detectors = GridList(self)
 
         # dictionary containing the objects in the grid
-        self.objects = []
+        self.objects = GridList(self)
 
     def _handle_distance(self, distance: Number) -> int:
         """ transform a distance to an integer number of gridpoints """
@@ -361,6 +375,28 @@ def __setitem__(self, key, attr):
             z=self._handle_single_key(z),
         )
 
+    def __delattr__(self, name):
+        attr = getattr(self, name)
+        super().__delattr__(name)
+        if not isinstance(attr, (Object, Source, Detector, Boundary)):
+            return
+        try:
+            del self.objects[self.objects.index(attr)]
+        except ValueError:
+            pass
+        try:
+            del self.sources[self.sources.index(attr)]
+        except ValueError:
+            pass
+        try:
+            del self.detectors[self.detectors.index(attr)]
+        except ValueError:
+            pass
+        try:
+            del self.boundaries[self.boundaries.index(attr)]
+        except ValueError:
+            pass
+
     def __repr__(self):
         return (
             f"{self.__class__.__name__}(shape=({self.Nx},{self.Ny},{self.Nz}), "
@@ -390,3 +426,11 @@ def __str__(self):
             for obj in self.objects:
                 s += str(obj)
         return s
+
+
+## Imports (placed here to prevent circular imports)
+# relative
+from .objects import Object
+from .sources import Source
+from .detectors import Detector
+from .boundaries import Boundary

fdtd/objects.py

@@ -22,7 +22,7 @@
 
 ## Object
 class Object:
-    """ An object to place in the grid """
+    """ An object to place in the grid [base class] """
 
     def __init__(self, permittivity: Tensorlike, name: str = None):
         """ Create an object """
@@ -63,24 +63,17 @@ def _register_grid(
             self._permittivity = self._permittivity[:, :, :, None]
         self.inverse_permittivity = (
             bd.ones((self.Nx, self.Ny, self.Nz, 3)) / self._permittivity
+            - self.grid.inverse_permittivity[self.x, self.y, self.z]
         )
 
         # set the permittivity values of the object at its border to be equal
         # to the grid permittivity. This way, the object is made symmetric.
         if self.Nx > 1:
-            self.inverse_permittivity[-1, :, :, 0] = self.grid.inverse_permittivity[
-                -1, self.y, self.z, 0
-            ]
+            self.inverse_permittivity[-1, :, :, 0] = 0
         if self.Ny > 1:
-            self.inverse_permittivity[:, -1, :, 1] = self.grid.inverse_permittivity[
-                self.x, -1, self.z, 1
-            ]
+            self.inverse_permittivity[:, -1, :, 1] = 0
         if self.Nz > 1:
-            self.inverse_permittivity[:, :, -1, 2] = self.grid.inverse_permittivity[
-                self.x, self.y, -1, 2
-            ]
-
-        self.grid.inverse_permittivity[self.x, self.y, self.z] = 0
+            self.inverse_permittivity[:, :, -1, 2] = 0
 
     def _handle_slice(self, s: ListOrSlice, max_index: int = None) -> slice:
         if isinstance(s, list):

fdtd/sources.py

@@ -17,9 +17,13 @@
 from .grid import Grid
 from .backend import backend as bd
 
+## Base source class:
+class Source:
+    """ an FDTD Source [base class] """
+
 
 ## LineSource class
-class LineSource:
+class LineSource(Source):
     """ A source along a line in the FDTD grid """
 
     def __init__(