witwin-maxwell 0.3.0__py3-none-win_amd64.whl

witwin/maxwell/fdtd/plotting.py

@@ -0,0 +1,121 @@
+import numpy as np
+import torch
+
+from ..visualization import (
+    extract_orthogonal_slice,
+    plot_cross_section_panels,
+    plot_orthogonal_views,
+)
+from .postprocess import (
+    get_centered_permittivity,
+    get_frequency_solution,
+    interpolate_yee_to_center,
+)
+from .coords import component_coords
+
+
+def _to_numpy_field(value):
+    if isinstance(value, torch.Tensor):
+        return value.detach().cpu().numpy()
+    return np.asarray(value)
+
+
+def plot_cross_section(
+    solver,
+    axis="z",
+    position=0.0,
+    component="abs",
+    field_log_scale=False,
+    figsize=(12, 5),
+    save_path=None,
+    verbose=True,
+):
+    freq_solution = get_frequency_solution(solver)
+
+    ex = _to_numpy_field(freq_solution["Ex"])
+    ey = _to_numpy_field(freq_solution["Ey"])
+    ez = _to_numpy_field(freq_solution["Ez"])
+    component_str = component.lower()
+
+    if component_str == "abs":
+        field_data, x_coords, y_coords, z_coords = interpolate_yee_to_center(solver, freq_solution)
+        title_prefix = "|E|"
+        eps_np = get_centered_permittivity(solver).cpu().numpy()
+    elif component_str == "ex":
+        field_data = np.abs(ex)
+        title_prefix = "|Ex|"
+        x_coords, y_coords, z_coords = component_coords(solver.scene, "Ex")
+        eps_np = (solver.eps_Ex / solver.eps0).cpu().numpy()
+    elif component_str == "ey":
+        field_data = np.abs(ey)
+        title_prefix = "|Ey|"
+        x_coords, y_coords, z_coords = component_coords(solver.scene, "Ey")
+        eps_np = (solver.eps_Ey / solver.eps0).cpu().numpy()
+    elif component_str == "ez":
+        field_data = np.abs(ez)
+        title_prefix = "|Ez|"
+        x_coords, y_coords, z_coords = component_coords(solver.scene, "Ez")
+        eps_np = (solver.eps_Ez / solver.eps0).cpu().numpy()
+    else:
+        field_data, x_coords, y_coords, z_coords = interpolate_yee_to_center(solver, freq_solution)
+        title_prefix = "|E|"
+        eps_np = get_centered_permittivity(solver).cpu().numpy()
+
+    field_info = extract_orthogonal_slice(field_data, axis, position, x_coords, y_coords, z_coords)
+    eps_info = extract_orthogonal_slice(eps_np, axis, position, x_coords, y_coords, z_coords)
+
+    field_slice = field_info["slice"]
+    if field_log_scale:
+        field_slice = np.where(field_slice > 1e-12, field_slice, 1e-12)
+        field_max = np.max(field_slice)
+        if field_max > 0:
+            field_slice = 20 * np.log10(field_slice / field_max)
+        cbar_label = f"{title_prefix} (dB)"
+    else:
+        cbar_label = f"{title_prefix} (V/m)"
+
+    plot_cross_section_panels(
+        field_slice=field_slice,
+        permittivity_slice=eps_info["slice"],
+        x_coords=field_info["x_coords"],
+        y_coords=field_info["y_coords"],
+        xlabel=field_info["xlabel"],
+        ylabel=field_info["ylabel"],
+        field_title=f"{title_prefix} at {axis}={position:.3f}m",
+        field_cbar_label=cbar_label,
+        permittivity_title=f"Permittivity at {axis}={position:.3f}m",
+        figsize=figsize,
+        save_path=save_path,
+        verbose=verbose,
+        contour_levels=[1.5],
+        contour_color="cyan",
+    )
+
+
+def plot_isotropic_3views(
+    solver,
+    position=0.0,
+    field_log_scale=True,
+    figsize=(18, 5),
+    save_path=None,
+    vmin_db=-60,
+    verbose=True,
+):
+    freq_solution = get_frequency_solution(solver)
+    field_data, x_coords, y_coords, z_coords = interpolate_yee_to_center(solver, freq_solution)
+    eps = get_centered_permittivity(solver).cpu().numpy()
+
+    plot_orthogonal_views(
+        field_data=field_data,
+        permittivity=eps,
+        x_coords=x_coords,
+        y_coords=y_coords,
+        z_coords=z_coords,
+        position=position,
+        field_log_scale=field_log_scale,
+        figsize=figsize,
+        save_path=save_path,
+        vmin_db=vmin_db,
+        verbose=verbose,
+        suptitle="Total Electric Field Intensity |E| (FDTD)",
+    )

