py-ewr 1.0.8__py3-none-any.whl → 2.1.0__py3-none-any.whl

py_ewr/data_inputs.py

@@ -1,35 +1,39 @@
-import io
-import requests
+import json
 import pandas as pd
 import numpy as np
 from pathlib import Path
 import os
+import logging
 
 from cachetools import cached, TTLCache
 
-BASE_PATH = Path(__file__).resolve().parent
+log = logging.getLogger(__name__)
+log.addHandler(logging.NullHandler())
 
-# Importing the climate cat data - to be replaced by RAS data once available:
+BASE_PATH = Path(__file__).resolve().parent
 
-def get_climate_cats(climate_file:str) -> pd.DataFrame:
-    '''Uses standard climate categorisation unless user selects the 10,000 year climate sequence,
-    in which case this is used
+@cached(cache=TTLCache(maxsize=1024, ttl=1800))
+def get_ewr_calc_config(file_path:str = None) -> dict:
+    '''Loads the EWR calculation configuration file from repository or local file
+    system
     
     Args:
-        climate_file (str): location of the climate categoration file
+        file_path (str): Location of the EWR calculation configuration file
 
     Returns:
-        pd.DataFrame: Returns a dataframe showing annual climate categories for catchments
-    
+        dict: Returns a dictionary of the EWR calculation configuration file
     '''
     
-    if climate_file == 'Standard - 1911 to 2018 climate categorisation':
-        climate_cats = pd.read_csv( BASE_PATH / 'climate_data/climate_cats.csv', index_col = 0)
-        
-    elif climate_file  == 'NSW 10,000 year climate sequence':
-        climate_cats = pd.read_csv(BASE_PATH / 'climate_data/climate_cats_10000year.csv', index_col = 0)
-        
-    return climate_cats
+    if file_path:
+        with open(file_path, 'r') as fp:
+            ewr_calc_config = json.load(fp)
+    
+    if not file_path:
+        repo_path = os.path.join(BASE_PATH, "parameter_metadata/ewr_calc_config.json")
+        with open(repo_path, 'r') as fp:
+            ewr_calc_config = json.load(fp)
+
+    return ewr_calc_config
 
 @cached(cache=TTLCache(maxsize=1024, ttl=1800))
 def get_EWR_table(file_path:str = None) -> dict:
@@ -49,26 +53,33 @@ def get_EWR_table(file_path:str = None) -> dict:
          usecols=['PlanningUnitID', 'PlanningUnitName',  'LTWPShortName', 'CompliancePoint/Node', 'Gauge', 'Code', 'StartMonth',
                               'EndMonth', 'TargetFrequency', 'TargetFrequencyMin', 'TargetFrequencyMax', 'EventsPerYear', 'Duration', 'MinSpell', 
                               'FlowThresholdMin', 'FlowThresholdMax', 'MaxInter-event', 'WithinEventGapTolerance', 'WeirpoolGauge', 'FlowLevelVolume', 
-                              'LevelThresholdMin', 'LevelThresholdMax', 'VolumeThreshold', 'DrawdownRate', 'AccumulationPeriod',
-                              'Multigauge', 'MaxSpell', 'TriggerDay', 'TriggerMonth', 'DrawDownRateWeek'],
-                            dtype='str', encoding='cp1252')
+                              'LevelThresholdMin', 'LevelThresholdMax', 'VolumeThreshold', 'DrawdownRate', 'MaxLevelRise','AccumulationPeriod',
+                              'Multigauge', 'MaxSpell', 'TriggerDay', 'TriggerMonth', 'DrawDownRateWeek', 'AnnualFlowSum','AnnualBarrageFlow',
+                              'ThreeYearsBarrageFlow', 'HighReleaseWindowStart', 'HighReleaseWindowEnd', 'LowReleaseWindowStart', 'LowReleaseWindowEnd',
+                              'PeakLevelWindowStart', 'PeakLevelWindowEnd', 'LowLevelWindowStart', 'LowLevelWindowEnd', 'NonFlowSpell', 'EggsDaysSpell',
+                              'LarvaeDaysSpell','MinLevelRise', 'RateOfRiseMax1','RateOfRiseMax2','RateOfFallMin','RateOfRiseThreshold1',
+                              'RateOfRiseThreshold2','RateOfRiseRiverLevel','RateOfFallRiverLevel', 'CtfThreshold', 'GaugeType'],
+                               dtype='str', encoding='cp1252') 	
+
 
     if not file_path:
-        my_url = os.path.join(BASE_PATH, "parameter_metadata/NSWEWR.csv")
+        my_url = os.path.join(BASE_PATH, "parameter_metadata/parameter_sheet.csv")
         proxies={} # Populate with your proxy settings
-        #s = requests.get(my_url, proxies=proxies).text
-        df = pd.read_csv(my_url,#io.StringIO(s),
+        df = pd.read_csv(my_url,
             usecols=['PlanningUnitID', 'PlanningUnitName',  'LTWPShortName', 'CompliancePoint/Node', 'Gauge', 'Code', 'StartMonth',
                               'EndMonth', 'TargetFrequency', 'TargetFrequencyMin', 'TargetFrequencyMax', 'EventsPerYear', 'Duration', 'MinSpell', 
                               'FlowThresholdMin', 'FlowThresholdMax', 'MaxInter-event', 'WithinEventGapTolerance', 'WeirpoolGauge', 'FlowLevelVolume', 
-                              'LevelThresholdMin', 'LevelThresholdMax', 'VolumeThreshold', 'DrawdownRate', 'AccumulationPeriod',
-                              'Multigauge', 'MaxSpell', 'TriggerDay', 'TriggerMonth', 'DrawDownRateWeek'],
+                              'LevelThresholdMin', 'LevelThresholdMax', 'VolumeThreshold', 'DrawdownRate', 'MaxLevelRise', 'AccumulationPeriod',
+                              'Multigauge', 'MaxSpell', 'TriggerDay', 'TriggerMonth', 'DrawDownRateWeek','AnnualFlowSum','AnnualBarrageFlow',
+                              'ThreeYearsBarrageFlow', 'HighReleaseWindowStart', 'HighReleaseWindowEnd', 'LowReleaseWindowStart', 'LowReleaseWindowEnd',
+                              'PeakLevelWindowStart', 'PeakLevelWindowEnd', 'LowLevelWindowStart', 'LowLevelWindowEnd', 'NonFlowSpell','EggsDaysSpell',
+                              'LarvaeDaysSpell','MinLevelRise', 'RateOfRiseMax1','RateOfRiseMax2','RateOfFallMin','RateOfRiseThreshold1',
+                              'RateOfRiseThreshold2','RateOfRiseRiverLevel','RateOfFallRiverLevel', 'CtfThreshold', 'GaugeType'],
                         dtype='str', encoding='cp1252'
                         )
 
     df = df.replace('?','')
     df = df.fillna('')
-
     # removing the 'See notes'
     okay_EWRs = df.loc[(df["StartMonth"] != 'See note') & (df["EndMonth"] != 'See note')]
     see_notes = df.loc[(df["StartMonth"] == 'See note') & (df["EndMonth"] == 'See note')]
@@ -101,96 +112,6 @@ def get_EWR_table(file_path:str = None) -> dict:
     
     return okay_EWRs, bad_EWRs
 
-@cached(cache=TTLCache(maxsize=1024, ttl=1800))
-def map_gauge_to_catchment(my_url:str = "parameter_metadata/NSWEWR.csv") -> dict:
-    ''' Allocates all the locations in the ewr table with catchments, as indicated by the
-    first three numbers for each gauge 
-    
-    Args:
-        my_url (str): location of the EWR dataset
-    Returns:
-        dict[dict]: Dictinoary of catchments, for each catchment a dictionary of gauge number and name key value pairs 
-    '''
-    
-    lower_darling_gauges = ['425054', '425010', '425011', '425052', '425013', '425056', '425007', 
-                            '425057', '425005', '425050', '425048', '425019', '425014', '425023', 
-                            '425012', '425044', '425049', '425001', '425022', '42510037', '42510036',
-                            '425034', '425046', '425020', ]
-    
-    EWR_table, bad_EWRs =  get_EWR_table(os.path.join(BASE_PATH, my_url))
-    
-    gauge_number = EWR_table['Gauge'].values
-    gauge_name = EWR_table['CompliancePoint/Node'].values
-    
-    gauge_to_name = dict()
-    for iteration, value in enumerate(gauge_number):
-        if type(value) == str:
-            gauge_to_name[value] = gauge_name[iteration]
-
-    gauge_to_catchment = dict()
-    namoi_catchment = dict()
-    gwydir_catchment = dict()
-    macquarie_catchment = dict()
-    lachlan_catchment = dict()
-    murray_catchment = dict()
-    lower_darling_catchment = dict()
-    barwon_darling_catchment = dict()
-    murrumbidgee_catchment = dict()
-    border_rivers_catchment = dict()
-    moonie_catchment = dict()
-    condamine_balonne = dict()
-    warrego_catchment = dict()
-    paroo_catchment = dict()
-    other_catchment = dict()
-    
-    for k, v in gauge_to_name.items():
-        if k.startswith('419'):
-            namoi_catchment.update({k: v})
-        elif k.startswith('418'):
-            gwydir_catchment.update({k: v})
-        elif (k.startswith('421') or k.startswith('420')):
-            macquarie_catchment.update({k: v})
-        elif k.startswith('412'):
-            lachlan_catchment.update({k: v})
-        elif (k.startswith('401') or k.startswith('409') or k.startswith('A426') or k.startswith('414')):
-            murray_catchment.update({k: v})
-        elif k.startswith('425'):
-            if k in lower_darling_gauges:
-                lower_darling_catchment.update({k: v})   
-            else:
-                barwon_darling_catchment.update({k: v}) 
-        elif k.startswith('410'):
-            murrumbidgee_catchment.update({k: v})
-        elif k.startswith('416'):
-            border_rivers_catchment.update({k: v})
-        elif k.startswith('417'):
-            moonie_catchment.update({k: v})
-        elif k.startswith('422'):
-            condamine_balonne.update({k: v})
-        elif k.startswith('423'):
-            warrego_catchment.update({k: v})
-        elif k.startswith('424'):
-            paroo_catchment.update({k: v})
-        else:
-            other_catchment.update({k: v})
-                
-    gauge_to_catchment.update({'Namoi': namoi_catchment, 
-                               'Gwydir': gwydir_catchment,
-                               'Macquarie-Castlereagh': macquarie_catchment, 
-                               'Lachlan': lachlan_catchment,
-                               'Lower Darling': lower_darling_catchment, 
-                               'Barwon-Darling': barwon_darling_catchment,
-                               'Murray': murray_catchment,
-                               'Murrumbidgee': murrumbidgee_catchment,
-                               'Border Rivers': border_rivers_catchment,
-                               'Moonie' : moonie_catchment,
-                               'Condamine-Balonne': condamine_balonne,
-                               'Warrego': warrego_catchment,
-                               'Paroo': paroo_catchment,
-                               'Other': other_catchment
-                              })
-    return gauge_to_catchment
-
 def get_MDBA_codes() -> pd.DataFrame:
     '''
     Load MDBA model metadata file containing model nodes
@@ -217,54 +138,6 @@ def get_NSW_codes() -> pd.DataFrame:
     
     return metadata
 
-def gauge_to_catchment(input_gauge:str) -> str:
-    '''
-    Takes in a gauge, maps it to the catchment
-    returns the catchment
-
-    Args:
-        input_gauge (str): Gauge string
-    
-    Returns:
-        str: The catchment name that the input gauge is located in
-
-    '''
-    catchments_gauges = map_gauge_to_catchment()
-    for catchment in catchments_gauges:
-        if input_gauge in catchments_gauges[catchment]:
-            return catchment
-    
-def wy_to_climate(water_years: np.array, catchment: str, climate_file: str) -> np.array:
-    '''
-    The function assigns a climate categorisation for every day, depending on the water year and catchment in the climate file
-
-    Args:
-        water_years (np.array): Daily water year array
-        catchment (str): The catchment that the gauge is in
-        climate file (str) = Which climate data to use
-
-    Returns:
-        np.array: Daily climate categorisation
-    
-    '''
-    # Get the climate categorisation:
-    climate_cats = get_climate_cats(climate_file)
-    
-    # Get the unique years covered in the flow dataframe, and how many days are in each year:
-    unique_years, count_years = np.unique(water_years, return_counts=True)
-    
-    # Get the years covered by the climate cats, and filter them to those of interest (using min and max from flow dataframe)
-    climateCatchment = climate_cats[catchment]
-    climateFiltered = climateCatchment[(climateCatchment.index>=min(unique_years)) & (climateCatchment.index<=max(unique_years))].values
-    # Repeating the climate result for that year over the total days in each year 
-    def mapper(climate, count):
-        return np.repeat(climate, count)
-
-    climateDailyYear = list(map(mapper, climateFiltered, count_years))
-    climateDaily = np.concatenate(climateDailyYear)
-    
-    return climateDaily
-
 def get_level_gauges() -> tuple:
     '''Returning level gauges with EWRs
 
@@ -277,7 +150,7 @@ def get_level_gauges() -> tuple:
 
     lachlanGauges = ['412107']
 
-    levelGauges = menindeeGauges + lachlanGauges
+    levelGauges = menindeeGauges + lachlanGauges 
     
     weirpoolGauges = {'414203': '414209', 
                       '425010': 'A4260501',
@@ -313,74 +186,6 @@ def get_multi_gauges(dataType: str) -> dict:
     
     return returnData
 
-def get_simultaneous_gauges(dataType: str) -> dict:
-    '''
-    Call function to return a dictionary of simultaneous gauges.
-    Simultaneous gauges are for EWRs that need to be met simultaneously with EWRs at another location
-
-    Args:
-        dataType (str): Pass 'all' to get simultaneous gauges and their planning units, pass 'gauges' to get only gauges.
-    Returns:
-        dict: if 'all', nested dict returned with a level for planning units.
-
-    '''
-    
-    all = {'PU_0000131': {'421090': '421022', '421022': '421090'},
-              'PU_0000132': {'421090': '421022', '421022': '421090'},
-              'PU_0000133': {'421090': '421022', '421022': '421090'}
-             }
-    returnData = {}
-    if dataType == 'all':
-        returnData = all
-    if dataType == 'gauges':
-        for i in all:
-            returnData = {**returnData, **all[i]}
-        
-    return returnData
-
-def get_complex_calcs() -> dict:
-    '''
-    Returns a dictionary of the complex EWRs, and the type of analysis that needs to be undertaken
-    These EWRs cannot be calculated using the standard suite of functions
-
-    Returns:
-        dict[dict]
-    '''
-    complexCalcs = {'409025': {'OB2_S': 'flowDurPostReq', 'OB2_P': 'flowDurPostReq',
-                              'OB3_S': 'flowDurOutsideReq', 'OB3_P': 'flowDurOutsideReq'}}
-    
-    return complexCalcs
-
-
-def get_gauges(category: str) -> set:
-    '''
-    Gathers a list of either all gauges that have EWRs associated with them,
-    a list of all flow type gauges that have EWRs associated with them,
-    or a list of all level type gauges that have EWRs associated with them
-
-    Args:
-        category(str): options = 'all gauges', 'flow gauges', or 'level gauges'
-    Returns:
-        list: list of gauges in selected category.
-
-    '''
-    EWR_table, bad_EWRs = get_EWR_table()
-    menindee_gauges, wp_gauges = get_level_gauges()
-    wp_gauges = list(wp_gauges.values())
-    
-    multi_gauges = get_multi_gauges('gauges')
-    simul_gauges = get_simultaneous_gauges('gauges')
-    multi_gauges = list(multi_gauges.values())
-    simul_gauges = list(simul_gauges.values())
-    if category == 'all gauges':
-        return set(EWR_table['Gauge'].to_list() + menindee_gauges + wp_gauges + multi_gauges + simul_gauges)
-    elif category == 'flow gauges':
-        return set(EWR_table['Gauge'].to_list() + multi_gauges + simul_gauges)
-    elif category == 'level gauges':
-        return set(menindee_gauges + wp_gauges)
-    else:
-        raise ValueError('''No gauge category sent to the "get_gauges" function''')
-
 def get_EWR_components(category):
     '''
     Ingests EWR category, returns the components required to analyse this type of EWR. 
@@ -398,13 +203,19 @@ def get_EWR_components(category):
     if category == 'flow':
         pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'GP', 'EPY', 'MIE', 'FLV']
     elif category == 'low flow':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR',  'ME', 'EPY', 'DURVD', 'MIE', 'FLV']
+        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR',  'ME', 'EPY', 'MIE', 'FLV']
     elif category == 'cease to flow':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'EPY', 'DURVD', 'MIE', 'FLV']
+        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'EPY', 'MIE', 'FLV']
     elif category == 'cumulative':
         pull =  ['SM', 'EM', 'MINV', 'DUR', 'ME', 'EPY', 'MINF', 'MAXF', 'MIE','AP','GP', 'FLV']
+    elif category == 'cumulative_bbr':
+        pull =  ['SM', 'EM', 'MINV', 'DUR', 'ME', 'EPY', 'MINF', 'MAXF', 'MIE','AP','GP', 'FLV','MAXL','WPG']
+    elif category == 'water_stability':
+        pull =  ['SM', 'EM', 'DUR', 'ME', 'EPY', 'MINF', 'MAXF', 'MIE','AP','GP', 'FLV','MAXL','WPG', 'EDS', 'LDS', 'ML', 'MD']
+    elif category == 'water_stability_level':
+        pull =  ['SM', 'EM', 'DUR', 'ME', 'EPY', 'MINF', 'MIE','AP','GP', 'FLV','MAXL', 'MINL', 'WPG', 'EDS', 'LDS', 'ML', 'MD']
     elif category == 'level':
-        pull = ['SM', 'EM', 'MINL', 'MAXL', 'DUR', 'ME', 'EPY', 'MD', 'MIE', 'FLV', 'MAXD','GP']
+        pull = ['SM', 'EM', 'MINL', 'MAXL', 'DUR', 'ME', 'EPY', 'MD', 'MIE', 'FLV', 'MAXD','GP','MLR']
     elif category == 'weirpool-raising':
         pull=['SM', 'EM', 'MINF', 'MAXF', 'MINL', 'DUR', 'ME',  'MD', 'EPY','WPG', 'MIE', 'FLV', 'GP']
     elif category == 'weirpool-falling':
@@ -416,19 +227,21 @@ def get_EWR_components(category):
     elif category == 'multi-gauge-flow':
         pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME',  'GP', 'EPY', 'MG', 'MIE', 'FLV']
     elif category == 'multi-gauge-low flow':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'EPY', 'DURVD', 'MG', 'MIE', 'FLV']
+        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'EPY', 'MG', 'MIE', 'FLV']
     elif category == 'multi-gauge-cease to flow':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'EPY', 'DURVD', 'MG', 'MIE', 'FLV']
+        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'EPY', 'MG', 'MIE', 'FLV']
     elif category == 'multi-gauge-cumulative':
         pull =  ['SM', 'EM', 'MINV', 'DUR', 'ME', 'EPY', 'MINF', 'MAXF','MG', 'MIE','AP','GP', 'FLV']
-    elif category == 'simul-gauge-flow':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'GP', 'EPY', 'DURVD', 'SG', 'MIE', 'FLV']
-    elif category == 'simul-gauge-low flow':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'GP', 'EPY', 'DURVD', 'SG', 'MIE', 'FLV']
-    elif category == 'simul-gauge-cease to flow':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'GP', 'EPY', 'DURVD', 'SG', 'MIE', 'FLV']
-    elif category == 'complex':
-        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME',  'GP', 'EPY', 'MIE', 'FLV']  
+    elif category == 'flood-plains':
+        pull=['SM', 'EM', 'MINF', 'MAXF', 'MAXL', 'DUR', 'ME',  'MD', 'ML','EPY','WPG', 'MIE', 'FLV', 'GP']
+    elif category == 'barrage-flow':
+        pull=['SM', 'EM','DUR', 'ME','EPY','MIE','FLV','ABF','TYBF','HRWS', 'HRWE', 'LRWS', 'LRWE']
+    elif category == 'barrage-level':
+        pull=['SM', 'EM','DUR', 'ME','EPY','MIE','FLV','HRWS', 'HRWE', 'LRWS', 'LRWE','PLWS', 'PLWE', 'LLWS', 'LLWE','MINL','MAXL']
+    elif category == 'flow-ctf':
+        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'GP', 'EPY', 'MIE', 'FLV', 'NFS', 'CTFT']
+    elif category == 'rise_fall':
+        pull = ['SM', 'EM', 'MINF', 'MAXF', 'DUR', 'ME', 'GP', 'EPY', 'MIE', 'FLV', 'NFS', 'MLR', 'RRM1', 'RRM2', 'RFM', 'RRT1', 'RRT2', 'RRL', 'RFL' ]
     return pull
 
 def get_bad_QA_codes() -> list:
@@ -484,8 +297,109 @@ def ewr_parameter_grabber(EWR_TABLE: pd.DataFrame, GAUGE: str, PU: str, EWR: str
         str: requested EWR component
     
     '''
-    component = list(EWR_TABLE[((EWR_TABLE['Gauge'] == GAUGE) & 
+    component = (EWR_TABLE[((EWR_TABLE['Gauge'] == GAUGE) & 
                            (EWR_TABLE['Code'] == EWR) &
                            (EWR_TABLE['PlanningUnitName'] == PU)
-                          )][PARAMETER])[0]
-    return component if component else 0
+                          )][PARAMETER]).to_list()[0]
+    return component if component else 0
+
+def get_barrage_flow_gauges()-> dict:
+    """Returns a dictionary of the flow gauges associated with each barrage.
+    Results:
+        dict: dictionary of flow gauges associated with each barrage.       	
+    """
+
+    flow_barrage_gauges = {'A4261002': ['A4261002']}
+
+    return flow_barrage_gauges
+
+def get_barrage_level_gauges()-> dict:
+    """Returns a dictionary of the level gauges associated with each barrage.
+    Results:
+        dict: dictionary of level gauges associated with each barrage.
+    """
+
+    level_barrage_gauges = {'A4260527': ['A4260527','A4261133', 'A4260524', 'A4260574', 'A4260575' ],
+                            'A4260633' : ['A4260633','A4261209', 'A4261165']}
+    
+    return level_barrage_gauges
+
+def get_qld_level_gauges()-> list:
+    """Returns a dictionary of the level gauges associated with each barrage.
+    Results:
+        dict: dictionary of level gauges associated with each barrage.
+    """
+    return ['422015','422030', '422034', '416011', '416048']
+
+def get_qld_flow_gauges()-> list:
+    """Returns a dictionary of the flow gauges associated with each barrage.
+    Results:
+        dict: dictionary of flow gauges associated with each barrage.
+    """
+    return ['422030','422207A',
+            '422209A',
+            '422211A',
+            '422502A',
+            '424201A',
+            '422034' ]
+
+def get_vic_level_gauges()-> list:
+    """Returns a list of the level gauges for VIC.
+    Results:
+        dict: dictionary of flow gauges associated with each barrage.
+    """
+    return ['405201', '405202', '405200']
+
+
+def get_cllmm_gauges()->list:
+    return ["A4261002", "A4260527", "A4260633"]
+
+
+def get_gauges(category: str, ewr_table_path: str = None) -> set:
+    '''
+    Gathers a list of either all gauges that have EWRs associated with them,
+    a list of all flow type gauges that have EWRs associated with them,
+    or a list of all level type gauges that have EWRs associated with them
+
+    Args:
+        category(str): options = 'all gauges', 'flow gauges', or 'level gauges'
+    Returns:
+        list: list of gauges in selected category.
+
+    '''
+    EWR_table, bad_EWRs = get_EWR_table(file_path=ewr_table_path)
+    menindee_gauges, wp_gauges = get_level_gauges()
+    wp_gauges = list(wp_gauges.values())
+    flow_barrage_gauges = [ val for sublist in get_barrage_flow_gauges().values() for val in sublist]
+    level_barrage_gauges = [ val for sublist in get_barrage_level_gauges().values() for val in sublist]
+    qld_level_gauges = get_qld_level_gauges()
+    qld_flow_gauges = get_qld_flow_gauges()
+    vic_level_gauges = get_vic_level_gauges()
+    
+    multi_gauges = get_multi_gauges('gauges')
+    multi_gauges = list(multi_gauges.values())
+    if category == 'all gauges':
+        return set(EWR_table['Gauge'].to_list() + menindee_gauges + wp_gauges + multi_gauges)
+    elif category == 'flow gauges':
+        return set(EWR_table['Gauge'].to_list() + multi_gauges + flow_barrage_gauges + qld_flow_gauges) 
+    elif category == 'level gauges':
+        level_gauges = EWR_table[EWR_table['FlowLevelVolume']=='L']['Gauge'].to_list()
+        return set(menindee_gauges + wp_gauges + level_barrage_gauges + qld_level_gauges + level_gauges)
+    else:
+        raise ValueError('''No gauge category sent to the "get_gauges" function''')
+    
+def get_scenario_gauges(gauge_results: dict) -> list:
+    """return a list of gauges process for the scenatios(s)
+
+    Args:
+        gauge_results (dict): the dictionary of gauge results either for
+        observed or scenarios handlers
+
+    Returns:
+        list: list of gauges process for the scenatios(s)
+    """
+    scenario_gauges = []
+    for scenario in gauge_results.values():
+        for gauge in scenario.keys():
+            scenario_gauges.append(gauge)
+    return list(set(scenario_gauges))