Method __init__

python/geom.py:593–697

Creates a `MaterialGrid` object. The input are two materials `medium1` and `medium2` along with a weight function $u(x)$ which is defined on a rectilinear grid by the NumPy array `weights` of size `grid_size` (a 3-tuple or `Vector3` of integers $N_x$,$N_y$,$N_z$). T

(
        self,
        grid_size: Union[Vector3, Tuple[float, ...]],
        medium1: Medium,
        medium2: Medium,
        weights: np.ndarray = None,
        grid_type: str = "U_DEFAULT",
        do_averaging: bool = False,
        beta: float = 0,
        eta: float = 0.5,
        damping: float = 0,
    )

        return np.clip(w, 0.0, 1.0)

    def __init__(
        self,
        grid_size: Union[Vector3, Tuple[float, ...]],
        medium1: Medium,
        medium2: Medium,
        weights: np.ndarray = None,
        grid_type: str = "U_DEFAULT",
        do_averaging: bool = False,
        beta: float = 0,
        eta: float = 0.5,
        damping: float = 0,
    ):
        """
        Creates a `MaterialGrid` object.

        The input are two materials `medium1` and `medium2` along with a weight function $u(x)$ which
        is defined on a rectilinear grid by the NumPy array `weights` of size `grid_size` (a 3-tuple or
        `Vector3` of integers $N_x$,$N_y$,$N_z$). The resolution of the grid may be nonuniform depending
        on the `size` property of the `Block` object as shown in the following example for a 2d `MaterialGrid`
        with $N_x=5$ and $N_y=4$. $N_z=0$ implies that the `MaterialGrid` is extruded in the $z$ direction.
        The grid points are defined at the corners of the voxels.

        ![](images/material_grid.png#center)

        Elements of the `weights` array must be in the range [0,1] where 0 is `medium1` and 1 is `medium2`.
        An array of boolean values `False` and `True` will be converted to 0 and 1, respectively.
        The `weights` array is used to define a linear interpolation from `medium1` to `medium2`.
        Two material types are supported: (1) frequency-independent isotropic $\\varepsilon$ (`epsilon_diag`
        and `epsilon_offdiag` are interpolated) and (2) `LorentzianSusceptibility` (`sigma` and `sigma_offdiag`
        are interpolated). `medium1` and `medium2` must both be the same type. The materials are
        [bilinearly interpolated](https://en.wikipedia.org/wiki/Bilinear_interpolation) from the rectilinear
        grid to Meep's [Yee grid](Yee_Lattice.md).

        For improving accuracy, [subpixel smoothing](Subpixel_Smoothing.md) can be enabled by specifying
        `do_averaging=True`. If you want to use a material grid to define a (nearly) discontinuous,
        piecewise-constant material that is *either* `medium1` or `medium2` almost everywhere, you can
        optionally enable a (smoothed) *projection* feature by setting the parameter `beta` to a
        positive value. The default is no projection (`beta=0`). When the projection feature is
        enabled, the weights $u(x)$ can be thought of as a
        [level-set function](https://en.wikipedia.org/wiki/Level-set_method) defining an interface at
        $u(x)=\\eta$ with a smoothing factor $\\beta$ where $\\beta=+\\infty$ gives an unsmoothed,
        discontinuous interface. The projection operator is $(\\tanh(\\beta\\times\\eta)
        +\\tanh(\\beta\\times(u-\\eta)))/(\\tanh(\\beta\\times\\eta)+\\tanh(\\beta\\times(1-\\eta)))$
        involving the parameters `beta` ($\\beta$: bias or "smoothness" of the turn on) and `eta`
        ($\\eta$: offset for erosion/dilation). The level set provides a general approach for defining
        a *discontinuous* function from otherwise continuously varying (via the bilinear interpolation)
        grid values. Subpixel smoothing is fast and accurate because it exploits an analytic formulation
        for level-set functions. Note that when subpixel smoothing is enabled via `do_averaging=True`,
        projecting the `weights` is done internally using the `beta` parameter. It is therefore not
        necessary to manually project the `weights` outside of `MaterialGrid`. However, visualizing
        the `weights` used to define the structure does require manually projecting the `weights` yourself.
        (Alternatively, you can output the actual structure using [`plot2D`](#data-visualization) or
        [`output_epsilon`](#output-functions_1).)

        A nonzero `damping` term creates an artificial conductivity $\\sigma = u(1-u)*$`damping`, which acts as
        dissipation loss that penalizes intermediate pixel values of non-binarized structures. The value of
        `damping` should be proportional to $2\\pi$ times the typical frequency of the problem.