"""
The patch module defines the classes necessary to describe finite-volume
data and the grid that it lives on.

Typical usage:

* create the grid::

   grid = Grid2d(nx, ny)

* create the data that lives on that grid::

   data = CellCenterData2d(grid)

   bc = BC(xlb="reflect", xrb="reflect",
          ylb="outflow", yrb="outflow")
   data.register_var("density", bc)
   ...

   data.create()

* initialize some data::

   dens = data.get_var("density")
   dens[:, :] = ...


* fill the ghost cells::

   data.fill_BC("density")

"""

import h5py
import numpy as np

import pyro.mesh.boundary as bnd
from pyro.mesh.array_indexer import ArrayIndexer, ArrayIndexerFC
from pyro.util import msg



[docs]
class Grid2d:
    """
    the 2-d grid class.  The grid object will contain the coordinate
    information (at various centerings).

    A basic (1-d) representation of the layout is::

       |     |      |     X     |     |      |     |     X     |      |     |
       +--*--+- // -+--*--X--*--+--*--+- // -+--*--+--*--X--*--+- // -+--*--+
          0          ng-1    ng   ng+1         ... ng+nx-1 ng+nx      2ng+nx-1

                            ilo                      ihi

       |<- ng guardcells->|<---- nx interior zones ----->|<- ng guardcells->|

    The '*' marks the data locations.
    """

    # pylint: disable=too-many-instance-attributes

    def __init__(self, nx, ny, *, ng=1,
                 xmin=0.0, xmax=1.0, ymin=0.0, ymax=1.0):
        """
        Create a Grid2d object.

        The only data that we require is the number of points that
        make up the mesh in each direction.  Optionally we take the
        extrema of the domain (default is [0,1]x[0,1]) and number of
        ghost cells (default is 1).

        Note that the Grid2d object only defines the discretization,
        it does not know about the boundary conditions, as these can
        vary depending on the variable.

        Parameters
        ----------
        nx : int
            Number of zones in the x-direction
        ny : int
            Number of zones in the y-direction
        ng : int, optional
            Number of ghost cells
        xmin : float, optional
            Physical coordinate at the lower x boundary
        xmax : float, optional
            Physical coordinate at the upper x boundary
        ymin : float, optional
            Physical coordinate at the lower y boundary
        ymax : float, optional
            Physical coordinate at the upper y boundary
        """

        # pylint: disable=too-many-arguments

        # size of grid
        self.nx = int(nx)
        self.ny = int(ny)
        self.ng = int(ng)

        self.qx = int(2*ng + nx)
        self.qy = int(2*ng + ny)

        # domain extrema
        self.xmin = xmin
        self.xmax = xmax

        self.ymin = ymin
        self.ymax = ymax

        # compute the indices of the block interior (excluding guardcells)
        self.ilo = self.ng
        self.ihi = self.ng + self.nx - 1

        self.jlo = self.ng
        self.jhi = self.ng + self.ny - 1

        # center of the grid (for convenience)
        self.ic = self.ilo + self.nx//2 - 1
        self.jc = self.jlo + self.ny//2 - 1

        # define the coordinate information at the left, center, and right
        # zone coordinates
        self.dx = (xmax - xmin)/nx

        self.xl = (np.arange(self.qx) - ng)*self.dx + xmin
        self.xr = (np.arange(self.qx) + 1.0 - ng)*self.dx + xmin
        self.x = 0.5*(self.xl + self.xr)

        self.dy = (ymax - ymin)/ny

        self.yl = (np.arange(self.qy) - ng)*self.dy + ymin
        self.yr = (np.arange(self.qy) + 1.0 - ng)*self.dy + ymin
        self.y = 0.5*(self.yl + self.yr)

        # 2-d versions of the zone coordinates
        x2d, y2d = np.meshgrid(self.x, self.y, indexing='ij')
        self.x2d = ArrayIndexer(d=x2d, grid=self)
        self.y2d = ArrayIndexer(d=y2d, grid=self)

        xl2d, yl2d = np.meshgrid(self.xl, self.yl, indexing='ij')
        self.xl2d = ArrayIndexer(d=xl2d, grid=self)
        self.yl2d = ArrayIndexer(d=yl2d, grid=self)

        xr2d, yr2d = np.meshgrid(self.xr, self.yr, indexing='ij')
        self.xr2d = ArrayIndexer(d=xr2d, grid=self)
        self.yr2d = ArrayIndexer(d=yr2d, grid=self)


