roms-tools 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

roms_tools/setup/datasets.py

@@ -12,8 +12,10 @@ from roms_tools.setup.utils import (
     interpolate_from_climatology,
     get_time_type,
     convert_cftime_to_datetime,
+    one_dim_fill,
 )
 from roms_tools.setup.download import download_correction_data
+from roms_tools.setup.fill import LateralFill
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -117,6 +119,8 @@ class Dataset:
             # Make sure that depth is ascending
             ds = self.ensure_dimension_is_ascending(ds, dim="depth")
 
+        self.infer_horizontal_resolution(ds)
+
         # Check whether the data covers the entire globe
         object.__setattr__(self, "is_global", self.check_if_global(ds))
 
@@ -487,6 +491,34 @@ class Dataset:
 
         return ds
 
+    def infer_horizontal_resolution(self, ds: xr.Dataset):
+        """Estimate and set the average horizontal resolution of a dataset based on
+        latitude and longitude spacing.
+
+        Parameters
+        ----------
+        ds : xr.Dataset
+            Dataset containing latitude and longitude dimensions.
+
+        Sets
+        ----
+        resolution : float
+            The average horizontal resolution, derived from the mean spacing
+            between points in latitude and longitude.
+        """
+        lat_dim = self.dim_names["latitude"]
+        lon_dim = self.dim_names["longitude"]
+
+        # Calculate mean difference along latitude and longitude
+        lat_resolution = ds[lat_dim].diff(dim=lat_dim).mean(dim=lat_dim)
+        lon_resolution = ds[lon_dim].diff(dim=lon_dim).mean(dim=lon_dim)
+
+        # Compute the average horizontal resolution
+        resolution = np.mean([lat_resolution, lon_resolution])
+
+        # Set the computed resolution as an attribute
+        object.__setattr__(self, "resolution", resolution)
+
     def check_if_global(self, ds) -> bool:
         """Checks if the dataset covers the entire globe in the longitude dimension.
 
@@ -569,40 +601,31 @@ class Dataset:
         """
         pass
 
-    def choose_subdomain(
-        self, latitude_range, longitude_range, margin, straddle, return_subdomain=False
-    ):
-        """Selects a subdomain from the xarray Dataset based on specified latitude and
-        longitude ranges, extending the selection by a specified margin. Handles
-        longitude conversions to accommodate different longitude ranges.
+    def choose_subdomain(self, target_coords, buffer_points=20, return_copy=False):
+        """Selects a subdomain from the xarray Dataset based on specified target
+        coordinates, extending the selection by a defined buffer. Adjusts longitude
+        ranges as necessary to accommodate the dataset's expected range and handles
+        potential discontinuities.
 
         Parameters
         ----------
-        latitude_range : tuple of float
-            A tuple (lat_min, lat_max) specifying the minimum and maximum latitude values of the subdomain.
-        longitude_range : tuple of float
-            A tuple (lon_min, lon_max) specifying the minimum and maximum longitude values of the subdomain.
-        margin : float
-            Margin in degrees to extend beyond the specified latitude and longitude ranges when selecting the subdomain.
-        straddle : bool
-            If True, target longitudes are expected in the range [-180, 180].
-            If False, target longitudes are expected in the range [0, 360].
+        target_coords : dict
+            A dictionary containing the target latitude and longitude coordinates, typically
+            with keys "lat", "lon", and "straddle".
+        buffer_points : int
+            The number of grid points to extend beyond the specified latitude and longitude
+            ranges when selecting the subdomain. Defaults to 20.
         return_subdomain : bool, optional
-            If True, returns the subset of the original dataset as an xarray Dataset. If False, assigns the subset to `self.ds`.
-            Defaults to False.
+            If True, returns the subset of the original dataset representing the chosen
+            subdomain. If False, assigns the subset to `self.ds`. Defaults to False.
 
         Returns
         -------
         xr.Dataset or None
-            If `return_subdomain` is True, returns the subset of the original dataset representing the chosen subdomain,
-            including an extended area to cover one extra grid point beyond the specified ranges. If `return_subdomain` is False,
-            returns None as the subset is assigned to `self.ds`.
-
-        Notes
-        -----
-        This method adjusts the longitude range if necessary to ensure it matches the expected range for the dataset.
-        It also handles longitude discontinuities that can occur when converting to different longitude ranges.
-        This is important for avoiding artifacts in the interpolation process.
+            Returns the subset of the original dataset as an xarray Dataset if
+            `return_subdomain` is True, including an extended area covering additional
+            grid points beyond the specified ranges. Returns None if `return_subdomain`
+            is False, as the subset is assigned to `self.ds`.
 
         Raises
         ------
