@@ -11,6 +11,8 @@
 class Sensor(SynapseDevice):
     """Base class for sensors"""
 
+    name: str = field(default="sensor", kw_only=True)
+    """name of the sensor device"""
     sigma_noise: float = field(kw_only=True)
     """standard deviation of Gaussian noise in ΔF/F measurement"""
     dFF_1AP: float = field(kw_only=True)
@@ -73,15 +75,15 @@ class DynamicCalcium(CalciumModel):
     )
     """from eq 8 in Lütke et al., 2013"""
 
-    Ca_rest: Quantity = field(kw_only=True)
+    Ca_rest: Quantity = field(default=50 * nmolar, kw_only=True)
     """resting Ca2+ concentration (molar)"""
-    gamma: Quantity = field(kw_only=True)
+    gamma: Quantity = field(default=292.3 / second, kw_only=True)
     """clearance/extrusion rate (1/sec)"""
-    B_T: Quantity = field(kw_only=True)
+    B_T: Quantity = field(default=200 * umolar, kw_only=True)
     """total indicator (buffer) concentration (molar)"""
-    kappa_S: float = field(kw_only=True)
+    kappa_S: float = field(default=110.0, kw_only=True)
     """Ca2+ binding ratio of the endogenous buffer"""
-    dCa_T: Quantity = field(kw_only=True)
+    dCa_T: Quantity = field(default=7.6 * umolar, kw_only=True)
     """total Ca2+ concentration increase per spike (molar)"""
 
     def init_syn_vars(self, syn: Synapses) -> None:
@@ -95,7 +97,6 @@ class CalBindingActivationModel:
     model: str
 
 
-
 @define(eq=False)
 class NullBindingActivation(CalBindingActivationModel):
     """Doesn't model binding/activation; i.e., goes straight from [Ca2+] to ΔF/F"""
@@ -168,11 +169,11 @@ class LightExcitation(ExcitationModel):
                         * exp(-k * Irr * soma_radius**2 * pi * (mwatt)) * (1/Hz)) : 1
     """, init=False)
 
-    baseline: float = field(kw_only=True)
-    A: float = field(kw_only=True)
-    n: float = field(kw_only=True)
-    ec50: float = field(kw_only=True)
-    k: float = field(kw_only=True)
+    baseline: float = field(default=1.0, kw_only=True)
+    A: float = field(default=1.0, kw_only=True)
+    n: float = field(default=1.0, kw_only=True)
+    ec50: float = field(default=1.0, kw_only=True)
+    k: float = field(default=0.0, kw_only=True)
 
 @define(eq=False)
 class GECI(Sensor):
@@ -186,6 +187,7 @@ class GECI(Sensor):
     to data, rather than to biophysical processes before the data.
     """
 
+    name: str = field(default="GECI", kw_only=True)
     cal_model: CalciumModel = field(kw_only=True)
     bind_act_model: CalBindingActivationModel = field(kw_only=True)
     exc_model: ExcitationModel = field(kw_only=True)
@@ -251,9 +253,15 @@ def params(self) -> dict:
 
 @define(eq=False, slots=False)
 class LightDependentGECI(GECI, LightDependent):