[docs]
    def scratch_array(self, *, nvar=1, dtype=np.float64):
        """
        return a standard numpy array dimensioned to have the size
        and number of ghostcells as the parent grid
        """
        if nvar == 1:
            _tmp = np.zeros((self.qx, self.qy), dtype=dtype)
        else:
            _tmp = np.zeros((self.qx, self.qy, nvar), dtype=dtype)
        return ArrayIndexer(d=_tmp, grid=self)



[docs]
    def coarse_like(self, N):
        """
        return a new grid object coarsened by a factor n, but with
        all the other properties the same
        """
        return Grid2d(self.nx//N, self.ny//N, ng=self.ng,
                      xmin=self.xmin, xmax=self.xmax,
                      ymin=self.ymin, ymax=self.ymax)



[docs]
    def fine_like(self, N):
        """
        return a new grid object finer by a factor n, but with
        all the other properties the same
        """
        return Grid2d(self.nx*N, self.ny*N, ng=self.ng,
                      xmin=self.xmin, xmax=self.xmax,
                      ymin=self.ymin, ymax=self.ymax)


    def __str__(self):
        """ print out some basic information about the grid object """
        return f"2-d grid: nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"

    def __eq__(self, other):
        """ are two grids equivalent? """
        result = (self.nx == other.nx and self.ny == other.ny and
                  self.ng == other.ng and
                  self.xmin == other.xmin and self.xmax == other.xmax and
                  self.ymin == other.ymin and self.ymax == other.ymax)

        return result




[docs]
class Cartesian2d(Grid2d):
    """
    This class defines a 2D Cartesian Grid.

    Define:
    x = x
    y = y
    """

    def __init__(self, nx, ny, *, ng=1,
                 xmin=0.0, xmax=1.0, ymin=0.0, ymax=1.0):

        super().__init__(nx, ny, ng=ng, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)

        self.coord_type = 0

        # Length of the side in x- and y-direction

        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
                                 grid=self)
        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.dy),
                                 grid=self)

        # This is area of the side that is perpendicular to x.

        self.Ax = self.Ly

        # This is area of the side that is perpendicular to y.

        self.Ay = self.Lx

        # Spatial derivative of log(area). It's zero for Cartesian

        self.dlogAx = ArrayIndexer(np.zeros_like(self.Ax),
                                   grid=self)
        self.dlogAy = ArrayIndexer(np.zeros_like(self.Ay),
                                   grid=self)

        # Volume of the cell.

        self.V = ArrayIndexer(np.full((self.qx, self.qy), self.dx * self.dy),
                              grid=self)

    def __str__(self):
        """ print out some basic information about the grid object """
        return f"Cartesian 2D Grid: xmin = {self.xmin}, xmax = {self.xmax}, " + \
               f"ymin = {self.ymin}, ymax = {self.ymax}, " + \
               f"nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"




