pyPRMS 0.9.7__py3-none-any.whl

pyPRMS/parameters/ParameterFile.py

@@ -0,0 +1,190 @@
+
+# from typing import Any,  Union, Dict, List, OrderedDict as OrderedDictType, Set
+import numpy as np
+from typing import List, Optional, Set
+
+from ..Exceptions_custom import ParameterExistsError, ParameterNotValidError
+from .Parameters import Parameters
+from ..constants import DIMENSIONS_HDR, PARAMETERS_HDR, VAR_DELIM, PTYPE_TO_DTYPE
+from ..prms_helpers import get_file_iter
+
+from rich.console import Console
+from rich import pretty
+
+pretty.install()
+con = Console()
+
+
+class ParameterFile(Parameters):
+
+    """Class to handle reading PRMS parameter file format."""
+
+    def __init__(self, filename: str,
+                 metadata,
+                 verbose: Optional[bool] = False):
+                 # verify: Optional[bool] = True):
+        """Create the ParameterFile object.
+
+        :param filename: name of parameter file
+        :param verbose: output debugging information
+        :param verify: whether to load the master parameters (default=True)
+        """
+
+        super(ParameterFile, self).__init__(metadata=metadata, verbose=verbose)
+
+        # self.__filename = None
+        # self.__header = None
+
+        self.__isloaded = False
+        self.__updated_parameters: Set[str] = set()
+        self.__verbose = verbose
+        self.filename = filename
+
+    @property
+    def filename(self) -> str:
+        """Get parameter filename.
+
+        :returns: name of parameter file
+        """
+
+        return self.__filename
+
+    @filename.setter
+    def filename(self, name: str):
+        """Set the name of the parameter file.
+
+        :param name: name of parameter file
+        """
+
+        self.__isloaded = False
+        self.__filename = name
+        self.__header: List[str] = []  # Initialize the list of file headers
+
+        self._read()
+
+    @property
+    def headers(self) -> List[str]:
+        """Get the headers from the parameter file.
+
+        :returns: list of headers from parameter file
+        """
+
+        return self.__header
+
+    @property
+    def updated_parameters(self) -> Set[str]:
+        """Get list of parameters that had more than one entry in the parameter file.
+
+        :returns: list of parameters
+        """
+
+        return self.__updated_parameters
+
+    def _read(self):
+        """Read parameter file.
+        """
+
+        if self.__verbose:   # pragma: no cover
+            con.print('INFO: Reading parameter file')
+
+        # Read the parameter file into memory and parse it
+        it = get_file_iter(self.filename)
+
+        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        # Grab the header stuff first
+        for line in it:
+            if line.strip('* ') == DIMENSIONS_HDR:
+                break
+            self.__header.append(line)
+
+        if self.__verbose:   # pragma: no cover
+            con.print(f'HEADERS: {self.__header}')
+
+        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        # Now process the dimensions
+        for line in it:
+            if line.strip('* ') == PARAMETERS_HDR:
+                break
+            if line == VAR_DELIM:
+                continue
+
+            # Add dimension - all dimensions are scalars
+            self.dimensions.add(name=line, size=int(next(it)))
+
+        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        # Lastly process the parameters
+        for line in it:
+            if line == VAR_DELIM:
+                continue
+            varname = line.split(' ')[0]
+            # if self.__verbose:   # pragma: no cover
+            #     print(f'{varname=}')
+
+            # Add the parameter
+            try:
+                self.add(name=varname)
+            except ParameterExistsError:
+                if self.__verbose:   # pragma: no cover
+                    con.print(f'[bold]{varname}[/]: updated with new values')
+                self.__updated_parameters.add(varname)
+            except ParameterNotValidError:
+                if self.__verbose:   # pragma: no cover
+                    con.print(f'[bold]{varname}[/]: [gold3]is not a valid parameter; skipping. [/]')
+
+                # Skip to the next parameter
+                try:
+                    while next(it) != VAR_DELIM:
+                        pass
+                except StopIteration:
+                    # Hit end of file
+                    pass
+                continue
+
+            # Read the dimension names
+            ndims = int(next(it))  # number of dimensions for this variable
+            dim_names = [next(it) for _ in range(ndims)]
+
+            # Total dimension size declared for parameter in file; it should equal the size of
+            # the declared global dimensions.
+            dim_size = int(next(it))
+
+            # The datatype
+            param_dtype = int(next(it))
+
+            if self.get(varname).is_scalar:
+                vals = np.array(next(it), dtype=PTYPE_TO_DTYPE[param_dtype])
+            else:
+                # Arrays of strings should be objects
+                if param_dtype == 4:
+                    vals = np.zeros(dim_size, dtype=object)
+                else:
+                    vals = np.zeros(dim_size, dtype=PTYPE_TO_DTYPE[param_dtype])
+
+                for idx in range(0, dim_size):
+                    # NOTE: string-float to int works but float to int does not
+                    vals[idx] = next(it)
+
+            # Make sure there are not any more values in the file
+            try:
+                cnt = dim_size
+                while True:
+                    cval = next(it)
+                    if cval[0:4] == VAR_DELIM or cval.strip() == '':
+                        break
+                    cnt += 1
+
+                if cnt > dim_size:
+                    print(f'WARNING: Too many values specified for {varname}')
+                    print(f'         {dim_size} expected, {cnt} given')
+                    print('          Removing parameter')
+
+                    self.remove(varname)
+                    continue
+            except StopIteration:
+                # Hit the end of the file
+                pass
+
+            self.get(varname).data = vals    # type: ignore
+
+        self.adjust_bounded_parameters()
+        self.__isloaded = True

