fdtdx.BoundaryConfig

@classmethod
def from_uniform_bound(
    cls,
    thickness: int = 10,
    boundary_type: str = "pml",
    kappa_start: float = 1,
    kappa_end: float = 1.5,
) -> "BoundaryConfig":
    """Creates a BoundaryConfig with uniform parameters for all boundaries.

    Args:
        thickness (int, optional): Grid thickness to use for all PML boundaries. Defaults to 10.
        boundary_type (str, optional): Type of boundary to use ("pml" or "periodic"). Defaults to "pml".
        kappa_start (float, optional): Initial kappa value for all boundaries. Defaults to 1.0.
        kappa_end (float, optional): Final kappa value for all boundaries. Defaults to 1.5.

    Returns:
        BoundaryConfig: New config object with uniform parameters
    """
    return cls(
        boundary_type_minx=boundary_type,
        boundary_type_maxx=boundary_type,
        boundary_type_miny=boundary_type,
        boundary_type_maxy=boundary_type,
        boundary_type_minz=boundary_type,
        boundary_type_maxz=boundary_type,
        thickness_grid_minx=thickness,
        thickness_grid_maxx=thickness,
        thickness_grid_miny=thickness,
        thickness_grid_maxy=thickness,
        thickness_grid_minz=thickness,
        thickness_grid_maxz=thickness,
        kappa_start_minx=kappa_start,
        kappa_end_minx=kappa_end,
        kappa_start_maxx=kappa_start,
        kappa_end_maxx=kappa_end,
        kappa_start_miny=kappa_start,
        kappa_end_miny=kappa_end,
        kappa_start_maxy=kappa_start,
        kappa_end_maxy=kappa_end,
        kappa_start_minz=kappa_start,
        kappa_end_minz=kappa_end,
        kappa_start_maxz=kappa_start,
        kappa_end_maxz=kappa_end,
    )

def get_dict(self) -> dict[str, int]:
    """Gets a dictionary mapping boundary names to their grid thicknesses.

    Returns:
        dict[str, int]: Dictionary with keys 'min_x', 'max_x', 'min_y', 'max_y', 'min_z', 'max_z'
            mapping to their respective grid thickness values.
    """
    return {
        "min_x": self.thickness_grid_minx,
        "max_x": self.thickness_grid_maxx,
        "min_y": self.thickness_grid_miny,
        "max_y": self.thickness_grid_maxy,
        "min_z": self.thickness_grid_minz,
        "max_z": self.thickness_grid_maxz,
    }

def get_inside_boundary_slice(self) -> tuple[slice, slice, slice]:
    """Gets slice objects for the non-PML interior region of the simulation volume.

    Returns:
        tuple[slice, slice, slice]: Three slice objects for indexing the x, y, z dimensions
            respectively, excluding the PML boundary regions.
    """
    return (
        slice(
            self.thickness_grid_minx + 1 if self.boundary_type_minx == "pml" else 0,
            -self.thickness_grid_maxx - 1 if self.boundary_type_maxx == "pml" else None,
        ),
        slice(
            self.thickness_grid_miny + 1 if self.boundary_type_miny == "pml" else 0,
            -self.thickness_grid_maxy - 1 if self.boundary_type_maxy == "pml" else None,
        ),
        slice(
            self.thickness_grid_minz + 1 if self.boundary_type_minz == "pml" else 0,
            -self.thickness_grid_maxz - 1 if self.boundary_type_maxz == "pml" else None,
        ),
    )

def get_kappa_dict(
    self,
    prop: Literal["kappa_start", "kappa_end"],
) -> dict[str, float]:
    """Gets a dictionary mapping boundary names to their kappa values.

    Args:
        prop (Literal["kappa_start", "kappa_end"]): Which kappa property to get,
            either "kappa_start" or "kappa_end".

    Returns:
        dict[str, float]: Dictionary with keys 'min_x', 'max_x', 'min_y', 'max_y', 'min_z', 'max_z'
            mapping to their respective kappa values.

    Raises:
        Exception: If prop is not "kappa_start" or "kappa_end"
    """
    if prop == "kappa_start":
        return {
            "min_x": self.kappa_start_minx,
            "max_x": self.kappa_start_maxx,
            "min_y": self.kappa_start_miny,
            "max_y": self.kappa_start_maxy,
            "min_z": self.kappa_start_minz,
            "max_z": self.kappa_start_maxz,
        }
    elif prop == "kappa_end":
        return {
            "min_x": self.kappa_end_minx,
            "max_x": self.kappa_end_maxx,
            "min_y": self.kappa_end_miny,
            "max_y": self.kappa_end_maxy,
            "min_z": self.kappa_end_minz,
            "max_z": self.kappa_end_maxz,
        }
    else:
        raise Exception(f"Unknown: {prop=}")

def get_type_dict(self) -> dict[str, str]:
    """Gets a dictionary mapping boundary names to their boundary types.

    Returns:
        dict[str, str]: Dictionary with keys 'min_x', 'max_x', 'min_y', 'max_y', 'min_z', 'max_z'
            mapping to their respective boundary types ("pml" or "periodic").
    """
    return {
        "min_x": self.boundary_type_minx,
        "max_x": self.boundary_type_maxx,
        "min_y": self.boundary_type_miny,
        "max_y": self.boundary_type_maxy,
        "min_z": self.boundary_type_minz,
        "max_z": self.boundary_type_maxz,
    }