[docs]
class SphericalPolar(Grid2d):
    """
    This class defines a spherical polar grid.
    This is technically a 3D geometry but assumes azimuthal symmetry,
    and zero velocity in phi-direction.
    Hence 2D.

    Define:
    r = x
    theta = y
    """

    def __init__(self, nx, ny, *, ng=1,
                 xmin=0.2, xmax=1.0, ymin=0.0, ymax=1.0):

        super().__init__(nx, ny, ng=ng, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)

        # Make sure theta is within [0, PI]
        assert ymin >= 0.0 and ymax <= np.pi, "y or \u03b8 should be within [0, \u03c0]."

        # Make sure the ghost cells doesn't extend out negative x(r)
        assert xmin - ng*self.dx >= 0.0, \
            "xmin (r-direction), must be large enough so ghost cell doesn't have negative x."

        self.coord_type = 1

        # Length of the side along r-direction, dr

        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
                               grid=self)

        # Length of the side along theta-direction, r*dtheta

        self.Ly = ArrayIndexer(self.x2d*self.dy, grid=self)

        # Returns an array of the face area that points in the r(x) direction.
        # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi

        # dAr_l = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
        self.Ax = np.abs(-2.0 * np.pi * self.xl2d**2 *
                         (np.cos(self.yr2d) - np.cos(self.yl2d)))

        # Returns an array of the face area that points in the theta(y) direction.
        # dL_phi x dL_r = dr * r * sin(theta) * dphi

        # dAtheta_l = pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
        self.Ay = np.abs(np.pi * np.sin(self.yl2d) *
                         (self.xr2d**2 - self.xl2d**2))

        # dlogAx = 1 / r^2 d( r^2 ) / dr = 2 / r
        self.dlogAx = 2.0 / self.x2d

        # dlogAy = 1 / (r sin(theta)) d( sin(theta) )/dtheta = cot(theta) / r
        self.dlogAy = 1.0 / (np.tan(self.y2d) * self.x2d)

        # Returns an array of the volume of each cell.
        # dV = dL_r * dL_theta * dL_phi
        #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
        # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)

        self.V = np.abs(-2.0 * np.pi / 3.0 *
                        (np.cos(self.yr2d) - np.cos(self.yl2d)) *
                        (self.xr2d - self.xl2d) *
                        (self.xr2d**2 + self.xl2d**2 + self.xr2d*self.xl2d))

    def __str__(self):
        """ print out some basic information about the grid object """
        return "Spherical Polar 2D Grid: Define x : r, y : \u03b8. " + \
               f"xmin (r) = {self.xmin}, xmax= {self.xmax}, " + \
               f"ymin = {self.ymin}, ymax = {self.ymax}, " + \
               f"nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"




[docs]
class CellCenterData2d:
    """
    A class to define cell-centered data that lives on a grid.  A
    CellCenterData2d object is built in a multi-step process before
    it can be used.

    * Create the object.  We pass in a grid object to describe where
      the data lives::

         my_data = patch.CellCenterData2d(myGrid)

    * Register any variables that we expect to live on this patch.
      Here BC describes the boundary conditions for that variable::

         my_data.register_var('density', BC)
         my_data.register_var('x-momentum', BC)
         ...

    * Register any auxiliary data -- these are any parameters that are
      needed to interpret the data outside of the simulation (for
      example, the gamma for the equation of state)::

         my_data.set_aux(keyword, value)

    * Finish the initialization of the patch::

         my_data.create()

    This last step actually allocates the storage for the state
    variables.  Once this is done, the patch is considered to be
    locked.  New variables cannot be added.
    """

    # pylint: disable=too-many-instance-attributes

    def __init__(self, grid, *, dtype=np.float64):

        """
        Initialize the CellCenterData2d object.

        Parameters
        ----------
        grid : Grid2d object
            The grid upon which the data will live
        dtype : NumPy data type, optional
            The datatype of the data we wish to create (defaults to
            np.float64
        """

        self.grid = grid

        self.dtype = dtype
        self.data = None

        self.names = []
        self.vars = self.names  # backwards compatibility hack
        self.nvar = 0
        self.ivars = []

        self.aux = {}

        # derived variables will have a callback function
        self.derives = []

        self.BCs = {}

        # time
        self.t = -1.0

        self.initialized = 0