witwin/maxwell/fdtd/postprocess.py

@@ -0,0 +1,205 @@
+import numpy as np
+import torch
+
+from .boundary import combine_complex_spectral_components
+from .coords import centered_cell_coords
+
+
+def _build_frequency_solution_from_fields(fields, *, sample_count, window_normalization, source_spectrum=None):
+    if sample_count == 0:
+        raise ValueError("No DFT samples recorded. Run solve() with dft_frequency first.")
+
+    if window_normalization > 0:
+        scale = 2.0 / window_normalization
+    else:
+        scale = 2.0 / sample_count
+
+    result = {}
+    for component_name in ("Ex", "Ey", "Ez"):
+        payload = fields[component_name]
+        result[component_name] = combine_complex_spectral_components(
+            payload["real"],
+            payload["imag"],
+            payload["aux_real"],
+            payload["aux_imag"],
+        ) * scale
+    if source_spectrum is not None:
+        abs_s = np.abs(source_spectrum)
+        floor = max(1e-10 * abs_s, 1e-30) if np.isscalar(abs_s) else 1e-30
+        safe = source_spectrum if abs_s > floor else floor
+        for comp in ("Ex", "Ey", "Ez"):
+            result[comp] = result[comp] / safe
+    return result
+
+
+def _legacy_frequency_solution(solver):
+    fields = {
+        "Ex": {
+            "real": solver.dft_Ex_real,
+            "imag": solver.dft_Ex_imag,
+            "aux_real": solver.dft_Ex_aux_real,
+            "aux_imag": solver.dft_Ex_aux_imag,
+        },
+        "Ey": {
+            "real": solver.dft_Ey_real,
+            "imag": solver.dft_Ey_imag,
+            "aux_real": solver.dft_Ey_aux_real,
+            "aux_imag": solver.dft_Ey_aux_imag,
+        },
+        "Ez": {
+            "real": solver.dft_Ez_real,
+            "imag": solver.dft_Ez_imag,
+            "aux_real": solver.dft_Ez_aux_real,
+            "aux_imag": solver.dft_Ez_aux_imag,
+        },
+    }
+    return _build_frequency_solution_from_fields(
+        fields,
+        sample_count=solver.dft_sample_count,
+        window_normalization=solver.dft_window_normalization,
+    )
+
+
+def _entry_source_spectrum(entry, scale):
+    """Compute complex source spectrum from a DFT entry's accumulated source DFT."""
+    sr = entry.get("source_dft_real", 0.0)
+    si = entry.get("source_dft_imag", 0.0)
+    return (sr + 1j * si) * scale
+
+
+def _solver_source_spectrum(solver, entry):
+    """Return source spectrum for an entry if normalize_source is active, else None."""
+    if not getattr(solver, '_normalize_source', False):
+        return None
+    if getattr(solver, '_source_time', None) is None:
+        return None
+    wn = entry.get("window_normalization", 0.0)
+    sc = entry.get("sample_count", 0)
+    if wn > 0:
+        scale = 2.0 / wn
+    elif sc > 0:
+        scale = 2.0 / sc
+    else:
+        return None
+    return _entry_source_spectrum(entry, scale)
+
+
+def _resolve_dft_entry(solver, *, frequency=None, freq_index=None):
+    if frequency is not None and freq_index is not None:
+        raise ValueError("Pass either frequency or freq_index, not both.")
+
+    entries = getattr(solver, "_dft_entries", ())
+    if not entries:
+        if frequency is not None or freq_index is not None:
+            raise ValueError("Legacy DFT state does not support selecting by frequency or freq_index.")
+        return None
+
+    if freq_index is not None:
+        index = int(freq_index)
+        if index < 0 or index >= len(entries):
+            raise IndexError(f"freq_index {index} is out of range for {len(entries)} DFT entries.")
+        return entries[index]
+
+    if frequency is not None:
+        target = float(frequency)
+        for entry in entries:
+            if abs(float(entry["frequency"]) - target) <= max(abs(target), 1.0) * 1e-12:
+                return entry
+        raise ValueError(f"DFT frequency {target} was not accumulated.")
+
+    return entries[0]
+
+
+def get_frequency_solution(solver, *, frequency=None, freq_index=None, all_frequencies=False):
+    if all_frequencies and (frequency is not None or freq_index is not None):
+        raise ValueError("all_frequencies cannot be combined with frequency or freq_index.")
+
+    entries = getattr(solver, "_dft_entries", ())
+    if all_frequencies and entries:
+        if len(entries) == 1:
+            entry = entries[0]
+            result = _build_frequency_solution_from_fields(
+                entry["fields"],
+                sample_count=entry["sample_count"],
+                window_normalization=entry["window_normalization"],
+                source_spectrum=_solver_source_spectrum(solver, entry),
+            )
+            if getattr(solver, "verbose", False):
+                print(
+                    f"DFT complete, accumulated {entry['sample_count']} samples, "
+                    f"window: {solver.dft_window_type}"
+                )
+            return result
+
+        solutions = [
+            _build_frequency_solution_from_fields(
+                entry["fields"],
+                sample_count=entry["sample_count"],
+                window_normalization=entry["window_normalization"],
+                source_spectrum=_solver_source_spectrum(solver, entry),
+            )
+            for entry in entries
+        ]
+        result = {
+            "Ex": torch.stack([solution["Ex"] for solution in solutions], dim=0),
+            "Ey": torch.stack([solution["Ey"] for solution in solutions], dim=0),
+            "Ez": torch.stack([solution["Ez"] for solution in solutions], dim=0),
+            "frequencies": tuple(float(entry["frequency"]) for entry in entries),
+        }
+        if getattr(solver, "verbose", False):
+            print(f"DFT complete, accumulated {len(entries)} frequency solutions, window: {solver.dft_window_type}")
+        return result
+
+    entry = _resolve_dft_entry(solver, frequency=frequency, freq_index=freq_index)
+    if entry is None:
+        result = _legacy_frequency_solution(solver)
+        sample_count = solver.dft_sample_count
+    else:
+        result = _build_frequency_solution_from_fields(
+            entry["fields"],
+            sample_count=entry["sample_count"],
+            window_normalization=entry["window_normalization"],
+            source_spectrum=_solver_source_spectrum(solver, entry),
+        )
+        sample_count = entry["sample_count"]
+
+    window_type = getattr(solver, "dft_window_type", "none")
+    if getattr(solver, "verbose", False):
+        print(f"DFT complete, accumulated {sample_count} samples, window: {window_type}")
+    return result
+
+
+def get_material_permittivity(solver):
+    if solver.material_eps_r is not None:
+        return solver.material_eps_r
+    return solver.scene.permittivity
+
+
+def get_centered_permittivity(solver):
+    eps = get_material_permittivity(solver)
+    return 0.125 * (
+        eps[:-1, :-1, :-1] + eps[1:, :-1, :-1] +
+        eps[:-1, 1:, :-1] + eps[1:, 1:, :-1] +
+        eps[:-1, :-1, 1:] + eps[1:, :-1, 1:] +
+        eps[:-1, 1:, 1:] + eps[1:, 1:, 1:]
+    )
+
+
+def interpolate_yee_to_center(solver, freq_solution):
+    ex = freq_solution["Ex"]
+    ey = freq_solution["Ey"]
+    ez = freq_solution["Ez"]
+    ex_int = 0.5 * (ex[:, :-1, :] + ex[:, 1:, :])
+    ex_int = 0.5 * (ex_int[:, :, :-1] + ex_int[:, :, 1:])
+    ey_int = 0.5 * (ey[:-1, :, :] + ey[1:, :, :])
+    ey_int = 0.5 * (ey_int[:, :, :-1] + ey_int[:, :, 1:])
+    ez_int = 0.5 * (ez[:-1, :, :] + ez[1:, :, :])
+    ez_int = 0.5 * (ez_int[:, :-1, :] + ez_int[:, 1:, :])
+    if isinstance(ex_int, torch.Tensor):
+        field_data = torch.sqrt(torch.abs(ex_int) ** 2 + torch.abs(ey_int) ** 2 + torch.abs(ez_int) ** 2)
+        field_data = field_data.detach().cpu().numpy()
+    else:
+        field_data = np.sqrt(np.abs(ex_int) ** 2 + np.abs(ey_int) ** 2 + np.abs(ez_int) ** 2)
+
+    x_coords, y_coords, z_coords = centered_cell_coords(solver.scene)
+    return field_data, x_coords, y_coords, z_coords

