hspf 2.1.2__py3-none-any.whl → 2.1.3__py3-none-any.whl

hspf/hbn.py

@@ -6,7 +6,7 @@ nutrients relevant for our current calibration methods. (See calibration_helpers
 
 @author: mfratki
 """
-from . import helpers
+from hspf import helpers
 import pandas as pd
 import math
 from struct import unpack
@@ -14,6 +14,7 @@ from numpy import fromfile
 from pandas import DataFrame
 from datetime import datetime, timedelta #, timezone
 from collections import defaultdict
+from collections.abc import MutableMapping
 #from pathlib import Path
 
 
@@ -189,11 +190,30 @@ class hbnInterface:
     def _clear_cache(self):
         [hbn._clear_cache() for hbn in self.hbns]
         
+
+        
     def get_time_series(self, t_opn, t_cons, t_code, opnid, activity = None):
-        return pd.concat([hbn.get_time_series(t_opn, t_cons, t_code, opnid, activity) for hbn in self.hbns],axis = 1)
+        df = pd.concat([hbn._get_time_series(t_opn, t_cons, t_code, opnid, activity) for hbn in self.hbns],axis = 1)
+        if df.empty:
+            raise ValueError(f"No data found for {t_opn} {t_cons} {t_code} {opnid} {activity}")
+        
+        if long_format:
+            df = df.reset_index().melt(id_vars = ['index'],var_name = 'OPNID',value_name = t_con)
+            df.rename(columns = {'index':'datetime'},inplace = True)
+            df['OPERATION'] = t_opn
+        return df
+        
+    def get_multiple_timeseries(self,t_opn,t_code,t_con,opnids = None,activity = None,axis = 1,long_format = False):
+        df = pd.concat([hbn._get_multiple_timeseries(t_opn,t_code,t_con,opnids,activity) for hbn in self.hbns],axis = 1)
+        if df.empty:
+            raise ValueError(f"No data found for {t_opn} {t_con} {t_code} {opnids} {activity}")
         
-    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)
+        if long_format:
+            df = df.reset_index().melt(id_vars = ['index'],var_name = 'OPNID',value_name = 'value')
+            df.rename(columns = {'index':'datetime'},inplace = True)
+            df['TIMESERIES'] = t_con
+            df['OPERATION'] = t_opn
+        return df
 
     def get_perlnd_constituent(self,constituent,perlnd_ids = None,time_step = 5):
         return get_simulated_perlnd_constituent(self,constituent,time_step)
@@ -217,13 +237,33 @@ class hbnInterface:
         # for dic in dics:
         #     for key, vals in dic.items():
         #         [dd[key].append(val) for val in vals]
-        dd = defaultdict(set)    
+        # dd = defaultdict(set)    
         dics =  [hbn.output_names() for hbn in self.hbns]
+        return merge_dicts(dics)
+        # for dic in dics:
+        #     for operation, vals in dic.items():
+        #         for activity,v in vals.items():
+        #             [dd[operation][activity].add(t) for t in v]
+        # return dd
+
+    def _timeseries(self):
+        mapn = self._mapn()
+        timeseries = []
+        for key, vals in mapn.items():
+            _key = list(key)
+            for val in vals:
+                timeseries.append(_key + [val])
+        return timeseries      
+            
+
+    def _mapn(self):
+        dd = defaultdict(set)    
+        dics =  [hbn.mapn for hbn in self.hbns]
         for dic in dics:
             for key, vals in dic.items():
                 [dd[key].add(val) for val in vals]
-        return dd
-
+        return dd 
+    
     def get_perlnd_data(self,constituent,t_code = 'yearly'):
         t_cons = helpers.get_tcons(constituent,'PERLND')
         
@@ -236,14 +276,13 @@ class hbnInterface:
         return df
          
           
-    def get_rchres_data(self,constituent,reach_ids,units = 'mg/l',t_code = 'daily'):
+    def get_rchres_output(self,constituent,units = 'mg/l',t_code = 5):
         '''
         Convience function for accessing the hbn time series associated with our current
         calibration method. Assumes you are summing across all dataframes.
        '''
-        
-        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
+        t_cons = helpers.get_tcons(constituent,'RCHRES',units)
+        df = sum([self.get_multiple_timeseries('RCHRES',t_code,t_con) for t_con in t_cons])
         df.attrs['unit'] = units
         df.attrs['constituent'] = constituent
         return df
@@ -399,19 +438,27 @@ class hbnClass:
     def infer_opnids(self,t_opn, t_cons,activity):
         result = [k[-2] for k,v in self.mapn.items() if (t_cons in v) & (k[0] == t_opn) & (k[-1] == activity)]
         if len(result) == 0:
-            return print('No Constituent-OPNID relationship found')
+            result = [-1]
+        #     return print('No Constituent-OPNID relationship found')
         return result
     
     
     def infer_activity(self,t_opn, t_cons):  
         result = [k[-1] for k,v in self.mapn.items() if (t_cons in v) & (k[0] == t_opn)]
         if len(result) == 0:
-            return print('No Constituent-Activity relationship found')
-        assert(len(set(result)) == 1)
-        return result[0]
-    
+            result = ''
+        else:#     return print('No Constituent-Activity relationship found')
+            assert(len(set(result)) == 1)
+            result = result[0]
+        return result
     
     def get_time_series(self, t_opn, t_cons, t_code, opnid, activity = None):
+        df = self._get_time_series(t_opn, t_cons, t_code, opnid, activity)
+        if df.empty:
+            raise ValueError(f"No data found for {t_opn} {t_cons} {t_code} {opnid} {activity}")
+        return df
+
+    def _get_time_series(self, t_opn, t_cons, t_code, opnid, activity = None):
         """
         get a single time series based on:
         1.      t_opn: RCHRES, IMPLND, PERLND
@@ -420,13 +467,15 @@ class hbnClass:
         4. t_activity: HYDR, IQUAL, etc
         5.  time_unit: yearly, monthly, full (default is 'full' simulation duration)
         """
+
+
         if isinstance(t_code,str):
             t_code = self.tcodes[t_code]
         
         if activity is None:
             activity = self.infer_activity(t_opn,t_cons)        
-            if activity is None:
-                return None
+
+            
         summaryindx = f'{t_opn}_{activity}_{opnid:03d}_{t_code}'
         if summaryindx in self.summaryindx:
             df = self.data_frames[summaryindx][t_cons].copy()
@@ -438,25 +487,31 @@ class hbnClass:
             #df.index = df.index.shift(-1,TCODES2FREQ[t_code])
             df = df[df.index >= '1996-01-01']
         else:
-            df = None
+            df = pd.DataFrame()
             
         return df
+    
     def get_multiple_timeseries(self,t_opn,t_code,t_con,opnids = None,activity = None):
+        df = self._get_multiple_timeseries(t_opn,t_code,t_con,opnids,activity)
+        if df.empty:
+            raise ValueError(f"No data found for {t_opn} {t_con} {t_code} {opnids} {activity}")
+        return df
+    
+    def _get_multiple_timeseries(self,t_opn,t_code,t_con,opnids = None,activity = None):
         # a single constituent but multiple opnids
+
+        
         if isinstance(t_code,str):
             t_code = self.tcodes[t_code]
             
         if activity is None:
-            activity = self.infer_activity(t_opn,t_con)
-            if activity is None:
-                return None
-           
+            activity = self.infer_activity(t_opn,t_con)   
+
         if opnids is None:
             opnids = self.infer_opnids(t_opn,t_con,activity)
-            if opnids is None:
-                return None 
+
            
-        df = None
+        df = pd.DataFrame()
         frames = []
         mapd_list = list(self.mapd.keys())
         for opnid in opnids:
@@ -475,9 +530,76 @@ class hbnClass:
             dic[activity] = set([item for sublist in t_cons for item in sublist])
         return dic
     
+
+    def output_names(self):
+
+        activities = []
+        operations = []
+        for k, v in self.mapn.items():
+            operations.append(k[0])
+            activities.append(k[-1])
+
+        operations = set(operations)
+        activities = set(activities)
+        #activities = set([k[-1] for k,v in self.mapn.items()])
+
+        dic = {}
+        for operation in operations:
+            acitivities = set([k[-1] for k,v in self.mapn.items() if k[0] == operation])
+            dic[operation] = {}
+            for activity in acitivities:
+                t_cons = [v for k,v in self.mapn.items() if (k[0] == operation) & (k[-1] == activity)]   
+                dic[operation][activity] = set([item for sublist in t_cons for item in sublist])
+        # for activity in activities:
+        #     t_cons = [v for k,v in self.mapn.items() if k[-1] == activity]   
+        #     dic[activity] = set([item for sublist in t_cons for item in sublist])
+        return dic
+    
+    def get_timeseries(self):
+        mapn = self.mapn
+        timeseries = []
+        for key, vals in mapn.items():
+            _key = list(key)
+            for val in vals:
+                timeseries.append(_key + [val])
+        return timeseries      
+
     @staticmethod          
     def get_perlands(summary_indxs):
          perlands =  [int(summary_indx.split('_')[-2]) for summary_indx in summary_indxs]
          return perlands
      
- 
+
+def merge_dicts(dicts):
+    """
+    Merge a list of dictionaries into a single dictionary, combining sets
+    at the leaf level and properly merging nested dictionaries.
+    
+    Args:
+        dicts (list): A list of dictionaries to merge.
+    
+    Returns:
+        dict: The merged dictionary.
+    """
+    def recursive_merge(d1, d2):
+        for key, value in d2.items():
+            if key in d1:
+                # If the value is a dictionary, recurse
+                if isinstance(d1[key], MutableMapping) and isinstance(value, MutableMapping):
+                    recursive_merge(d1[key], value)
+                # If the value is a set, merge the sets
+                elif isinstance(d1[key], set) and isinstance(value, set):
+                    d1[key].update(value)
+                else:
+                    raise ValueError(f"Incompatible types for key '{key}': {type(d1[key])} vs {type(value)}")
+            else:
+                # If the key does not exist in d1, copy it
+                d1[key] = value
+    
+    # Start with an empty dictionary
+    merged_dict = {}
+    
+    for d in dicts:
+        recursive_merge(merged_dict, d)
+    
+    return merged_dict

hspf/hspfModel.py

@@ -7,17 +7,19 @@ Created on Thu Oct 13 09:26:05 2022
 from pathlib import Path
 import os.path
 import subprocess
+import concurrent.futures
 
-from .uci import UCI
-from . import hbn
-from .reports import Reports
-from .wdm import wdmInterface
-from . import wdmReader
+from hspf.uci import UCI
+from hspf import hbn
+from hspf.reports import Reports
+from hspf.wdm import wdmInterface
+from hspf import wdmReader
 
 
 
 
 
+winHSPF = str(Path(__file__).resolve().parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'
 
 
 # Only for accessing information regarding a specific uci_file
@@ -51,6 +53,15 @@ class hspfModel():
         # Compositions
         self.reports = Reports(self.uci,self.hbns,self.wdms)
         
+    def _reinitialize(self,uci_file:str,run_model:bool = False):
+        self.uci = UCI(uci_file)
+        self.validate_uci(run_model = run_model)
+        self.hbns = hbn.hbnInterface(self.hbn_paths)
+        try:
+            self.wdms = wdmInterface(self.wdm_paths)
+        except:
+            self.wdms = None
+        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
@@ -92,15 +103,16 @@ class hspfModel():
         else:
             self.run_model()
 
-    def run_model(self,new_uci_file = None):
+    def run_model(self,new_uci_file = None,):
         
         if new_uci_file is None:
             new_uci_file = self.uci_file
         
         # 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,run_model = False)
+
+        subprocess.run([winHSPF,self.uci_file.as_posix()]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
+        self._reinitialize(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())
@@ -177,8 +189,35 @@ class hspfModel():
 
 
 
+def run_uci(uci_file:str, ):
+    """
+    convenience function to run a single model uci file.
+    """
+    print(f"Starting model: {uci_file}")
+    subprocess.run([winHSPF, uci_file]) 
+    print(f"Completed model: {uci_file}")
 
 
+def run_batch_files(file_list, max_concurrent=4):
+    """
+    Takes a list of .uci file paths and runs them N at a time.
+    """
+    # Create a pool of workers (threads)
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_concurrent) as executor:
+        # Submit all jobs to the pool
+        future_to_file = {
+            executor.submit(run_uci, uci_file): uci_file 
+            for uci_file in file_list
+        }
+        
+        # Monitor completion (optional, but good for error catching)
+        for future in concurrent.futures.as_completed(future_to_file):
+            uci_file = future_to_file[future]
+            try:
+                future.result() # This will raise exceptions if run_uci failed
+            except Exception as exc:
+                print(f"File {uci_file} generated an exception: {exc}")
+                
 
 # class runManager():
 #     def __init__()

hspf/parser/graph.py

@@ -635,7 +635,8 @@ class reachNetwork():
         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 = areas.groupby(['source_type','source_name']).sum()
+            #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
 

hspf/reports.py

@@ -25,8 +25,8 @@ class Reports():
         return scour(self.hbns,self.uci,start_year = start_year,end_year=end_year)
 
 # Hydrology Reports
-    def landcover_area(self):
-        return landcover_areas(self.uci)
+    def landcover_area(self,reach_ids,upstream_reach_ids = None):
+        return watershed_landcover_areas(self.uci,reach_ids,upstream_reach_ids)
     
     def annual_water_budget(self,operation):
         assert operation in ['PERLND','RCHRES','IMPLND']
@@ -36,10 +36,37 @@ class Reports():
             return annual_implnd_water_budget(self.uci,self.hbns)
         else:
             return annual_reach_water_budget(self.uci,self.hbns)
+
+    def annual_precip(self):
+        return avg_annual_precip(self.uci,self.wdms)
+    
+    def simulated_et(self):
+        return simulated_et(self.uci,self.hbns)
+    
+    def annual_perlnd_runoff(self,reach_ids = None,upstream_reach_ids = None,start_year = 1996,end_year = 2100):
+        if (reach_ids is None) and (upstream_reach_ids is None):
+            opnids = None
+        else:
+            opnids = self.uci.network.get_opnids('PERLND',reach_ids,upstream_reach_ids)
+        return annual_perlnd_runoff(self.uci,self.hbns,opnids,start_year,end_year)
+    
+    #% Catchment and Watershed Loading (Edge of Field Load) Reports 
+    # 
+    def average_annual_catchment_loading(self,constituent,by_landcover = False,start_year = 1996,end_year = 2100):
+        return average_annual_catchment_loading(self.uci,self.hbns,constituent,by_landcover = by_landcover,start_year = start_year,end_year = end_year)
+    
+    def average_monthly_catchment_loading(self,constituent,by_landcover = False,start_year = 1996,end_year = 2100):
+        return average_monthly_catchment_loading(self.uci,self.hbns,constituent,by_landcover = by_landcover,start_year = start_year,end_year = end_year)
+    
+    def average_annual_watershed_loading(self,constituent,reach_ids,upstream_reach_ids = None, start_year = 1996, end_year = 2100, by_landcover = False,drainage_area = None):
+        return average_annual_watershed_loading(self.uci,self.hbns,constituent,reach_ids,upstream_reach_ids, start_year, end_year, by_landcover,drainage_area)
+    
+    def average_monthly_watershed_loading(self,constituent,reach_ids,upstream_reach_ids = None, start_year = 1996, end_year = 2100, by_landcover = False,drainage_area = None):
+        return average_monthly_watershed_loading(self.uci,self.hbns,constituent,reach_ids,upstream_reach_ids, start_year, end_year, by_landcover,drainage_area)
         
     def watershed_loading(self,constituent,reach_ids,upstream_reach_ids = None,by_landcover = False):
         '''
-        Calculate the loading to channels from a watershed.
+        Calculate the edge of field loading to channels from each catchment within the watershed defined by reach_ids and upstream_reach_ids.
         
         Parameters
         ----------
@@ -57,40 +84,40 @@ class Reports():
     def catchment_loading(self,constituent,by_landcover = False):
         return get_catchment_loading(self.uci,self.hbns,constituent,by_landcover)
     
+    # def average_annual_subwatershed_loading(self,constituent):
+    #     return ann_avg_subwatershed_loading(constituent,self.uci, self.hbns)
+    
+    # def average_annual_watershed_loading(self,constituent,reach_ids):
+    #     landcovers = ann_avg_watershed_loading(constituent,reach_ids,self.uci, self.hbns, True)
+    #     total = ann_avg_watershed_loading(constituent,reach_ids,self.uci, self.hbns, False)
+    #     total.index = ['Total']
+    #     total = pd.concat([landcovers,total])
+    #     total['volume'] = total['area']*total[f'weighted_mean_{constituent}']
+    #     total['volume_percent'] = total['volume']/total.loc['Total','volume']*100
+    #     total['area_percent'] = total['area']/total.loc['Total','area']*100
+    #     total['share'] = total['volume_percent']/total['area_percent']
+    #     return total
+    # Contributions Reports
     def contributions(self,constituent,target_reach_id):
         return total_contributions(constituent,self.uci,self.hbns,target_reach_id)
 
     def landcover_contributions(self,constituent,target_reach_id,landcover = None):
         return catchment_contributions(self.uci,self.hbns,constituent,target_reach_id)
     
-    def ann_avg_subwatershed_loading(self,constituent):
-        return ann_avg_subwatershed_loading(constituent,self.uci, self.hbns)
-    
-    def ann_avg_watershed_loading(self,constituent,reach_ids):
-        landcovers = ann_avg_watershed_loading(constituent,reach_ids,self.uci, self.hbns, True)
-        total = ann_avg_watershed_loading(constituent,reach_ids,self.uci, self.hbns, False)
-        total.index = ['Total']
-        total = pd.concat([landcovers,total])
-        total['volume'] = total['area']*total[f'weighted_mean_{constituent}']
-        total['volume_percent'] = total['volume']/total.loc['Total','volume']*100
-        total['area_percent'] = total['area']/total.loc['Total','area']*100
-        total['share'] = total['volume_percent']/total['area_percent']
-        return total
+    # Landscape Yield Reports
   
-    def ann_avg_yield(self,constituent,reach_ids,upstream_reach_ids = None):
-        df= avg_ann_yield(self.uci,self.hbns,constituent,reach_ids,upstream_reach_ids)
+    def average_annual_yield(self,constituent,reach_ids,upstream_reach_ids = None,start_year = 1996,end_year = 2100):
+        df= average_annual_yield(self.uci,self.hbns,constituent,reach_ids,upstream_reach_ids,start_year,end_year)
+        return df
+
+    def average_monthly_yield(self,constituent,reach_ids,upstream_reach_ids = None,start_year = 1996,end_year = 2100):
+        df= average_monthly_yield(self.uci,self.hbns,constituent,reach_ids,upstream_reach_ids,start_year,end_year)
         return df
     
-    def annual_precip(self):
-        return avg_annual_precip(self.uci,self.wdms)
-    
-    def simulated_et(self):
-        return simulated_et(self.uci,self.hbns)
-    
- 
+
 
 #%% Channel Reports    
-def scour(hbn,uci,start_year = '1996',end_year = '2030'):
+def scour(hbn,uci,start_year = 1996,end_year = 2030):
     # Should eventually create an entire reports module or class indorder to calculate all of the different model checks
     # TODO: Incorporate IMPLNDS
     schematic = uci.table('SCHEMATIC').copy()
@@ -103,7 +130,7 @@ def scour(hbn,uci,start_year = '1996',end_year = '2030'):
                                                      activity = 'SEDMNT',
                                                      t_code = 'yearly',
                                                      opnids = None)
-    sosed = sosed.loc[(sosed.index > start_year) & (sosed.index < end_year)].mean().rename('mean').to_frame()
+    sosed = sosed.loc[(sosed.index.year >= start_year) & (sosed.index.year <= end_year)].mean().rename('mean').to_frame()
 
     sosld =  hbn.get_multiple_timeseries(t_opn = 'IMPLND',
                                              t_con = 'SOSLD',
@@ -124,7 +151,7 @@ def scour(hbn,uci,start_year = '1996',end_year = '2030'):
     scour_report = []
     # schematic block will have all the possible perlands while sosed only has perlands that were simulated
     # in other words information from sosed is a subset of schematic
-    for tvolno in lakeflag.index: #schematic['TVOLNO'].unique():
+    for tvolno in lakeflag.index.intersection(uci.opnid_dict['RCHRES'].index): #schematic['TVOLNO'].unique():
         implnd_load = 0
         prlnd_load = 0
         reach_load = depscr.loc[tvolno].values[0]
@@ -171,43 +198,91 @@ def get_catchments(uci,reach_ids):
     
 
 
-#%% Landscape Yields
+#%% Constituent Loads
 
-def yield_flow(uci,hbn,constituent,reach_id):
-    hbn.get_rchres_data('Q',reach_id,'cfs','yearly')/uci.network.drainage_area(reach_id)
+def _constituent_load(hbn,constituent,time_step = 5):
+    #reach_ids = uci.network.G.nodes
+    if constituent == 'Q':
+        units = 'acrft'
+    else:
+        units = 'lb'
 
+    df = hbn.get_rchres_output(constituent,units,time_step)
 
-def yield_sediment(uci,hbn,constituent,reach_id):
-    hbn.get_rchres_data('TSS',reach_id,'lb','yearly').mean()*2000/uci.network.drainage_area(reach_id)
+    return df
 
-def avg_ann_yield(uci,hbn,constituent,reach_ids,upstream_reach_ids = None):
+def constituent_load(hbn,constituent,reach_ids,time_step = 5,upstream_reach_ids = None):
     #reach_ids = uci.network.G.nodes
-    
-    reach_ids = uci.network.get_opnids('RCHRES',reach_ids,upstream_reach_ids)
-    area = uci.network.drainage_area(reach_ids,upstream_reach_ids)
-    
     if constituent == 'Q':
         units = 'acrft'
     else:
         units = 'lb'
+
+    upstream_load = 0
+    if upstream_reach_ids is not None:
+        upstream_load = constituent_load(hbn,constituent,upstream_reach_ids,time_step)
+
+    df = hbn.get_reach_constituent(constituent,reach_ids,time_step,unit =units) - upstream_load
+
+    return df
+
+#%% Landscape Yields
+
+def _constituent_yield(uci,hbn,constituent,time_step = 5):
+    df = _constituent_load(hbn,constituent,time_step)
+
+    areas = [uci.network.drainage_area([reach_id]) for reach_id in df.columns]
+    return df/areas
+
+def constituent_yield(uci,hbn,constituent,reach_ids,time_step = 5,upstream_reach_ids = None,drainage_area = None):
+    #reach_ids = uci.network.G.nodes
+
+    if drainage_area is None:
+        drainage_area = uci.network.drainage_area(reach_ids,upstream_reach_ids)
+
+    df = constituent_load(hbn,constituent,reach_ids,time_step,upstream_reach_ids)/drainage_area
         
-    df = hbn.get_reach_constituent(constituent,reach_ids,5,unit =units).mean() # Gross
+    return df
+
+def average_annual_yield(uci,hbn,constituent,reach_ids,upstream_reach_ids = None,start_year = 1996,end_year = 2100,drainage_area = None): 
+    df = constituent_yield(uci,hbn,constituent,reach_ids,5,upstream_reach_ids,drainage_area)
+    df = df.loc[(df.index.year >= start_year) & (df.index.year <= end_year)].mean()
+    return df
+
+def average_monthly_yield(uci,hbn,constituent,reach_ids,upstream_reach_ids = None,start_year = 1996,end_year = 2100,drainage_area = None): 
+    df = constituent_yield(uci,hbn,constituent,reach_ids,4,upstream_reach_ids,drainage_area)
+    df = df.loc[(df.index.year >= start_year) & (df.index.year <= end_year)]
+    df = df.groupby(df.index.month).mean()
+    return df
+
 
-    return df/area
 
-#%% Catchment and Watershed Loading
+#%% Catchment and Watershed Loading (Edge of Field Load)
  
-def landcover_areas(uci):
-    df = uci.network.operation_area('PERLND').groupby('LSID').sum()    
-    df['percent'] = 100*(df['AFACTR']/df['AFACTR'].sum())
+def watershed_landcover_areas(uci,reach_ids,upstream_reach_ids = None):
+    df = uci.network.drainage_area_landcover(reach_ids,upstream_reach_ids,group=True).reset_index()
+    df['percent'] = 100*(df['area']/df['area'].sum())
     return df
 
+def catchment_landcover_areas(uci,reach_ids = None):
+    df = uci.network.subwatersheds().reset_index()[['TVOLNO','SVOL','LSID','AFACTR']]
+    df.rename(columns = {'AFACTR':'area',
+                         'TVOLNO':'catchment_id',
+                         'LSID':'landcover',
+                         'SVOL':'landcover_type'},inplace = True)
+    if reach_ids is not None:
+        df = df.loc[df['catchment_id'].isin(reach_ids)]
+    return df
+
+
+
 def catchment_areas(uci):
     df = uci.network.subwatersheds().reset_index()
     df = df.groupby('TVOLNO')['AFACTR'].sum().reset_index()
     df.rename(columns = {'AFACTR':'catchment_area'},inplace = True)
     return df
 
+
 def get_constituent_loading(uci,hbn,constituent,time_step = 5):
 
     
@@ -237,42 +312,170 @@ def get_constituent_loading(uci,hbn,constituent,time_step = 5):
     # df['time_step'] = time_step
     # df['year'] = pd.DatetimeIndex(df['datetime']).year
     # df['month'] = pd.DatetimeIndex(df['datetime']).month
+    return df
+
+
+    # subwatersheds = uci.network.subwatersheds().reset_index()
+    # subwatersheds = subwatersheds.loc[subwatersheds['SVOL'].isin(['PERLND','IMPLND'])]
+    # areas = catchment_areas(uci)
+
+    # df = pd.merge(subwatersheds,df,left_on = ['SVOL','SVOLNO'], right_on=['OPERATION','OPNID'],how='right')
+    # df = pd.merge(df,areas,left_on = ['TVOLNO'], right_on='TVOLNO',how='left')
+    # df['load'] = df['value']*df['AFACTR']
+    # df = df.rename(columns = {'value':'loading_rate', 'AFACTR':'landcover_area','LSID':'landcover'})
+    # df['constituent'] = constituent
+    # return df[['index','constituent','TVOLNO','SVOLNO','SVOL','landcover','landcover_area','catchment_area','loading_rate','load']]
+def _join_catchments(df,uci,constituent):
+    subwatersheds = uci.network.subwatersheds().reset_index()
+    subwatersheds = subwatersheds.loc[subwatersheds['SVOL'].isin(['PERLND','IMPLND'])]
+    areas = catchment_areas(uci)
+
+    df = pd.merge(
+        subwatersheds, df,
+        left_on=['SVOL', 'SVOLNO'],
+        right_on=['OPERATION', 'OPNID'],
+        how='inner'
+    )
+    df = pd.merge(df, areas, on='TVOLNO', how='left')
+    
+    df['load'] = df['value'] * df['AFACTR']
+    df = df.rename(columns={
+        'value': 'loading_rate',
+        'AFACTR': 'landcover_area',
+        'LSID': 'landcover'
+    })
+    df['constituent'] = constituent
+    return df
+
+def get_catchment_loading(uci,hbn,constituent,time_step=5,by_landcover = False):
+    df = get_constituent_loading(uci,hbn,constituent,time_step)
+    
+    subwatersheds = uci.network.subwatersheds().reset_index()
+    subwatersheds = subwatersheds.loc[subwatersheds['SVOL'].isin(['PERLND','IMPLND'])]
+    areas = catchment_areas(uci)
+
+
+    df = pd.merge(subwatersheds,df,left_on = ['SVOL','SVOLNO'], right_on=['OPERATION','OPNID'],how='inner')
+    df = pd.merge(df,areas,left_on = ['TVOLNO'], right_on='TVOLNO',how='left')
+    df['load'] = df['value']*df['AFACTR']
+    df = df.rename(columns = {'value':'loading_rate', 'AFACTR':'landcover_area','LSID':'landcover'})
+    df['constituent'] = constituent
+    df = df[['index','constituent','TVOLNO','SVOLNO','SVOL','landcover','landcover_area','catchment_area','loading_rate','load']]
+    return df
+
+
 
+def get_watershed_loading(uci,hbn,reach_ids,constituent,upstream_reach_ids = None,by_landcover = False,time_step = 5):
+    '''
+    Edge of field loading for all catchments within a watershed defined by reach_ids and upstream_reach_ids
+    
+    
+    '''
+    reach_ids = uci.network.get_opnids('RCHRES',reach_ids,upstream_reach_ids)
+
+    df = get_catchment_loading(uci,hbn,constituent,time_step)
+    df = df.loc[df['TVOLNO'].isin(reach_ids)]
+    return df
+
+
+def average_annual_constituent_loading(uci,hbn,constituent,start_year = 1996,end_year = 2100):
+    df = get_constituent_loading(uci,hbn,constituent,time_step=5)
+    df = df.loc[(df['index'].dt.year >= start_year) & (df['index'].dt.year <= end_year)]
+    df['year'] = df['index'].dt.year
+    df = df.groupby(['OPERATION','OPNID'])['value'].mean().reset_index()
+    return df
+
+def average_monthly_constituent_loading(uci,hbn,constituent,start_year = 1996,end_year = 2100):
+    df = get_constituent_loading(uci,hbn,constituent,time_step=4)
+    df = df.loc[(df['index'].dt.year >= start_year) & (df['index'].dt.year <= end_year)]
+    df['month'] = df['index'].dt.month
+    df = df.groupby(['month','OPERATION','OPNID'])['value'].mean().reset_index()
+    return df
+
+def average_annual_catchment_loading(uci,hbn,constituent,start_year = 1996,end_year = 2100,by_landcover = False):
+    df = average_annual_constituent_loading(uci,hbn,constituent,start_year,end_year)    
 
     subwatersheds = uci.network.subwatersheds().reset_index()
     subwatersheds = subwatersheds.loc[subwatersheds['SVOL'].isin(['PERLND','IMPLND'])]
     areas = catchment_areas(uci)
 
-    df = pd.merge(subwatersheds,df,left_on = ['SVOL','SVOLNO'], right_on=['OPERATION','OPNID'],how='right')
+
+    df = pd.merge(subwatersheds,df,left_on = ['SVOL','SVOLNO'], right_on=['OPERATION','OPNID'],how='inner')
     df = pd.merge(df,areas,left_on = ['TVOLNO'], right_on='TVOLNO',how='left')
     df['load'] = df['value']*df['AFACTR']
     df = df.rename(columns = {'value':'loading_rate', 'AFACTR':'landcover_area','LSID':'landcover'})
     df['constituent'] = constituent
-    return df[['index','constituent','TVOLNO','SVOLNO','SVOL','landcover','landcover_area','catchment_area','loading_rate','load']]
+    df = df[['constituent','TVOLNO','SVOLNO','SVOL','landcover','landcover_area','catchment_area','loading_rate','load']]
 
 
-def get_catchment_loading(uci,hbn,constituent,by_landcover = False):
-    df = get_constituent_loading(uci,hbn,constituent)
-    if not by_landcover:
-        df = df.groupby(['TVOLNO','constituent'])[['landcover_area','load']].sum().reset_index()
+    if by_landcover:
+        df = df.groupby(['TVOLNO','landcover','constituent'])[['landcover_area','load']].sum().reset_index()
         df['loading_rate'] = df['load']/df['landcover_area']
+    else:
+        df = df.groupby(['TVOLNO','constituent','catchment_area'])[['load']].sum().reset_index()
+        df['loading_rate'] = df['load']/df['catchment_area']
     return df
 
-def get_watershed_loading(uci,hbn,reach_ids,constituent,upstream_reach_ids = None,by_landcover = False):
-    reach_ids = uci.network.get_opnids('RCHRES',reach_ids,upstream_reach_ids)
+def average_monthly_catchment_loading(uci,hbn,constituent,start_year = 1996,end_year = 2100,by_landcover = False):  
+    df = average_monthly_constituent_loading(uci,hbn,constituent,start_year,end_year)    
+
+    subwatersheds = uci.network.subwatersheds().reset_index()
+    subwatersheds = subwatersheds.loc[subwatersheds['SVOL'].isin(['PERLND','IMPLND'])]
+    areas = catchment_areas(uci)
 
-    df = get_constituent_loading(uci,hbn,constituent)
+
+    df = pd.merge(subwatersheds,df,left_on = ['SVOL','SVOLNO'], right_on=['OPERATION','OPNID'],how='inner')
+    df = pd.merge(df,areas,left_on = ['TVOLNO'], right_on='TVOLNO',how='left')
+    df['load'] = df['value']*df['AFACTR']
+    df = df.rename(columns = {'value':'loading_rate', 'AFACTR':'landcover_area','LSID':'landcover'})
+    df['constituent'] = constituent
+    df = df[['month','constituent','TVOLNO','SVOLNO','SVOL','landcover','landcover_area','catchment_area','loading_rate','load']]
+
+
+    if by_landcover:
+        df = df.groupby(['month','TVOLNO','landcover','constituent'])[['landcover_area','load']].sum().reset_index()
+        df['loading_rate'] = df['load']/df['landcover_area']
+    else:
+        df = df.groupby(['month','TVOLNO','constituent','catchment_area'])[['load']].sum().reset_index()
+        df['loading_rate'] = df['load']/df['catchment_area']
+    return df
+
+
+
+def average_annual_watershed_loading(uci,hbn,constituent,reach_ids, upstream_reach_ids = None, start_year = 1996, end_year = 2100, by_landcover = False,drainage_area = None):
+    df = average_annual_catchment_loading(uci,hbn,constituent,by_landcover = by_landcover,start_year = start_year,end_year = end_year)
+    reach_ids = uci.network.get_opnids('RCHRES',reach_ids,upstream_reach_ids)
     df = df.loc[df['TVOLNO'].isin(reach_ids)]
+    if drainage_area is None:
+        df['watershed_area'] = uci.network.drainage_area(reach_ids,upstream_reach_ids) #df.drop_duplicates(subset=['TVOLNO'])['catchment_area'].sum()
+    else:
+        df['watershed_area'] = drainage_area
 
     if by_landcover:
         df = df.groupby(['landcover','constituent'])[['landcover_area','load']].sum().reset_index()
         df['loading_rate'] = df['load']/df['landcover_area']
     else:
-        df = df.groupby(['constituent'])[['landcover_area','load']].sum().reset_index()
-        df['loading_rate'] = df['load']/df['landcover_area']
+        df = df.groupby(['constituent','watershed_area'])[['load']].sum().reset_index()
+        df['loading_rate'] = df['load']/df['watershed_area']
 
     return df
 
+def average_monthly_watershed_loading(uci,hbn,constituent,reach_ids, upstream_reach_ids = None, start_year = 1996, end_year = 2100, by_landcover = False,drainage_area = None):
+    df = average_monthly_catchment_loading(uci,hbn,constituent,by_landcover = by_landcover,start_year = start_year,end_year = end_year)
+    reach_ids = uci.network.get_opnids('RCHRES',reach_ids,upstream_reach_ids)
+    df = df.loc[df['TVOLNO'].isin(reach_ids)]
+    if drainage_area is None:
+        df['watershed_area'] = uci.network.drainage_area(reach_ids,upstream_reach_ids) #df.drop_duplicates(subset=['TVOLNO'])['catchment_area'].sum()
+    else:
+        df['watershed_area'] = drainage_area
+
+    if by_landcover:
+        df = df.groupby(['month','TVOLNO','landcover','constituent'])[['landcover_area','load']].sum().reset_index()
+        df['loading_rate'] = df['load']/df['landcover_area']
+    else:
+        df = df.groupby(['month','constituent','watershed_area'])['load'].sum().reset_index()
+        df['loading_rate'] = df['load']/df['watershed_area']
+    return df
 
 #%% Contributions
 allocation_selector = {'Q': {'input': ['IVOL'],
@@ -427,6 +630,7 @@ def weighted_describe(df, value_col, weight_col):
     # })
 
 
+
 def monthly_avg_constituent_loading(constituent,uci,hbn):
     dfs = []
     for t_opn in ['PERLND','IMPLND']:
@@ -729,9 +933,27 @@ def avg_annual_precip(uci,wdm):
 
 #%%
 #%%% Other Reports       
+# ts_names = ['PRECIP','PERO','AGWO','IFWO','SURO']
+# operation = 'PERLND'
+# t_code = 4
+# df = pd.concat([hbn.get_multiple_timeseries(operation,t_code,ts_name,opnids = opnids) for ts_name in ts_names],axis =0)
+# df = pd.merge(df,subwatershed.reset_index(),left_on = ['OPERATION','OPNID'],right_on = ['SVOL','SVOLNO'],how='inner')
+# df[['datetime','TVOLNO','OPERATION','OPNID','LSID','AFACTR','TIMESERIES','value']]
 
+# grouping_columns = ['TVOLNO','LSID','TIMESERIES']
+# df.groupby[grouping_columns]
 
+def weighted_output(uci,hbn,ts_name,operation = 'PERLND',t_code = 5,opnids = None):
+    df = hbn.get_multiple_timeseries(operation,t_code,ts_name,opnids = opnids)
 
+    subwatersheds = uci.network.subwatersheds().reset_index()
+    subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == operation]
+            
+          
+    df = pd.merge(subwatersheds,df,left_on = 'SVOLNO', right_on='SVOLNO',how='left')
+    df = weighted_mean(df,ts_name,'AFACTR')
+    df = df.set_index([df.index,'AFACTR'])
+    return df
 
 def weighted_mean(df,value_col,weight_col):
    weighted_mean = (df[value_col] * df[weight_col]).sum() / df[weight_col].sum()
@@ -739,9 +961,11 @@ def weighted_mean(df,value_col,weight_col):
        'AFACTR' : df[weight_col].sum(),
        value_col: [weighted_mean]})
                         
-def annual_weighted_output(uci,hbn,ts_name,operation = 'PERLND',t_code = 5,opnids = None,group_by = None):
+def annual_weighted_output(uci,hbn,ts_name,operation = 'PERLND',t_code = 5,opnids = None,group_by = None,start_year = 1996,end_year = 2100):
     assert (group_by in [None,'landcover','opnid'])
-    df = hbn.get_multiple_timeseries(operation,t_code,ts_name,opnids = opnids).mean().reset_index()
+    df = hbn.get_multiple_timeseries(operation,t_code,ts_name,opnids = opnids)
+    df = df.loc[(df.index.year >= start_year) & (df.index.year <= end_year)]   
+    df = df.mean().reset_index() 
     df.columns = ['SVOLNO',ts_name]
     subwatersheds = uci.network.subwatersheds().reset_index()
     subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == operation]
@@ -761,41 +985,41 @@ def annual_weighted_output(uci,hbn,ts_name,operation = 'PERLND',t_code = 5,opnid
     return df
 
                         
-def monthly_weighted_output(uci,hbn,ts_name,operation = 'PERLND',opnids = None, as_rate = False, by_landcover = True, months = [1,2,3,4,5,6,7,8,9,10,11,12]):
-    df = hbn.get_multiple_timeseries(operation,4,ts_name,opnids = opnids) 
-    df = df.loc[df.index.month.isin(months)]
+# def monthly_weighted_output(uci,hbn,ts_name,operation = 'PERLND',opnids = None, as_rate = False, by_landcover = True, months = [1,2,3,4,5,6,7,8,9,10,11,12]):
+#     df = hbn.get_multiple_timeseries(operation,4,ts_name,opnids = opnids) 
+#     df = df.loc[df.index.month.isin(months)]
 
-    areas = uci.network.operation_area(operation)
-    areas.loc[areas.index.intersection(df.columns)]
-    df = df[areas.index.intersection(df.columns)]
+#     areas = uci.network.operation_area(operation)
+#     areas.loc[areas.index.intersection(df.columns)]
+#     df = df[areas.index.intersection(df.columns)]
     
-    df = (df.groupby(df.index.month).mean()*areas['AFACTR'])
+#     df = (df.groupby(df.index.month).mean()*areas['AFACTR'])
 
-    if by_landcover:
-        df = df.T.groupby(areas['LSID']).sum().T
-        if as_rate:
-            df = df/areas['AFACTR'].groupby(areas['LSID']).sum().to_list()
-    else:
-        if as_rate:
-            df = df/areas['AFACTR'].sum()
+#     if by_landcover:
+#         df = df.T.groupby(areas['LSID']).sum().T
+#         if as_rate:
+#             df = df/areas['AFACTR'].groupby(areas['LSID']).sum().to_list()
+#     else:
+#         if as_rate:
+#             df = df/areas['AFACTR'].sum()
 
-    df.columns.name = ts_name
+#     df.columns.name = ts_name
 
-    return df
+#     return df
 
-def monthly_perlnd_runoff(uci,hbn):
-    ts_names = ['PRECIP','PERO','AGWO','IFWO','SURO']
-    df = pd.concat({ts_name:monthly_weighted_output(uci,hbn,ts_name,by_landcover=True,as_rate=True) for ts_name in ts_names},keys =ts_names)
-    suro_perc = (df.loc['SURO']/df.loc['PERO'])*100
-    suro_perc = suro_perc.reset_index()
-    suro_perc['name'] = 'SURO_perc'
-    suro_perc = suro_perc.set_index(['name','index'])
-    return pd.concat([df,suro_perc])
+# def monthly_perlnd_runoff(uci,hbn):
+#     ts_names = ['PRECIP','PERO','AGWO','IFWO','SURO']
+#     df = pd.concat({ts_name:monthly_weighted_output(uci,hbn,ts_name,by_landcover=True,as_rate=True) for ts_name in ts_names},keys =ts_names)
+#     suro_perc = (df.loc['SURO']/df.loc['PERO'])*100
+#     suro_perc = suro_perc.reset_index()
+#     suro_perc['name'] = 'SURO_perc'
+#     suro_perc = suro_perc.set_index(['name','index'])
+#     return pd.concat([df,suro_perc])
 
 
-def annual_perlnd_runoff(uci,hbn):
+def annual_perlnd_runoff(uci,hbn,opnids = None,start_year=1996,end_year=2100):
     ts_names = ['PRECIP','PERO','AGWO','IFWO','SURO']
-    df = pd.concat([annual_weighted_output(uci,hbn,ts_name,group_by='landcover') for ts_name in ts_names],axis = 1)
+    df = pd.concat([annual_weighted_output(uci,hbn,ts_name,group_by='landcover',opnids=opnids,start_year=start_year,end_year=end_year) for ts_name in ts_names],axis = 1)
     df.columns = ts_names
     df['suro_perc'] = (df['SURO']/df['PERO'])*100
     return df
@@ -860,48 +1084,6 @@ def annual_sediment_budget(uci,hbn):
     df.columns = ['Sediment','Percentage']
     return df
     
-# def annual_loading_rate():
-    
-    
-# def annual_yield(uci,hbn,constituent):
-    
-
-def subwatershed_weighted_output(uci,hbn,reach_ids,ts_name,time_step,by_landcover=False,as_rate = True):
-    subwatersheds = uci.network.subwatersheds(reach_ids)
-    subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == 'PERLND']
-    
-    areas = subwatersheds[['SVOLNO','AFACTR']].set_index('SVOLNO')
-    areas = areas.join( uci.table('PERLND','GEN-INFO')['LSID'])
-    opnids = subwatersheds['SVOLNO'].to_list()
-    
-    df = hbn.get_multiple_timeseries('PERLND',time_step,ts_name,opnids = opnids) 
-
-    areas.loc[areas.index.intersection(df.columns)]
-    df = df[areas.index.intersection(df.columns)]
-    
-    if by_landcover:
-        df = (df*areas['AFACTR'].values).T.groupby(areas['LSID']).sum()
-        if as_rate:
-            df = df.T/areas['AFACTR'].groupby(areas['LSID']).sum().to_list()
-        df.columns.name = ts_name
-    else:
-        df = (df * areas['AFACTR'].values).sum(axis=1)
-        if as_rate:
-            df = df/areas['AFACTR'].sum()
-        df.name = ts_name    
-        
-    return df
-            
-        
-    
-    
-
-# def perlnd_water_budget(uci,hbn,time_step = 5):
-    
-#     ts_names = ['SUPY','SURO','IFWO','AGWO','PERO','AGWI','IGWI','PET','UZET','LZET','AGWET','BASET','TAET']
-#     dfs = [area_weighted_output(uci,hbn,ts_name,time_step) for ts_name in ts_names]
-        
-    
 
 
 #%% Phosphorous Loading Calculations
@@ -946,11 +1128,15 @@ def total_phosphorous(uci,hbn,t_code,operation = 'PERLND'):
     totals = []
     for mlno in opnids['MLNO'].unique():
         total = dissolved_orthophosphate(uci,hbn,operation,mlno,t_code) + particulate_orthophosphate(uci,hbn,operation,mlno, t_code) + organic_refactory_phosphorous(uci,hbn,operation,mlno,t_code) + labile_oxygen_demand(uci,hbn,operation,mlno,t_code)*0.007326 # Conversation factor to P
-        if not isinstance(total,float): #TODO fix for when no data is present. Don't like this workaround.
-            totals.append(total[opnids['SVOLNO'].loc[opnids['MLNO'] == mlno].to_list()])
-    
-    total = pd.concat(totals,axis=1)
-    total = total.T.groupby(total.columns).sum().T
+        if isinstance(total, (int, float)): #TODO fix for when no data is present. Don't like this workaround.
+            pass
+        elif not total.empty:
+            valid_opnids = total.columns.intersection(opnids['SVOLNO'].loc[opnids['MLNO'] == mlno])
+            totals.append(total[valid_opnids])
+    
+    if len(totals) > 0:
+        total = pd.concat(totals,axis=1)
+        total = total.T.groupby(total.columns).sum().T
     return total
 
 
@@ -984,8 +1170,10 @@ def qualprop_transform(uci,hbn,operation,mlno,tmemn,tmemsb1,tmemsb2 = '',t_code
     masslink.fillna({'MFACTOR': 1}, inplace=True)
     ts = 0
     for index,row in masslink.iterrows():
-        hbn_name = uci.table(operation,'QUAL-PROPS', int(row['SMEMSB1']) - 1).iloc[0]['QUALID']
-        hbn_name = row['SMEMN'] + hbn_name
+        hbn_name = row['SMEMN']
+        if hbn_name in ['IOQUAL','SOQUAL','POQUAL','AOQUAL']:
+            qual_name = uci.table(operation,'QUAL-PROPS', int(row['SMEMSB1']) - 1).iloc[0]['QUALID']
+            hbn_name = row['SMEMN'] + qual_name
         mfactor = row['MFACTOR']
         ts = hbn.get_multiple_timeseries(row['SVOL'],t_code,hbn_name)*mfactor + ts
     return ts

hspf/uci.py

@@ -221,7 +221,7 @@ class UCI():
             for line in self.lines:    
                 the_file.write(line+'\n')
 
-    def add_parameter_template(self,block,table_name,table_id,parameter,tpl_char = '~'):
+    def add_parameter_template(self,block,table_name,table_id,parameter,tpl_char = '~',opnids = None,single_template = True, group_id = ''):
         
         table = self.table(block,table_name,0,False).reset_index()
         column_names,dtypes,starts,stops = self.uci[(block,table_name,table_id)]._delimiters()
@@ -229,20 +229,31 @@ class UCI():
         width = stops[column_names.index(parameter)] - starts[column_names.index(parameter)]
 
         ids = ~table[parameter].isna() # Handle comment lines in uci
+        parameter = parameter.lower()
+        if opnids is not None:
+            ids = ids & (table['OPNID'].isin(opnids))
 
         # Replace paramter name with PEST/PEST++ specification. Note this does not use the HSPF supplemental file so parameters are limited to width of uci file column
-        pest_param = tpl_char + parameter.lower() +  table.loc[ids,'OPNID'].astype(str)
-        pest_param = pest_param.apply(lambda name: name + ' '*(width-len(name)-1)+ tpl_char)
+        if single_template:
+            pest_param = group_id + parameter 
+            template = tpl_char + pest_param + ' '*(width-len(pest_param)-2)+ tpl_char
+            pest_param = [pest_param]
+        else:
+            pest_param = group_id + parameter +  table.loc[ids,'OPNID'].astype(str)
+            pest_param = pest_param.tolist()
+            template = [tpl_char + pest_param + ' '*(width-len(pest_param)-2)+ tpl_char for pest_param in pest_param]
+            #template = pest_param.apply(lambda name: tpl_char + name + ' '*(width-len(name)-1)+ tpl_char)
 
-        table.loc[ids,parameter] = pest_param
+        table.loc[ids,parameter.upper()] = template
         table = table.set_index('OPNID')
         self.replace_table(table,block,table_name,table_id)
+        return list(set(pest_param))
 
     def write_tpl(self,tpl_char = '~',new_tpl_path = None):    
         if new_tpl_path is None:
             new_tpl_path = self.filepath.parent.joinpath(self.filepath.stem + '.tpl')
         self.merge_lines()
-        self.lines.insert(0,tpl_char)
+        self.lines.insert(0,'ptf ' + tpl_char)
         self._write(new_tpl_path)
 
     def write(self,new_uci_path):

{hspf-2.1.2.dist-info → hspf-2.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hspf
-Version: 2.1.2
+Version: 2.1.3
 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.1.2.dist-info → hspf-2.1.3.dist-info}/RECORD

@@ -1,15 +1,15 @@
 hspf/Masslink_Timeseries.csv,sha256=TOV6PpR0SBI0FaAU1T-qyD2DyGsBFjUWZenvWXiS3wA,4985
 hspf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hspf/build_warehouse.py,sha256=y91vNmdt918H5_jx9nxMUVmRG9ORdChYWEqQbbi3YKs,22861
-hspf/hbn.py,sha256=g09tEQE196JA_f-4txISr3TA7aq98bv2SxEwNw0gkDA,19606
+hspf/hbn.py,sha256=-db1mC8m7MetQGQ8T_UZZW6KkbVwrVkKE4ub9Ji6i9M,24133
 hspf/hbn2.py,sha256=OmuTVDxd0Boyd3GvBgzEfqvP7CTeYIJYPC7EXPgYu30,13190
 hspf/hbn_cy.c,sha256=ZIJwWxyGx8fE5nM1HBd8-zNotmStGZscqXijl3KSRdI,593464
 hspf/hbn_cy.html,sha256=o8wMdvEE547DRXcUHFPgAkkyJ665b6rloGL-qKClaTo,137735
 hspf/hbn_cy.pyx,sha256=T-itpkvHlxHzQHKtJBS-M8_ToLBa1U_ajpV53hh_oI8,4323
 hspf/helpers.py,sha256=Jv5lSUKVqML8iJOFfBPcA3bgHn9MbFZC4OO-9YHHP_w,3277
-hspf/hspfModel.py,sha256=K_xF7HtuMpDMod56Z3IXDCeGsnUi8KGhly_9tm-mxoY,9070
-hspf/reports.py,sha256=UzEDkgrmUNncPHFzOkbYoGFUFXVlFuEu_BE0Nh_qhSw,46449
-hspf/uci.py,sha256=rsi_KJqdfBFp0rlKCHyhmQGdB_rgNE8k6abTjH26UqE,33982
+hspf/hspfModel.py,sha256=Dpf0VHWAdQ7N932u6aYzXDzZCPrJbObW38tP0WRkG0E,10682
+hspf/reports.py,sha256=cDhjMFrUAzU7zzoX4VPyCJvgVLObtApEWTkK1vFsKfQ,57304
+hspf/uci.py,sha256=mi5lkt2bZlO0Lq4S7j3uZsLpHhS6dtdOIaO2Vi0ZNn8,34607
 hspf/validations.py,sha256=BcNT0h5QDZW9lHpXk8KuHQvycl8a_4jQ91srwWFodRo,6666
 hspf/warehouse.py,sha256=12Scro1a_hK5IvE9FENAMQv9jKWgtMYtAftJZ4p3nTQ,12239
 hspf/wdm.py,sha256=q0hNqsMNrTkxHtKEX0q0wWlIZabXv6UX2HjNCF9WEW4,12734
@@ -48,8 +48,8 @@ hspf/data/Timeseries Catalog/RCHRES/OXRX.txt,sha256=NWdRFpJ60LsYzCGHjt8Llay3OI8j
 hspf/data/Timeseries Catalog/RCHRES/PLANK.txt,sha256=0MAehIrF8leYQt0Po-9h6IiujzoWOlw-ADCV-bPiqs0,3508
 hspf/data/Timeseries Catalog/RCHRES/SEDTRN.txt,sha256=SiTgD4_YWctTgEfhoMymZfv8ay74xzCRdnI005dXjyE,659
 hspf/parser/__init__.py,sha256=2HvprGVCaJ9L-egvTj1MI-bekq5CNjtSBZfrCtQi3fs,92
-hspf/parser/graph.py,sha256=jvkjz9eNtBFEmxUeQosuQE7XgsIRlrNH-rSny5KBDoE,33046
+hspf/parser/graph.py,sha256=un5B7PiiaG9aWQHFeD1gHZtlWIIUnx4GG_-IER-4SmU,33119
 hspf/parser/parsers.py,sha256=x3othxQogUmGNe_ctCU20atDrRM_B4lEbVJb3EMbwto,20850
-hspf-2.1.2.dist-info/METADATA,sha256=vjAn3jjlUlIIHBwJ43d-ut130cS-tR4QmmUwaAfFIa8,605
-hspf-2.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-hspf-2.1.2.dist-info/RECORD,,
+hspf-2.1.3.dist-info/METADATA,sha256=U-tcOOkBzPIgs2oMbnSdXznyT4oTU2lxvnneVSC5vvk,605
+hspf-2.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hspf-2.1.3.dist-info/RECORD,,