[docs]
    def register_var(self, name, bc):
        """
        Register a variable with CellCenterData2d object.

        Parameters
        ----------
        name : str
            The variable name
        bc : BC object
            The boundary conditions that describe the actions to take
            for this variable at the physical domain boundaries.
        """

        if self.initialized == 1:
            msg.fail("ERROR: grid already initialized")

        self.names.append(name)
        self.nvar += 1

        self.BCs[name] = bc



[docs]
    def set_aux(self, keyword, value):
        """
        Set any auxiliary (scalar) data.  This data is simply carried
        along with the CellCenterData2d object

        Parameters
        ----------
        keyword : str
            The name of the datum
        value : any time
            The value to associate with the keyword
        """
        self.aux[keyword] = value



[docs]
    def add_derived(self, func):
        """
        Register a function to compute derived variable

        Parameters
        ----------
        func : function
            A function to call to derive the variable.  This function
            should take two arguments, a CellCenterData2d object and a
            string variable name (or list of variables)
        """
        self.derives.append(func)



[docs]
    def add_ivars(self, ivars):
        """
        Add ivars
        """

        self.ivars = ivars



[docs]
    def create(self):
        """
        Called after all the variables are registered and allocates
        the storage for the state data.
        """

        if self.initialized == 1:
            msg.fail("ERROR: grid already initialized")

        _tmp = np.zeros((self.grid.qx, self.grid.qy, self.nvar),
                        dtype=self.dtype)
        self.data = ArrayIndexer(_tmp, grid=self.grid)

        self.initialized = 1


    def __str__(self):
        """ print out some basic information about the CellCenterData2d
            object """

        if self.initialized == 0:
            my_str = "CellCenterData2d object not yet initialized"
            return my_str

        my_str = f"cc data: nx = {self.grid.nx}, ny = {self.grid.ny}, ng = {self.grid.ng}\n"
        my_str += f"         nvars = {self.nvar}\n"
        my_str += "         variables:\n"

        for n in range(self.nvar):
            name = self.names[n]
            my_str += f"{name:>16s}: min: {self.min(name):15.10f}    max: {self.max(name):15.10f}\n"
            my_str += f"{' ':>16s}  BCs: -x: {self.BCs[name].xlb:12s} +x: {self.BCs[name].xrb:12s}"
            my_str += f" -y: {self.BCs[name].ylb:12s} +y: {self.BCs[name].yrb:12s}\n"

        return my_str


[docs]
    def get_var(self, name):
        """
        Return a data array for the variable described by name.  Stored
        variables will be checked first, and then any derived variables
        will be checked.

        For a stored variable, changes made to this are automatically
        reflected in the CellCenterData2d object.

        Parameters
        ----------
        name : str
            The name of the variable to access

        Returns
        -------
        out : ndarray
            The array of data corresponding to the variable name

        """
        # ns = [self.names.index(name) for name in self.names]
        try:
            n = self.names.index(name)
        except ValueError:
            for f in self.derives:
                try:
                    var = f(self, name)
                except TypeError:
                    var = f(self, name, self.ivars, self.grid)
                if len(var) > 0:
                    return var
            raise KeyError(f"name {name} is not valid") from None
        return self.get_var_by_index(n)



[docs]
    def get_var_by_index(self, n):
        """
        Return a data array for the variable with index n in the
        data array.  Any changes made to this are automatically
        reflected in the CellCenterData2d object.

        Parameters
        ----------
        n : int
            The index of the variable to access

        Returns
        -------
        out : ndarray
            The array of data corresponding to the index

        """
        return ArrayIndexer(d=self.data[:, :, n], grid=self.grid)



[docs]
    def get_vars(self):
        """
        Return the entire data array.  Any changes made to this
        are automatically reflected in the CellCenterData2d object.

        Returns
        -------
        out : ndarray
            The array of data

        """
        return ArrayIndexer(d=self.data, grid=self.grid)