witwin/maxwell/fdtd/runtime/__init__.py

@@ -0,0 +1,119 @@
+from .initialization import initialize_solver
+from .materials import (
+    advance_magnetic_component_dispersive_state,
+    advance_magnetic_dispersive_state,
+    advance_component_dispersive_state,
+    advance_dispersive_state,
+    apply_magnetic_component_dispersive_currents,
+    apply_magnetic_dispersive_corrections,
+    apply_component_dispersive_currents,
+    apply_dispersive_corrections,
+    average_node_to_component,
+    average_node_to_magnetic_component,
+    build_dispersive_templates,
+    build_magnetic_dispersive_templates,
+    build_materials,
+    build_update_coefficients,
+    initialize_dispersive_state,
+    initialize_magnetic_dispersive_state,
+    update_kerr_electric_curls,
+    update_nonlinear_electric_coefficients,
+)
+from .module_cache import get_fdtd_module, require_cuda_scene
+from .spectral import (
+    accumulate_dft,
+    accumulate_dft_gpu,
+    advance_phase,
+    build_dft_step_tables,
+    compute_spectral_start_step,
+    compute_window_weight,
+    enable_dft,
+    normalize_target_frequencies,
+    reset_dft_runtime_state,
+    resolve_spectral_window_type,
+    source_time_kind,
+    sync_dft_entries_from_runtime_state,
+    sync_dft_legacy_state,
+    sync_dft_primary_runtime_state,
+    sync_observer_legacy_state,
+    sync_observer_primary_state,
+    synchronize_device,
+)
+from .stepping import (
+    clamp_field_face,
+    clamp_pec_boundaries,
+    cpml_layout_params,
+    enforce_pec_boundaries,
+    init_field,
+    iter_cpml_memory_regions,
+    solve,
+    update_electric_fields,
+    update_electric_fields_bloch,
+    update_electric_fields_cpml,
+    update_electric_fields_cpml_compressed,
+    update_electric_fields_cpml_dense,
+    update_electric_fields_standard,
+    update_magnetic_fields,
+    update_magnetic_fields_cpml,
+    update_magnetic_fields_cpml_compressed,
+    update_magnetic_fields_cpml_dense,
+    update_magnetic_fields_standard,
+)
+
+__all__ = [
+    "accumulate_dft",
+    "accumulate_dft_gpu",
+    "build_dft_step_tables",
+    "advance_magnetic_component_dispersive_state",
+    "advance_magnetic_dispersive_state",
+    "advance_component_dispersive_state",
+    "advance_dispersive_state",
+    "advance_phase",
+    "apply_magnetic_component_dispersive_currents",
+    "apply_magnetic_dispersive_corrections",
+    "apply_component_dispersive_currents",
+    "apply_dispersive_corrections",
+    "average_node_to_component",
+    "average_node_to_magnetic_component",
+    "build_dispersive_templates",
+    "build_magnetic_dispersive_templates",
+    "build_materials",
+    "build_update_coefficients",
+    "clamp_field_face",
+    "clamp_pec_boundaries",
+    "compute_spectral_start_step",
+    "cpml_layout_params",
+    "enable_dft",
+    "enforce_pec_boundaries",
+    "get_fdtd_module",
+    "init_field",
+    "initialize_dispersive_state",
+    "initialize_magnetic_dispersive_state",
+    "initialize_solver",
+    "iter_cpml_memory_regions",
+    "normalize_target_frequencies",
+    "require_cuda_scene",
+    "reset_dft_runtime_state",
+    "resolve_spectral_window_type",
+    "solve",
+    "source_time_kind",
+    "sync_dft_entries_from_runtime_state",
+    "sync_dft_legacy_state",
+    "sync_dft_primary_runtime_state",
+    "sync_observer_legacy_state",
+    "sync_observer_primary_state",
+    "synchronize_device",
+    "update_kerr_electric_curls",
+    "update_nonlinear_electric_coefficients",
+    "update_electric_fields",
+    "update_electric_fields_bloch",
+    "update_electric_fields_cpml",
+    "update_electric_fields_cpml_compressed",
+    "update_electric_fields_cpml_dense",
+    "update_electric_fields_standard",
+    "update_magnetic_fields",
+    "update_magnetic_fields_cpml",
+    "update_magnetic_fields_cpml_compressed",
+    "update_magnetic_fields_cpml_dense",
+    "update_magnetic_fields_standard",
+]