@@ -610,13 +633,17 @@ class Dataset:
             If the selected latitude or longitude range does not intersect with the dataset.
         """
 
-        lat_min, lat_max = latitude_range
-        lon_min, lon_max = longitude_range
+        lat_min = target_coords["lat"].min().values
+        lat_max = target_coords["lat"].max().values
+        lon_min = target_coords["lon"].min().values
+        lon_max = target_coords["lon"].max().values
+
+        margin = self.resolution * buffer_points
 
         if not self.is_global:
             # Adjust longitude range if needed to match the expected range
             lon = self.ds[self.dim_names["longitude"]]
-            if not straddle:
+            if not target_coords["straddle"]:
                 if lon.min() < -180:
                     if lon_max + margin > 0:
                         lon_min -= 360
@@ -626,7 +653,7 @@ class Dataset:
                         lon_min -= 360
                         lon_max -= 360
 
-            if straddle:
+            if target_coords["straddle"]:
                 if lon.max() > 360:
                     if lon_min - margin < 180:
                         lon_min += 360
@@ -637,6 +664,7 @@ class Dataset:
                         lon_max += 360
 
         # Select the subdomain
+
         subdomain = self.ds.sel(
             **{
                 self.dim_names["latitude"]: slice(lat_min - margin, lat_max + margin),
@@ -655,16 +683,109 @@ class Dataset:
 
         # Adjust longitudes to expected range if needed
         lon = subdomain[self.dim_names["longitude"]]
-        if straddle:
+        if target_coords["straddle"]:
             subdomain[self.dim_names["longitude"]] = xr.where(lon > 180, lon - 360, lon)
         else:
             subdomain[self.dim_names["longitude"]] = xr.where(lon < 0, lon + 360, lon)
 
-        if return_subdomain:
-            return subdomain
+        if return_copy:
+            return Dataset.from_ds(self, subdomain)
         else:
             object.__setattr__(self, "ds", subdomain)
 
+    def apply_lateral_fill(self):
+        """Apply lateral fill to variables using the dataset's mask and grid dimensions.
+
+        This method fills masked values in `self.ds` using `LateralFill` based on
+        the horizontal grid dimensions. A separate mask (`mask_vel`) is used for
+        velocity variables (e.g., `u`, `v`) if available in the dataset.
+
+        Notes
+        -----
+        Looping over `self.ds.data_vars` instead of `self.var_names` ensures that each
+        dataset variable is filled only once, even if multiple entries in `self.var_names`
+        point to the same variable in the dataset.
+        """
+        lateral_fill = LateralFill(
+            self.ds["mask"],
+            [self.dim_names["latitude"], self.dim_names["longitude"]],
+        )
+
+        separate_fill_for_velocities = False
+        if "mask_vel" in self.ds.data_vars:
+            lateral_fill_vel = LateralFill(
+                self.ds["mask_vel"],
+                [self.dim_names["latitude"], self.dim_names["longitude"]],
+            )
+            separate_fill_for_velocities = True
+
+        for var_name in self.ds.data_vars:
+            if var_name.startswith("mask"):
+                # Skip variables that are mask types
+                continue
+            elif (
+                separate_fill_for_velocities
+                and "u" in self.var_names
+                and "v" in self.var_names
+                and var_name in [self.var_names["u"], self.var_names["v"]]
+            ):
+                # Apply lateral fill with velocity mask for velocity variables if present
+                self.ds[var_name] = lateral_fill_vel.apply(self.ds[var_name])
+            else:
+                # Apply standard lateral fill for other variables
+                self.ds[var_name] = lateral_fill.apply(self.ds[var_name])
+
+    def extrapolate_deepest_to_bottom(self):
+        """Extrapolate deepest non-NaN values to fill bottom NaNs along the depth
+        dimension.
+
+        For each variable with a depth dimension, fills missing values at the bottom by
+        propagating the deepest available data downward.
+        """
+
+        if "depth" in self.dim_names:
+            for var_name in self.ds.data_vars:
+                if self.dim_names["depth"] in self.ds[var_name].dims:
+                    self.ds[var_name] = one_dim_fill(
+                        self.ds[var_name], self.dim_names["depth"], direction="forward"
+                    )
+
+    @classmethod
+    def from_ds(cls, original_dataset: "Dataset", ds: xr.Dataset) -> "Dataset":
+        """Substitute the internal dataset of a Dataset object with a new xarray
+        Dataset.
+
+        This method creates a new Dataset instance, bypassing the usual `__init__`
+        and `__post_init__` processes. It allows for the direct assignment of the
+        provided xarray Dataset (`ds`) to the new instance's `ds` attribute. All
+        other attributes from the original dataset instance are copied to the new one.
+
+        Parameters
+        ----------
+        original_dataset : Dataset
+            The original Dataset instance from which attributes will be copied.
+        ds : xarray.Dataset
+            The new xarray Dataset to assign to the `ds` attribute of the new instance.
+
+        Returns
+        -------
+        Dataset
+            A new Dataset instance with the `ds` attribute set to the provided dataset
+            and other attributes copied from the original instance.
+        """
+        # Create a new Dataset instance without calling __init__ or __post_init__
+        dataset = cls.__new__(cls)
+
+        # Directly set the provided dataset as the 'ds' attribute
+        object.__setattr__(dataset, "ds", ds)
+
+        # Copy all other attributes from the original data instance
+        for attr in vars(original_dataset):
+            if attr != "ds":
+                object.__setattr__(dataset, attr, getattr(original_dataset, attr))
+
+        return dataset
+
 
 @dataclass(frozen=True, kw_only=True)
 class TPXODataset(Dataset):
@@ -803,9 +924,12 @@ class TPXODataset(Dataset):
         """
 
         if "depth" in self.var_names.keys():