[docs]
    def get_aux(self, keyword):
        """
        Get the auxiliary data associated with keyword

        Parameters
        ----------
        keyword : str
            The name of the auxiliary data to access

        Returns
        -------
        out : variable type
            The value corresponding to the keyword

        """
        if keyword in self.aux:
            return self.aux[keyword]

        return None



[docs]
    def zero(self, name):
        """
        Zero out the data array associated with variable name.

        Parameters
        ----------
        name : str
            The name of the variable to zero

        """
        n = self.names.index(name)
        self.data[:, :, n] = 0.0



[docs]
    def fill_BC_all(self):
        """
        Fill boundary conditions on all variables.
        """
        for name in self.names:
            self.fill_BC(name)



[docs]
    def fill_BC(self, name):
        """
        Fill the boundary conditions.  This operates on a single state
        variable at a time, to allow for maximum flexibility.

        We do periodic, reflect-even, reflect-odd, and outflow

        Each variable name has a corresponding BC stored in the
        CellCenterData2d object -- we refer to this to figure out the
        action to take at each boundary.

        Parameters
        ----------
        name : str
            The name of the variable for which to fill the BCs.

        """

        n = self.names.index(name)
        self.data.fill_ghost(n=n, bc=self.BCs[name])

        # that will handle the standard type of BCs, but if we asked
        # for a custom BC, we handle it here
        if self.BCs[name].xlb in bnd.ext_bcs:
            try:
                bnd.ext_bcs[self.BCs[name].xlb](self.BCs[name].xlb, "xlb", name, self, self.ivars)
            except TypeError:
                bnd.ext_bcs[self.BCs[name].xlb](self.BCs[name].xlb, "xlb", name, self)
        if self.BCs[name].xrb in bnd.ext_bcs:
            try:
                bnd.ext_bcs[self.BCs[name].xrb](self.BCs[name].xrb, "xrb", name, self)
            except TypeError:
                bnd.ext_bcs[self.BCs[name].xrb](self.BCs[name].xrb, "xrb", name, self, self.ivars)
        if self.BCs[name].ylb in bnd.ext_bcs:
            try:
                bnd.ext_bcs[self.BCs[name].ylb](self.BCs[name].ylb, "ylb", name, self)
            except TypeError:
                bnd.ext_bcs[self.BCs[name].ylb](self.BCs[name].ylb, "ylb", name, self, self.ivars)
        if self.BCs[name].yrb in bnd.ext_bcs:
            try:
                bnd.ext_bcs[self.BCs[name].yrb](self.BCs[name].yrb, "yrb", name, self)
            except TypeError:
                bnd.ext_bcs[self.BCs[name].yrb](self.BCs[name].yrb, "yrb", name, self, self.ivars)



[docs]
    def min(self, name, *, ng=0):
        """
        return the minimum of the variable name in the domain's valid region
        """
        n = self.names.index(name)
        return np.min(self.data.v(buf=ng, n=n))



[docs]
    def max(self, name, *, ng=0):
        """
        return the maximum of the variable name in the domain's valid region
        """
        n = self.names.index(name)
        return np.max(self.data.v(buf=ng, n=n))



[docs]
    def restrict(self, varname, N=2):
        """
        Restrict the variable varname to a coarser grid (factor of 2
        coarser) and return an array with the resulting data (and same
        number of ghostcells)
        """

        fine_grid = self.grid
        fdata = self.get_var(varname)

        # allocate an array for the coarsely gridded data
        coarse_grid = fine_grid.coarse_like(N)
        cdata = coarse_grid.scratch_array()

        # fill the coarse array with the restricted data -- just
        # by averaging the fine cells into the corresponding coarse cell
        # that encompasses them.
        if N == 2:
            cdata.v()[:, :] = \
                0.25*(fdata.v(s=2) + fdata.ip(1, s=2) +
                      fdata.jp(1, s=2) + fdata.ip_jp(1, 1, s=2))
        elif N == 4:
            cdata.v()[:, :] = \
                (fdata.v(s=4) +
                 fdata.ip(1, s=4) +
                 fdata.ip(2, s=4) + fdata.ip(3, s=4) +
                 fdata.jp(1, s=4) + fdata.ip_jp(1, 1, s=4) +
                 fdata.ip_jp(2, 1, s=4) + fdata.ip_jp(3, 1, s=4) +
                 fdata.jp(2, s=4) + fdata.ip_jp(1, 2, s=4) +
                 fdata.ip_jp(2, 2, s=4) + fdata.ip_jp(3, 2, s=4) +
                 fdata.jp(3, s=4) + fdata.ip_jp(1, 3, s=4) +
                 fdata.ip_jp(2, 3, s=4) + fdata.ip_jp(3, 3, s=4))/16.0

        else:
            raise ValueError("restriction is only allowed by 2 or 4")

        return cdata