pyPRMS/parameters/ParameterNetCDF.py

@@ -0,0 +1,74 @@
+
+import xarray as xr
+from typing import Optional
+
+from .Parameters import Parameters
+
+
+NCF_TO_NHM_TYPES = {'int32': 1, 'float32': 2, 'float64': 3, '|S1': 4}
+
+
+class ParameterNetCDF(Parameters):
+    """Read parameter database stored in netCDF format"""
+
+    def __init__(self,
+                 filename: str,
+                 metadata,
+                 verbose: Optional[bool] = False):
+        """Initialize ParamDb object.
+
+        :param filename: Path the ParamDb netcdf file
+        :param verbose: Output additional debugging information
+        :param verify: Verify parameters against master list
+        """
+
+        super(ParameterNetCDF, self).__init__(metadata=metadata, verbose=verbose)
+        self.__filename = filename
+        self.__verbose = verbose
+
+        # Read the parameters from the parameter database
+        self._read()
+
+    def _read(self):
+        """Read a parameter netCDF file.
+        """
+
+        xr_df = xr.open_dataset(self.__filename, mask_and_scale=False, decode_timedelta=False)
+
+        # Populate the dimensions first
+        self.dimensions.add(name='one', size=1)
+        # self.dimensions.add(name='ndays')
+
+        for dn, ds in dict(xr_df.sizes).items():
+            self.dimensions.add(name=str(dn), size=ds)
+
+        # Add ndepl using ndeplval
+        self.dimensions.add(name='ndepl', size=int(xr_df.sizes['ndeplval'] / 11))
+
+        # Add nobs if needed
+        if not self.dimensions.exists('nobs'):
+            if self.dimensions.exists('npoigages'):
+                self.dimensions.add(name='nobs', size=self.dimensions.get('npoigages').size)
+            else:
+                self.dimensions.add(name='nobs', size=0)
+
+        if not self.dimensions.exists('ngw'):
+            self.dimensions.add(name='ngw', size=self.dimensions.get('nhru').size)
+
+        if not self.dimensions.exists('nssr'):
+            self.dimensions.add(name='nssr', size=self.dimensions.get('nhru').size)
+
+        # Now add the parameters
+        for var in xr_df.variables.keys():
+            if self.__verbose:   # pragma: no cover
+                print(str(var))
+
+            cparam = xr_df[var].T
+
+            # Add the parameter
+            self.add(name=str(var))
+
+            # Add the data
+            self.get(str(var)).data = cparam.values
+
+        self.adjust_bounded_parameters()

pyPRMS/parameters/ParameterSet.py