witwin/maxwell/fdtd/runtime/initialization.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import torch
+
+from ...compiler.monitors import compile_fdtd_observers, compile_fdtd_time_observers
+from ...compiler.sources import compile_fdtd_sources
+from ..boundary import DEFAULT_CPML_CONFIG
+from .module_cache import get_fdtd_module, require_cuda_scene
+
+
+def _pole_parameter_bound(value) -> float:
+    """Scalar upper bound of a pole parameter (per-cell custom poles carry tensors)."""
+    if torch.is_tensor(value):
+        return float(value.detach().max())
+    return float(value)
+
+
+def _material_characteristic_frequency(material) -> float:
+    if material is None:
+        return 0.0
+
+    characteristic = 0.0
+    for pole in getattr(material, "debye_poles", ()):
+        characteristic = max(characteristic, 1.0 / (2.0 * np.pi * float(pole.tau)))
+    for pole in getattr(material, "drude_poles", ()):
+        characteristic = max(
+            characteristic,
+            _pole_parameter_bound(pole.plasma_frequency),
+            float(pole.gamma),
+        )
+    for pole in getattr(material, "lorentz_poles", ()):
+        characteristic = max(
+            characteristic,
+            float(pole.resonance_frequency),
+            float(pole.gamma),
+        )
+    for pole in getattr(material, "mu_debye_poles", ()):
+        characteristic = max(characteristic, 1.0 / (2.0 * np.pi * float(pole.tau)))
+    for pole in getattr(material, "mu_drude_poles", ()):
+        characteristic = max(
+            characteristic,
+            _pole_parameter_bound(pole.plasma_frequency),
+            float(pole.gamma),
+        )
+    for pole in getattr(material, "mu_lorentz_poles", ()):
+        characteristic = max(
+            characteristic,
+            float(pole.resonance_frequency),
+            float(pole.gamma),
+        )
+    # Sheet media (e.g. Graphene) expose their relaxation rate directly.
+    characteristic = max(
+        characteristic, float(getattr(material, "characteristic_frequency", 0.0) or 0.0)
+    )
+    return characteristic
+
+
+def _scene_material_characteristic_frequency(scene) -> float:
+    characteristic = 0.0
+    for structure in getattr(scene, "structures", ()):
+        material = getattr(structure, "material", None)
+        characteristic = max(characteristic, _material_characteristic_frequency(material))
+    return characteristic
+
+
+def initialize_solver(solver, scene, frequency=1e9, absorber_type="cpml", cpml_config=None):
+    require_cuda_scene(scene)
+    solver.scene = scene
+    solver.Nx = scene.Nx
+    solver.Ny = scene.Ny
+    solver.Nz = scene.Nz
+    solver.min_dx = float(scene.dx_primal64.min())
+    solver.min_dy = float(scene.dy_primal64.min())
+    solver.min_dz = float(scene.dz_primal64.min())
+    solver.device = torch.device(scene.device)
+    solver.verbose = bool(scene.verbose)
+    solver.c = 299792458.0
+    solver.mu0 = 4 * np.pi * 1e-7
+    solver.eps0 = 1 / (solver.mu0 * solver.c**2)
+    solver.plot_interval = 50
+    solver.progress_update_interval = 25
+    compiled_sources = compile_fdtd_sources(scene, default_frequency=float(frequency))
+    solver._compiled_sources = tuple(compiled_sources)
+    primary_tfsf_source = next(
+        (source for source in solver._compiled_sources if source.get("injection", {}).get("kind") == "tfsf"),
+        None,
+    )
+    solver._compiled_source = primary_tfsf_source or (
+        solver._compiled_sources[0] if solver._compiled_sources else None
+    )
+    solver._source_time = None if solver._compiled_source is None else solver._compiled_source["source_time"]
+    time_step_frequency = (
+        max(
+            float(source["source_time"].get("characteristic_frequency", source["source_time"]["frequency"]))
+            for source in solver._compiled_sources
+        )
+        if solver._compiled_sources
+        else float(frequency)
+    )
+    time_step_frequency = max(time_step_frequency, _scene_material_characteristic_frequency(scene))
+    solver.source_frequency = (
+        float(solver._source_time["frequency"])
+        if solver._source_time is not None
+        else float(frequency)
+    )
+    solver.source_omega = 2 * np.pi * solver.source_frequency
+    solver.absorber_type = absorber_type.lower()
+    solver.boundary_kind = scene.boundary.kind
+    solver.active_absorber_type = "none"
+    solver.complex_fields_enabled = False
+    solver.cpml_config = dict(DEFAULT_CPML_CONFIG)
+    if cpml_config is not None:
+        solver.cpml_config.update(cpml_config)
+    solver._cpml_memory_mode_requested = str(solver.cpml_config.get("memory_mode", "auto")).strip().lower()
+    solver._cpml_memory_mode = "none"
+    solver._cpml_memory_layouts = {}
+    solver._cpml_layout_cache = {}
+    solver._cpml_dense_memory_bytes = 0
+    solver._cpml_slab_memory_bytes = 0
+    solver._cpml_allocated_memory_bytes = 0
+    solver._cpml_dense_memory_limit_bytes = None
+    solver._cpml_auto_free_bytes = None
+
+    solver.dt = solver.auto_dt(solver.min_dx, solver.min_dy, solver.min_dz, time_step_frequency)
+    # Per-axis spacing arrays: `_e` scales backward diffs in E updates (dual
+    # spacing, length N); `_h` scales forward diffs in H updates (primal
+    # spacing, length N-1). Reciprocals are computed in float64 then cast.
+    solver.inv_dx_e = torch.tensor(1.0 / scene.dx_dual64, dtype=torch.float32, device=solver.device)
+    solver.inv_dy_e = torch.tensor(1.0 / scene.dy_dual64, dtype=torch.float32, device=solver.device)
+    solver.inv_dz_e = torch.tensor(1.0 / scene.dz_dual64, dtype=torch.float32, device=solver.device)
+    solver.inv_dx_h = torch.tensor(1.0 / scene.dx_primal64, dtype=torch.float32, device=solver.device)
+    solver.inv_dy_h = torch.tensor(1.0 / scene.dy_primal64, dtype=torch.float32, device=solver.device)
+    solver.inv_dz_h = torch.tensor(1.0 / scene.dz_primal64, dtype=torch.float32, device=solver.device)
+    solver.fdtd_module = get_fdtd_module()
+
+    solver.dft_enabled = False
+    solver.dft_frequency = None
+    solver.dft_frequencies = ()
+    solver.dft_Ex_real = None
+    solver.dft_Ex_imag = None
+    solver.dft_Ey_real = None
+    solver.dft_Ey_imag = None
+    solver.dft_Ez_real = None
+    solver.dft_Ez_imag = None
+    solver.dft_Ex_aux_real = None
+    solver.dft_Ex_aux_imag = None
+    solver.dft_Ey_aux_real = None
+    solver.dft_Ey_aux_imag = None
+    solver.dft_Ez_aux_real = None
+    solver.dft_Ez_aux_imag = None
+    solver.dft_sample_count = 0
+    solver.dft_sample_counts = ()
+    solver.dft_start_step = None
+    solver.dft_start_steps = ()
+    solver.dft_end_step = None
+    solver.dft_end_steps = ()
+    solver.dft_window_normalization = 0.0
+    solver.dft_window_normalizations = ()
+    solver.dft_phase_step_cos = None
+    solver.dft_phase_step_sin = None
+    solver._dft_entries = []
+    solver._dft_batched_fields = {}
+    solver._dft_phase_cos = None
+    solver._dft_phase_sin = None
+    solver._dft_phase_step_cos_values = None
+    solver._dft_phase_step_sin_values = None
+    solver._dft_start_steps = None
+    solver._dft_end_steps = None
+    solver._dft_window_normalization_values = None
+    solver._dft_sample_count_values = None
+    solver._dft_source_dft_real_values = None
+    solver._dft_source_dft_imag_values = None
+
+    solver._source_terms = None
+    solver._magnetic_source_terms = None
+    solver._electric_source_terms = None
+    solver.material_eps_r = None
+    solver.material_mu_r = None
+    solver._compiled_material_model = None
+    solver.dispersive_enabled = False
+    solver.electric_dispersive_enabled = False
+    solver.magnetic_dispersive_enabled = False
+    solver._dispersive_templates = {}
+    solver._magnetic_dispersive_templates = {}
+    solver.kerr_enabled = False
+    solver.chi2_enabled = False
+    solver.tpa_enabled = False
+    solver.nonlinear_enabled = False
+    solver.nonlinear_general_enabled = False
+    solver.kerr_chi3 = None
+    solver.kerr_chi3_Ex = None
+    solver.kerr_chi3_Ey = None
+    solver.kerr_chi3_Ez = None
+    solver.nonlinear_chi2_Ex = None
+    solver.nonlinear_chi2_Ey = None
+    solver.nonlinear_chi2_Ez = None
+    solver.tpa_sigma_Ex = None
+    solver.tpa_sigma_Ey = None
+    solver.tpa_sigma_Ez = None
+    solver.cex_curl_dynamic = None
+    solver.cey_curl_dynamic = None
+    solver.cez_curl_dynamic = None
+    solver.cex_decay_dynamic = None
+    solver.cey_decay_dynamic = None
+    solver.cez_decay_dynamic = None
+    solver.cex_decay_external = None
+    solver.cey_decay_external = None
+    solver.cez_decay_external = None
+    solver._point_observer_groups = {}
+    solver._plane_observer_groups = {}
+    solver.last_solve_elapsed_s = None
+    solver.tfsf_enabled = False
+    solver._tfsf_state = None
+
+    solver.observers = compile_fdtd_observers(scene)
+    solver.observers_enabled = False
+    solver.time_observers = compile_fdtd_time_observers(scene)
+    solver.time_observers_enabled = False
+    solver.observer_frequency = None
+    solver.observer_frequencies = ()
+    solver.observer_window_type = "hanning"
+    solver.observer_start_step = None
+    solver.observer_start_steps = ()
+    solver.observer_end_step = None
+    solver.observer_end_steps = ()
+    solver.observer_window_normalization = 0.0
+    solver.observer_sample_count = 0
+    solver.observer_sample_counts = ()
+    solver.observer_phase_step_cos = None
+    solver.observer_phase_step_sin = None
+    solver._observer_spectral_entries = []
+    solver._observer_point_groups_by_frequency = []
+    solver._observer_plane_groups_by_frequency = []