[docs]
    def prolong(self, varname):
        """
        Prolong the data in the current (coarse) grid to a finer
        (factor of 2 finer) grid.  Return an array with the resulting
        data (and same number of ghostcells).  Only the data for the
        variable varname will be operated upon.

        We will reconstruct the data in the zone from the
        zone-averaged variables using the same limited slopes as in
        the advection routine.  Getting a good multidimensional
        reconstruction polynomial is hard -- we want it to be bilinear
        and monotonic -- we settle for having each slope be
        independently monotonic::

                     (x)         (y)
           f(x,y) = m    x/dx + m    y/dy + <f>

        where the m's are the limited differences in each direction.
        When averaged over the parent cell, this reproduces <f>.

        Each zone's reconstrution will be averaged over 4 children::

           +-----------+     +-----+-----+
           |           |     |     |     |
           |           |     |  3  |  4  |
           |    <f>    | --> +-----+-----+
           |           |     |     |     |
           |           |     |  1  |  2  |
           +-----------+     +-----+-----+

        We will fill each of the finer resolution zones by filling all
        the 1's together, using a stride 2 into the fine array.  Then
        the 2's and ..., this allows us to operate in a vector
        fashion.  All operations will use the same slopes for their
        respective parents.

        """

        coarse_grid = self.grid
        cdata = self.get_var(varname)

        # allocate an array for the finely gridded data
        fine_grid = coarse_grid.fine_like(2)
        fdata = fine_grid.scratch_array()

        # slopes for the coarse data
        m_x = coarse_grid.scratch_array()
        m_x.v()[:, :] = 0.5*(cdata.ip(1) - cdata.ip(-1))

        m_y = coarse_grid.scratch_array()
        m_y.v()[:, :] = 0.5*(cdata.jp(1) - cdata.jp(-1))

        # fill the children
        fdata.v(s=2)[:, :] = cdata.v() - 0.25*m_x.v() - 0.25*m_y.v()      # 1 child
        fdata.ip(1, s=2)[:, :] = cdata.v() + 0.25*m_x.v() - 0.25*m_y.v()  # 2
        fdata.jp(1, s=2)[:, :] = cdata.v() - 0.25*m_x.v() + 0.25*m_y.v()  # 3
        fdata.ip_jp(1, 1, s=2)[:, :] = cdata.v() + 0.25*m_x.v() + 0.25*m_y.v()  # 4

        return fdata



[docs]
    def write(self, filename):
        """
        create an output file in HDF5 format and write out our data and
        grid.
        """

        if not filename.endswith(".h5"):
            filename += ".h5"

        with h5py.File(filename, "w") as f:
            self.write_data(f)



