pyPRMS 0.9.7__py3-none-any.whl

pyPRMS/constants.py

@@ -0,0 +1,131 @@
+import numpy as np
+
+from packaging.version import Version
+from typing import Dict, List, NamedTuple, Union
+
+# Define aliases for static typing
+MetaDataType = Dict[str, Dict]
+
+# Version = NamedTuple('Version', [('major', Union[int, None]),
+#                                  ('minor', Union[int, None]),
+#                                  ('revision', Union[int, None])])
+
+# Default PRMS version to use for metadata
+PRMS_VERSION = Version('5.2.1.1')
+
+# PRMS6 experimental development version
+PRMS6_DEV_VERSION = Version('60.0')
+
+# Order to write control file parameters for printing and writing a new control file
+ctl_order: List[str] = ['start_time', 'end_time', 'initial_deltat', 'executable_desc', 'executable_model', 'model_mode',
+                        'param_file', 'data_file', 'model_output_file', 'print_debug',
+                        'et_module', 'precip_module', 'soilzone_module', 'solrad_module', 'srunoff_module',
+                        'strmflow_module', 'temp_module', 'transp_module',
+                        'init_vars_from_file', 'save_vars_to_file', 'var_init_file', 'var_save_file',
+                        'albedo_day', 'cloud_cover_day', 'humidity_day', 'potet_day', 'precip_day', 'precip_grid',
+                        'swrad_day', 'tmax_day', 'tmax_grid', 'tmin_day', 'transp_day', 'windspeed_day',
+                        'tmin_grid',
+                        'albedo_cbh_flag', 'cascade_flag', 'cascadegw_flag', 'cbh_binary_flag', 'cbh_check_flag',
+                        'cloud_cover_cbh_flag', 'dprst_flag', 'frozen_flag', 'glacier_flag',
+                        'gwflow_cbh_flag', 'gwr_swale_flag', 'humidity_cbh_flag', 'mbInit_flag', 'orad_flag',
+                        'parameter_check_flag', 'snarea_curve_flag', 'snow_cbh_flag', 'snow_cloudcover_flag',
+                        'soilzone_aet_flag',
+                        'stream_temp_flag', 'stream_temp_shade_flag', 'strmtemp_humidity_flag',
+                        'subbasin_flag', 'windspeed_cbh_flag',
+                        'prms_warmup',
+                        'csvON_OFF', 'csv_output_file',
+                        'nhruOutON_OFF', 'nhruOutBaseFileName', 'nhruOutVars', 'nhruOutVar_names', 'nhruOut_freq',
+                        'nhruOut_format', 'nhruOutNcol', 'outputSelectDatesON_OFF', 'selectDatesFileName',
+                        'nsegmentOutON_OFF', 'nsegmentOutBaseFileName', 'nsegmentOutVars', 'nsegmentOutVar_names',
+                        'nsegmentOut_freq', 'nsegmentOut_format',
+                        'basinOutON_OFF', 'basinOutBaseFileName', 'basinOutVars', 'basinOutVar_names', 'basinOut_freq',
+                        'nsubOutON_OFF', 'nsubOutBaseFileName', 'nsubOutVars', 'nsubOutVar_names', 'nsubOut_format',
+                        'nsubOut_freq',
+                        'statsON_OFF', 'stat_var_file', 'nstatVars', 'statVar_element', 'statVar_names',
+                        'dyn_covden_flag', 'dyn_covtype_flag', 'dyn_dprst_flag', 'dyn_fallfrost_flag',
+                        'dyn_imperv_flag',
+                        'dyn_intcp_flag', 'dyn_potet_flag', 'dyn_radtrncf_flag', 'dyn_snareathresh_flag',
+                        'dyn_soil_flag',
+                        'dyn_springfrost_flag', 'dyn_sro2dprst_imperv_flag', 'dyn_sro2dprst_perv_flag',
+                        'dyn_transp_flag', 'dyn_transp_on_flag',
+                        'dynamic_param_log_file',
+                        'covden_sum_dynamic', 'covden_win_dynamic', 'covtype_dynamic', 'dprst_depth_dynamic',
+                        'dprst_frac_dynamic', 'fallfrost_dynamic', 'imperv_frac_dynamic', 'imperv_stor_dynamic',
+                        'potetcoef_dynamic', 'radtrncf_dynamic', 'snareathresh_dynamic', 'snow_intcp_dynamic',
+                        'soilmoist_dynamic', 'soilrechr_dynamic', 'springfrost_dynamic', 'srain_intcp_dynamic',
+                        'sro2dprst_imperv_dynamic', 'sro2dprst_perv_dynamic',
+                        'transp_on_dynamic', 'transpbeg_dynamic', 'transpend_dynamic', 'wrain_intcp_dynamic',
+                        'dprst_transferON_OFF', 'dprst_transfer_file', 'external_transferON_OFF',
+                        'external_transfer_file', 'gwr_transferON_OFF', 'gwr_transfer_file', 'lake_transferON_OFF',
+                        'lake_transfer_file', 'segment_transferON_OFF', 'segment_transfer_file', 'segmentOutON_OFF',
+                        'aniOutON_OFF', 'ani_output_file', 'naniOutVars', 'aniOutVar_names',
+                        'dispGraphsBuffSize', 'ndispGraphs', 'dispVar_element', 'dispVar_names', 'dispVar_plot',
+                        'mapOutON_OFF', 'nmapOutVars', 'mapOutVar_names']
+
+# ctl_variable_modules: List[str] = ['et_module', 'precip_module', 'soilzone_module', 'solrad_module',
+#                                    'srunoff_module', 'strmflow_module', 'temp_module', 'transp_module']
+
+# ctl_summary_modules: List[str] = ['basin_sum', 'basin_summary', 'map_results',
+#                                   'nhru_summary', 'nsegment_summary', 'nsub_summary', 'subbasin']
+
+ctl_implicit_modules: Dict[str, str] = {'basin_module': 'basin',
+                                        'intcp_module': 'intcp',
+                                        'obs_module': 'obs',
+                                        'snow_module': 'snowcomp',
+                                        'gw_module': 'gwflow',
+                                        'soilzone_module': 'soilzone'}
+
+# This is a map between what is in the control file and what is in the parameters.xml file
+internal_module_map = dict(et_module={'climate_hru': 'potet_hru'},
+                           precip_module={'climate_hru': 'precipitation_hru'},
+                           solrad_module={'climate_hru': 'solar_radiation_hru'},
+                           temp_module={'climate_hru': 'temperature_hru'},
+                           transp_module={'climate_hru': 'transpiration_hru'})
+
+# This maps the internal parameters.xml names to the external control file module names
+external_module_map = dict(potet_hru='climate_hru',
+                           precipitation_hru='climate_hru',
+                           solar_radiation_hru='climate_hru',
+                           temperature_hru='climate_hru',
+                           transpiration_hru='climate_hru')
+
+# Constants related to parameter files
+DIMENSIONS_HDR: str = 'Dimensions'
+PARAMETERS_HDR: str = 'Parameters'
+CATEGORY_DELIM: str = '**'  # Delimiter for categories of variables
+VAR_DELIM: str = '####'  # Used to delimit dimensions and parameters
+# DATA_TYPES: Dict[int, str] = {1: 'integer', 2: 'float', 3: 'double', 4: 'string'}
+
+# Valid dimensions names for PRMS
+# DIMENSION_NAMES: List[str] = ['mxnsos', 'ncascade', 'ncascdgw', 'nconsumed', 'ndays', 'ndepl',
+#                               'ndeplval', 'ngate', 'ngate2', 'ngate3', 'ngate4',
+#                               'nevap', 'nexternal', 'ngw', 'ngwcell', 'nhru', 'nhrucell', 'nhumid',
+#                               'nlake', 'nlakeelev', 'nlapse', 'nmonths', 'nobs', 'npoigages', 'nrain',
+#                               'nratetbl', 'nsegment', 'nsnow', 'nsol', 'nssr', 'nsub', 'ntemp',
+#                               'numlakes', 'nwateruse', 'nwind', 'one',
+#                               'nstage', 'nstage2', 'nstage3', 'nstage4']
+
+# These dimensions are related and should have same size
+# NOTE: 2025-02-05 PAN - this is currently needed by Bandit
+HRU_DIMS: List[str] = ['nhru', 'ngw', 'nssr']
+
+# Constants for NhmParamDb
+REGIONS: List[str] = ['r01', 'r02', 'r03', 'r04', 'r05', 'r06', 'r07', 'r08', 'r09',
+                      'r10L', 'r10U', 'r11', 'r12', 'r13', 'r14', 'r15', 'r16', 'r17', 'r18']
+PARAMETERS_XML: str = 'parameters.xml'
+DIMENSIONS_XML: str = 'dimensions.xml'
+
+# 2025-01-24 PAN - used by Parameters.write_parameter_netcdf()
+NETCDF_DATATYPES: Dict[int, str] = {1: 'i4', 2: 'f4', 3: 'f8', 4: 'S1'}
+
+# 2025-01-24 PAN - used by Parameters.xml_global_parameters()
+NHM_DATATYPES: Dict[str, int] = {'I': 1, 'F': 2, 'D': 3, 'S': 4}
+
+# 2025-01-24 PAN - used by ControlFile._read() and ParameterFile._read()
+PTYPE_TO_DTYPE = {1: np.int32, 2: np.float32, 3: np.float64, 4: np.str_}
+
+NEW_PTYPE_TO_DTYPE = {'int32': np.int32, 'float32': np.float32, 'float64': np.float64, 'string': np.str_, 'datetime': np.datetime64}
+PTYPE_TO_PRMS_TYPE: Dict[str, int] = {'int32': 1, 'float32': 2, 'float64': 3, 'string': 4, 'datetime': 1}
+
+# PARNAME_DATATYPES = {'long': 1, 'float': 2, 'double': 3, 'string': 4}
+# DATATYPE_TO_DTYPE = {1: int, 2: np.float32, 3: np.float64, 4: np.str_}

