hspf 2.0.3__tar.gz → 2.1.0__tar.gz

{hspf-2.0.3 → hspf-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hspf
-Version: 2.0.3
+Version: 2.1.0
 Summary: Python package for downloading and running HSPF models
 Project-URL: Homepage, https://github.com/mfratkin1/pyHSPF
 Author-email: Mulu Fratkin <michael.fratkin@state.mn.us>

{hspf-2.0.3 → hspf-2.1.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "hspf"
 urls = { "Homepage" = "https://github.com/mfratkin1/pyHSPF" }  # ? Add this!
-version = "2.0.3"
+version = "2.1.0"
 dependencies = [
   "pandas",
   "requests",

{hspf-2.0.3 → hspf-2.1.0}/src/hspf/hbn.py

@@ -176,6 +176,12 @@ class hbnInterface:
     def get_multiple_timeseries(self,t_opn,t_code,t_con,opnids = None,activity = None,axis = 1):
         return pd.concat([hbn.get_multiple_timeseries(t_opn,t_code,t_con,opnids,activity) for hbn in self.hbns],axis = 1)
 
+    def get_perlnd_constituent(self,constituent,perlnd_ids = None,time_step = 5):
+        return get_simulated_perlnd_constituent(self,constituent,time_step)
+
+    def get_implnd_constituent(self,constituent,implnd_ids = None,time_step = 5):
+        return get_simulated_implnd_constituent(self,constituent,time_step)
+
     def get_reach_constituent(self,constituent,reach_ids,time_step,unit = None):
         if constituent == 'Q':
             df = get_simulated_flow(self,time_step,reach_ids,unit = unit)
@@ -209,48 +215,17 @@ class hbnInterface:
         
         return df
          
-         
+          
     def get_rchres_data(self,constituent,reach_ids,units = 'mg/l',t_code = 'daily'):
         '''
         Convience function for accessing the hbn time series associated with our current
         calibration method. Assumes you are summing across all dataframes.
-
-        Parameters
-        ----------
-        hbn : TYPE
-            DESCRIPTION.
-        nutrient_id : TYPE
-            DESCRIPTION.
-        reach_ids : TYPE
-            DESCRIPTION.
-        flux : TYPE, optional
-            DESCRIPTION. The default is None.
-
-        Returns
-        -------
-        df : TYPE
-            DESCRIPTION.
-
-        '''
-        
-        
+       '''
         
-        t_cons = helpers.get_tcons(constituent,'RCHRES',units)
-        
-
-        
-        df = pd.concat([self.get_multiple_timeseries(t_opn = 'RCHRES',
-                                     t_code =t_code,
-                                     t_con = t_con,
-                                     opnids = reach_ids)
-                         for t_con in t_cons],axis = 1).sum(1).to_frame()
-        
-        if (constituent == 'Q') & (units == 'cfs'):            
-            df = df/CF2CFS[t_code]*43560 #Acrfeet/invl to cubic feet/s
-            
+        df = pd.concat([self.get_reach_constituent(constituent,[reach_id],t_code,units) for reach_id in reach_ids], axis = 1)
+        df.columns = reach_ids
         df.attrs['unit'] = units
         df.attrs['constituent'] = constituent
-        df.attrs['reach_ids'] = reach_ids
         return df
     
         

{hspf-2.0.3 → hspf-2.1.0}/src/hspf/hspfModel.py

@@ -30,7 +30,7 @@ class hspfModel():
 
     # Imposed structures of an hspf model:
         # 1. all model files are located in the same directory as the uci file.
-    def __init__(self,uci_file:str):
+    def __init__(self,uci_file:str,run_model:bool = False):
                       #wdm_files:list = None,
                       #hbn_files:str = None):
         # Inputs
@@ -39,7 +39,7 @@ class hspfModel():
         self.wdm_paths = []
         self.uci_file = Path(uci_file).resolve()
         # Validate and load binary data
-        self.validate_uci()
+        self.validate_uci(run_model = run_model)
         
         
         self.hbns = hbn.hbnInterface(self.hbn_paths)
@@ -51,8 +51,28 @@ class hspfModel():
         # Compositions
         self.reports = Reports(self.uci,self.hbns,self.wdms)
         
+
+    def validate_wdms(self):
+        # Ensure wdm files exist and the folders for the other file types exist relative
+        # to the uci path   
+
+        for index, row in self.uci.table('FILES',drop_comments = False).iterrows():
+            file_path = self.uci_file.parent.joinpath(Path(row['FILENAME']))            
+            if file_path.suffix.lower() == '.wdm':
+                assert file_path.exists(),'File Specified in the UCI does not exist:' + file_path.as_posix()
+                self.wdm_paths.append(file_path)
   
-    def validate_uci(self):
+    def validate_pltgens(self):
+        raise NotImplementedError() 
+
+    def validate_folders(self):
+        for index, row in self.uci.table('FILES',drop_comments = False).iterrows():
+            file_path = self.uci_file.parent.joinpath(Path(row['FILENAME']))            
+            assert file_path.parent.exists(),'File folder Specified in the UCI does not exist: ' + file_path.as_posix()
+
+
+ 
+    def validate_uci(self,run_model:bool = False):
         # Ensure wdm files exist and the folders for the other file types exist relative
         # to the uci path   
 
@@ -63,15 +83,15 @@ class hspfModel():
                 self.wdm_paths.append(file_path)
             elif file_path.suffix.lower() == '.hbn':
                 assert file_path.parent.exists(),'File folder Specified in the UCI does not exist: ' + file_path.as_posix()
-                #self.hbns[file_path.name.split('.')[0]] = None
-                if file_path.exists():
-                    #self.hbns[file_path.name.split('.')[0]] = hbn.hbnClass(file_path)
-                    self.hbn_paths.append(file_path)
-                else:
-                    self.run_model()
+                self.hbn_paths.append(file_path)
             else:
                 assert file_path.parent.exists(),'File folder Specified in the UCI does not exist: ' + file_path.as_posix()
 
+        if (all(file_path.exists() for file_path in self.hbn_paths)) & (run_model == False):
+            pass
+        else:
+            self.run_model()
+
     def run_model(self,new_uci_file = None):
         
         if new_uci_file is None:
@@ -80,14 +100,14 @@ class hspfModel():
         # new_uci_file = self.model_path.joinpath(uci_name)
         # self.uci.write(new_uci_file)
         subprocess.run([self.winHSPF,self.uci_file.as_posix()]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
-        self.load_uci(new_uci_file)
+        self.load_uci(new_uci_file,run_model = False)
 
     def load_hbn(self,hbn_name):
         self.hbns[hbn_name] = hbn.hbnClass(self.uci_file.parent.joinpath(hbn_name).as_posix())
 
-    def load_uci(self,uci_file):
+    def load_uci(self,uci_file,run_model:bool = False):
         self.uci = UCI(uci_file)
-        self.validate_uci()
+        self.validate_uci(run_model = run_model)
     
     def convert_wdms(self):
         for wdm_file in self.wdm_paths:

{hspf-2.0.3 → hspf-2.1.0}/src/hspf/parser/graph.py

@@ -4,10 +4,12 @@ Created on Thu Feb  6 14:50:45 2025
 
 @author: mfratki
 """
+
 import networkx as nx
 import pandas as pd
 import numpy as np
 import math
+from itertools import chain
 
 class Node(object):
     nodes = []
@@ -18,7 +20,37 @@ class Node(object):
     def __str__(self):
         return self._label
    
-    
+
+
+# G = nx.MultiDiGraph()
+# reach_nodes = schematic[['TVOL','TVOLNO']].drop_duplicates().reset_index(drop=True).reset_index()
+# nodes = schematic.loc[schematic['SVOL'].isin(['IMPLND','PERLND','GENER'])][['SVOL','SVOLNO']].reset_index(drop=True).reset_index()
+
+
+# reach_nodes.rename(columns = {'index':'TNODE'},inplace=True)
+# nodes.rename(columns = {'index':'SNODE','TVOL':'OPERATION','TVOLNO':'OPNID'},inplace=True)
+# [G.add_node(row['TNODE'], id = row['TNODE'], category = 'OPERATION', type_id = row['TVOLNO'], type = row['RCHRES'] ) for node,label in reach_nodes.iterrows()] 
+
+# df = pd.merge(schematic,reach_nodes,right_on = ['TVOL','TVOLNO'],left_on = ['TVOL','TVOLNO']).reset_index()
+# df.rename(columns = {'index':'SNODE'},inplace=True)
+
+
+# for index, row in df.iterrows():
+#     if row['SVOL'] == 'GENER':
+#         G.add_edge(row['SNODE'],row['TNODE'],
+#                             mlno = row['MLNO'],
+#                             count = row['AFACTR'],
+#                             tmemsb1 = row['TMEMSB1'],
+#                             tmemsb2 = row['TMEMSB2'])
+#     else:
+#         G.add_edge(row['SNODE'],row['TNODE'],
+#                             mlno = row['MLNO'],
+#                             area = row['AFACTR'],
+#                             tmemsb1 = row['TMEMSB1'],
+#                             tmemsb2 = row['TMEMSB2'])
+
+# G = nx.from_pandas_edgelist(df,'SNODE','TNODE',edge_attr = True,edge_key = 'SNODE', create_using=nx.MultiDiGraph())
+
 def create_graph(uci):
     
     
@@ -46,9 +78,9 @@ def create_graph(uci):
     # Nodes in the schematic block that are missing from the opn sequence block (usually the outlet reach)
     #schematic.loc[schematic.index.map(labels).isna()]
     schematic = schematic.loc[schematic[['snode','tnode']].dropna().index] # For now remove that missing node
-    schematic.loc[:,'TMEMSB1'].replace('',pd.NA,inplace=True)
-    schematic.loc[:,'TMEMSB2'].replace('',pd.NA,inplace=True)
-    schematic.loc[:,'MLNO'].replace('',pd.NA,inplace=True)
+    schematic.loc[:,'TMEMSB1'] = schematic['TMEMSB1'].replace('',pd.NA)
+    schematic.loc[:,'TMEMSB2'] = schematic['TMEMSB2'].replace('',pd.NA)
+    schematic.loc[:,'MLNO'] = schematic['MLNO'].replace('',pd.NA)
 
     schematic = schematic.astype({'snode': int,'tnode':int,'MLNO':pd.Int64Dtype(),'TMEMSB1':pd.Int64Dtype(),'TMEMSB2':pd.Int64Dtype()})
     for index, row in schematic.iterrows():
@@ -169,19 +201,28 @@ def nodes(G,node_type,node_type_id,adjacent_node_type):
 
 #%% Methods using node_type, node_type_id interface
 
-def upstream_network(G,reach_id):
-    node_id = get_node_id(G,'RCHRES',reach_id)
-    return G.subgraph([node_id] + list(nx.ancestors(G,node_id))).copy()
+def upstream_network(G,reach_ids):
+    node_ids = [get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids]
+        # Initialize an empty set to store all unique ancestors
+    
+    all_ancestors = set()
+    # Iterate through the target nodes and find ancestors for each
+    for node_id in node_ids:
+        ancestors_of_node = nx.ancestors(G, node_id)
+        all_ancestors.update(ancestors_of_node) # Add ancestors to the combined set
+
+    all_ancestors.update(node_ids) # Include the target nodes themselves
+    return G.subgraph(all_ancestors).copy()
+    #return G.subgraph([node_id] + list(nx.ancestors(G,node_id))).copy()
 
 def downstream_network(G,reach_id):
     node_id = get_node_id(G,'RCHRES',reach_id)
     return G.subgraph([node_id] + list(nx.descendants(G,node_id))).copy()
 
-def subset_network(G,reach_id,upstream_reach_ids = None):
-    G = upstream_network(G,reach_id)
+def subset_network(G,reach_ids,upstream_reach_ids = None):
+    G = upstream_network(G,reach_ids)
     if upstream_reach_ids is not None:
-        for upstream_reach_id in upstream_reach_ids:
-            G.remove_nodes_from(get_node_ids(upstream_network(G,upstream_reach_id),'RCHRES'))
+        G.remove_nodes_from(get_node_ids(upstream_network(G,upstream_reach_ids),'RCHRES'))
         #assert([len(sinks(G)) == 0,sinks(G)[0] == reach_id])
     return G
 
@@ -259,8 +300,8 @@ def routing_reachs(G):
 def is_routing(G,reach_id):
     return all([node['type'] not in ['PERLND', 'IMPLND'] for node in adjacent_nodes(G,reach_id)])
 
-def watershed_area(G,reach_ids):
-    return float(np.nansum(list(nx.get_edge_attributes(make_watershed(G,reach_ids),'area').values())))
+def watershed_area(G,reach_ids,upstream_reach_ids = None):
+    return float(np.nansum(list(nx.get_edge_attributes(make_watershed(G,reach_ids,upstream_reach_ids),'area').values())))
 
 def catchment_area(G,reach_id):
     return float(np.nansum(list(nx.get_edge_attributes(make_catchment(G,reach_id),'area').values())))
@@ -300,22 +341,47 @@ def make_catchment(G,reach_id):
     nx.set_node_attributes(catchment,node_id,'catchment_id')
     return catchment
 
-from itertools import chain
-
-def make_watershed(G,reach_ids):
+def make_watershed(G,reach_ids,upstream_reach_ids = None):
     '''
     Creates a sugraph representing the the catchments upstream of the specified hspf model reaches. Note that a negative reach_ids indicate to subtract that area from the total.
     
     
     ''' 
-    node_ids = set([get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids if reach_id > 0])
-    nodes_to_exclude = set([get_node_id(G,'RCHRES',abs(reach_id)) for reach_id in reach_ids if reach_id < 0])
-    node_ids = node_ids - nodes_to_exclude
+
+    node_ids = set(get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids)
+
+    # Initialize an empty set to store all unique ancestors
     
+    # Iterate through the target nodes and find ancestors for each
+    all_upstream_reaches = set()
+    for node_id in node_ids:
+        ancestors_of_node = [node['id'] for node in ancestors(G, node_id,'RCHRES')]
+        all_upstream_reaches.update(ancestors_of_node) # Add ancestors to the combined set
+    all_upstream_reaches.update(node_ids) # Include the target nodes themselves
+
+    if upstream_reach_ids is not None:
+        upstream_node_ids = set(get_node_id(G,'RCHRES',reach_id) for reach_id in upstream_reach_ids)
+        for node_id in upstream_node_ids:
+            ancestors_of_node = [node['id'] for node in ancestors(G, node_id,'RCHRES')]
+            all_upstream_reaches = all_upstream_reaches - set(ancestors_of_node)
+    else:
+        upstream_node_ids = set()
+
+    nodes = set(chain.from_iterable([list(G.predecessors(node_id)) for node_id in all_upstream_reaches])) | node_ids
+    nodes = nodes - upstream_node_ids # Include the target nodes themselves
+
+
+    return G.subgraph(nodes).copy()
+    
+    
+    # node_ids = set([get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids if reach_id > 0])
+    # nodes_to_exclude = set([get_node_id(G,'RCHRES',abs(reach_id)) for reach_id in reach_ids if reach_id < 0])
+    # node_ids = node_ids - nodes_to_exclude
     
-    nodes = [list(nx.ancestors(G,node_id)) for node_id in node_ids]
-    nodes.append(node_ids)
-    nodes = list(set(chain.from_iterable(nodes)))
+    #nodes = get_opnids(G,'RCHRES',reach_ids,upstream_reach_ids) #[ancestors(G,node_id,'RCHRES')) for node_id in node_ids]
+    nodes = subset_network(G,reach_ids,upstream_reach_ids)
+    #nodes.append(node_ids)
+    #nodes = list(set(chain.from_iterable(nodes)))
     watershed = subgraph(G, nodes)
     catchment_id = '_'.join([str(reach_id) for reach_id in reach_ids])
     nx.set_node_attributes(watershed,node_ids,catchment_id)
@@ -401,8 +467,17 @@ class Catchment():
     def dsn(self,tmemn):
         return [self.catchment.nodes[k[0]]['id']  for k,v in nx.get_edge_attributes(self.catchment,'tmemn').items() if v == tmemn]
     
-    def to_dataframe():
-        return 
+    def to_dataframe(self):
+        edges = []
+        for u, v, edge_data in self.catchment.edges(data=True):
+            source_node_attributes = self.catchment.nodes[u]
+            # Add or update edge attributes with source node attributes
+            edge_data["source_type"] = source_node_attributes.get("type")
+            edge_data["source_name"] = source_node_attributes.get("name")
+            edge_data["source_type_id"] = source_node_attributes.get("type_id")
+            edges.append(edge_data)
+        
+        return pd.DataFrame(edges)
 # def _watershed(G,reach_id):
     
 #     predecessors = (list(G.predecessors(node)))
@@ -423,7 +498,17 @@ class Catchment():
     
 #     {source:[node for node in nx.shortest_path(G,source,reach_id)] for source in nx.ancestors(G,reach_id)}
 
-
+def to_dataframe(G):
+    edges = []
+    for u, v, edge_data in G.edges(data=True):
+        source_node_attributes = G.nodes[u]
+        # Add or update edge attributes with source node attributes
+        edge_data["source_type"] = source_node_attributes.get("type")
+        edge_data["source_name"] = source_node_attributes.get("name")
+        edge_data["source_type_id"] = source_node_attributes.get("type_id")
+        edges.append(edge_data)
+    
+    return pd.DataFrame(edges)
 
 
 #%% Legacy Methods for Backwards compatability
@@ -457,8 +542,16 @@ class reachNetwork():
         downstream.insert(0,reach_id)
         return downstream
         
-    def calibration_order(self,reach_id,upstream_reach_ids = None):
-        return calibration_order(self.G,reach_id,upstream_reach_ids)
+    def calibration_order(self,reach_ids,upstream_reach_ids = None):
+        '''
+        Calibration order of reaches to prevent upstream influences. Equivalent to iteritivlye pruning the network remving nodes with no upstream connections.
+        A list of lists is returned where each sublist contains reaches that can be calibrated in parallel.
+        
+        :param self: Description
+        :param reach_ids: Description
+        :param upstream_reach_ids: Description
+        '''
+        return calibration_order(make_watershed(self.G,reach_ids,upstream_reach_ids))
     
     def station_order(self,reach_ids):
         raise NotImplementedError()
@@ -478,30 +571,30 @@ class reachNetwork():
         '''
         return  [node['type_id'] for node in predecessors(self.G,'RCHRES',get_node_id(self.G,'RCHRES',reach_id))]
         
-    def get_opnids(self,operation,reach_id, upstream_reach_ids = None):
+    def get_opnids(self,operation,reach_ids, upstream_reach_ids = None):
         '''
         Operation IDs with a path to reach_id. Operations upstream of upstream_reach_ids will not be included
 
         '''
-        return get_opnids(self.G,operation=operation,reach_id = reach_id, upstream_reach_ids = upstream_reach_ids)
-    
+        return get_opnids(self.G,operation,reach_ids,upstream_reach_ids)    
     def operation_area(self,operation,opnids = None):
+        '''
+        Area of operation type for specified operation IDs. If None returns all operation areas.
+        Equivalent to the schematic table filtered by operation and opnids.
+        '''
+
         return operation_area(self.uci,operation)  
         
     def drainage(self,reach_id):
-        # Merge source node attributes into edge attributes
-    
-        edges = []
-        for u, v, edge_data in make_catchment(self.G,reach_id).edges(data=True):
-            source_node_attributes = self.G.nodes[u]
-            # Add or update edge attributes with source node attributes
-            edge_data["source_type"] = source_node_attributes.get("type")
-            edge_data["source_name"] = source_node_attributes.get("name")
-            edge_data["source_type_id"] = source_node_attributes.get("type_id")
-            edges.append(edge_data)
+        '''
+        Docstring for drainage
         
-        return pd.DataFrame(edges)
-    
+        :param self: Network class instance
+        :param reach_id: Target reach id 
+        '''
+        # Merge source node attributes into edge attributes
+        return to_dataframe(make_catchment(self.G,reach_id))
+
     def subwatersheds(self,reach_ids = None):
         df = subwatersheds(self.uci)
         if reach_ids is None:
@@ -520,15 +613,16 @@ class reachNetwork():
     def reach_contributions(self,operation,opnids):
         return reach_contributions(self.uci,operation,opnids)
     
-    def drainage_area(self,reach_ids):
-        return watershed_area(self.G,reach_ids)
+    def drainage_area(self,reach_ids,upstream_reach_ids = None):
+        return watershed_area(self.G,reach_ids,upstream_reach_ids)
     
-    def drainage_area_landcover(self,reach_id,group = True):
-        reach_ids = self._upstream(reach_id)
-        areas = pd.concat([self.subwatershed(reach_id) for reach_id in reach_ids]).groupby(['SVOL','SVOLNO'])['AFACTR'].sum()
-        
-        if group:    
-            areas = pd.concat([areas[operation].groupby(self.uci.opnid_dict[operation].loc[areas[operation].index,'LSID'].values).sum() for operation in ['PERLND','IMPLND']])
+    def drainage_area_landcover(self,reach_ids,upstream_reach_ids = None, group = True):
+        areas = to_dataframe(make_watershed(self.G,reach_ids,upstream_reach_ids))
+        areas = areas.groupby(['source_type','source_type_id','source_name'])['area'].sum()[['PERLND','IMPLND']]
+
+        if group:  
+            areas = pd.concat([areas[operation].groupby('source_name').sum()  for operation in ['PERLND','IMPLND']])
+            #areas = pd.concat([areas[operation].groupby(self.uci.opnid_dict[operation].loc[areas[operation].index,'LSID'].values).sum() for operation in ['PERLND','IMPLND']])
         return areas
 
     def outlets(self):
@@ -546,49 +640,28 @@ class reachNetwork():
     def paths(self,reach_id):
         return paths(self.G,reach_id)
     
-    
-def calibration_order(G,reach_id,upstream_reach_ids = None):
+
+def get_opnids(G,operation,reach_ids, upstream_reach_ids = None):
+    return get_node_type_ids(make_watershed(G,reach_ids,upstream_reach_ids),operation)
+
+
+def calibration_order(G):
     '''
-    Determines the order in which the specified reaches should be calibrated to
+    Determines the order in which the model reaches should be calibrated to
     prevent upstream influences. Primarily helpful when calibrating sediment and
     adjusting in channel erosion rates.
     '''
     
+    nodes = get_node_ids(G,'RCHRES')
+    G = G.subgraph(nodes).copy()
     order = []
-    Gsub = subgraph(G,get_node_ids(G,'RCHRES'))
-    while(len(Gsub.nodes)) > 0:
-   
-        nodes_to_remove = [node for node, in_degree in Gsub.in_degree() if in_degree == 0]
+    while(len(nodes)) > 0:
+        nodes_to_remove = [node for node in nodes if G.in_degree(node) == 0]
         order.append([G.nodes[node]['type_id'] for node in nodes_to_remove])
-        Gsub.remove_nodes_from(nodes_to_remove)         
+        nodes = [node for node in nodes if node not in nodes_to_remove]
+        G.remove_nodes_from(nodes_to_remove)
     return order
-    
-
-
-
-def get_opnids(G,operation,reach_id = None, upstream_reach_ids = None):
-    G = subset_network(G,reach_id,upstream_reach_ids)
-    return ancestors(G,get_node_id(G,'RCHRES',reach_id),operation)
-    perlnds = [node['type_id'] for node in get_nodes(G,'PERLND')]
-    implnds = [node['type_id'] for node in get_nodes(G,'IMPLND')]
-    reachs = [node['type_id'] for node in get_nodes(G,'RCHRES')]
-    return {'RCHRES':reachs,'PERLND':perlnds,'IMPLND':implnds}[operation]
-    #return reachs,perlnds,implnds
-
-def drainage(uci,reach_ids):
-    return subwatersheds(uci).loc[reach_ids].reset_index()[['SVOL','LSID','AFACTR']].groupby(['LSID','SVOL']).sum()
-
-
-
-def drainage_area(uci,reach_ids,drng_area = 0):
-    if len(reach_ids) == 0:
-        return drng_area
-    else:
-        sign = math.copysign(1,reach_ids[0])
-        reach_id = int(reach_ids[0]*sign)
-        drng_area = drng_area + sign*uci.network.drainage_area(reach_id)
-        drainage_area(uci,reach_ids[1:],drng_area)
-                
+       
 
 def reach_contributions(uci,operation,opnids):
     schematic = uci.table('SCHEMATIC').set_index('SVOL')

{hspf-2.0.3 → hspf-2.1.0}/src/hspf/parser/parsers.py

@@ -6,6 +6,7 @@ Created on Fri Oct  7 12:13:23 2022
 """
 
 from abc import abstractmethod
+from multiprocessing.util import info
 import numpy as np
 import pandas as pd
 from pathlib import Path
@@ -289,7 +290,29 @@ class masslinkParser(Parser):
                 table_lines[index] = line[-1]
                 
         return table_lines       
-  
+
+class globalParser(Parser):
+    def parse(block,table_name,table_lines):
+        table_lines = [line for line in table_lines if '***' not in line]
+        data = {
+            'description' : table_lines[0].strip(),
+            'start_date' : table_lines[1].split('END')[0].split()[1],
+            'start_hour' :  int(table_lines[1].split('END')[0].split()[2][:2])-1,
+            'end_date' : table_lines[1].strip().split('END')[1].split()[0],
+            'end_hour' : int(table_lines[1].strip().split('END')[1].split()[1][:2])-1,
+            'echo_flag1' : int(table_lines[2].split()[-2]),
+            'echo_flag2' : int(table_lines[3].split()[-1]),
+            'units_flag' : int(table_lines[3].split()[5]),
+            'resume_flag': int(table_lines[3].split()[1]),
+            'run_flag': int(table_lines[3].split()[3]) 
+        }
+        df = pd.DataFrame([data])
+        df['comments'] = ''
+        return df
+    
+    def write(block,table_name,table):
+        raise NotImplementedError()
+
 class specactionsParser(Parser):
     def parse(block,table,lines):
         raise NotImplementedError()
@@ -304,7 +327,7 @@ class externalsourcesParser():
     def write(block,table,lines):
         raise NotImplementedError()
 
-parserSelector = {'GLOBAL':defaultParser,
+parserSelector = {'GLOBAL':globalParser,
                 'FILES':standardParser,
                 'OPN SEQUENCE':opnsequenceParser,
                 'PERLND':operationsParser,

{hspf-2.0.3 → hspf-2.1.0}/src/hspf/reports.py

@@ -325,6 +325,7 @@ def ann_avg_subwatershed_loading(constituent,uci,hbn):
     return df
 
 def ann_avg_watershed_loading(constituent,reach_ids,uci,hbn, by_landcover = False):
+    reach_ids = [item for sublist in [uci.network._upstream(reach_id) for reach_id in reach_ids] for item in sublist]
     df = ann_avg_constituent_loading(constituent,uci,hbn)
     df = df.loc[df['TVOLNO'].isin(reach_ids)]
     if by_landcover:

{hspf-2.0.3 → hspf-2.1.0}/src/hspf/uci.py

@@ -8,6 +8,7 @@ Created on Mon Jul 11 08:39:57 2022
 
 #lines = reader('C:/Users/mfratki/Documents/Projects/LacQuiParle/ucis/LacQuiParle_0.uci')
 import subprocess
+import sys
 import numpy as np
 import pandas as pd
 from .parser.parsers import Table
@@ -78,7 +79,7 @@ class UCI():
                  
     def table(self,block,table_name = 'na',table_id = 0,drop_comments = True):
         # Dynamic parsing of tables when called by user
-        assert block in ['FILES','PERLND','IMPLND','RCHRES','SCHEMATIC','OPN SEQUENCE','MASS-LINK','EXT SOURCES','NETWORK','GENER','MONTH-DATA','EXT TARGETS','COPY','FTABLES']
+        assert block in ['GLOBAL','FILES','PERLND','IMPLND','RCHRES','SCHEMATIC','OPN SEQUENCE','MASS-LINK','EXT SOURCES','NETWORK','GENER','MONTH-DATA','EXT TARGETS','COPY','FTABLES']
         
         table = self.uci[(block,table_name,table_id)] #[block][table_name][table_id]
         #TODO move the format_opnids into the Table class?
@@ -103,7 +104,7 @@ class UCI():
         self.uci[(block,table_name,table_id)].replace(table)
 
     def table_lines(self,block,table_name = 'na',table_id = 0):
-        return self.uci[(block,table_name,table_id)].lines
+        return self.uci[(block,table_name,table_id)].lines.copy()
         
     def comments(block,table_name = None,table_id = 0): # comments of a table
         raise NotImplementedError()
@@ -177,6 +178,43 @@ class UCI():
         lines += ['END RUN']
         self.lines = lines       
 
+    def set_simulation_period(self,start_year,end_year):
+        # Update GLOBAL table with new start and end dates very janky implementation but not a priority.
+
+        # if start_hour < 10:
+        #     start_hour = f'0{int(start_hour+1)}:00'
+        # else:
+        #     start_hour = f'{int(start_hour+1)}:00'
+        
+        # if end_hour < 10:
+        #     end_hour = f'0{int(end_hour+1)}:00'
+        # else:
+        #     end_hour = f'{int(end_hour+1)}:00'
+
+        table_lines = self.table_lines('GLOBAL')  
+        for index, line in enumerate(table_lines):
+            if '***' in line: #in case there are comments in the global block
+                continue
+            elif line.strip().startswith('START'):
+                table_lines[index] = line[0:14] + f'{start_year}/01/01 00:00  ' + f'END    {end_year}/12/31 24:00'
+            else:
+                continue
+
+        self.uci[('GLOBAL','na',0)].lines = table_lines
+
+    def set_echo_flags(self,flag1,flag2):
+        table_lines = self.table_lines('GLOBAL')  
+        for index, line in enumerate(table_lines):
+            if '***' in line: #in case there are comments in the global block
+                continue
+            elif line.strip().startswith('RUN INTERP OUTPT LEVELS'):
+                table_lines[index] = f'  RUN INTERP OUTPT LEVELS    {flag1}    {flag2}'
+            else:
+                continue
+        
+
+        self.uci[('GLOBAL','na',0)].lines = table_lines
+
 
     def _write(self,filepath):
         with open(filepath, 'w') as the_file:
@@ -211,6 +249,9 @@ class UCI():
         self.merge_lines()
         self._write(new_uci_path) 
 
+    def _run(self,wait_for_completion=True):
+        run_model(self.filepath, wait_for_completion=wait_for_completion)
+
     def update_bino(self,name):
         #TODO: Move up to busniess/presentation layer
         table = self.table('FILES',drop_comments = False) # initialize the table
@@ -325,9 +366,25 @@ class UCI():
 
 #TODO: More conveince methods that should probably be in a separate module
 
-def run_model(uci_file):
-    winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
-    subprocess.run([winHSPF,uci_file.as_posix()]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
+def run_model(uci_file, wait_for_completion=True):
+    winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFlt\\WinHspfLt.exe'
+    
+    # Arguments for the subprocess
+    args = [winHSPF, uci_file.as_posix()]
+
+    if wait_for_completion:
+        # Use subprocess.run to wait for the process to complete (original behavior)
+        subprocess.run(args)
+    else:
+        # Use subprocess.Popen to run the process in the background without waiting
+        # On Windows, you can use creationflags to prevent a console window from appearing
+        if sys.platform.startswith('win'):
+            # Use a variable for the flag to ensure it's only used on Windows
+            creationflags = subprocess.CREATE_NO_WINDOW
+            subprocess.Popen(args, creationflags=creationflags)
+        else:
+            # For other platforms (like Linux/macOS), Popen without special flags works fine
+            subprocess.Popen(args)
 
 def get_filepaths(uci,file_extension):
     files = uci.table('FILES')

hspf-2.1.0/tests/test_graph.py

@@ -0,0 +1,86 @@
+from hspf.parser import graph
+from pathlib import Path
+
+from hspf.uci import UCI
+
+
+
+
+uci = UCI(Path(__file__).parent.joinpath('data\Clearwater.uci'))
+
+
+def test_lakes():
+    assert uci.network._lakes() == [12,
+                                    32,
+                                    52,
+                                    112,
+                                    114,
+                                    140,
+                                    152,
+                                    172,
+                                    214,
+                                    272,
+                                    434,
+                                    442,
+                                    446,
+                                    502,
+                                    504,
+                                    512,
+                                    522,
+                                    532,
+                                    542,
+                                    592,
+                                    594,
+                                    596,
+                                    636]
+
+def test_calibration_order():
+    orders = graph.calibration_order(graph.make_watershed(uci.network.G,[90]))
+    test_orders = [[52,53,10,12,32,71],
+                    [55,13],
+                    [30],
+                    [50],
+                    [70],
+                    [90]]
+    assert(len(orders) == len(test_orders))
+    for order,test_order in zip(orders,test_orders):
+        assert set(order) == set(test_order)
+                                           
+def test_get_opnids():
+    opnids = uci.network.get_opnids('RCHRES',[90])
+    expected_opnids = [10,12,13,30,32,50,52,53,55,70,71,90]
+    assert set(opnids) == set(expected_opnids)
+
+'''
+Methods of the Network class:
+_downstream',
+ '_lakes',
+ '_routing_reaches',
+ '_upstream',
+ 'calibration_order',
+ 'catchment_ids',
+ 'downstream',
+ 'drainage',
+ 'drainage_area',
+ 'drainage_area_landcover',
+ 'get_node_type_ids',
+ 'get_opnids',
+ 'lake_area',
+ 'lakes',
+ 'operation_area',
+ 'outlets',
+ 'paths',
+ 'reach_contributions',
+ 'routing_reaches',
+ 'schematic',
+ 'station_order',
+ 'subwatershed',
+ 'subwatershed_area',
+ 'subwatersheds',
+ 'uci',
+ 'upstream'
+'''
+
+
+
+