+            ds = self.ds
             mask = xr.where(self.ds["depth"] > 0, 1, 0)
+            ds["mask"] = mask
+            ds = ds.drop_vars(["depth"])
 
-            self.ds["mask"] = mask
+            object.__setattr__(self, "ds", ds)
 
         # Remove "depth" from var_names
         updated_var_names = {**self.var_names}  # Create a copy of the dictionary
@@ -1261,9 +1385,13 @@ class ERA5Dataset(Dataset):
                 )
             )
             cff = cff * qair
-            self.ds["qair"] = 0.62197 * (cff / (patm - 0.378 * cff))
-            self.ds["qair"].attrs["long_name"] = "Absolute humidity at 2m"
-            self.ds["qair"].attrs["units"] = "kg/kg"
+
+            ds = self.ds
+            ds["qair"] = 0.62197 * (cff / (patm - 0.378 * cff))
+            ds["qair"].attrs["long_name"] = "Absolute humidity at 2m"
+            ds["qair"].attrs["units"] = "kg/kg"
+            ds = ds.drop_vars([self.var_names["d2m"]])
+            object.__setattr__(self, "ds", ds)
 
             # Update var_names dictionary
             var_names = {**self.var_names, "qair": "qair"}
@@ -1271,9 +1399,11 @@ class ERA5Dataset(Dataset):
             object.__setattr__(self, "var_names", var_names)
 
         if "mask" in self.var_names.keys():
+            ds = self.ds
             mask = xr.where(self.ds[self.var_names["mask"]].isel(time=0).isnull(), 0, 1)
-
-            self.ds["mask"] = mask
+            ds["mask"] = mask
+            ds = ds.drop_vars([self.var_names["mask"]])
+            object.__setattr__(self, "ds", ds)
 
             # Remove mask from var_names dictionary
             var_names = self.var_names

roms_tools/setup/fill.py

@@ -301,39 +301,3 @@ def stencil_grid_mod(S, grid, msk, dtype=None, format=None):
                 data[4, i + diags[4]] = 0
 
     return sparse.dia_matrix((data, diags), shape=(N_v, N_v)).asformat(format)