pyPRMS/control/Control.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+
+import io
+import numpy as np
+import operator
+import pandas as pd   # type: ignore
+import pkgutil
+import re
+import xml.etree.ElementTree as xmlET
+
+from typing import Dict, List, Optional, Sequence, Union   # OrderedDict as OrderedDictType,
+
+from networkx.utils.misc import check_create_using
+
+from .ControlVariable import ControlVariable
+from ..Exceptions_custom import ControlError
+from ..constants import (ctl_order, ctl_implicit_modules, internal_module_map,
+                         MetaDataType, VAR_DELIM, PTYPE_TO_PRMS_TYPE)
+
+cond_check = {'=': operator.eq,
+              '>': operator.gt,
+              '<': operator.lt}
+
+class Control(object):
+    """
+    Class object for a collection of control variables.
+    """
+
+    # Author: Parker Norton (pnorton@usgs.gov)
+    # Create date: 2019-04-18
+
+    def __init__(self, metadata: MetaDataType, verbose: Optional[bool] = False):
+        """Create Control object.
+        """
+
+        # Container to hold dicionary of ControlVariables
+        # self.__control_vars = OrderedDict()
+        self.__control_vars: Dict = {}
+        self.__header: Optional[List[str]] = None
+        self.__verbose = verbose
+
+        # Create an entry for each variable in the control section of
+        # the metadata dictionary
+        # for cvar, cvals in metadata['control'].items():
+        #     self.add(name=cvar, meta=cvals)
+        for cvar in metadata['control'].keys():
+            self.add(name=cvar, meta=metadata['control'])
+
+        if verbose:
+            print('Pre-populate control variables done')
+
+    def __getitem__(self, item: str) -> ControlVariable:
+        """Get ControlVariable object for a variable.
+
+        :param item: name of control file variable
+        :returns: ControlVariable object
+        """
+        return self.get(item)
+
+    @property
+    def additional_modules(self) -> List[str]:
+        """Get list of summary modules in PRMS
+        """
+
+        # TODO: module_requirements should be added to metadata?
+        # NOTE: 20231109 PAN - we always want basin_sum included since the
+        #                      print_debug could be set to 4 (which uses the basin_sum module)
+        module_requirements = {'basin_sum': 'print_debug < 100',
+                               # 'basin_sum': 'print_debug = 4',
+                               'basin_summary': 'basinOutON_OFF > 0',
+                               'map_results': 'mapOutON_OFF > 0',
+                               'nhru_summary': 'nhruOutON_OFF > 0',
+                               'nsegment_summary': 'nsegmentOutON_OFF > 0',
+                               'nsub_summary': 'nsubOutON_OFF > 0',
+                               'stream_temp': 'stream_temp_flag > 0',
+                               'subbasin': 'subbasin_flag = 1'}
+
+        active_modules = []
+
+        for cmod, cond in module_requirements.items():
+            if self._check_condition(cond):
+                active_modules.append(cmod)
+
+        return active_modules
+
+    @property
+    def cbh_files(self) -> List[str]:
+        """Get list of possible CBH filenames.
+
+        :returns: list of CBH files
+        """
+
+        # List of control variables that specify possible CBH files
+        ctl_cbh_files = ['albebo_day', 'cloud_cover_day', 'humidity_day', 'potet_day', 'precip_day',
+                         'swrad_day', 'tmax_day', 'tmin_day', 'transp_day', 'windspeed_day']
+        cbh_files = []
+
+        for cvar in ctl_cbh_files:
+            if self.exists(cvar):
+                cbh_files.append(self.get(cvar).values)
+
+        return sorted(list(set(cbh_files)))
+
+    @property
+    def control_variables(self) -> Dict[str, ControlVariable]:
+    # def control_variables(self) -> OrderedDictType[str, ControlVariable]:
+        """Get control variable objects.
+
+        :returns: control variable objects
+        """
+        return self.__control_vars
+
+    @property
+    def dynamic_parameters(self) -> List[str]:
+        """Get list of parameter names for which a dynamic flag set.
+
+        :returns: list of parameter names
+        """
+
+        dyn_params: List[str] = []
+
+        for dv in self.__control_vars.keys():
+            cvar = self.get(dv)
+
+            if (cvar.meta.get('valid_value_type', '') == 'parameter' and
+                    (isinstance(cvar.values, int | np.int32 | np.int64))):
+                # Dynamic parameter flags should always be integers
+                if cvar.values > 0:
+                    dyn_params.extend(cvar.dyn_param_meaning)
+                    # dyn_params.append(self.get(dv).associated_values)
+        return dyn_params
+
+    @property
+    def has_dynamic_parameters(self) -> bool:
+        """Indicates if any dynamic parameters have been requested.
+
+        :returns: True if dynamic parameters are required
+        """
+        return len(self.dynamic_parameters) > 0
+
+    @property
+    def header(self) -> Optional[Sequence[str]]:
+        """Get header information defined for a control object.
+
+        This is typically taken from the first two lines of a control file.
+
+        :returns: Header information from control file
+        """
+        return self.__header
+
+    @header.setter
+    def header(self, info: Union[Sequence[str], str, None]):
+        """Set the header information.
+
+        :param info: list or string of header line(s)
+        """
+
+        if info is None:
+            self.__header = None
+        elif isinstance(info, list):
+            self.__header = info
+        elif isinstance(info, str):
+            self.__header = [info]
+
+    @property
+    def modules(self) -> Dict[str, str]:
+        """Get the modules defined in the control file.
+
+        Note: climate_hru is changed to precipitation_hru, temperature_hru,
+        potet_hru, or solar_radiation_hru depending on the module type. This
+        makes for easier identification of which process(es) is/are actually using
+        climate_hru. Interally the module type is still climate_hru.
+
+        :returns: dictionary of control variable, module name pairs
+        """
+
+        mod_dict = {}
+
+        for vv in self.control_variables.values():
+            if vv.meta.get('valid_value_type', '') == 'module':
+                mname = internal_module_map.get(vv.name, {}).get(vv.values, vv.values)
+
+                mod_dict[vv.name] = str(mname)
+
+        # Add the modules that are implicitly included
+        for mtype, mname in ctl_implicit_modules.items():
+            if mtype not in mod_dict:
+                mod_dict[mtype] = mname
+
+        return mod_dict
+
+    def add(self, name: str, meta=None):
+        """Add a control variable by name.
+
+        :param name: Name of the control variable
+        :param datatype: The datatype of the control variable
+
+        :raises ControlError: if control variable already exists
+        """
+
+        if self.exists(name):
+            raise ControlError("Control variable already exists")
+        self.__control_vars[name] = ControlVariable(name=name, meta=meta)
+        # self.__control_vars[name] = ControlVariable(name=name, datatype=datatype, meta=meta)
+
+    def exists(self, name: str) -> bool:
+        """Checks if control variable exists.
+
+        :param name: Name of the control variable
+        :returns: True if control variable exists otherwise False
+        """
+        return name in self.__control_vars.keys()
+
+    def get(self, name: str) -> ControlVariable:
+        """Returns the given control variable object.
+
+        :param name: Name of the control variable
+        :returns: Control variable object
+
+        :raises ValueError: if control variable does not exist
+        """
+
+        if self.exists(name):
+            return self.__control_vars[name]
+        raise ValueError(f'Control variable, {name}, does not exist.')
+
+    def remove(self, name: str):
+        """Delete a control variable if it exists.
+
+        :param name: Name of the control variable
+        """
+
+        if self.exists(name):
+            del self.__control_vars[name]
+
+    def to_dict(self):
+        """Dictionary of data for each control variable"""
+
+        return {kk: vv.values for (kk, vv) in self.__control_vars.items()}
+
+    def write(self, filename: str):
+        """Write a control file.
+
+        :param filename: Name of control file to create
+        """
+
+        outfile = open(filename, 'w')
+
+        if self.__header is not None:
+            for hh in self.__header:
+                outfile.write(f'{hh}\n')
+
+        order = ['datatype', 'values']
+
+        # Get set of variables in ctl_order that are missing from control_vars
+        setdiff = set(self.__control_vars.keys()).difference(set(ctl_order))
+
+        # Add missing control variables (setdiff) in ctl_order to the end of the list
+        ctl_order.extend(list(setdiff))
+
+        for kk in ctl_order:
+            if self.exists(kk):
+                cvar = self.get(kk)
+
+                outfile.write(f'{VAR_DELIM}\n')
+                outfile.write(f'{kk}\n')
+
+                for item in order:
+                    if cvar.meta['datatype'] == 'datetime':
+                        date_tmp = [int(xx) for xx in re.split(r'[-T:.]+', str(cvar.values))[0:6]]
+
+                        if item == 'datatype':
+                            outfile.write(f'{len(date_tmp)}\n')
+                            outfile.write(f'{PTYPE_TO_PRMS_TYPE[cvar.meta["datatype"]]}\n')
+                        if item == 'values':
+                            for cval in date_tmp:
+                                outfile.write(f'{cval}\n')
+                    else:
+                        if item == 'datatype':
+                            outfile.write(f'{cvar.size}\n')
+                            outfile.write(f'{PTYPE_TO_PRMS_TYPE[cvar.meta["datatype"]]}\n')
+                        if item == 'values':
+                            if cvar.meta['context'] == 'scalar':
+                                # Single-values (e.g. int, float, str)
+                                # print(type(cvar.values))
+                                if isinstance(cvar.values, np.bytes_):
+                                    print("BYTES")
+                                    outfile.write(f'{cvar.values.decode()}\n')
+                                else:
+                                    outfile.write(f'{cvar.values}\n')
+                            else:
+                                # Multiple-values
+                                if isinstance(cvar.values, np.ndarray):
+                                    for cval in cvar.values:
+                                        outfile.write(f'{cval}\n')
+                                else:
+                                    outfile.write(f'{cvar.values}\n')
+
+        outfile.close()
+
+    def write_metadata_csv(self, filename: str, sep: str = '\t'):
+        """Writes the control metadata to a CSV file"""
+
+        out_list = []
+
+        # <control_param name="soilrechr_dynamic" version="5.0">
+        #     <default>dyn_soil_rechr.param</default>
+        #     <force_default>1</force_default>
+        #     <type>4</type>
+        #     <numvals>1</numvals>
+        #     <desc>Pathname of the time series of pre-processed values for dynamic parameter soil_rechr_max_frac</desc>
+        # </control_param>
+
+        for pk in sorted(list(self.__control_vars.keys())):
+            cvar = self.get(pk)
+            md = cvar.meta
+            assert md is not None
+
+            meta_default = md.get('default')
+            assert meta_default is not None
+
+            if pk in ['start_time', 'end_time']:
+                dt = pd.Timestamp(meta_default)
+                out_list.append([cvar.name,
+                                 'int32',
+                                 md.get('description', ''),
+                                 f'{dt.year},{dt.month},{dt.day},{dt.hour},{dt.minute},{dt.second}'])
+                                 # pd.Timestamp(meta_default).strftime('%-Y,%-m,%-d,%-H,%-M,%-S')])
+            else:
+                out_list.append([cvar.name,
+                                 md.get('datatype', ''),
+                                 md.get('description', ''),
+                                 md.get('default')])
+
+        col_names = ['variable_name', 'datatype', 'description', 'default']
+
+        df = pd.DataFrame.from_records(out_list, columns=col_names)
+        if sep == ',':   # pragma: no cover
+            df.to_csv(filename, sep=sep, quotechar='"', index=False)
+        else:
+            df.to_csv(filename, sep=sep, index=False)
+
+    def _check_condition(self, cstr: str) -> bool:
+        """Takes a string of the form '<control_var> <op> <value>' and checks
+        if the condition is True
+        """
+        # if len(cstr) == 0:
+        #     return True
+        value: Union[int, str]
+
+        var, op, value = cstr.split(' ')
+        value = int(value)
+
+        ctl_val = self.get(var).values
+        assert ctl_val is not None
+
+        return cond_check[op](ctl_val, value)
+
+    def _read(self):
+        """Abstract function for reading.
+        """
+        assert False, 'Control._read() must be defined by child class'