-    """Light-dependent calcium indicator (not yet implemented)"""
-    """Uses a Hill equation to convert from Ca2+ to ΔF/F, as in Song et al., 2021"""
-    pass
+    """Light-dependent calcium indicator"""
+
+    name: str = field(default="LightDependentGECI", kw_only=True)
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        # Ensure LightDependent mixin initialization runs to set spectrum defaults
+        if hasattr(LightDependent, "__post_init__"):
+            LightDependent.__post_init__(self)
 
 def geci(
     light_dependent: bool, doub_exp_conv: bool, pre_existing_cal: bool, **kwparams
@@ -402,8 +410,6 @@ def geci_fn(
             **extra_kwparams,
         )
 
-    # geci_fn.spectrum = spectrum
-
     geci_fn.__doc__ += "\n\n" + (" " * 8) + extra_doc
 
     globals()[brian_safe_name(name.lower())] = geci_fn
@@ -448,6 +454,7 @@ def load_geci_dataframe(name: str):
             return gcamp
     except Exception as e:
         print(f"Failed to register sensors from csv: {e}")
+
 import matplotlib.pyplot as plt
 def Plot_Generator(time_history, dFF_history, count):
     for i in range(len(dFF_history[0])):
 
@@ -78,8 +78,9 @@ class LightDependent:
 
     @spectrum.default
     def _default_spectrum(self):
+        device_name = getattr(self, "name", self.__class__.__name__)
         warnings.warn(
-            f"No spectrum provided for light-dependent device {self.name}."
+            f"No spectrum provided for light-dependent device {device_name}."
             " Assuming ε = 1 for all λ."
         )
         return [(-1e10, 1), (1e10, 1)]
@@ -101,14 +102,15 @@ def light_agg_ngs(self) -> dict[str, NeuronGroup]:
     def _get_source_for_synapse(
         self, target_ng: NeuronGroup, i_targets: list[int]
     ) -> Tuple[NeuronGroup, list[int]]:
+        device_name = getattr(self, "name", self.__class__.__name__)
         # create light aggregator neurons
         light_agg_ng = NeuronGroup(
             len(i_targets),
             model="""
             phi : 1/second/meter**2
             Irr : watt/meter**2
             """,
-            name=f"light_agg_{brian_safe_name(self.name)}_{target_ng.name}",
+            name=f"light_agg_{brian_safe_name(device_name)}_{target_ng.name}",
         )
         assign_xyz(
             light_agg_ng,
@@ -122,6 +124,7 @@ def _get_source_for_synapse(
     def epsilon(self, lambda_new: Quantity) -> float:
         """Returns the :math:`\\varepsilon` value for a given lambda (including units)
         representing the relative sensitivity of the opsin to that wavelength."""
+        device_name = getattr(self, "name", self.__class__.__name__)
         lam_eps_array = np.array(self.spectrum)
         lambdas, epsilons = lam_eps_array[lam_eps_array[:, 0].argsort()].T
         lambda_new /= nmeter
@@ -132,19 +135,19 @@ def epsilon(self, lambda_new: Quantity) -> float:
             if not self.extrapolate:
                 warnings.warn(
                     f"λ = {lambda_new} nm is outside the range of the action spectrum data"
-                    f" for {self.name} and extrapolate=False. Assuming ε = 0."
+                    f" for {device_name} and extrapolate=False. Assuming ε = 0."
                 )
                 return 0
             elif self.extrapolate:
                 warnings.warn(
                     f"λ = {lambda_new} nm is outside the range of the action spectrum data"
-                    f" for {self.name}. Extrapolating: ε = {eps_new:.3f}."
+                    f" for {device_name}. Extrapolating: ε = {eps_new:.3f}."
                 )
         if eps_new < 0:
-            warnings.warn(f"ε = {eps_new} < 0 for {self.name}. Setting ε = 0.")
+            warnings.warn(f"ε = {eps_new} < 0 for {device_name}. Setting ε = 0.")
             eps_new = 0
         if eps_new > 1:
-            warnings.warn(f"ε = {eps_new} > 1 for {self.name}. Setting ε = 1.")
+            warnings.warn(f"ε = {eps_new} > 1 for {device_name}. Setting ε = 1.")
             eps_new = 1
         return eps_new
 
@@ -219,7 +222,8 @@ def plot_spectra(
         epsilons_new = ldd.spectrum_interpolator(lambdas, epsilons, lambdas_new)
         c_points = [wavelength_to_rgb(l) for l in lambdas * nmeter]
         c_line = wavelength_to_rgb(lambdas[np.argmax(epsilons)] * nmeter)
-        ax.plot(lambdas_new, epsilons_new, c=c_line, label=ldd.name)
+        device_name = getattr(ldd, "name", ldd.__class__.__name__)
+        ax.plot(lambdas_new, epsilons_new, c=c_line, label=device_name)
         ax.scatter(lambdas, epsilons, marker="o", s=50, color=c_points)
 
     title = (