pyhcal 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

pyhcal/ERROR.FIL

@@ -0,0 +1,78 @@
+16:15:00.416 : LOG_MSG:ERROR.FIL OPENED
+16:15:00.417 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+16:15:00.417 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:06:13.144 : LOG_MSG:ERROR.FIL OPENED
+18:06:13.145 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:06:13.145 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:09:53.704 : LOG_MSG:ERROR.FIL OPENED
+18:09:53.705 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:09:53.705 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:19:02.896 : LOG_MSG:ERROR.FIL OPENED
+18:19:02.896 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:19:02.896 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:19:05.790 : LOG_MSG:ERROR.FIL OPENED
+18:19:05.790 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:19:05.790 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:32:46.775 : LOG_MSG:ERROR.FIL OPENED
+18:32:46.776 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:32:46.776 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:38:43.431 : LOG_MSG:ERROR.FIL OPENED
+18:38:43.432 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:38:43.432 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:44:23.798 : LOG_MSG:ERROR.FIL OPENED
+18:44:23.799 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:44:23.800 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:52:12.607 : LOG_MSG:ERROR.FIL OPENED
+18:52:12.608 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:52:12.608 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:59:18.608 : LOG_MSG:ERROR.FIL OPENED
+18:59:18.609 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:59:18.609 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+19:05:51.046 : LOG_MSG:ERROR.FIL OPENED
+19:05:51.047 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+19:05:51.047 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+19:14:05.088 : LOG_MSG:ERROR.FIL OPENED
+19:14:05.088 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+19:14:05.089 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+19:18:33.712 : LOG_MSG:ERROR.FIL OPENED
+19:18:33.713 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+19:18:33.713 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0

pyhcal/calibrators.py

@@ -10,6 +10,7 @@ import subprocess
 #non-standard imports
 import pandas as pd
 import numpy as np
+import geopandas as gpd
 from pathlib import Path
 
 #My packages
@@ -20,7 +21,7 @@ from mpcaHydro import data_manager as dm
 from pyhcal import metrics
 from pyhcal import figures
 from pyhcal import setup_utils
-
+from pyhcal.mappers import Mapper
 
 def new_calibration(project_folder,model_name,download_station_data = True,run_model = True,convert_wdms = True):
     return setup_utils.create_calibration_project(model_name,project_folder,download_station_data,run_model,convert_wdms)
@@ -37,6 +38,7 @@ def validate_project_folder(project_folder):
     assert project_path.joinpath('data').exists(), 'Data folder does not exist'
     assert project_path.joinpath('output').exists(), 'Output folder does not exist'
     assert project_path.joinpath('targets.csv').exists(), 'targets.csv file does not exist in project folder'
+    assert project_path.joinpath('gis').exists(), 'GIS folder does not exist'
     return True
  
 class calibrator:
@@ -45,6 +47,7 @@ class calibrator:
         self.project_name = self.project_path.name
         self.model_path = self.project_path.joinpath('model')
         self.output_path = self.project_path.joinpath('output')
+        self.gis_path = self.project_path.joinpath('gis')
         self.run = None
         self.start_date = '1996-01-01'
         self.end_date = '2100-01-01'
@@ -54,29 +57,58 @@ class calibrator:
      
         self.targets = None
         if self.project_path.joinpath('targets.csv').exists():
-            self.targets = pd.read_csv(self.project_path.joinpath('targets.csv'))  
-              
+            self._load_targets()
+
         self.MODL_DB = pd.read_csv(self.project_path.joinpath('_'.join([self.project_name ,'MODL_DB.csv'])))
         
+        if 'repo_name' in self.MODL_DB.columns:
+            self.model_name =self.MODL_DB['repo_name'].to_list()[0]
+            
+        # Alot of effort to try and include the subwatershed gdf if it exists. TODO: refactor
+        self.subwatershed_gdf_filepath = self.gis_path.joinpath('_'.join([self.project_name ,'Subwatersheds.shp']))
+        if self.subwatershed_gdf_filepath.exists():
+            self.subwatershed_gdf = gpd.read_file(self.subwatershed_gdf_filepath)
+            if 'SubID' in self.subwatershed_gdf.columns:
+                self.subwatershed_gdf = self.subwatershed_gdf.set_index('SubID')
+            else:
+                print("Warning: 'SubID' column not found in subwatershed shapefile. GIS operations will not function correctly.")
+        else:
+            self.subwatershed_gdf = None
+        
         self.model = None
         self._wdms = None
         self.uci = None