pyPRMS/control/ControlFile.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+
+import numpy as np
+
+from pathlib import Path
+from typing import Optional, Union
+from ..constants import PTYPE_TO_DTYPE, VAR_DELIM
+from ..prms_helpers import get_file_iter
+from .Control import Control
+from ..Exceptions_custom import ControlError
+
+
+class ControlFile(Control):
+    """
+    Class which handles the processing of PRMS control files.
+    """
+
+    # Author: Parker Norton (pnorton@usgs.gov)
+    # Create date: 2019-04-18
+    # Description: Class object to handle reading and writing PRMS control files.
+
+    def __init__(self, filename: Union[str, Path],
+                 metadata,
+                 verbose: Optional[bool] = False):
+        super(ControlFile, self).__init__(metadata=metadata, verbose=verbose)
+
+        self.__verbose = verbose
+        self.__isloaded = False
+
+        if isinstance(filename, str):
+            filename = Path(filename)
+        self.filename = filename
+
+    @property
+    def filename(self) -> Union[str, Path]:
+        """Get control filename.
+
+        :returns: Name of control file
+        """
+        return self.__filename
+
+    @filename.setter
+    def filename(self, filename: Union[str, Path]):
+        """Set the name of the control file and read it in.
+
+        :param filename: Name of the control file
+        """
+
+        self.__isloaded = False
+        self.__filename = filename
+        self._read()
+
+    def _read(self):
+        """Read contents of control file.
+
+        Reads the contents of a control file into the class.
+        """
+
+        if self.__verbose:
+            chk_vars = []
+
+        self.__isloaded = False
+
+        it = get_file_iter(self.filename)
+        header_tmp = []
+
+        for fidx, line in enumerate(it):
+            if fidx == 0:
+                header_tmp.append(line)
+                continue
+            elif line == VAR_DELIM:
+                continue
+            else:
+                # We're dealing with a control parameter/variable
+                # We're in a parameter section
+                varname = line.split(' ')[0]
+
+                if self.__verbose:
+                    if varname in chk_vars:
+                        print(f'WARNING: {varname} already exists')
+                    chk_vars.append(varname)
+
+                numval = int(next(it))  # number of values for this variable
+                valuetype = int(next(it))  # Variable type (1 - integer, 2 - float, 4 - character)
+
+                try:
+                    # if self.get(varname).context == 'scalar' and varname not in ['start_time', 'end_time']:
+                    if self.get(varname).meta['context'] == 'scalar':
+                        if numval == 1:  # varname not in ['start_time', 'end_time']:
+                            vals = PTYPE_TO_DTYPE[valuetype](next(it))
+                        else:
+                            # Currently only start_time and end_time are scalars with numval > 1
+                            vals = np.zeros(numval, dtype=PTYPE_TO_DTYPE[valuetype])
+                            for idx in range(0, numval):
+                                # NOTE: string-float to int works but float to int does not
+                                vals[idx] = next(it)
+                    elif self.get(varname).meta['context'] == 'array':
+                        if valuetype == 4:
+                            # Arrays of strings should be objects
+                            vals = np.zeros(numval, dtype=object)
+                        else:
+                            vals = np.zeros(numval, dtype=PTYPE_TO_DTYPE[valuetype])
+
+                        for idx in range(0, numval):
+                            # NOTE: string-float to int works but float to int does not
+                            vals[idx] = next(it)
+                    else:
+                        print(f'WARNING: {varname} has context={self.get(varname).meta["context"]} which is not supported')
+
+                    # After reading expected values make sure there aren't more values
+                    # before the next delimiter.
+                    try:
+                        cnt = numval
+                        while next(it) != VAR_DELIM:
+                            cnt += 1
+
+                        if cnt > numval:
+                            raise ControlError(f'{varname}: too many values specified')
+                            # print(f'WARNING: Too many values specified for {varname}')
+                            # print(f'      {numval} expected, {cnt} given')
+                            # print(f'       Keeping first {numval} values')
+                    except StopIteration:
+                        # Hit the end of the file
+                        pass
+
+                    self.get(varname).values = vals
+
+                except ValueError as err:
+                    print(f'WARNING: {varname} is not a valid control variable')
+                    print(err)
+
+                    try:
+                        while next(it) != VAR_DELIM:
+                            pass
+                    except StopIteration:
+                        # Hit the end of the file
+                        continue
+
+        self.header = header_tmp
+        self.__isloaded = True
+
+    # def clear_parameter_group(self, group_name):
+    #     """Clear a parameter group.
+    #
+    #     Given a single parameter group name will clear out values for that parameter
+    #        and all related parameters.
+    #
+    #     Args:
+    #         group_name: The name of a group of related parameters.
+    #             One of 'statVar', 'aniOut', 'mapOut', 'dispVar', 'nhruOut'.
+    #     """
+    #
+    #     groups = {'aniOut': {'naniOutVars': 0, 'aniOutON_OFF': 0, 'aniOutVar_names': []},
+    #               'dispVar': {'ndispGraphs': 0, 'dispVar_element': [], 'dispVar_names': [], 'dispVar_plot': []},
+    #               'mapOut': {'nmapOutVars': 0, 'mapOutON_OFF': 0, 'mapOutVar_names': []},
+    #               'nhruOut': {'nhruOutVars': 0, 'nhruOutON_OFF': 0, 'nhruOutVar_names': []},
+    #               'statVar': {'nstatVars': 0, 'statsON_OFF': 0, 'statVar_element': [], 'statVar_names': []}}
+    #
+    #     for (kk, vv) in iteritems(groups[group_name]):
+    #         if kk in self.__controldict:
+    #             self.replace_values(kk, vv)