hspf 2.0.3__py3-none-any.whl → 2.1.1__py3-none-any.whl

hspf/hbn_cy.pyx

@@ -0,0 +1,107 @@
+# cython: language_level=3, boundscheck=False, wraparound=False, cdivision=True
+# hbn_cy.pyx - Cython helpers for reading HBN binary files
+from cpython.bytes cimport PyBytes_AsStringAndSize
+cimport cython
+import numpy as np
+cimport numpy as cnp
+from datetime import datetime, timedelta
+
+@cython.inline
+cdef unsigned int _read_uint32_le(const unsigned char* buf, Py_ssize_t offset) nogil:
+    """Reads a little-endian unsigned 32-bit integer."""
+    return buf[offset] | (buf[offset+1] << 8) | (buf[offset+2] << 16) | (buf[offset+3] << 24)
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def map_hbn_file(str file_path):
+    """
+    Parses an HBN file from a file path to produce mapn and mapd dictionaries.
+    Returns (mapn, mapd, data_bytes).
+    """
+    cdef:
+        bytes data_bytes
+        const unsigned char* cbuf
+        Py_ssize_t buf_len, index = 1, i, slen, ln
+        unsigned int rectype, tcode, idval, reclen
+        unsigned char rc1, rc2, rc3, rc
+        dict mapn = {}
+        dict mapd = {}
+
+    with open(file_path, 'rb') as f:
+        data_bytes = f.read()
+    if not data_bytes:
+        raise ValueError(f"File is empty: {file_path}")
+
+    PyBytes_AsStringAndSize(data_bytes, <char **>&cbuf, &buf_len)
+    if cbuf[0] != 0xFD:
+        raise ValueError("BAD HBN FILE - must start with magic number 0xFD")
+
+    while index < buf_len:
+        if index + 28 > buf_len: break
+        rc1 = cbuf[index]; rc2 = cbuf[index+1]; rc3 = cbuf[index+2]; rc = cbuf[index+3]
+        rectype = _read_uint32_le(cbuf, index + 4)
+        idval = _read_uint32_le(cbuf, index + 16)
+        reclen = (<unsigned int>(rc) * 4194304) + (<unsigned int>(rc3) * 16384) + (<unsigned int>(rc2) * 64) + (<unsigned int>(rc1) >> 2) - 24
+
+        operation = data_bytes[index+8:index+16].decode('ascii', 'ignore').strip()
+        activity = data_bytes[index+20:index+28].decode('ascii', 'ignore').strip()
+
+        if rectype == 1:  # data record
+            if index + 36 > buf_len: break
+            tcode = _read_uint32_le(cbuf, index + 32)
+            key = (operation, idval, activity, int(tcode))
+            if key not in mapd: mapd[key] = []
+            mapd[key].append((index, reclen))
+        elif rectype == 0:  # data names record
+            key = (operation, idval, activity)
+            if key not in mapn: mapn[key] = []
+            i = index + 28
+            slen = 0
+            while slen < reclen:
+                if i + slen + 4 > buf_len: break
+                ln = _read_uint32_le(cbuf, i + slen)
+                if i + slen + 4 + ln > buf_len: break
+                name = data_bytes[i + slen + 4 : i + slen + 4 + ln].decode('ascii', 'ignore').strip().replace('-', '')
+                mapn[key].append(name)
+                slen += 4 + ln
+        
+        if reclen < 36: index += reclen + 29
+        else: index += reclen + 30
+
+    return mapn, mapd, data_bytes
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def read_data_entries(bytes data_bytes, list entries, int nvals):
+    """
+    Reads data entries from the file's bytes. Returns (times, rows_array).
+    """
+    cdef:
+        const unsigned char* cbuf
+        Py_ssize_t buf_len, num_entries = len(entries), k, idx
+        unsigned int yr, mo, dy, hr, mn
+        cnp.ndarray[cnp.float32_t, ndim=2] rows2d = np.empty((num_entries, nvals), dtype=np.float32)
+        list times = [None] * num_entries
+
+    PyBytes_AsStringAndSize(data_bytes, <char **>&cbuf, &buf_len)
+
+    for k in range(num_entries):
+        idx = entries[k][0] # Get just the index from the (index, reclen) tuple
+        
+        # Boundary check for safety
+        if idx + 56 + (nvals * 4) > buf_len: continue
+
+        yr = _read_uint32_le(cbuf, idx + 36)
+        mo = _read_uint32_le(cbuf, idx + 40)
+        dy = _read_uint32_le(cbuf, idx + 44)
+        hr = _read_uint32_le(cbuf, idx + 48)
+        mn = _read_uint32_le(cbuf, idx + 52)
+        
+        try:
+            times[k] = datetime(int(yr), int(mo), int(dy), int(hr) - 1, int(mn))
+        except ValueError:
+            times[k] = datetime(1900, 1, 1) # Fallback for bad date data
+
+        rows2d[k] = np.frombuffer(data_bytes, dtype=np.float32, count=nvals, offset=idx + 56)
+        
+    return times, rows2d