[docs]
    def write_data(self, f):
        """
        write the data out to an hdf5 file -- here, f is an h5py
        File pbject

        """

        # auxiliary data
        gaux = f.create_group("aux")
        for k, v in self.aux.items():
            gaux.attrs[k] = v

        # grid information
        ggrid = f.create_group("grid")
        ggrid.attrs["nx"] = self.grid.nx
        ggrid.attrs["ny"] = self.grid.ny
        ggrid.attrs["ng"] = self.grid.ng

        ggrid.attrs["xmin"] = self.grid.xmin
        ggrid.attrs["xmax"] = self.grid.xmax
        ggrid.attrs["ymin"] = self.grid.ymin
        ggrid.attrs["ymax"] = self.grid.ymax

        try:
            ggrid.attrs["coord_type"] = self.grid.coord_type
        except AttributeError:
            pass

        # data
        gstate = f.create_group("state")

        for n in range(self.nvar):
            gvar = gstate.create_group(self.names[n])
            gvar.create_dataset("data",
                                data=self.get_var_by_index(n).v())
            gvar.attrs["xlb"] = self.BCs[self.names[n]].xlb
            gvar.attrs["xrb"] = self.BCs[self.names[n]].xrb
            gvar.attrs["ylb"] = self.BCs[self.names[n]].ylb
            gvar.attrs["yrb"] = self.BCs[self.names[n]].yrb



[docs]
    def pretty_print(self, var, fmt=None):
        """print out the contents of the data array with pretty formatting
        indicating where ghost cells are."""
        a = self.get_var(var)
        a.pretty_print(fmt=fmt)





[docs]
class FaceCenterData2d(CellCenterData2d):
    """
    A class to define face-centered data that lives on a grid.  Data
    can be face-centered in x or y.  This is built in the same multistep
    process  as a CellCenterData2d object"""

    def __init__(self, grid, idir, dtype=np.float64):
        """
        Initialize the FaceCenterData2d object

        Parameters
        ----------
        grid : Grid2d object
            The grid upon which the data will live
        idir : the direction in which we are face-centered (this will be
               1 for x or 2 for y)
        dtype : NumPy data type, optional
            The datatype of the data we wish to create (defaults to
            np.float64
        """

        super().__init__(grid, dtype=dtype)
        self.idir = idir


[docs]
    def add_derived(self, func):
        raise NotImplementedError("derived variables not yet supported for face-centered data")



[docs]
    def create(self):
        """Called after all the variables are registered and allocates the
        storage for the state data.  For face-centered data, we have
        one more zone in the face-centered direction.

        """

        if self.initialized == 1:
            msg.fail("ERROR: grid already initialized")

        if self.idir == 1:
            _tmp = np.zeros((self.grid.qx+1, self.grid.qy, self.nvar),
                            dtype=self.dtype)
            self.data = ArrayIndexerFC(_tmp, idir=self.idir, grid=self.grid)

        elif self.idir == 2:
            _tmp = np.zeros((self.grid.qx, self.grid.qy+1, self.nvar),
                            dtype=self.dtype)
            self.data = ArrayIndexerFC(_tmp, idir=self.idir, grid=self.grid)

        self.initialized = 1


    def __str__(self):
        """ print out some basic information about the FaceCenterData2d
            object """

        if self.initialized == 0:
            my_str = "FaceCenterData2d object not yet initialized"
            return my_str

        my_str = f"fc data: idir = {self.idir}, nx = {self.grid.nx}, ny = {self.grid.ny}, ng = {self.grid.ng}\n"
        my_str += f"         nvars = {self.nvar}\n"
        my_str += "         variables:\n"

        for n in range(self.nvar):
            name = self.names[n]
            my_str += f"{name:>16s}: min: {self.min(name):15.10f}    max: {self.max(name):15.10f}\n"
            my_str += f"{' ':>16s}  BCs: -x: {self.BCs[name].xlb:12s} +x: {self.BCs[name].xrb:12s}"
            my_str += f" -y: {self.BCs[name].ylb:12s} +y: {self.BCs[name].yrb:12s}\n"

        return my_str