@@ -0,0 +1,96 @@
+
+# class ParameterSet(object):
+    # def degenerate_parameters(self):
+    #     """Print parameters that have fewer dimensions than specified in the master parameters."""
+    #
+    #     result = []
+    #     # TODO: 20230726 PAN - This is not needed with the current parameter code
+    #     if self.__master_params is not None:
+    #         for kk, vv in self.parameters.items():
+    #             try:
+    #                 if set(vv.dimensions.keys()) != set(self.__master_params[kk].dimensions.keys()):
+    #                     if not (set(self.__master_params[kk].dimensions.keys()).issubset(set(HRU_DIMS)) and
+    #                             set(vv.dimensions.keys()).issubset(HRU_DIMS)):
+    #                         result.append(kk)
+    #                         if self.verbose:
+    #                             print(f'Parameter, {kk}, is degenerate')
+    #                             print('  parameter: ', list(vv.dimensions.keys()))
+    #                             print('     master: ', list(self.__master_params[kk].dimensions.keys()))
+    #             except ValueError:
+    #                 if self.verbose:
+    #                     print(f'ERROR: Parameter, {kk}, is not a valid PRMS parameter')
+    #     return result
+
+    # def expand_parameter(self, name: str):
+    #     """Expand an existing parameter.
+    #
+    #     Expand (e.g. reshape) a parameter, broadcasting existing value(s) into
+    #     new shape specified by master parameters. The hru_deplcrv parameter has
+    #     special handling to also update the snarea_curve parameter.
+    #
+    #     :param name: name of parameter
+    #     """
+    #     # TODO: 20230726 PAN - This is not needed with the current parameter code
+    #     if self.__master_params is not None:
+    #         # 1) make sure parameter exists
+    #         if self.__master_params.exists(name):
+    #             # 2) get dimensions from master parameters
+    #             new_dims = self.__master_params.parameters[name].dimensions.copy()
+    #
+    #             # The new_dims copy is no longer of type Dimensions, instead it
+    #             # is an OrderedDict
+    #             # 3) get dimension sizes from global dimensions object
+    #             for kk, vv in new_dims.items():
+    #                 vv.size = self.__dimensions[kk].size
+    #
+    #             if self.verbose and set(new_dims.keys()) == set(self.__parameters[name].dimensions.keys()):
+    #                 print(f'Parameter, {name}, already has the maximum number of dimensions')
+    #                 print('    current: ', list(self.__parameters[name].dimensions.keys()))
+    #                 print('  requested: ', list(new_dims.keys()))
+    #
+    #                 # TODO: Write special case where hru_deplcrv is dimensioned nhru, but
+    #                 #       the number of snarea_curve entries is less than nhru * 11.
+    #             else:
+    #                 # 4) call reshape for the parameter
+    #                 self.__parameters[name].reshape(new_dims)
+    #
+    #                 if name == 'hru_deplcrv':
+    #                     # hru_deplcrv needs special handling
+    #                     # 2) get current value of hru_deplcrv, this is the snow_index to use
+    #                     # 3) replace broadcast original value with np.arange(1:nhru)
+    #                     orig_index = self.__parameters[name].data[0] - 1
+    #                     new_indices = np.arange(1, new_dims['nhru'].size + 1)
+    #                     self.__parameters['hru_deplcrv'].data = new_indices
+    #
+    #                     # 5) get snarea_curve associated with original hru_deplcrv value
+    #                     curr_snarea_curve = self.__parameters['snarea_curve'].data.reshape((-1, 11))[orig_index, :]
+    #
+    #                     # 6) replace current snarea_curve values with broadcast of select snarea_curve*nhru
+    #                     new_snarea_curve = np.broadcast_to(curr_snarea_curve, (new_dims['nhru'].size, 11))
+    #                     # 7) reset snarea_curve dimension size to nhru*11
+    #                     self.__parameters['snarea_curve'].dimensions['ndeplval'].size = new_dims['nhru'].size * 11
+    #                     self.__parameters['snarea_curve'].data = new_snarea_curve.flatten(order='C')
+    #
+    #                     if self.verbose:
+    #                         print('hru_deplcrv and snarea_curve have been expanded/updated')
+
+    # def remove_by_global_id(self, hrus: Optional[List] = None,
+    #                         segs: Optional[List] = None):
+    #     """Removes data-by-id (nhm_seg, nhm_id) from all parameters.
+    #
+    #     :param hrus: List of HRU IDs to remove
+    #     :param segs: List of segment IDs to remove
+    #     """
+    #     self.__parameters.remove_by_global_id(hrus=hrus, segs=segs)
+    #
+    #     # Adjust the global dimensions
+    #     if segs is not None:
+    #         self.__dimensions['nsegment'].size -= len(segs)
+    #
+    #     if hrus is not None:
+    #         self.__dimensions['nhru'].size -= len(hrus)
+    #
+    #         if self.__dimensions.exists('nssr'):
+    #             self.__dimensions['nssr'].size -= len(hrus)
+    #         if self.__dimensions.exists('ngw'):
+    #             self.__dimensions['ngw'].size -= len(hrus)