-        
+        self.mapper = None
     ## Input/Output methods
+
+
     def initialize(self,reach_ids,default = 4):
 
         self.uci.update_table(default,'RCHRES','BINARY-INFO',0,columns = ['HEATPR','HYDRPR','SEDPR','OXRXPR','NUTRPR','PLNKPR'],operator = 'set')
         self.uci.update_table(2,'RCHRES','BINARY-INFO',0,columns = ['HEATPR','HYDRPR','SEDPR','OXRXPR','NUTRPR','PLNKPR'],opnids = reach_ids,operator = 'set')
         
         self.uci.write(self.model.uci_file)
-        winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
-        subprocess.run([winHSPF,self.model.uci_file]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
+        subprocess.run([self.model.winHSPF,self.model.uci_file]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
         
     def set_dates(self, start_date = '1996-01-01',end_date ='2100-01-01'):
         self.start_date = start_date
         self.end_date = end_date
 
-        
+    def _load_gdf(self,catchment_id_column = 'SubID'):
+        self.subwatershed_gdf_filepath = self.gis_path.joinpath('_'.join([self.project_name ,'Subwatersheds.shp']))
+        if self.subwatershed_gdf_filepath.exists():
+            self.subwatershed_gdf = gpd.read_file(self.subwatershed_gdf_filepath)
+            self.subwatershed_gdf = self.subwatershed_gdf.set_index(catchment_id_column)
+        else:
+            self.subwatershed_gdf = None
+
+    def _load_targets(self):
+        self.targets = pd.read_csv(self.project_path.joinpath('targets.csv'))
+
+    def _update_mapper(self):
+        if self.subwatershed_gdf is not None:
+            self.mapper = Mapper(self.project_name,self.uci,self.subwatershed_gdf,hbn = self.model.hbns)
+
     def load_model(self,name):
 
         if isinstance(name,int): # Default approach
@@ -98,8 +130,10 @@ class calibrator:
                 
         self.model.wdms = self._wdms
         self.model.reports.wdms = self._wdms
-        self.uci = deepcopy(self.model.uci) #uci to be manipulated 
+        self.uci = deepcopy(self.model.uci) #uci to be manipulated
 
+        if self.subwatershed_gdf is not None:
+            self.mapper = Mapper(self.project_name,self.uci,self.subwatershed_gdf,hbn = self.model.hbns)
 
     def run_model(self,name = None,overwrite_hbn = False): # NO STATE CHANGE 
         
@@ -118,14 +152,24 @@ class calibrator:
         #winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
         subprocess.run([self.model.winHSPF,uci_file]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
     
-
+    def get_outlets(self):
+        df = self.dm.get_outlets(self.model_name)
+        outlets = {}
+        for outlet_id in df['outlet_id'].unique():
+            outlets[int(outlet_id)] = {}
+            df_outlet = df.loc[df['outlet_id'] == outlet_id]
+            outlets[int(outlet_id)]['station_ids'] = list(set(df_outlet['station_id']))
+            outlets[int(outlet_id)]['reach_ids'] = list(set(df_outlet['reach_id']))
+            outlets[int(outlet_id)]['model_name'] = df_outlet['repository_name'].iloc[0]
+        return outlets
+    
     def get_simulated_output(self,reach_ids,constituent,time_step = 'YE'):
         sim = self.model.hbns.get_reach_constituent(constituent,reach_ids,time_step)
         sim.name = 'simulated'
         return sim
     
     def get_observed_data(self,station_ids,constituent,time_step = 'YE',baseflow_percentage = None):
-        obs = self.dm._get_data(station_ids,constituent,agg_period = time_step).sort_index(level = 'index')
+        obs = self.dm.get_observation_data(station_ids,constituent,agg_period = time_step)['observed'].sort_index(level = 'index')
         obs.name = 'observed'
         return obs
      
@@ -533,110 +577,3 @@ def threshold(adjustment,threshold,max_change):
     #Note that in uci.update_table() there is further screening to account for adjustments below the model precision
     return adjustment  
 
-
-#class hydrologyCalibrator(calibrator):
-    
-#class nutrientCalibrator(calibrator):
-        
-class sedimentCalibrator(calibrator):
-    
-    def update_kser(self,method,opnid = None):   
-        #TODO account for the additional comment column
-        assert method in ['load','landcover','sftl']
-        
-        table = self.uci.table('PERLND','SED-PARM3',0,False)
-        
-        
-        if method == 'load':
-            adjustment = self.compare(0,aggregate = True).loc['Mean']['ratio']      
-        elif method == 'landcover':
-            adjustment = self.landcover(0)['target']
-            table = self.uci.table('PERLND','SED-PARM3',0)
-            if opnid == None:
-                opnid = table.index
-            adjustment = np.array(adjustment.loc[opnid])[:,None]
-        elif method == 'sftl':
-            adjustment = self.sftl()
-        
-        self.uci.replace_table('PERLND','SED-PARM3',0)
-    
-    def update_erosivity(self,param = 'M',opnid = None,update_alg = '*'):
-        adjustment = self.scour()  
-        table = self.uci.table('RCHRES','SILT-CLAY-PM',0)
-        if opnid == None:
-            opnid = table.index
-        adjustment = np.array(adjustment.loc[opnid])[:,None]
-        self.uci.update_table(adjustment,'RCHRES','SILT-CLAY-PM',table_id = 0,opnid = opnid,columns = [param],update_alg = update_alg)
-        
-        adjustment = self.scour()
-        adjustment = np.array(adjustment.loc[opnid])[:,None]
-        self.uci.update_table(adjustment,'RCHRES','SILT-CLAY-PM',table_id = 1,opnid = opnid,columns = [param],update_alg = update_alg) 
-    
-        
-    def fit_param(self,param,m_factor,N = 2,opnid = None,run = None):
-        bounds = {'M':[.000000001,.01,2,5], #maxlow,low,high,maxhigh
-                  'TAUCD':[.001,.01,.3,1],
-                  'TAUCS':[.01,.05,.5,3]}
-        if run == None:
-            run = self.run
-        
-        data = self.load_data('scour',N=10000)
-        data = data.loc[:,range(run-N+1,run+1),:]
-    
-        if opnid == None:
-            opnid = data.reset_index(level=[1]).index.unique() # assumes multiindex
-        
-        for index in opnid:
-            if any(data.loc[index]['LKFG'] == 0):
-                x = data.loc[index]['depscour']
-                y = data.loc[index][param]
-                linear_model=np.polyfit(x,y,1)
-                linear_model_fn=np.poly1d(linear_model)
-                m = linear_model_fn(-data.loc[index]['nonpoint'].iloc[1]*.25)
-                if m < bounds[param][0]:
-                    m = bounds[param][0]
-                if m > bounds[param][3]:
-                    m = bounds[param][3]
-                self.update_table('RCHRES','SILT-CLAY-PM',0,m,'set',opnid = index,columns = [param]) #mod.update_table(operation,table_name,table_id,adjustment,operator,opnids,columns)
-                self.update_table('RCHRES','SILT-CLAY-PM',1,m*m_factor,'set',opnid = index,columns = [param]) #mod.update_table(operation,table_name,table_id,adjustment,operator,opnids,columns)
-    
-    def erosivity(self,m_factor,param = 'M',opnid = None,run = None,iterations = 1):
-        
-        if run == None:
-            run = self.run
-        
-        # run model updating erosivity for N iterations
-        for iteration in range(iterations):
-            self.update_erosivity(param = param,opnid = opnid)
-            self.run_model() # creates the run+1 uci file and runs it using WinHspfLT
-            run = run + 1
-            self.load_model(run)
-            self.save_data()
-     
-    
-        self.fit_param(param,m_factor,iterations+1,opnid,run)
-        self.run_model() # creates the run+1 uci file and runs it using WinHspfLT
-        
-        run = run + 1
-        self.load_model(run)
-        self.save_data()
-
-    def scour(hbn,uci):     
-        # Erosivity adjustment only
-        scour  = reports.scour_report(hbn,uci)
-        #TODO: add check for this
-        # Assume all nonpoint values are greater than 0...
-        # if depscour is greater than 0
-        target = scour['nonpoint']*.25 # Assuming nonpoint load is set
-        adjustment = np.abs(scour['depscour'])/target
-        adjustment[(adjustment < 1.05) & (adjustment > .95)] = 1 # Don't change reaches where the depscour is close to the target
-        adjustment[adjustment > 1.05] = .95 # Since depscour is negative we have to swap this. I think if I do target/depscour this line would be less confusing
-        adjustment[adjustment < .95] = 1.05
-        adjustment[scour['depscour'] > 0] = 2 # Double any values where the depscour is positive
-        adjustment[scour['LKFG'] == 1] = 1  # Ignore lake flags
-        adjustment[np.isnan(adjustment)] = 1
-        
-        return adjustment
-
-
-    

pyhcal/mappers.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jan 27 11:20:47 2025
+
+@author: mfratki
+"""
+
+from pyhcal.repository import Repository
+from hspf.uci import UCI
+import geopandas as gpd
+import matplotlib.pyplot as plt
+import pandas as pd
+from pathlib import Path
+
+# Try to load statewide subwatersheds from data folder,
+
+# try:
+#     SUBWATERSHEDS = gpd.read_file(str(Path(__file__).resolve().parent/'data\\statewide_subwatersheds.gpkg'))
+# except:
+#     print("Could not load statewide subwatersheds. Please ensure the file 'statewide_subwatersheds.gpkg' is located in the 'data' folder of the pyhcal package.")
+    
+
+
+class uciMapper():
+    def __init__(self,model_names,gis_layer,huc6 = False):
+        self.mappers = []
+        
+        if huc6:
+            model_names = Repository.HUC_DIRECTORY.loc[Repository.HUC_DIRECTORY['Repository_HUC6 Name'].isin(model_names),'Repository_HUC8 Name']
+            model_names = model_names.loc[model_names.isin(Repository.valid_models())].values
+    
+        for model_name in model_names:
+            repo = Repository(model_name)
+            uci = UCI(repo.uci_file)
+            #gis_layer = SUBWATERSHEDS.loc[SUBWATERSHEDS['repo_name'] == model_name,:]
+            #gis_layer.set_index('SubID',inplace=True)
+            self.mappers.append(Mapper(model_name,uci,gis_layer))
+    
+    def map_parameter(self,operation,table_name,parameter,table_id):
+        table = self.join_table(operation,table_name,table_id)
+        fig, ax = plt.subplots()
+        #[table.plot(column = parameter,ax = ax) for table in tables]
+        table.plot(column = parameter,ax = ax,cmap='viridis',legend=True)
+        plt.title(parameter)
+    
+    def join_table(self,operation,table_name,table_id):
+        tables = [mapper.join_table(operation,table_name,table_id) for mapper in self.mappers]
+        table = pd.concat(tables)
+        return table
+    
+class Mapper():
+    def __init__(self,model_name,uci,subwatershed_gdf,hbn = None):
+        self.model_name = model_name
+        self.uci = uci
+        self.hbn = hbn
+        # if subwatershed_gdf is None:
+        #     subwatershed_gdf = SUBWATERSHEDS.loc[SUBWATERSHEDS['repo_name'] == model_name,:]
+        #     subwatershed_gdf.set_index('SubID',inplace=True)
+        
+        self.subwatershed_gdf = subwatershed_gdf
+        self.subwatersheds = uci.network.subwatersheds()
+        self.subwatershed_ids = list(set(self.subwatersheds.index))
+
+    def map_parameter(self,operation,table_name,parameter,table_id=0,weight_by_area = True):
+        fig, ax = plt.subplots()
+        self.join_table(operation,table_name,parameter,table_id).plot(column = parameter,ax = ax,cmap='viridis',legend=True)
+        plt.title(parameter)
+        
+    def join_table(self,operation,table_name,parameter,table_id=0,weight_by_area = True):
+        table = self.uci.table(operation,table_name,table_id)
+        subwatersheds = self.uci.network.subwatersheds()
+        subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == 'PERLND'].reset_index(drop=False).set_index('SVOLNO').join(table,how = 'left')
+        subwatersheds.index.name = 'SVOLNO' # Sometimes the index name gets dropped. I'm guessing when there are missing joins.
+        subwatersheds = subwatersheds.reset_index('SVOLNO').set_index(['SVOLNO','TVOLNO','SVOL','MLNO'])
+        
+        #weight by area factor:
+        if weight_by_area:
+            subwatersheds['weighted_param'] = subwatersheds['AFACTR']*subwatersheds[parameter]
+            subwatersheds = subwatersheds.groupby(subwatersheds.index.get_level_values('TVOLNO'))['weighted_param'].sum()/subwatersheds.groupby(subwatersheds.index.get_level_values('TVOLNO'))['AFACTR'].sum()
+            subwatersheds.name = parameter
+        else:
+            subwatersheds = subwatersheds.groupby(subwatersheds.index.get_level_values('TVOLNO'))[parameter].mean()
+            subwatersheds.name = parameter
+        return self.subwatershed_gdf.join(subwatersheds)
+ 
+    def map_flag():
+        raise NotImplementedError()
+        
+    def map_output(self,operation,output_name,t_code=5,agg_func = 'mean'):
+        subwatersheds = self.subwatersheds.loc[(self.subwatersheds['SVOL'] == operation),:].copy()
+        opnids = list(subwatersheds['SVOLNO'].unique())
+        output = self.hbn.get_multiple_timeseries(operation,t_code,output_name,opnids = opnids).agg(agg_func)
+        if operation in ['PERLND','IMPLND']:
+            subwatersheds = pd.merge(subwatersheds,output.to_frame(output_name),right_index = True,left_on = 'SVOLNO')
+            subwatersheds['area_output'] = subwatersheds['AFACTR']*subwatersheds[output_name]
+            subwatersheds = subwatersheds[['AFACTR','area_output']].groupby(subwatersheds.index).sum()
+            subwatersheds[output_name] = subwatersheds['area_output']/subwatersheds['AFACTR']
+        
+        fig, ax = plt.subplots()
+        #[table.plot(column = parameter,ax = ax) for table in tables]
+        self.subwatershed_gdf.join(subwatersheds).plot(column = output_name,ax = ax,cmap='viridis',legend=True)
+        plt.title(output_name)
+    
+    def map_table(self,df, mapping_col):
+        '''Maps a dataframe column to the subwatershed geodataframe based on subwatershed IDs.
+        Assumes the dataframe index contains the subwatershed IDs.'''
+        fig, ax = plt.subplots()
+        #[table.plot(column = parameter,ax = ax) for table in tables]
+        self.subwatershed_gdf.join(df).plot(column = mapping_col,ax = ax,cmap='viridis',legend=True)
+        plt.title(mapping_col)
+        #return self.subwatershed_gdf.join(subwatersheds)
+
+ 

pyhcal/repository.py

@@ -6,7 +6,7 @@ Created on Wed Nov 27 09:16:30 2024
 """
 
 import pandas as pd
-from pyhcal import modl_db
+from mpcaHydro import outlets
 from pathlib import Path
 import shutil
 
@@ -38,7 +38,7 @@ class Repository():
         
         self.REPOSITORY_PATH = repository_path
         huc_directory = self.HUC_DIRECTORY.loc[self.HUC_DIRECTORY['Repository_HUC8 Name'] == model_name]
-        self.modl_db = modl_db.get_model_db(model_name) #self.MODL_DB.loc[self.MODL_DB['repository_name'] == model_name]
+        self.modl_db = outlets.get_model_db(model_name) #self.MODL_DB.loc[self.MODL_DB['repository_name'] == model_name]
         #self.modl_db  = pd.concat([self.MODL_DB.loc[self.MODL_DB['repository_name'].str.startswith(huc8_id,na=False)] for huc8_id in huc8_ids])        
         self.model_name = model_name
         self.huc8_ids = list(huc_directory['USGS HUC-8'])
@@ -48,8 +48,8 @@ class Repository():
         self.uci_file = self.repo_folder.joinpath('HSPF','.'.join([self.model_name,'uci']))
         self.wdm_files = [item for item in self.repo_folder.joinpath('HSPF').iterdir() if (item.name.endswith('.wdm')) | (item.name.endswith('.WDM'))]
         self.shapefiles = {item.name.split('.')[0].split('_')[-1]:item for item in self.repo_folder.joinpath('GIS').iterdir() if (item.name.endswith('.shp')) | (item.name.endswith('.SHP'))}
-        self.wiski_stations = modl_db.wiski_stations(model_name)
-        self.equis_stations = modl_db.equis_stations(model_name)
+        self.wiski_stations = outlets.wiski_stations(model_name)
+        self.equis_stations = outlets.equis_stations(model_name)
 
 
     def copy(self,copy_path):

pyhcal/setup_utils.py

@@ -8,7 +8,7 @@ from mpcaHydro.data_manager import dataManager
 from hspf.wdmReader import readWDM
 from hspf.uci import UCI
 from pyhcal.repository import Repository
-from pyhcal import modl_db
+from mpcaHydro import outlets
 
 import numpy as np
 import pandas as pd
@@ -16,8 +16,8 @@ from pathlib import Path
 import subprocess
 
 
-def create_calibration_project(model_name,project_location,download_station_data = True,run_model = True,convert_wdms = True):
-    project = Builder(model_name)
+def create_calibration_project(model_name,project_location, download_station_data = True,run_model = True,convert_wdms = True,oracle_username = None, oracle_password = None):
+    project = Builder(model_name,oracle_username = oracle_username, oracle_password = oracle_password)
     project.copy(project_location,model_name)
     project.load_uci()
     project.format_uci()
@@ -25,6 +25,7 @@ def create_calibration_project(model_name,project_location,download_station_data
     if convert_wdms: project.convert_wdms()
     if download_station_data: project.download_station_data()
     if run_model: project.run_model()
+    return project
    
     
     
@@ -32,32 +33,34 @@ def create_calibration_project(model_name,project_location,download_station_data
 
 class Builder():
     
-    def __init__(self,model_name):
+    def __init__(self,model_name,oracle_username = None, oracle_password = None):
         self.repository = Repository(model_name)
+        self.model_name = model_name
         self.project_path = None
         self.project_name = None
         self.new_uci = None
         self.uci = None
         self.dm = None
-        self.calibration_reaches = modl_db.wplmn_station_opnids(model_name)
-
+        self.calibration_reaches = outlets.wplmn_station_opnids(model_name)
+        self.oracle_username = oracle_username
+        self.oracle_password = oracle_password
     
     def valid_models():
         return Repository.valid_models()
     
-    def set_project_path(self,project_path):
-        self.project_path = Path(project_path)
-        self.project_name = Path(project_path).name
+    def set_project_path(self,project_location,project_name):
+        self.project_path = Path(project_location).joinpath(project_name)
+        self.project_name = project_name
+        self.dm = dataManager(self.project_path.joinpath('data'),oracle_username = self.oracle_username, oracle_password = self.oracle_password)
+        self.dm._build_warehouse()
         #self.new_uci = self.project_path.joinpath('model','_'.join([self.project_name,'0.uci']))
         #self.uci = UCI(self.project_path.joinpath('model','.'.join([self.project_name,'uci'])))
         
     def copy(self,project_location,project_name):
-        self.project_path = Path(project_location).joinpath(project_name)
-        self.project_name = project_name
+        self.set_project_path(project_location,project_name)
         self.repository.copy(self.project_path)
-        self.dm = dataManager(self.project_path.joinpath('data'))
+        
 
-    
     def load_uci(self):
         self.new_uci = self.project_path.joinpath('model','_'.join([self.project_name,'0.uci']))
         self.uci = UCI(self.project_path.joinpath('model','.'.join([self.project_name,'uci'])))
@@ -80,21 +83,27 @@ class Builder():
         setup_qualid(self.uci)
         self.uci.write(self.new_uci)
         
-    
-    def download_station_data(self,start_year,end_year):#:,station_id,source_id):
-        #%% Old approach. Store as indvidual processed station files then load to warehouse
-        if len(equis_stations) > 0:
-            if self.dm.credentials_exist():
-                station_origin = 'equis'
-            else: station_origin = 'swd'
-        
-            for station_id in equis_stations:
-                self.dm.download_station_data(station_id,station_origin, True)
+    def download_wiski_data(self,station_ids):
+        if len(station_ids) > 0:
+            self.dm._download_wiski_data(station_ids)
+        else:
+            print("No Wiski stations have been manually matched to modeled reaches.")
         
-        if len(wiski_stations) > 0:
-            for station_id in wiski_stations:
-                self.dm.download_station_data(station_id,'wiski', True)
-                 
+    def download_equis_data(self,station_ids):
+        if len(station_ids) > 0:
+            if self.dm.credentials_exist():
+                self.dm.connect_to_oracle()
+                self.dm._download_equis_data(station_ids)
+            else:
+                print("Oracle credentials not provided. Cannot download Equis data.")
+        else:
+            print("No Equis stations have been manually matched to modeled reaches.")
+    
+    def download_station_data(self):
+        equis_stations = self.dm.outlets.mapped_equis_stations(self.model_name)
+        wiski_stations = self.dm.outlets.mapped_wiski_stations(self.model_name)
+        self.download_equis_data(equis_stations)
+        self.download_wiski_data(wiski_stations)
     
     def convert_wdms(self):
         copy_path = Path(self.project_path.joinpath('model'))
@@ -584,3 +593,5 @@ def setup_qualid(uci):
 
 
 
+
+# %%

{pyhcal-1.1.0.dist-info → pyhcal-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyhcal
-Version: 1.1.0
+Version: 1.1.2
 Summary: Python package for calibrating MPCA HSPF models
 Project-URL: Homepage, https://github.com/mfratkin1/pyhcal
 Author-email: Mulu Fratkin <michael.fratkin@state.mn.us>

pyhcal-1.1.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyhcal/ERROR.FIL,sha256=w35iHJYKYpcU9lrmU4FqLGMlKLabOOX-_Z567kHF8CA,5018
+pyhcal/__init__.py,sha256=4TEpGD-PfEY8yK-od8DpEMA4_iQ-q9y0PBvROXSPdB0,94
+pyhcal/calibrators.py,sha256=J_RdArI5FAAiU-tEnvSQxiRtIBv3ol13vOJmb34CuGk,27964
+pyhcal/figures.py,sha256=Iu7LaN_i2IuDA_nfxj-a8AkG-FTLZVicJ3-efIs5OiE,45534
+pyhcal/mappers.py,sha256=bAeBb-_EbhegPTn4sR4elRyQNrcBpr9CFzNoZcMDng8,5674
+pyhcal/metrics.py,sha256=GUGHd-op-g1Foj8wnS_JVURSms4ifcC0a5h8ketQ29I,17911
+pyhcal/repository.py,sha256=cZfAZRCI99_rhCSHi58_O6pV8aAofXuvQHrao0B5CzI,4606
+pyhcal/setup_utils.py,sha256=YyFpOUlyzsJySrnBBnLs3CPLs3al93Mez_H69di4yeo,31145
+pyhcal/data/HUC_Names.csv,sha256=UGmd3Q5E8DyFWggXzaXWpsRze7sFyrlpYqaYpMWAiGM,18946
+pyhcal-1.1.2.dist-info/METADATA,sha256=CNDp8wMXQJNlttSLA9uI_z9zjImiZrY6lRTisF7_3jQ,560
+pyhcal-1.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pyhcal-1.1.2.dist-info/RECORD,,