[docs]
    def get_var_by_index(self, n):
        """
        Return a data array for the variable with index n in the
        data array.  Any changes made to this are automatically
        reflected in the CellCenterData2d object.

        Parameters
        ----------
        n : int
            The index of the variable to access

        Returns
        -------
        out : ndarray
            The array of data corresponding to the index

        """
        return ArrayIndexerFC(d=self.data[:, :, n], idir=self.idir, grid=self.grid)



[docs]
    def get_vars(self):
        """
        Return the entire data array.  Any changes made to this
        are automatically reflected in the CellCenterData2d object.

        Returns
        -------
        out : ndarray
            The array of data

        """
        return ArrayIndexerFC(d=self.data, idir=self.idir, grid=self.grid)



[docs]
    def fill_BC(self, name):
        """
        Fill the boundary conditions.  This operates on a single state
        variable at a time, to allow for maximum flexibility.

        We do periodic, reflect-even, reflect-odd, and outflow

        Each variable name has a corresponding BC stored in the
        CellCenterData2d object -- we refer to this to figure out the
        action to take at each boundary.

        Parameters
        ----------
        name : str
            The name of the variable for which to fill the BCs.

        """

        n = self.names.index(name)
        self.data.fill_ghost(n=n, bc=self.BCs[name])

        if self.BCs[name].xlb in bnd.ext_bcs or \
           self.BCs[name].xrb in bnd.ext_bcs or \
           self.BCs[name].ylb in bnd.ext_bcs or \
           self.BCs[name].yrb in bnd.ext_bcs:
            raise NotImplementedError("custom boundary conditions not supported for FaceCenterData2d")



[docs]
    def restrict(self, varname, N=2):
        raise NotImplementedError("restriction not implemented for FaceCenterData2d")



[docs]
    def prolong(self, varname):
        raise NotImplementedError("prolongation not implemented for FaceCenterData2d")



[docs]
    def write_data(self, f):
        """
        write the data out to an hdf5 file -- here, f is an h5py
        File pbject

        """

        # data
        gstate = f.create_group("face-centered-state")

        for n in range(self.nvar):
            gvar = gstate.create_group(self.names[n])
            gvar.create_dataset("data",
                                data=self.get_var_by_index(n).v())
            gvar.attrs["xlb"] = self.BCs[self.names[n]].xlb
            gvar.attrs["xrb"] = self.BCs[self.names[n]].xrb
            gvar.attrs["ylb"] = self.BCs[self.names[n]].ylb
            gvar.attrs["yrb"] = self.BCs[self.names[n]].yrb





[docs]
def cell_center_data_clone(old):
    """
    Create a new CellCenterData2d object that is a copy of an existing
    one

    Parameters
    ----------
    old : CellCenterData2d object
        The CellCenterData2d object we wish to copy

    """

    if not isinstance(old, CellCenterData2d):
        msg.fail("Can't clone object")

    # we may be a type derived from CellCenterData2d, so use the same
    # type
    myt = type(old)
    new = myt(old.grid, dtype=old.dtype)

    for n in range(old.nvar):
        new.register_var(old.names[n], old.BCs[old.names[n]])

    new.create()

    new.aux = old.aux.copy()
    new.data = old.data.copy()
    new.derives = old.derives.copy()

    return new




[docs]
def do_demo():
    """ show examples of the patch methods / classes """
    # pylint: disable-next=import-outside-toplevel  # required to avoid import loops
    import pyro.util.io_pyro as io

    # illustrate basic mesh operations

    myg = Grid2d(8, 16, xmax=1.0, ymax=2.0)

    mydata = CellCenterData2d(myg)

    bc = bnd.BC()

    mydata.register_var("a", bc)
    mydata.create()

    a = mydata.get_var("a")
    a[:, :] = np.exp(-(myg.x2d - 0.5)**2 - (myg.y2d - 1.0)**2)

    print(mydata)

    # output
    print("writing\n")
    mydata.write("mesh_test")

    print("reading\n")
    myd2 = io.read("mesh_test")
    print(myd2)

    mydata.pretty_print("a")



if __name__ == "__main__":
    do_demo()