-
-
-def _lateral_fill(data_vars, data):
-    """Wrapper function to apply lateral fill to variables using the dataset's mask and
-    grid dimensions.
-
-    Parameters
-    ----------
-    data_vars : dict of str : xarray.DataArray
-        Dictionary of variables to be filled.
-    data : Dataset
-        Dataset containing the mask and grid dimensions.
-
-    Returns
-    -------
-    dict of str : xarray.DataArray
-        Dictionary of filled variables.
-    """
-    lateral_fill = LateralFill(
-        data.ds["mask"],
-        [data.dim_names["latitude"], data.dim_names["longitude"]],
-    )
-
-    if "mask_vel" in data.ds.data_vars:
-        lateral_fill_vel = LateralFill(
-            data.ds["mask_vel"],
-            [data.dim_names["latitude"], data.dim_names["longitude"]],
-        )
-
-    for var in data.var_names:
-        if var in ["u", "v"]:
-            data_vars[var] = lateral_fill_vel.apply(data_vars[var])
-        else:
-            data_vars[var] = lateral_fill.apply(data_vars[var])
-
-    return data_vars

roms_tools/setup/initial_conditions.py

@@ -15,11 +15,9 @@ from roms_tools.setup.utils import (
     get_target_coords,
     rotate_velocities,
     compute_barotropic_velocity,
-    _extrapolate_deepest_to_bottom,
     transpose_dimensions,
 )
-from roms_tools.setup.fill import _lateral_fill
-from roms_tools.setup.regrid import _lateral_regrid, _vertical_regrid
+from roms_tools.setup.regrid import LateralRegrid, VerticalRegrid
 from roms_tools.setup.plot import _plot, _section_plot, _profile_plot, _line_plot
 import matplotlib.pyplot as plt
 from pathlib import Path
@@ -92,31 +90,31 @@ class InitialConditions:
 
         self._input_checks()
 
-        data_vars = {}
-        data_vars = self._process_data(data_vars, type="physics")
+        processed_fields = {}
+        processed_fields = self._process_data(processed_fields, type="physics")
 
         if self.bgc_source is not None:
-            data_vars = self._process_data(data_vars, type="bgc")
+            processed_fields = self._process_data(processed_fields, type="bgc")
 
-        for var in data_vars.keys():
-            data_vars[var] = transpose_dimensions(data_vars[var])
+        for var_name in processed_fields.keys():
+            processed_fields[var_name] = transpose_dimensions(
+                processed_fields[var_name]
+            )
 
         d_meta = get_variable_metadata()
-        ds = self._write_into_dataset(data_vars, d_meta)
+        ds = self._write_into_dataset(processed_fields, d_meta)
 
         ds = self._add_global_metadata(ds)
 
-        ds["zeta"].load()
-        # NaN values at wet points indicate that the raw data did not cover the domain, and the following will raise a ValueError
-        nan_check(ds["zeta"].squeeze(), self.grid.ds.mask_rho)
+        self._validate(ds)
 
         # substitute NaNs over land by a fill value to avoid blow-up of ROMS
-        for var in ds.data_vars:
-            ds[var] = substitute_nans_by_fillvalue(ds[var])
+        for var_name in ds.data_vars:
+            ds[var_name] = substitute_nans_by_fillvalue(ds[var_name])
 
         object.__setattr__(self, "ds", ds)
 
-    def _process_data(self, data_vars, type="physics"):
+    def _process_data(self, processed_fields, type="physics"):
 
         target_coords = get_target_coords(self.grid)
 
@@ -126,35 +124,29 @@ class InitialConditions:
             data = self._get_bgc_data()
 
         data.choose_subdomain(
-            latitude_range=[
-                target_coords["lat"].min().values,
-                target_coords["lat"].max().values,
-            ],
-            longitude_range=[
-                target_coords["lon"].min().values,
-                target_coords["lon"].max().values,
-            ],
-            margin=2,
-            straddle=target_coords["straddle"],
+            target_coords,
+            buffer_points=20,  # lateral fill needs good buffer from data margin
         )
 
-        variable_info = self._set_variable_info(data, type=type)
-
-        data_vars = _extrapolate_deepest_to_bottom(data_vars, data)
+        data.extrapolate_deepest_to_bottom()
+        data.apply_lateral_fill()
 
-        data_vars = _lateral_fill(data_vars, data)
+        variable_info = self._set_variable_info(data, type=type)
+        var_names = variable_info.keys()
 
         # lateral regridding
-        var_names = variable_info.keys()
-        data_vars = _lateral_regrid(
-            data, target_coords["lon"], target_coords["lat"], data_vars, var_names
-        )
+        lateral_regrid = LateralRegrid(target_coords, data.dim_names)
+        for var_name in var_names:
+            if var_name in data.var_names.keys():
+                processed_fields[var_name] = lateral_regrid.apply(
+                    data.ds[data.var_names[var_name]]
+                )
 
         # rotation of velocities and interpolation to u/v points
         if "u" in variable_info and "v" in variable_info:
-            (data_vars["u"], data_vars["v"],) = rotate_velocities(
-                data_vars["u"],
-                data_vars["v"],
+            (processed_fields["u"], processed_fields["v"],) = rotate_velocities(
+                processed_fields["u"],
+                processed_fields["v"],
                 target_coords["angle"],
                 interpolate=True,
             )
@@ -167,28 +159,32 @@ class InitialConditions:
                 if info["location"] == location and info["is_3d"]
             ]
             if len(var_names) > 0:
-                data_vars = _vertical_regrid(
-                    data,
+                vertical_regrid = VerticalRegrid(
                     self.grid.ds[f"layer_depth_{location}"],
-                    data_vars,
-                    var_names,
+                    data.ds[data.dim_names["depth"]],
                 )
+                for var_name in var_names:
+                    if var_name in processed_fields:
+                        processed_fields[var_name] = vertical_regrid.apply(
+                            processed_fields[var_name]
+                        )
 
         # compute barotropic velocities
         if "u" in variable_info and "v" in variable_info:
-            for var in ["u", "v"]:
-                data_vars[f"{var}bar"] = compute_barotropic_velocity(
-                    data_vars[var], self.grid.ds[f"interface_depth_{var}"]
+            for var_name in ["u", "v"]:
+                processed_fields[f"{var_name}bar"] = compute_barotropic_velocity(
+                    processed_fields[var_name],
+                    self.grid.ds[f"interface_depth_{var_name}"],
                 )
 
         if type == "bgc":
             # Ensure time coordinate matches that of physical variables
-            for var in variable_info.keys():
-                data_vars[var] = data_vars[var].assign_coords(
-                    {"time": data_vars["temp"]["time"]}
+            for var_name in variable_info.keys():
+                processed_fields[var_name] = processed_fields[var_name].assign_coords(
+                    {"time": processed_fields["temp"]["time"]}
                 )
 
-        return data_vars
+        return processed_fields
 
     def _input_checks(self):
 
@@ -314,24 +310,26 @@ class InitialConditions:
             }
         elif type == "bgc":
             variable_info = {}
-            for var in data.var_names.keys():
-                variable_info[var] = default_info
+            for var_name in data.var_names.keys():
+                variable_info[var_name] = default_info
 
         return variable_info
 
-    def _write_into_dataset(self, data_vars, d_meta):
+    def _write_into_dataset(self, processed_fields, d_meta):
 
         # save in new dataset
         ds = xr.Dataset()
 
-        for var in data_vars.keys():
-            ds[var] = data_vars[var].astype(np.float32)
-            ds[var].attrs["long_name"] = d_meta[var]["long_name"]
-            ds[var].attrs["units"] = d_meta[var]["units"]
+        for var_name in processed_fields.keys():
+            ds[var_name] = processed_fields[var_name].astype(np.float32)
+            ds[var_name].attrs["long_name"] = d_meta[var_name]["long_name"]
+            ds[var_name].attrs["units"] = d_meta[var_name]["units"]
 
         # initialize vertical velocity to zero
         ds["w"] = xr.zeros_like(
-            self.grid.ds["interface_depth_rho"].expand_dims(time=data_vars["u"].time)
+            self.grid.ds["interface_depth_rho"].expand_dims(
+                time=processed_fields["u"].time
+            )
         ).astype(np.float32)
         ds["w"].attrs["long_name"] = d_meta["w"]["long_name"]
         ds["w"].attrs["units"] = d_meta["w"]["units"]
@@ -351,7 +349,7 @@ class InitialConditions:
             "layer_depth_v",
             "interface_depth_v",
         ]
-        existing_vars = [var for var in variables_to_drop if var in ds]
+        existing_vars = [var_name for var_name in variables_to_drop if var_name in ds]
         ds = ds.drop_vars(existing_vars)
 
         ds["Cs_r"] = self.grid.ds["Cs_r"]
@@ -375,6 +373,29 @@ class InitialConditions:
 
         return ds
 
+    def _validate(self, ds):
+        """Validates the dataset by checking for NaN values in SSH at wet points, which
+        would indicate missing raw data coverage over the target domain.
+
+        Parameters
+        ----------
+        ds : xarray.Dataset
+            The dataset to validate.
+
+        Raises
+        ------
+        ValueError
+            If NaN values are found in any of the specified variables at wet points,
+            indicating incomplete data coverage.
+
+        Notes
+        -----
+        This check is only applied to the 2D variable SSH to improve performance.
+        """
+
+        ds["zeta"].load()
+        nan_check(ds["zeta"].squeeze(), self.grid.ds.mask_rho)
+
     def _add_global_metadata(self, ds):
 
         ds.attrs["title"] = "ROMS initial conditions file created by ROMS-Tools"
@@ -398,7 +419,7 @@ class InitialConditions:
 
     def plot(
         self,
-        varname,
+        var_name,
         s=None,
         eta=None,
         xi=None,
@@ -409,7 +430,7 @@ class InitialConditions:
 
         Parameters
         ----------
-        varname : str
+        var_name : str
             The name of the initial conditions field to plot. Options include:
 
             - "temp": Potential temperature.
@@ -480,25 +501,25 @@ class InitialConditions:
         Raises
         ------
         ValueError
-            If the specified `varname` is not one of the valid options.
-            If the field specified by `varname` is 3D and none of `s`, `eta`, or `xi` are specified.
-            If the field specified by `varname` is 2D and both `eta` and `xi` are specified.
+            If the specified `var_name` is not one of the valid options.
+            If the field specified by `var_name` is 3D and none of `s`, `eta`, or `xi` are specified.
+            If the field specified by `var_name` is 2D and both `eta` and `xi` are specified.
         """
 
-        if len(self.ds[varname].squeeze().dims) == 3 and not any(
+        if len(self.ds[var_name].squeeze().dims) == 3 and not any(
             [s is not None, eta is not None, xi is not None]
         ):
             raise ValueError(
                 "For 3D fields, at least one of s, eta, or xi must be specified."
             )
 
-        if len(self.ds[varname].squeeze().dims) == 2 and all(
+        if len(self.ds[var_name].squeeze().dims) == 2 and all(
             [eta is not None, xi is not None]
         ):
             raise ValueError("For 2D fields, specify either eta or xi, not both.")
 
-        self.ds[varname].load()
-        field = self.ds[varname].squeeze()
+        self.ds[var_name].load()
+        field = self.ds[var_name].squeeze()
 
         if all(dim in field.dims for dim in ["eta_rho", "xi_rho"]):
             interface_depth = self.grid.ds.interface_depth_rho
@@ -553,7 +574,7 @@ class InitialConditions:
                     field = field.assign_coords({"layer_depth": layer_depth})
             else:
                 raise ValueError(
-                    f"None of the expected dimensions (eta_rho, eta_v) found in ds[{varname}]."
+                    f"None of the expected dimensions (eta_rho, eta_v) found in ds[{var_name}]."
                 )
         if xi is not None:
             if "xi_rho" in field.dims:
@@ -572,18 +593,18 @@ class InitialConditions:
                     field = field.assign_coords({"layer_depth": layer_depth})
             else:
                 raise ValueError(
-                    f"None of the expected dimensions (xi_rho, xi_u) found in ds[{varname}]."
+                    f"None of the expected dimensions (xi_rho, xi_u) found in ds[{var_name}]."
                 )
 
         # chose colorbar
-        if varname in ["u", "v", "w", "ubar", "vbar", "zeta"]:
+        if var_name in ["u", "v", "w", "ubar", "vbar", "zeta"]:
             vmax = max(field.max().values, -field.min().values)
             vmin = -vmax
             cmap = plt.colormaps.get_cmap("RdBu_r")
         else:
             vmax = field.max().values
             vmin = field.min().values
-            if varname in ["temp", "salt"]:
+            if var_name in ["temp", "salt"]:
                 cmap = plt.colormaps.get_cmap("YlOrRd")
             else:
                 cmap = plt.colormaps.get_cmap("YlGn")