hspf/helpers.py

@@ -53,21 +53,22 @@ def get_tcons(nutrient_name,operation,units = 'mg/l'):
         'acrft' : {'Q': ['ROVOL']}}
         
         t_cons = MAP[units]
-    if operation == 'PERLND':
+    elif operation == 'PERLND':
         t_cons = {'TSS' :['SOSED'],
                   'TKN' :['POQUALNH3+NH4'],
                   'N' :['POQUALNO3'],
                   'OP' :['POQUALORTHO P'],
                   'BOD' :['POQUALBOD'],
                   'Q' : ['PERO']} # BOD is the difference of ptot and ortho
-    if operation == 'IMPLND':
+    elif operation == 'IMPLND':
         t_cons = {'TSS' :['SLDS'],
-                  'TKN' :['POQUALNH3+NH4'],
-                  'N' :['POQUALNO3'],
-                  'OP' :['POQUALORTHO P'],
-                  'BOD' :['POQUALBOD'],
+                  'TKN' :['SOQUALNH3+NH4'],
+                  'N' :['SOQUALNO3'],
+                  'OP' :['SOQUALORTHO P'],
+                  'BOD' :['SOQUALBOD'],
                   'Q' : ['SURO']} # BOD is the difference of ptot and ortho
-        
+    else:
+        raise ValueError(f'Operation {operation} not recognized for nutrient time constituent lookup.')
     return t_cons[nutrient_name]
 
 

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/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
 
@@ -222,6 +263,9 @@ def get_implnd_node(G,implnd_id):
 def get_node_type_ids(G,node_type = 'RCHRES'):
     return [data['type_id'] for node, data in G.nodes(data = True) if data['type'] == node_type]
 
+def get_node_type_id(G,node_id):
+    return G.nodes[node_id]['type_id']
+
 def get_reaches(G):
     return get_node_type_ids(G, node_type = 'RCHRES')
     
@@ -259,8 +303,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 +344,48 @@ 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 +471,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 +502,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
@@ -435,10 +524,20 @@ class reachNetwork():
         self.routing_reaches = self._routing_reaches()
         self.lakes = self._lakes()
         self.schematic = uci.table('SCHEMATIC').astype({'TVOLNO': int, "SVOLNO": int, 'AFACTR':float})
-    
+        #self.subwatersheds = self._subwatersheds(self.uci)
+
     def get_node_type_ids(self,node_type):
         return get_node_type_ids(self.G, node_type)
     
+    def watershed_outlets(self):
+        reach_ids = []
+        for reach_id in self.get_node_type_ids('RCHRES'):
+            upstream = self.upstream(reach_id)
+            reach_ids.append([reach_id])
+            if len(upstream) > 1:
+                reach_ids.append(upstream)
+        return reach_ids
+
     def _upstream(self,reach_id,node_type = 'RCHRES'):
         '''
         Returns list of model reaches upstream of inclusive of reach_id
@@ -457,8 +556,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 +585,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 +627,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 +654,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')
@@ -617,6 +704,7 @@ def subwatersheds(uci):
     
     df = pd.concat(dfs).reset_index()
     df = df.set_index('TVOLNO')
+    
     return df
 
 def subwatershed(uci,reach_id):

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,