py-ewr 2.3.8__py3-none-any.whl → 2.4.0__py3-none-any.whl

py_ewr/evaluate_EWRs.py

@@ -22,7 +22,7 @@ warnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)
 
 def component_pull(EWR_table: pd.DataFrame, gauge: str, pu: str, ewr: str, component: str, pu_ID: bool = True) -> str:
     '''Pass ewr details (planning unit, gauge, ewr, and ewr component) and the ewr table, 
-    this function will then pull the component from the table.
+    this function will then pull the component from the table.   
 
     Args:
         EWR_table (pd.DataFrame): Dataframe of EWRs
@@ -302,7 +302,7 @@ def ctf_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.
         PU_df (pd.DataFrame): ewr results for the current planning unit iteration
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
 
     '''
     # Get information about ewr:
@@ -314,11 +314,11 @@ def ctf_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.
     water_years = wateryear_daily(df_F, EWR_info)
     # Check flow data against ewr requirements and then perform analysis on the results:
     if ((EWR_info['start_month'] == 7) and (EWR_info['end_month'] == 6)):
-        E, D = ctf_calc_anytime(EWR_info, df_F[gauge].values, water_years, df_F.index)
+        E = ctf_calc_anytime(EWR_info, df_F[gauge].values, water_years, df_F.index)
     else:
-        E, D = ctf_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+        E = ctf_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def lowflow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling low flow type EWRs (Very low flows and baseflows)
@@ -332,7 +332,7 @@ def lowflow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F:
         PU_df (pd.DataFrame): ewr results for the current planning unit iteration
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
     
     '''
     # Get information about ewr:
@@ -343,9 +343,9 @@ def lowflow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F:
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_F, EWR_info)
     # Check flow data against ewr requirements and then perform analysis on the results:
-    E, D = lowflow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = lowflow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def flow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling non low flow based flow EWRs (freshes, bankfulls, overbanks)
@@ -359,7 +359,7 @@ def flow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd
         PU_df (pd.DataFrame): ewr results for the current planning unit iteration
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
     
     '''
     # Get information about ewr:
@@ -370,9 +370,9 @@ def flow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_F, EWR_info)
     # Check flow data against ewr requirements and then perform analysis on the results:
-    E, D = flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def flow_handle_anytime(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling flow based flow EWRs (freshes, bankfulls, overbanks) to allow flows to continue to record
@@ -388,7 +388,7 @@ def flow_handle_anytime(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame,
 
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
     
     '''
     # Get information about ewr:
@@ -400,11 +400,11 @@ def flow_handle_anytime(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame,
     water_years = wateryear_daily(df_F, EWR_info)
     # Check flow data against ewr requirements and then perform analysis on the results
     if ((EWR_info['start_month'] == 7) and (EWR_info['end_month'] == 6)):
-        E,  D = flow_calc_anytime(EWR_info, df_F[gauge].values, water_years, df_F.index)
+        E = flow_calc_anytime(EWR_info, df_F[gauge].values, water_years, df_F.index)
     else:
-        E,  D = flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+        E = flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def flow_handle_check_ctf(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling non low flow based flow EWRs 
@@ -418,7 +418,7 @@ def flow_handle_check_ctf(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame
         PU_df (pd.DataFrame): ewr results for the current planning unit iteration
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information 
     
     '''
     # Get information about ewr:
@@ -429,9 +429,9 @@ def flow_handle_check_ctf(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_F, EWR_info)
     # Check flow data against ewr requirements and then perform analysis on the results:
-    E, D = flow_calc_check_ctf(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = flow_calc_check_ctf(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def cumulative_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame):
     '''For handling cumulative flow EWRs (some large freshes and overbanks, wetland flows).
@@ -455,10 +455,10 @@ def cumulative_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df
     masked_dates = mask_dates(EWR_info, df_F)
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_F, EWR_info)
-    E, D = cumulative_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
+    E = cumulative_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
 
-    return PU_df, tuple([E])
+    return PU_df, E
 
 def cumulative_handle_qld(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame):
     '''For handling cumulative flow EWRs this to meet QLD requirements for bird breeding type 2.
@@ -482,10 +482,10 @@ def cumulative_handle_qld(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame
     masked_dates = mask_dates(EWR_info, df_F)
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_F, EWR_info)
-    E, D = cumulative_calc_qld(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
+    E = cumulative_calc_qld(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
 
-    return PU_df, tuple([E])
+    return PU_df, E
 
 def cumulative_handle_bbr(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, df_L: pd.DataFrame, PU_df: pd.DataFrame):
     '''For handling cumulative flow EWRs (for bird breeding ewr QLD).
@@ -517,10 +517,10 @@ def cumulative_handle_bbr(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame
         return PU_df, None
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_F, EWR_info)
-    E, D = cumulative_calc_bbr(EWR_info, df_F[gauge].values, levels, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
+    E = cumulative_calc_bbr(EWR_info, df_F[gauge].values, levels, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
 
-    return PU_df, tuple([E])
+    return PU_df, E
 
 def water_stability_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, df_L: pd.DataFrame, 
                            PU_df: pd.DataFrame):
@@ -553,10 +553,10 @@ def water_stability_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFram
         return PU_df, None
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_F, EWR_info)
-    E, D = water_stability_calc(EWR_info, df_F[gauge].values, levels, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
+    E = water_stability_calc(EWR_info, df_F[gauge].values, levels, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
 
-    return PU_df, tuple([E])
+    return PU_df, E
 
 def water_stability_level_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_L: pd.DataFrame, PU_df: pd.DataFrame):
     '''For handling Fish Recruitment with water stability requirement (QLD).
@@ -588,10 +588,10 @@ def water_stability_level_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.Da
         return PU_df, None
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_L, EWR_info)
-    E, D = water_stability_level_calc(EWR_info, levels, water_years, df_L.index, masked_dates)
-    PU_df = event_stats(df_L, PU_df, gauge, ewr, EWR_info, E, D, water_years)
+    E = water_stability_level_calc(EWR_info, levels, water_years, df_L.index, masked_dates)
+    PU_df = event_stats(df_L, PU_df, gauge, ewr, EWR_info, E, water_years)
 
-    return PU_df, tuple([E])
+    return PU_df, E
 
 def level_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_L: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling level type EWRs (low, mid, high and very high level lake fills).
@@ -615,9 +615,9 @@ def level_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_L: p
     masked_dates = mask_dates(EWR_info, df_L) 
     # Extract a daily timeseries for water years
     water_years = wateryear_daily(df_L, EWR_info)  
-    E, D = lake_calc(EWR_info, df_L[gauge].values, water_years, df_L.index, masked_dates)
-    PU_df = event_stats(df_L, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = lake_calc(EWR_info, df_L[gauge].values, water_years, df_L.index, masked_dates)
+    PU_df = event_stats(df_L, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def weirpool_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, df_L: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling weirpool type EWRs.
@@ -632,7 +632,7 @@ def weirpool_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F
         PU_df (pd.DataFrame): ewr results for the current planning unit iteration
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information
     
     '''
 
@@ -656,9 +656,9 @@ def weirpool_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F
         also needs data for level gauge {EWR_info.get('weirpool_gauge', 'no wp gauge')}''')
         return PU_df, None
     # Check flow and level data against ewr requirements and then perform analysis on the results: 
-    E, D = weirpool_calc(EWR_info, df_F[gauge].values, levels, water_years, weirpool_type, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = weirpool_calc(EWR_info, df_F[gauge].values, levels, water_years, weirpool_type, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def nest_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, df_L: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling nest style EWRs.
@@ -673,7 +673,7 @@ def nest_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd
         PU_df (pd.DataFrame): ewr results for the current planning unit iteration
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information    
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information    
     
     '''
     # Get information about ewr (changes depending on if theres a weirpool level gauge in the ewr)
@@ -691,7 +691,7 @@ def nest_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd
     if not requires_weirpool_gauge:
         try:
             # calculate based on a trigger date and % drawdown drop
-            E, D = nest_calc_percent_trigger(EWR_info, df_F[gauge].values, water_years, df_F.index)
+            E = nest_calc_percent_trigger(EWR_info, df_F[gauge].values, water_years, df_F.index)
         except ValueError:
             log.info(f"""Please pass a value to TriggerMonth between 1..12 and TriggerDay you passed 
             TriggerMonth:{EWR_info['trigger_month']} TriggerDay:{EWR_info['trigger_day']} """)
@@ -707,13 +707,13 @@ def nest_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd
             return PU_df, None
         # handle any error in missing values in parameter sheet
         try:
-            E, D = nest_calc_weirpool(EWR_info, df_F[gauge].values, levels, water_years, df_F.index, masked_dates)
+            E = nest_calc_weirpool(EWR_info, df_F[gauge].values, levels, water_years, df_F.index, masked_dates)
         except KeyError:
             log.info(f'''Cannot evaluate this ewr for {gauge} {ewr}, due to missing parameter data. Specifically this ewr 
             also needs data for level threshold min or level threshold max''')
             return PU_df, None
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def flow_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling flow EWRs where flow needs to be combined at two gauges
@@ -727,7 +727,7 @@ def flow_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df
         PU_df (pd.DataFrame): ewr results for the current planning unit iteration
 
     Results:
-        tuple[pd.DataFrame, tuple[dict]]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information     
+        tuple[pd.DataFrame, dict]: ewr results for the current planning unit iteration (updated); dictionary of ewr event information     
     
     '''
     # Get information about the ewr:
@@ -749,9 +749,9 @@ def flow_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df
         summed flows at these two gauges.''')
         flows = flows1
 
-    E, D = flow_calc(EWR_info, flows, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = flow_calc(EWR_info, flows, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def lowflow_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling low flow EWRs where flow needs to be combined at two gauges.
@@ -787,9 +787,9 @@ def lowflow_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame,
         summed flows at these two gauges.''')
         flows = flows1
     # Check flow data against ewr requirements and then perform analysis on the results: 
-    E, D = lowflow_calc(EWR_info, flows, water_years, df_F.index, masked_dates)  
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = lowflow_calc(EWR_info, flows, water_years, df_F.index, masked_dates)  
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
  
 def ctf_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling cease to flow EWRs where flow needs to be combined at two gauges
@@ -826,11 +826,11 @@ def ctf_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_
         flows = flows1
     # Check flow data against ewr requirements and then perform analysis on the results:
     if ((EWR_info['start_month'] == 7) and (EWR_info['end_month'] == 6)):
-        E, D = ctf_calc_anytime(EWR_info, df_F[gauge].values, water_years, df_F.index)
+        E = ctf_calc_anytime(EWR_info, df_F[gauge].values, water_years, df_F.index)
     else:
-        E, D = ctf_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+        E = ctf_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def cumulative_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     '''For handling cumulative volume EWRs where flow needs to be combined at two gauges.
@@ -865,9 +865,9 @@ def cumulative_handle_multi(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFra
         flow at the gauge {gauge}. If you are running a model scenario through please disregard this message - most hydrology models have already
         summed flows at these two gauges.''')
         flows = flows1
-    E, D = cumulative_calc(EWR_info, flows, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)    
-    return PU_df, tuple([E])
+    E = cumulative_calc(EWR_info, flows, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)    
+    return PU_df, E
 
 
 def flow_handle_sa(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
@@ -895,9 +895,9 @@ def flow_handle_sa(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F:
     # Extract a daily timeseries for water years:
     water_years = wateryear_daily(df_F, EWR_info)
 
-    E, D = flow_calc_sa(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-    return PU_df, tuple([E])
+    E = flow_calc_sa(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+    return PU_df, E
 
 def barrage_flow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame, df_F: pd.DataFrame, PU_df: pd.DataFrame) -> tuple:
     """handle function to calculate barrage flow type EWRs
@@ -927,9 +927,9 @@ def barrage_flow_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame,
             # If there is no level data loaded in, let user know and skip the analysis
             df = df_F.copy(deep=True)
             df['combined_flow'] = df[all_required_gauges].sum(axis=1)
-            E, D = barrage_flow_calc(EWR_info, df['combined_flow'], water_years, df_F.index)
-            PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
-            return PU_df, tuple([E])
+            E = barrage_flow_calc(EWR_info, df['combined_flow'], water_years, df_F.index)
+            PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
+            return PU_df, E
     else:
         print(f'Missing data for barrage gauges {" ".join(all_required_gauges)}')
         return PU_df, None
@@ -969,12 +969,12 @@ def barrage_level_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame,
         df_5_day_averages['mean'] = df[all_required_gauges_in_df_L].mean(axis=1)
         cllmm_type = what_cllmm_type(EWR_info)
         if cllmm_type == 'c':
-            E, D = lower_lakes_level_calc(EWR_info, df_5_day_averages['mean'], water_years, df_L.index, masked_dates)
+            E = lower_lakes_level_calc(EWR_info, df_5_day_averages['mean'], water_years, df_L.index, masked_dates)
         if cllmm_type == 'd':
-            E, D = coorong_level_calc(EWR_info, df_5_day_averages['mean'], water_years, df_L.index, masked_dates)
+            E = coorong_level_calc(EWR_info, df_5_day_averages['mean'], water_years, df_L.index, masked_dates)
         
-        PU_df = event_stats(df_L, PU_df, gauge, ewr, EWR_info, E, D, water_years)    
-        return PU_df, tuple([E])
+        PU_df = event_stats(df_L, PU_df, gauge, ewr, EWR_info, E, water_years)    
+        return PU_df, E
 
     else:
         print(f'skipping calculation because gauge {" ".join(all_required_gauges)} is not the main barrage level gauge ') #TODO: improve error message
@@ -1006,17 +1006,17 @@ def rise_and_fall_handle(pu: str, gauge: str, ewr: str, EWR_table: pd.DataFrame,
     water_years = wateryear_daily(df_F, EWR_info)
 
     if 'RRF' in ewr:
-        E, D = rate_rise_flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+        E = rate_rise_flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
     if 'RFF' in ewr:
-        E, D = rate_fall_flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
+        E = rate_fall_flow_calc(EWR_info, df_F[gauge].values, water_years, df_F.index, masked_dates)
     if 'RRL' in ewr:
-        E, D = rate_rise_level_calc(EWR_info, df_L[gauge].values, water_years, df_F.index, masked_dates)
+        E = rate_rise_level_calc(EWR_info, df_L[gauge].values, water_years, df_F.index, masked_dates)
     if 'RFL' in ewr:
-        E, D = rate_fall_level_calc(EWR_info, df_L[gauge].values, water_years, df_F.index, masked_dates)
+        E = rate_fall_level_calc(EWR_info, df_L[gauge].values, water_years, df_F.index, masked_dates)
 
-    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, D, water_years)
+    PU_df = event_stats(df_F, PU_df, gauge, ewr, EWR_info, E, water_years)
 
-    return PU_df, tuple([E])
+    return PU_df, E
 
 
 #---------------------------------------- Checking EWRs ------------------------------------------#
@@ -2788,13 +2788,12 @@ def lowflow_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates:
         masked_dates (set): Dates within required date range
     
     Results:
-        tuple[dict, dict, list, list]: dictionaries of all events and event gaps in timeseries. Lists of annual required durations
+        dict: dictionary of all events and event gaps in timeseries.
 
     '''
     # Declare variables:
     event = []
     all_events = construct_event_dict(water_years)
-    durations = []
     # Iterate over daily flow, sending to the lowflow_check function for each iteration 
     for i, flow in enumerate(flows[:-1]):
         if dates[i] in masked_dates:
@@ -2805,7 +2804,6 @@ def lowflow_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates:
             if len(event) > 0:
                 all_events[water_years[i]].append(event)
             event = [] # Reset at the end of the water year
-            durations.append(EWR_info['duration'])
         
     # Check the final iteration, saving any ongoing events/event gaps to their spots in the dictionaries
     if dates[-1] in masked_dates:
@@ -2813,8 +2811,7 @@ def lowflow_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates:
         event, all_events = lowflow_check(EWR_info, -1, flows[-1], event, all_events, water_years, flow_date)
     if len(event) > 0:
         all_events[water_years[-1]].append(event)
-    durations.append(EWR_info['duration'])
-    return all_events,  durations
+    return all_events
 
 def ctf_calc_anytime(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.array) -> tuple:
     '''For calculating cease to flow ewrs. These have a consecutive requirement on their durations
@@ -2828,30 +2825,23 @@ def ctf_calc_anytime(EWR_info: dict, flows: np.array, water_years: np.array, dat
         dates (np.array): array of dates
     
     Results:
-        tuple[dict, dict, list, list]: dictionaries of all events and event gaps in timeseries. Lists of annual required durations
+        dict: dictionary of all events and event gaps in timeseries.
 
     '''
     # Declare variables:
     event = []
     all_events = construct_event_dict(water_years)
-    durations = []
     # Iterate over daily flow, sending to the ctf_check function each iteration:
     for i, flow in enumerate(flows[:-1]):
         flow_date = dates[i]
         event, all_events = ctf_check(EWR_info, i, flow, event, all_events, water_years, flow_date)
-        # At the end of each water year, save any ongoing events and event gaps to the dictionaries, and reset the list and counter
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     flow_date = dates[-1]
     event, all_events = ctf_check(EWR_info, -1, flows[-1], event, all_events, water_years, flow_date) 
     if len(event) > 0:
         all_events[water_years[-1]].append(event)
     
-    durations.append(EWR_info['duration'])
-    
-    return all_events, durations
-
+    return all_events
 
 def ctf_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.array, masked_dates: set) -> tuple:
     '''For calculating cease to flow ewrs. These have a consecutive requirement on their durations
@@ -2859,7 +2849,7 @@ def ctf_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.a
     water year.
 
     Args:
-        EWR_info (dict): dictionary with the parameter info of the ewr being calculated
+        EWR_info (dict): dictionary with the parameter info of the EWR being calculated
         flows (np.array): array of daily flows
         water_years (np.array): array of daily water year values
         dates (np.array): array of dates
@@ -2872,7 +2862,6 @@ def ctf_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.a
     # Declare variables:
     event = []
     all_events = construct_event_dict(water_years)
-    durations = []
     # Iterate over daily flow, sending to the ctf_check function each iteration:
     for i, flow in enumerate(flows[:-1]):
         if dates[i] in masked_dates:
@@ -2883,16 +2872,14 @@ def ctf_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.a
             if len(event) > 0:
                 all_events[water_years[i]].append(event)
                 event = []
-            durations.append(EWR_info['duration'])
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
         flow_date = dates[-1]
         event, all_events = ctf_check(EWR_info, -1, flows[-1], event, all_events, water_years, flow_date) 
     if len(event) > 0:
         all_events[water_years[-1]].append(event)
-    durations.append(EWR_info['duration'])
     
-    return all_events, durations
+    return all_events
 
 def flow_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.array, masked_dates: set) -> tuple:
     '''For calculating flow EWRs with a time constraint within their requirements. Events are
@@ -2906,14 +2893,13 @@ def flow_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.
         masked_dates (set): Dates within required date range
     
     Results:
-        tuple[dict, dict, list, list]: dictionaries of all events and event gaps in timeseries. Lists of annual required durations
+        dict: dictionary of all events and event gaps in timeseries.
 
     '''
     # Declare variables:
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
     gap_track = 0
     # Iterate over flow timeseries, sending to the flow_check function each iteration:
     for i, flow in enumerate(flows[:-1]):
@@ -2926,7 +2912,6 @@ def flow_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.
                 all_events[water_years[i]].append(event)
                 total_event = 0
             event = []
-            durations.append(EWR_info['duration'])
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -2935,9 +2920,8 @@ def flow_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.
     if len(event) > 0:
         all_events[water_years[-1]].append(event)
         total_event = 0
-    durations.append(EWR_info['duration'])
 
-    return all_events, durations
+    return all_events
 
 def flow_calc_check_ctf(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.array, masked_dates: set) -> tuple:
     '''For calculating flow EWRs with a time constraint within their requirements. Events are
@@ -2952,30 +2936,26 @@ def flow_calc_check_ctf(EWR_info: dict, flows: np.array, water_years: np.array,
         masked_dates (set): Dates within required date range
     
     Results:
-        tuple[dict, dict, list, list]: dictionaries of all events and event gaps in timeseries. Lists of annual required durations
+        dict: dictionary of all events and event gaps in timeseries.
 
     '''
     # Declare variables:
     event = []
     all_events = construct_event_dict(water_years)
-    durations = []
     ctf_state = {'events':[], 'in_event': False}
     # Iterate over flow timeseries, sending to the flow_check_ctf function each iteration:
     for i, _ in enumerate(flows[:-1]):
         if dates[i] in masked_dates:
             flow_date = dates[i]
-            all_events, ctf_state = flow_check_ctf(EWR_info, i, flows, all_events, water_years, flow_date, ctf_state)
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
+            all_events, ctf_state = flow_check_ctf(EWR_info,i, flows, all_events, water_years, flow_date, ctf_state)
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
         flow_date = dates[-1]
         if ctf_state['in_event']:
             all_events, ctf_state = process_checks_once_ctf_period_over(EWR_info, -1, flows, water_years, all_events, ctf_state)
                 
-    durations.append(EWR_info['duration'])
 
-    return all_events, durations
+    return all_events
     
 def flow_calc_anytime(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.array) -> tuple:
     '''For calculating flow EWRs with no time constraint within their requirements. Events crossing
@@ -2988,30 +2968,26 @@ def flow_calc_anytime(EWR_info: dict, flows: np.array, water_years: np.array, da
         dates (np.array): array of dates
     
     Results:
-        tuple[dict, dict, list, list]: dictionaries of all events and event gaps in timeseries. Lists of annual required durations
+        dict: dictionary of all events and event gaps in timeseries.
 
     '''
     # Declare variables:
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
     gap_track = 0
     # Iterate over flows:
     for i, flow in enumerate(flows[:-1]):
         flow_date = dates[i]
         event, all_events,  gap_track, total_event = flow_check(EWR_info, i, flow, event, all_events, gap_track, water_years, total_event, flow_date)  
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     flow_date = dates[-1]
     event, all_events, gap_track, total_event = flow_check(EWR_info, -1, flows[-1], event, all_events, gap_track, water_years, total_event, flow_date)
     if len(event) > 0:
         water_year = which_water_year(-1, total_event, water_years)
         all_events[water_year].append(event)
-    durations.append(EWR_info['duration'])
 
-    return all_events, durations
+    return all_events
 
 
 def lake_calc(EWR_info: dict, levels: np.array, water_years: np.array, dates: np.array, masked_dates: set)-> tuple:
@@ -3029,14 +3005,13 @@ def lake_calc(EWR_info: dict, levels: np.array, water_years: np.array, dates: np
         masked_dates (set): List of the dates that the ewr needs to be calculated i.e. the time window.
 
     Returns:
-        tuple: final output with the calculation of volume all_events, durations
+        dict: final output with the calculation of volume all_events
     """
 
     # Declare variables:
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
     gap_track = 0
     # Iterate over flow timeseries, sending to the flow_check function each iteration:
     for i, level in enumerate(levels[:-1]):
@@ -3052,7 +3027,6 @@ def lake_calc(EWR_info: dict, levels: np.array, water_years: np.array, dates: np
                 event_at_year_end = deepcopy(event)
                 all_events[water_years[i]].append(event_at_year_end)
                 total_event = 0
-            durations.append(EWR_info['duration'])
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -3063,9 +3037,8 @@ def lake_calc(EWR_info: dict, levels: np.array, water_years: np.array, dates: np
         
     if len(event) >= EWR_info['duration'] and len(event) <= EWR_info['max_duration']:
         all_events[water_years[-1]].append(event)
-    durations.append(EWR_info['duration'])
 
-    return all_events, durations
+    return all_events
 
 def cumulative_calc(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.array, masked_dates: set)-> tuple:
     """ Calculate and manage state of the Volume ewr calculations. It delegates to volume_check function
@@ -3080,12 +3053,11 @@ def cumulative_calc(EWR_info: dict, flows: np.array, water_years: np.array, date
         masked_dates (set): List of the dates that the ewr needs to be calculated i.e. the time window.
 
     Returns:
-        tuple: final output with the calculation of volume all_events, durations
+        dict: final output with the calculation of volume all_events
     """
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
     gap_track = 0
     # Iterate over flow timeseries, sending to the flow_check function each iteration:
     roller = 0
@@ -3104,7 +3076,6 @@ def cumulative_calc(EWR_info: dict, flows: np.array, water_years: np.array, date
                 all_events[water_years[i]].append(event)
                 total_event = 0
             event = []
-            durations.append(EWR_info['duration'])
     
     if dates[-1] in masked_dates:
         roller = check_roller_reset_points(roller, dates[-1], EWR_info)
@@ -3112,10 +3083,9 @@ def cumulative_calc(EWR_info: dict, flows: np.array, water_years: np.array, date
         event, all_events, gap_track, total_event, roller = volume_check(EWR_info, -1, flows[-1], event, all_events,
                                                                                              gap_track, water_years, 
                                                                                             total_event, flow_date, roller, max_roller, flows)   
-    durations.append(EWR_info['duration'])
 
 
-    return all_events, durations
+    return all_events
 
 def cumulative_calc_qld(EWR_info: dict, flows: np.array, water_years: np.array, dates: np.array, masked_dates: set)-> tuple:
     """ Calculate and manage state of the Volume ewr calculations. It delegates to volume_check function
@@ -3130,12 +3100,11 @@ def cumulative_calc_qld(EWR_info: dict, flows: np.array, water_years: np.array,
         masked_dates (set): List of the dates that the ewr needs to be calculated i.e. the time window.
 
     Returns:
-        tuple: final output with the calculation of volume all_events, durations
+        dict: final output with the calculation of volume all_events
     """
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
     # Iterate over flow timeseries, sending to the flow_check function each iteration:
     roller = 0
     max_roller = EWR_info['accumulation_period']
@@ -3146,19 +3115,15 @@ def cumulative_calc_qld(EWR_info: dict, flows: np.array, water_years: np.array,
             event, all_events, total_event, roller = volume_check_qld(EWR_info, i, event, all_events, 
                                                                                               water_years, total_event, flow_date, 
                                                                                              roller, max_roller, flows)
-        # At the end of each water year, save any ongoing events and event gaps to the dictionaries, and reset the list and counter
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
     
     if dates[-1] in masked_dates:
         roller = check_roller_reset_points(roller, dates[-1], EWR_info)
         flow_date = dates[-1]
         event, all_events, total_event, roller = volume_check_qld(EWR_info, -1, event, all_events,
                                                                                            water_years, total_event, flow_date, 
-                                                                                            roller, max_roller, flows)   
-    durations.append(EWR_info['duration'])
+                                                                                            roller, max_roller, flows)
 
-    return all_events, durations
+    return all_events
 
 def cumulative_calc_bbr(EWR_info: dict, flows: np.array, levels: np.array, water_years: np.array, dates: np.array, masked_dates: set)-> tuple:
     """ Calculate and manage state of the Volume ewr calculations. It delegates to volume_check function
@@ -3174,12 +3139,11 @@ def cumulative_calc_bbr(EWR_info: dict, flows: np.array, levels: np.array, water
         masked_dates (set): List of the dates that the ewr needs to be calculated i.e. the time window.
 
     Returns:
-        tuple: final output with the calculation of volume all_events, durations
+        dict: final output with the calculation of volume all_events
     """
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
     # Iterate over flow timeseries, sending to the flow_check function each iteration:
     event_state = {}
     event_state["level_crossed_up"] = False
@@ -3190,17 +3154,15 @@ def cumulative_calc_bbr(EWR_info: dict, flows: np.array, levels: np.array, water
         flow_date = dates[i]
         event, all_events, total_event, event_state = volume_level_check_bbr(EWR_info, i, flow, event, all_events, 
                                                                                         water_years, total_event, flow_date, event_state, levels)
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
+
     
     if dates[-1] in masked_dates:
         flow_date = dates[-1]
         event, all_events, total_event, event_state = volume_level_check_bbr(EWR_info, -1, flows[-1], event, all_events,
-                                                                                             water_years, total_event, flow_date, event_state, levels)   
-    durations.append(EWR_info['duration'])
+                                                                                             water_years, total_event, flow_date, event_state, levels)
 
 
-    return all_events, durations
+    return all_events
 
 
 def water_stability_calc(EWR_info: dict, flows: np.array, levels: np.array, water_years: np.array, dates: np.array, masked_dates: set)-> tuple:
@@ -3216,21 +3178,21 @@ def water_stability_calc(EWR_info: dict, flows: np.array, levels: np.array, wate
         masked_dates (set): List of the dates that the ewr needs to be calculated i.e. the time window.
 
     Returns:
-        tuple: final output with the calculation of volume all_events, durations
+        dict: final output with the calculation of volume all_events
     """
     all_events = construct_event_dict(water_years)
-    durations = []
+    
 
 
     for i, _ in enumerate(flows):
         if dates[i] in masked_dates:
             flow_date = dates[i]
             all_events = water_stability_check(EWR_info, i, flows, all_events, water_years, flow_date, levels)
-            durations.append(EWR_info['duration'])
+           
     
-    durations.append(EWR_info['duration'])
+   
 
-    return all_events, durations
+    return all_events
 
 def water_stability_level_calc(EWR_info: dict, levels: np.array, water_years: np.array, dates: np.array, masked_dates: set)-> tuple:
     """ Calculate the water stability EWRs (LEVEL VERSION)  
@@ -3248,18 +3210,18 @@ def water_stability_level_calc(EWR_info: dict, levels: np.array, water_years: np
         tuple: final output with the calculation of volume all_events, durations
     """
     all_events = construct_event_dict(water_years)
-    durations = []
+    
 
 
     for i, _ in enumerate(levels):
         if dates[i] in masked_dates:
             flow_date = dates[i]
             all_events = water_stability_level_check(EWR_info, i, all_events, water_years, flow_date, levels)
-            durations.append(EWR_info['duration'])
+           
     
-    durations.append(EWR_info['duration'])
+   
 
-    return all_events, durations
+    return all_events
 
 
 def nest_calc_weirpool(EWR_info: dict, flows: list, levels: list, water_years: list, 
@@ -3287,7 +3249,7 @@ def nest_calc_weirpool(EWR_info: dict, flows: list, levels: list, water_years: l
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     # Iterate over flow timeseries, sending to the weirpool_check function each iteration:
     for i, flow in enumerate(flows[:-1]):
@@ -3304,9 +3266,6 @@ def nest_calc_weirpool(EWR_info: dict, flows: list, levels: list, water_years: l
                 all_events[water_years[i]].append(event)
             total_event = 0
             event = []
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
-        
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
         flow_date = dates[-1]
@@ -3318,9 +3277,9 @@ def nest_calc_weirpool(EWR_info: dict, flows: list, levels: list, water_years: l
         all_events[water_years[-1]].append(event)
         total_event = 0
     
-    durations.append(EWR_info['duration'])
+   
 
-    return all_events, durations
+    return all_events
 
 
 def nest_calc_percent_trigger(EWR_info:Dict, flows:List, water_years:List, dates:List)->tuple:
@@ -3351,7 +3310,7 @@ def nest_calc_percent_trigger(EWR_info:Dict, flows:List, water_years:List, dates
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     for i, flow in enumerate(flows[:-1]):   
             flow_date = dates[i]
@@ -3387,10 +3346,6 @@ def nest_calc_percent_trigger(EWR_info:Dict, flows:List, water_years:List, dates
                 if is_in_trigger_window and iteration_no_event == 0:
                     event, all_events,  gap_track, total_event, iteration_no_event = nest_flow_check(EWR_info, i, flow, event, all_events, 
                                                          gap_track, water_years, total_event, flow_date, flow_percent_change, iteration_no_event)
-
-            # at end of water year record duration and min event values
-            if water_years[i] != water_years[i+1]:
-                durations.append(EWR_info['duration'])
     
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     # reset all variable to last flow
@@ -3423,8 +3378,8 @@ def nest_calc_percent_trigger(EWR_info:Dict, flows:List, water_years:List, dates
         all_events[water_years[-1]].append(event)
         total_event = 0
         
-    durations.append(EWR_info['duration'])
-    return all_events, durations
+    
+    return all_events
        
 
 def weirpool_calc(EWR_info: Dict, flows: List, levels: List, water_years: List, weirpool_type: str, 
@@ -3448,7 +3403,7 @@ def weirpool_calc(EWR_info: Dict, flows: List, levels: List, water_years: List,
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     # Iterate over flow timeseries, sending to the weirpool_check function each iteration:
     for i, flow in enumerate(flows[:-1]):
@@ -3464,7 +3419,7 @@ def weirpool_calc(EWR_info: Dict, flows: List, levels: List, water_years: List,
                 all_events[water_years[i]].append(event)
             total_event = 0
             event = []
-            durations.append(EWR_info['duration'])
+           
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -3477,9 +3432,9 @@ def weirpool_calc(EWR_info: Dict, flows: List, levels: List, water_years: List,
         all_events[water_years[-1]].append(event)
         total_event = 0
         
-    durations.append(EWR_info['duration'])
+   
 
-    return all_events, durations
+    return all_events
 
 def flow_calc_sa(EWR_info: Dict, flows: List, water_years: List, 
                         dates:List, masked_dates:List)-> tuple:
@@ -3500,7 +3455,7 @@ def flow_calc_sa(EWR_info: Dict, flows: List, water_years: List,
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     for i, flow in enumerate(flows[:-1]):
         if dates[i] in masked_dates:
@@ -3516,7 +3471,7 @@ def flow_calc_sa(EWR_info: Dict, flows: List, water_years: List,
                     all_events[water_years[i]].append(event)
             total_event = 0
             event = []
-            durations.append(EWR_info['duration'])
+           
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -3530,9 +3485,9 @@ def flow_calc_sa(EWR_info: Dict, flows: List, water_years: List,
             all_events[water_years[-1]].append(event)
         total_event = 0
         
-    durations.append(EWR_info['duration'])
+    
 
-    return all_events, durations
+    return all_events
 
 def rate_rise_flow_calc(EWR_info: Dict, flows: List, water_years: List, 
                         dates:List, masked_dates:List)-> tuple:
@@ -3552,7 +3507,7 @@ def rate_rise_flow_calc(EWR_info: Dict, flows: List, water_years: List,
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     for i, flow in enumerate(flows[1:-1]):
         if dates[i] in masked_dates:
@@ -3560,9 +3515,6 @@ def rate_rise_flow_calc(EWR_info: Dict, flows: List, water_years: List,
             event, all_events, gap_track, total_event = rate_rise_flow_check(EWR_info, i, event,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, flows)
-        # At the end of each water year, save any ongoing events and event gaps to the dictionaries, and reset the list and counter
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -3570,9 +3522,9 @@ def rate_rise_flow_calc(EWR_info: Dict, flows: List, water_years: List,
         event, all_events, gap_track, total_event = rate_rise_flow_check(EWR_info, i, event,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, flows)
-    durations.append(EWR_info['duration'])
 
-    return all_events, durations
+
+    return all_events
 
 def rate_fall_flow_calc(EWR_info: Dict, flows: List, water_years: List, 
                         dates:List, masked_dates:List)-> tuple:
@@ -3592,7 +3544,7 @@ def rate_fall_flow_calc(EWR_info: Dict, flows: List, water_years: List,
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     for i, _ in enumerate(flows[:-1]):
         if i == 0:
@@ -3603,8 +3555,7 @@ def rate_fall_flow_calc(EWR_info: Dict, flows: List, water_years: List,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, flows)
         # At the end of each water year, save any ongoing events and event gaps to the dictionaries, and reset the list and counter
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
+        
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -3612,9 +3563,9 @@ def rate_fall_flow_calc(EWR_info: Dict, flows: List, water_years: List,
         event, all_events, gap_track, total_event = rate_fall_flow_check(EWR_info, -1, event,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, flows)
-    durations.append(EWR_info['duration'])
+   
 
-    return all_events, durations
+    return all_events
 
 
 def rate_rise_level_calc(EWR_info: Dict, levels: List, water_years: List, 
@@ -3635,7 +3586,7 @@ def rate_rise_level_calc(EWR_info: Dict, levels: List, water_years: List,
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     for i, _ in enumerate(levels[:-1]):
         if i == 0:
@@ -3645,8 +3596,7 @@ def rate_rise_level_calc(EWR_info: Dict, levels: List, water_years: List,
             event, all_events, gap_track, total_event = rate_rise_level_check(EWR_info, i,  event,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, levels)
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
+       
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -3654,9 +3604,9 @@ def rate_rise_level_calc(EWR_info: Dict, levels: List, water_years: List,
         event, all_events, gap_track, total_event =  rate_rise_level_check(EWR_info, i, event,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, levels)
-    durations.append(EWR_info['duration'])
+   
 
-    return all_events, durations
+    return all_events
 
 def rate_fall_level_calc(EWR_info: Dict, levels: List, water_years: List, 
                         dates:List, masked_dates:List)-> tuple:
@@ -3676,7 +3626,7 @@ def rate_fall_level_calc(EWR_info: Dict, levels: List, water_years: List,
     event = []
     total_event = 0
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     gap_track = 0
     for i, flow in enumerate(levels[1:-1]):
         if i == 0:
@@ -3686,9 +3636,6 @@ def rate_fall_level_calc(EWR_info: Dict, levels: List, water_years: List,
             event, all_events, gap_track, total_event = rate_fall_level_check(EWR_info, i, event,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, levels)
-        # At the end of each water year, save any ongoing events and event gaps to the dictionaries, and reset the list and counter
-        if water_years[i] != water_years[i+1]:
-            durations.append(EWR_info['duration'])
         
     # Check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     if dates[-1] in masked_dates:
@@ -3696,9 +3643,9 @@ def rate_fall_level_calc(EWR_info: Dict, levels: List, water_years: List,
         event, all_events, gap_track, total_event =  rate_fall_level_check(EWR_info, i, event,
                                                                                 all_events, gap_track, 
                                                                                 water_years, total_event, flow_date, levels)
-    durations.append(EWR_info['duration'])
+   
 
-    return all_events, durations
+    return all_events
 
 
 def barrage_flow_calc(EWR_info: Dict, flows: pd.Series, water_years: List, dates:List)-> tuple:
@@ -3718,7 +3665,7 @@ def barrage_flow_calc(EWR_info: Dict, flows: pd.Series, water_years: List, dates
     # declare variables:
     event = []
     all_events = construct_event_dict(water_years)
-    durations = []
+    
 
     for i, _ in enumerate(flows.values[:-1]):
         # At the end of each water year check last year barrage flow total if it above minimum threshold
@@ -3726,13 +3673,13 @@ def barrage_flow_calc(EWR_info: Dict, flows: pd.Series, water_years: List, dates
             flow_date = dates[i]
             event, all_events= barrage_flow_check(EWR_info, flows, event, all_events,  flow_date)
             event = []
-            durations.append(EWR_info['duration'])
+           
     
     # check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     event, all_events = barrage_flow_check(EWR_info, flows, event, all_events, dates[-1])
     event = []
-    durations.append(EWR_info['duration'])
-    return  all_events, durations
+   
+    return  all_events
     
 def coorong_level_calc(EWR_info: Dict, levels: pd.Series, water_years: List, dates:List, masked_dates:List)-> tuple:
     """iterate level data for barrage combined levels are with in minimum levels
@@ -3750,7 +3697,7 @@ def coorong_level_calc(EWR_info: Dict, levels: pd.Series, water_years: List, dat
     # declare variables:
     event = []
     all_events = construct_event_dict(water_years)
-    durations = []
+    
     total_event = 0
 
     for i, _ in enumerate(levels.values[:-1]):
@@ -3763,15 +3710,15 @@ def coorong_level_calc(EWR_info: Dict, levels: pd.Series, water_years: List, dat
                 all_events[water_years[i]].append(event)
             total_event = 0
             event = []
-            durations.append(EWR_info['duration'])
+           
     
     # check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     event, all_events = coorong_check(EWR_info, levels, event, all_events, level_date, water_years, i, total_event)
     event = []
-    durations.append(EWR_info['duration'])
-    return all_events,  durations
+   
+    return all_events
 
-def lower_lakes_level_calc(EWR_info: Dict, levels: pd.Series, water_years: List, dates:List, masked_dates:List)-> tuple:
+def lower_lakes_level_calc(EWR_info: Dict, levels: pd.Series, water_years: List, dates:List, masked_dates:List) -> dict:
     """iterate level data for barrage combined levels and check at the end of each year
     if barrage level is at the required minimum as well as the seasonal peak levels threshold
 
@@ -3783,12 +3730,12 @@ def lower_lakes_level_calc(EWR_info: Dict, levels: pd.Series, water_years: List,
         masked_dates (List): List of the dates that the ewr needs to be calculated i.e. the time window.
 
     Returns:
-        tuple: final output with the calculation of volume all_events,  durations
+        dict: final output with the calculation of volume all_events
     """
     # declare variables:
     event = []
     all_events = construct_event_dict(water_years)
-    durations = []
+    
 
     for i, _ in enumerate(levels.values[:-1]):
         # At the end of each water year check last year barrage flow total if it above minimum threshold
@@ -3796,13 +3743,13 @@ def lower_lakes_level_calc(EWR_info: Dict, levels: pd.Series, water_years: List,
             flow_date = dates[i]
             event, all_events = lower_lakes_level_check(EWR_info, levels, event, all_events, flow_date)
             event = []
-            durations.append(EWR_info['duration'])
+           
     
     # check final iteration in the flow timeseries, saving any ongoing events/event gaps to their spots in the dictionaries:
     event, all_events = lower_lakes_level_check(EWR_info, levels, event, all_events, flow_date)
     event = []
-    durations.append(EWR_info['duration'])
-    return  all_events, durations
+   
+    return all_events
 
 #------------------------------------ Stats on ewr events ----------------------------------------#
 
@@ -3823,7 +3770,7 @@ def filter_min_events(EWR_info:Dict, events:Dict)-> Dict:
 
     return filtered_events
 
-def get_event_years(EWR_info:Dict, events:Dict, unique_water_years:set, durations:List) -> List:
+def get_event_years(EWR_info:Dict, events:Dict, unique_water_years:set) -> List:
     '''Returns a list of years with events (represented by a 1), and years without events (0)
     
     Args:
@@ -3842,7 +3789,7 @@ def get_event_years(EWR_info:Dict, events:Dict, unique_water_years:set, duration
         combined_len = 0
         for e in events_filtered[year]:
             combined_len += len(e)
-        if ((combined_len >= durations[index] and len(events_filtered[year])>=EWR_info['events_per_year'])):
+        if ((combined_len >=EWR_info['duration'] and len(events_filtered[year])>=EWR_info['events_per_year'])):
             event_years.append(1)
         else:
             event_years.append(0)
@@ -3850,7 +3797,7 @@ def get_event_years(EWR_info:Dict, events:Dict, unique_water_years:set, duration
     return event_years
 
 
-def get_achievements(EWR_info:Dict, events:Dict, unique_water_years:set, durations:List) -> List:
+def get_achievements(EWR_info:Dict, events:Dict, unique_water_years:set) -> List:
     '''Returns a list of number of events per year.
     
     Args:
@@ -3869,7 +3816,7 @@ def get_achievements(EWR_info:Dict, events:Dict, unique_water_years:set, duratio
         yearly_events = 0
         for e in events_filtered[year]:
             combined_len += len(e)
-            if combined_len >= durations[index]:
+            if combined_len >=EWR_info['duration']:
                 yearly_events += 1
                 combined_len = 0
         total = yearly_events/EWR_info['events_per_year']
@@ -3903,7 +3850,7 @@ def get_achievements_connecting_events(events: Dict, unique_water_years:set)->Li
                 achievements_per_years.append(achievement_count)
     return achievements_per_years
 
-def get_number_events(EWR_info:Dict, events:Dict, unique_water_years:set, durations:List) -> List:
+def get_number_events(EWR_info:Dict, events:Dict, unique_water_years:set) -> List:
     '''Returns a list of number of events per year
     
     Args:
@@ -3923,7 +3870,7 @@ def get_number_events(EWR_info:Dict, events:Dict, unique_water_years:set, durati
         yearly_events = 0
         for e in events_filtered[year]:
             combined_len += len(e)
-            if combined_len >= durations[index]:
+            if combined_len >=EWR_info['duration']:
                 yearly_events += 1
                 combined_len = 0
         total = yearly_events
@@ -4147,7 +4094,7 @@ def get_event_max_inter_event_achieved(EWR_info:Dict, no_events:Dict , unique_wa
         log.error(e)
     return [0 if (max_inter_event > EWR_info['max_inter-event']*365) else 1 for max_inter_event in max_inter_event_achieved]
 
-def get_max_rolling_duration_achievement(durations:List[int], max_consecutive_days:List[int])-> List[int]:
+def get_max_rolling_duration_achievement(EWR_info:Dict, max_consecutive_days:List[int])-> List[int]:
     """test if in a given year the max rolling duration was equals or above the min duration.
 
     Args:
@@ -4157,7 +4104,7 @@ def get_max_rolling_duration_achievement(durations:List[int], max_consecutive_da
     Returns:
         List[int]: a list of 1 and 0 where 1 is achievement and 0 is no achievement.
     """
-    return [1 if (max_rolling >= durations[index]) else 0 for index, max_rolling in enumerate(max_consecutive_days)]
+    return [1 if (max_rolling >=EWR_info['duration']) else 0 for index, max_rolling in enumerate(max_consecutive_days)]
 
 def get_all_events(yearly_events:dict)-> List:
     """count the events in a collection of years
@@ -4226,7 +4173,7 @@ def get_total_series_days(water_years:List) -> pd.Series:
     
     return intoSeries
 
-def event_stats(df:pd.DataFrame, PU_df:pd.DataFrame, gauge:str, ewr:str, EWR_info:Dict, events:Dict, durations:List, water_years:List) -> pd.DataFrame:
+def event_stats(df:pd.DataFrame, PU_df:pd.DataFrame, gauge:str, ewr:str, EWR_info:Dict, events:Dict, water_years:List) -> pd.DataFrame:
     ''' Produces statistics based on the event dictionaries and event gap dictionaries.
     
     Args:
@@ -4246,7 +4193,7 @@ def event_stats(df:pd.DataFrame, PU_df:pd.DataFrame, gauge:str, ewr:str, EWR_inf
     '''
     unique_water_years = set(water_years)
     # Years with events
-    years_with_events = get_event_years(EWR_info, events, unique_water_years, durations)
+    years_with_events = get_event_years(EWR_info, events, unique_water_years)
 
     ## reset the no_events to keep functionality but switched off
     no_events = construct_event_dict(water_years)
@@ -4263,7 +4210,7 @@ def event_stats(df:pd.DataFrame, PU_df:pd.DataFrame, gauge:str, ewr:str, EWR_inf
     YWE = pd.Series(name = str(ewr + '_eventYears'), data = years_with_events, index = unique_water_years)
     # PU_df = pd.concat([PU_df, YWE], axis = 1)
     # Number of event achievements:
-    num_event_achievements = get_achievements(EWR_info, events, unique_water_years, durations)
+    num_event_achievements = get_achievements(EWR_info, events, unique_water_years)
 
     if EWR_info['Code'] in ['rANA']:
         num_event_achievements = get_achievements_connecting_events(events, unique_water_years)
@@ -4271,7 +4218,7 @@ def event_stats(df:pd.DataFrame, PU_df:pd.DataFrame, gauge:str, ewr:str, EWR_inf
     NEA = pd.Series(name = str(ewr + '_numAchieved'), data= num_event_achievements, index = unique_water_years)
     # PU_df = pd.concat([PU_df, NEA], axis = 1)
     # Total number of events THIS ONE IS ONLY ACHIEVED due to Filter Applied
-    num_events = get_number_events(EWR_info, events, unique_water_years, durations)
+    num_events = get_number_events(EWR_info, events, unique_water_years)
     NE = pd.Series(name = str(ewr + '_numEvents'), data= num_events, index = unique_water_years)
     # PU_df = pd.concat([PU_df, NE], axis = 1)
     # Total number of events THIS ONE IS ALL EVENTS
@@ -4317,7 +4264,7 @@ def event_stats(df:pd.DataFrame, PU_df:pd.DataFrame, gauge:str, ewr:str, EWR_inf
         # PU_df = pd.concat([PU_df, MR], axis = 1)
         log.error(e)
     # Max rolling duration achieved
-    achieved_max_rolling_duration = get_max_rolling_duration_achievement(durations, max_consecutive_days)
+    achieved_max_rolling_duration = get_max_rolling_duration_achievement(EWR_info, max_consecutive_days)
     MRA = pd.Series(name = str(ewr + '_maxRollingAchievement'), data = achieved_max_rolling_duration, index = unique_water_years)
     # PU_df = pd.concat([PU_df, MRA], axis = 1)
     # Append information around available and missing data: