diff --git a/.gitignore b/.gitignore index 68bc17f9..f875d659 100644 --- a/.gitignore +++ b/.gitignore @@ -158,3 +158,5 @@ cython_debug/ # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +.DS_Store \ No newline at end of file diff --git a/README.md b/README.md index f63cdc45..9f8ae507 100644 --- a/README.md +++ b/README.md @@ -132,7 +132,7 @@ We provide two methods to access location data: ```python from watttime import WattTimeMaps -wt = WattTimeMaps(username, password) +wt = WattTimeMaps() # get BA region for a given location wt.region_from_loc( @@ -144,3 +144,17 @@ wt.region_from_loc( # get shape files for all regions of a signal type wt.get_maps_json('co2_moer') ``` + +# Optimizer Package + +[Optimizer Read Me](https://github.com/jbadsdata/watttime-python-client/blob/5780c09e1a7aaae0bc9746cd0004c64c263ead1f/watttime_optimizer/Optimizer%20README.md) + +WattTime data users use WattTime electricity grid-related data for real-time, evidence-based emissions reduction strategies. + +The [WattTimeOptimizer](https://github.com/jbadsdata/watttime-python-client/tree/b45fd677cb38ec8e9095b1e4a53f5bb43383820b/watttime_optimizer) is an experimental feature designed to support the rapid development of automated emissions reduction (“AER”) software applications. It produces a proposed power usage schedule that minimizes carbon emissions subject to user and device constraints. + +The feature has four basic requirements: Watttime’s forecast of marginal emissions (MOER) for a particular region, device capacity and energy needs, project usage window start time and projected window end time. The [underlying algorithms](https://github.com/jbadsdata/watttime-python-client/tree/b45fd677cb38ec8e9095b1e4a53f5bb43383820b/watttime_optimizer/alg) are simple enough to serve as a base for set of predefined use cases, outlined in the Optimizer Read Me, and mature enough to extend to encompass the requirements of more complex machinery. + +Get started by reviewing example notebooks [here](https://github.com/jbadsdata/watttime-python-client/tree/b45fd677cb38ec8e9095b1e4a53f5bb43383820b/watttime_optimizer/notebooks). + + diff --git a/setup.py b/setup.py index 86ba5e47..d5823dac 100644 --- a/setup.py +++ b/setup.py @@ -6,7 +6,7 @@ long_description=open('README.md').read(), long_description_content_type="text/markdown", version="v1.2.1", - packages=["watttime"], + packages=["watttime","watttime_optimizer"], python_requires=">=3.8", - install_requires=["requests", "pandas>1.0.0", "python-dateutil"], + install_requires=["requests", "pandas>1.0.0", "python-dateutil","tqdm"], ) diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/test_battery.py b/tests/test_battery.py new file mode 100644 index 00000000..505a0453 --- /dev/null +++ b/tests/test_battery.py @@ -0,0 +1,16 @@ +from watttime_optimizer.battery import Battery, CARS +import pandas as pd + +tesla_charging_curve = pd.DataFrame( + columns=["SoC", "kW"], + data = CARS['tesla'] + ) + +capacity_kWh = 70 +initial_soc = .50 + +batt = Battery(tesla_charging_curve) + +df = batt.get_usage_power_kw_df(capacity_kWh=capacity_kWh, initial_soc=initial_soc) + +print(df.head()) \ No newline at end of file diff --git a/tests/test_optimizer.py b/tests/test_optimizer.py new file mode 100644 index 00000000..597363c1 --- /dev/null +++ b/tests/test_optimizer.py @@ -0,0 +1,598 @@ +import os +from datetime import datetime, timedelta +import unittest +import pandas as pd +from pytz import UTC +from watttime_optimizer import WattTimeOptimizer + +REGION = "CAISO_NORTH" + +def get_usage_plan_mean_power(usage_plan): + usage_plan_when_active = usage_plan[usage_plan["usage"] != 0].copy() + usage_plan_when_active["power_kw"] = ( + usage_plan_when_active["energy_usage_mwh"] + / (usage_plan_when_active["usage"] / 60) + * 1000 + ) + + return usage_plan_when_active["power_kw"].mean() + + +def get_contiguity_info(usage_plan): + """ + Extract contiguous non-zero components from a DataFrame column 'usage' + and compute the sum for each component. + + Args: + usage_plan (pd.DataFrame): DataFrame with a column named 'usage'. + + Returns: + List[Dict]: A list of dictionaries, each containing the indices and sum + of a contiguous non-zero component. + """ + components = [] + current_component = [] + current_sum = 0 + + for index, value in usage_plan["usage"].items(): + if value != 0: + current_component.append(index) + current_sum += value + else: + if current_component: + components.append({"indices": current_component, "sum": current_sum}) + current_component = [] + current_sum = 0 + + # Add the last component if the dataframe ends with a non-zero sequence + if current_component: + components.append({"indices": current_component, "sum": current_sum}) + + return components + + +def pretty_format_usage(usage_plan): + return "".join(["." if usage == 0 else "E" for usage in usage_plan["usage"]]) + + +class TestWattTimeOptimizer(unittest.TestCase): + @classmethod + def setUpClass(cls): + """Initialize WattTimeOptimizer before running any tests.""" + username = os.getenv("WATTTIME_USER") + password = os.getenv("WATTTIME_PASSWORD") + cls.wt_opt = WattTimeOptimizer(username, password) + cls.region = REGION + cls.usage_power_kw = 12 + now = datetime.now(UTC) + cls.window_start_test = now + timedelta(minutes=10) + cls.window_end_test = now + timedelta(minutes=720) + + def test_baseline_plan(self): + """Test the baseline plan.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=240, + usage_power_kw=self.usage_power_kw, + optimization_method="baseline", + ) + print("Using Baseline Plan\n", pretty_format_usage(usage_plan)) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 240) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 240 * self.usage_power_kw / 60 + ) + # Check number of components (1 for baseline) + self.assertEqual(len(get_contiguity_info(usage_plan)), 1) + + def test_simple_plan(self): + """Test the simple plan.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=240, + usage_power_kw=self.usage_power_kw, + optimization_method="simple", + ) + print("Using Simple Plan\n", pretty_format_usage(usage_plan)) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 240) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 240 * self.usage_power_kw / 60 + ) + + def test_dp_fixed_power_rate(self): + """Test the sophisticated plan with a fixed power rate.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=240, + usage_power_kw=self.usage_power_kw, + optimization_method="sophisticated", + ) + print("Using DP Plan w/ fixed power rate\n", pretty_format_usage(usage_plan)) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 240) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 240 * self.usage_power_kw / 60 + ) + + def test_dp_fixed_power_rate_with_uncertainty(self): + """Test the sophisticated plan with fixed power rate and time uncertainty.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=240, + usage_power_kw=self.usage_power_kw, + usage_time_uncertainty_minutes=180, + optimization_method="sophisticated", + ) + print("Using DP Plan w/ fixed power rate and charging uncertainty") + print(usage_plan["emissions_co2_lb"].sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 240) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 240 * self.usage_power_kw / 60 + ) + + def test_dp_variable_power_rate(self): + """Test the plan with variable power rate.""" + usage_power_kw_df = pd.DataFrame( + [[0, 12], [20, 12], [40, 12], [100, 12], [219, 12], [220, 2.4], [320, 2.4]], + columns=["time", "power_kw"], + ) + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=320, + usage_power_kw=usage_power_kw_df, + optimization_method="auto", + ) + print("Using DP Plan w/ variable power rate") + print(usage_plan["emissions_co2_lb"].sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 320) + # Check power + usage_plan_nonzero_entries = usage_plan[usage_plan["usage"] > 0] + power_kwh_array = ( + usage_plan_nonzero_entries["energy_usage_mwh"].values * 1e3 * 60 / 5 + ) + self.assertAlmostEqual(power_kwh_array[: 220 // 5].mean(), 12.0) + self.assertAlmostEqual(power_kwh_array[220 // 5 :].mean(), 2.4) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 220 * 12 / 60 + 100 * 2.4 / 60 + ) + + def test_dp_non_round_usage_time(self): + """Test auto mode with non-round usage time minutes.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=7, + usage_power_kw=self.usage_power_kw, + optimization_method="auto", + ) + print("Using auto mode, but with a non-round usage time minutes") + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 7) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 7 * self.usage_power_kw / 60 + ) + + def test_dp_input_time_energy(self): + """Test auto mode with a usage time and energy required.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=120, + energy_required_kwh=17, + optimization_method="auto", + ) + print("Using auto mode, with energy required in kWh") + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 120) + # Check power + self.assertAlmostEqual(get_usage_plan_mean_power(usage_plan), 8.5) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 120 * 8.5 / 60 + ) + + def test_dp_input_constant_power_energy(self): + """Test auto mode with a constant power and energy required.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_power_kw=5, + energy_required_kwh=15, + optimization_method="auto", + ) + print("Using auto mode, with energy required in kWh") + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 180) + # Check power + self.assertAlmostEqual(get_usage_plan_mean_power(usage_plan), 5) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 180 * 5 / 60 + ) + + def test_dp_two_segments_unbounded(self): + """Test auto mode with two segments.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[(0, 999999), (0, 999999)], + optimization_method="auto", + ) + print( + "Using auto mode with two unbounded segments\n", + pretty_format_usage(usage_plan), + ) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + # Check number of components + self.assertLessEqual(len(get_contiguity_info(usage_plan)), 2) + + def test_dp_two_segments_flexible_length(self): + """Test auto mode with two variable length segments.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[(60, 100), (60, 100)], + optimization_method="auto", + ) + print( + "Using auto mode with two flexible segments\n", + pretty_format_usage(usage_plan), + ) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertLessEqual(len(contiguity_info), 2) + if len(contiguity_info) == 2: + # Check first component length + self.assertGreaterEqual(contiguity_info[0]["sum"], 60) + self.assertLessEqual(contiguity_info[0]["sum"], 100) + # Check second component length + self.assertGreaterEqual(contiguity_info[1]["sum"], 60) + self.assertLessEqual(contiguity_info[1]["sum"], 100) + else: + # Check combined component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 160) + + def test_dp_two_segments_one_sided_length(self): + """Test auto mode with two variable length segments.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[(30, None), (30, None), (30, None), (30, None)], + optimization_method="auto", + ) + print( + "Using auto mode with one-sided segments\n", + pretty_format_usage(usage_plan), + ) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertLessEqual(len(contiguity_info), 4) + for i in range(len(contiguity_info)): + # Check component length + self.assertGreaterEqual(contiguity_info[i]["sum"], 30) + + def test_dp_two_segments_one_sided_length_use_all_false(self): + """Test auto mode with two variable length segments.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[(40, None), (40, None), (40, None), (40, None)], + use_all_segments=False, + optimization_method="auto", + ) + print( + "Using auto mode with one-sided segments\n", + pretty_format_usage(usage_plan), + ) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertLessEqual(len(contiguity_info), 4) + for i in range(len(contiguity_info)): + # Check component length + self.assertGreaterEqual(contiguity_info[i]["sum"], 40) + + def test_dp_two_segments_exact_input_a(self): + """Test auto mode with two segments.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[(60, 60), (100, 100)], + optimization_method="auto", + ) + print( + "Using auto mode with two exact segments\n", + pretty_format_usage(usage_plan), + ) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertLessEqual(len(contiguity_info), 2) + if len(contiguity_info) == 2: + # Check first component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 60) + # Check second component length + self.assertAlmostEqual(contiguity_info[1]["sum"], 100) + else: + # Check combined component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 160) + + def test_dp_two_segments_exact_input_b(self): + """Test auto mode with two segments.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[60, 100], + optimization_method="auto", + ) + print("Using auto mode, but with two segments") + print(pretty_format_usage(usage_plan)) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertLessEqual(len(contiguity_info), 2) + if len(contiguity_info) == 2: + # Check first component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 60) + # Check second component length + self.assertAlmostEqual(contiguity_info[1]["sum"], 100) + else: + # Check combined component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 160) + + def test_dp_two_segments_exact_unround(self): + """Test auto mode with two segments, specified via list of tuple.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[(67, 67), (93, 93)], + optimization_method="auto", + ) + print( + "Using auto mode with two exact unround segments\n", + pretty_format_usage(usage_plan), + ) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertLessEqual(len(contiguity_info), 2) + if len(contiguity_info) == 2: + # Check first component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 67) + # Check second component length + self.assertAlmostEqual(contiguity_info[1]["sum"], 93) + else: + # Check combined component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 160) + + def test_dp_two_segments_exact_unround_alternate_input(self): + """Test auto mode with two segments, specified via list of ints.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[67, 93], + optimization_method="auto", + ) + print( + "Using auto mode with two exact unround segments\n", + pretty_format_usage(usage_plan), + ) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 160) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 160 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertLessEqual(len(contiguity_info), 2) + if len(contiguity_info) == 2: + # Check first component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 67) + # Check second component length + self.assertAlmostEqual(contiguity_info[1]["sum"], 93) + else: + # Check combined component length + self.assertAlmostEqual(contiguity_info[0]["sum"], 160) + + def test_dp_two_segments_exact_inconsistent_b(self): + """Test auto mode with one segment that is inconsistent with usage_time_required.""" + usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start_test, + usage_window_end=self.window_end_test, + usage_time_required_minutes=160, + usage_power_kw=self.usage_power_kw, + charge_per_segment=[(65, 65)], + optimization_method="auto", + ) + print("Using auto mode, but with two segments") + print(pretty_format_usage(usage_plan)) + print(usage_plan.sum()) + + # Check time required + self.assertAlmostEqual(usage_plan["usage"].sum(), 65) + # Check power + self.assertAlmostEqual( + get_usage_plan_mean_power(usage_plan), self.usage_power_kw + ) + # Check energy required + self.assertAlmostEqual( + usage_plan["energy_usage_mwh"].sum() * 1000, 65 * self.usage_power_kw / 60 + ) + + contiguity_info = get_contiguity_info(usage_plan) + # Check number of components + self.assertEqual(len(contiguity_info), 1) + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_recalculator.py b/tests/test_recalculator.py new file mode 100644 index 00000000..cbb37fb4 --- /dev/null +++ b/tests/test_recalculator.py @@ -0,0 +1,103 @@ +import unittest +import os +from pytz import UTC +from watttime.api import WattTimeForecast, WattTimeOptimizer, WattTimeRecalculator +from datetime import timedelta, datetime +import pandas as pd + +class TestRecalculatingOptimizer(unittest.TestCase): + def setUp(self): + self.region = "CAISO_NORTH" + self.username = os.getenv("WATTTIME_USER") + self.password = os.getenv("WATTTIME_PASSWORD") + self.static_start_time = datetime(2025, 1, 1, hour=20, second=0, tzinfo=UTC) + self.static_end_time = datetime(2025, 1, 2, hour=8, second=0, tzinfo=UTC) + self.wt_hist = WattTimeForecast(self.username, self.password) + self.wt_opt = WattTimeOptimizer(self.username, self.password) + + self.initial_usage_plan = self.wt_opt.get_optimal_usage_plan( + region = self.region, + usage_window_start=self.static_start_time, + usage_window_end=self.static_end_time, + usage_time_required_minutes=240, + usage_power_kw=2, + optimization_method="auto", + moer_data_override = self.moer_data_override(self.static_start_time,self.static_end_time,self.region) + ) + + self.recalculating_optimizer = WattTimeRecalculator( + initial_schedule=self.initial_usage_plan, + start_time=self.static_start_time, + end_time=self.static_end_time, + total_time_required=240 + ) + + def moer_data_override(self, start_time,end_time,region): + df = self.wt_hist.get_historical_forecast_pandas( + start=start_time, + end=end_time, + region=region + ) + return df[df.generated_at == df.generated_at.min()] + + def next_query_time(self,time,interval:int = 60): + return time + timedelta(minutes=interval) + + # test initializing the recalculator class + def test_init_recalculator_class(self) -> None: + + starting_schedule = self.recalculating_optimizer.get_combined_schedule() + + self.assertEqual( + self.initial_usage_plan["usage"].tolist(), starting_schedule["usage"].tolist() + ) + + self.assertEqual(len(self.recalculating_optimizer.all_schedules), 1) + + self.assertEqual(self.initial_usage_plan["usage"].sum(), 240) + self.assertEqual(starting_schedule["usage"].sum(), 240) + + def test_multiple_schedules_combined(self) -> None: + """Test combining two schedules""" + + new_window_start = self.next_query_time(time=self.static_start_time) + new_time_required = self.recalculating_optimizer.get_remaining_time_required(new_window_start) + new_usage_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=new_window_start, + usage_window_end=self.static_end_time, + usage_time_required_minutes=new_time_required, + usage_power_kw=2, + optimization_method="auto", + moer_data_override=self.moer_data_override(new_window_start,self.static_end_time,self.region) + ) + + first_combined_schedule = self.recalculating_optimizer.get_combined_schedule() + + self.recalculating_optimizer.update_charging_schedule( + new_schedule = new_usage_plan, + next_query_time=new_window_start + ) + + second_combined_schedule = self.recalculating_optimizer.get_combined_schedule() + + self.assertNotEqual( + first_combined_schedule["usage"].tolist(), + second_combined_schedule["usage"].tolist(), + ) + self.assertEqual( + first_combined_schedule["usage"].tolist()[: 12], + second_combined_schedule["usage"].tolist()[: 12], + ) + self.assertEqual(first_combined_schedule["usage"].sum(), 240) + self.assertEqual(second_combined_schedule["usage"].sum(), 240) + + + def test_schedules_date_index(self) -> None: + idx = self.recalculating_optimizer.get_combined_schedule().index + + self.assertTrue(idx.is_unique) + self.assertListEqual(list(idx), list(pd.date_range(idx.min(),idx.max(),freq=timedelta(minutes=5)))) + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/watttime-python-client.code-workspace b/watttime-python-client.code-workspace new file mode 100644 index 00000000..ef9f5d27 --- /dev/null +++ b/watttime-python-client.code-workspace @@ -0,0 +1,7 @@ +{ + "folders": [ + { + "path": "." + } + ] +} \ No newline at end of file diff --git a/watttime/api.py b/watttime/api.py index bc5b18c0..bafaa150 100644 --- a/watttime/api.py +++ b/watttime/api.py @@ -1,5 +1,6 @@ import os import time +import math from datetime import date, datetime, timedelta from functools import cache from pathlib import Path @@ -8,7 +9,7 @@ import pandas as pd import requests from dateutil.parser import parse -from pytz import UTC +from pytz import UTC, timezone class WattTimeBase: @@ -189,19 +190,19 @@ def get_historical_jsons( """ Base function to scrape historical data, returning a list of .json responses. - Args: - start (datetime): inclusive start, with a UTC timezone. - end (datetime): inclusive end, with a UTC timezone. - region (str): string, accessible through the /my-access endpoint, or use the free region (CAISO_NORTH) - signal_type (str, optional): one of ['co2_moer', 'co2_aoer', 'health_damage']. Defaults to "co2_moer". - model (Optional[Union[str, date]], optional): Optionally provide a model, used for versioning models. - Defaults to None. + Args: + start (datetime): inclusive start, with a UTC timezone. + end (datetime): inclusive end, with a UTC timezone. + region (str): string, accessible through the /my-access endpoint, or use the free region (CAISO_NORTH) + signal_type (str, optional): one of ['co2_moer', 'co2_aoer', 'health_damage']. Defaults to "co2_moer". + model (Optional[Union[str, date]], optional): Optionally provide a model, used for versioning models. + Defaults to None. - Raises: - Exception: Scraping failed for some reason + Raises: + Exception: Scraping failed for some reason - Returns: - List[dict]: A list of dictionary representations of the .json response object + Returns: + List[dict]: A list of dictionary representations of the .json response object """ if not self._is_token_valid(): self._login() @@ -224,7 +225,7 @@ def get_historical_jsons( rsp.raise_for_status() j = rsp.json() responses.append(j) - except Exception as e: + except Exception: raise Exception( f"\nAPI Response Error: {rsp.status_code}, {rsp.text} [{rsp.headers.get('x-request-id')}]" ) @@ -493,7 +494,7 @@ def get_historical_forecast_json( rsp.raise_for_status() j = rsp.json() responses.append(j) - except Exception as e: + except Exception: raise Exception( f"\nAPI Response Error: {rsp.status_code}, {rsp.text} [{rsp.headers.get('x-request-id')}]" ) @@ -541,7 +542,6 @@ def get_historical_forecast_pandas( out = pd.concat([out, _df]) return out - class WattTimeMaps(WattTimeBase): def get_maps_json( self, @@ -567,4 +567,4 @@ def get_maps_json( params = {"signal_type": signal_type} rsp = requests.get(url, headers=headers, params=params) rsp.raise_for_status() - return rsp.json() + return rsp.json() \ No newline at end of file diff --git a/watttime/optimizer/README.md b/watttime/optimizer/README.md new file mode 100644 index 00000000..82a1785b --- /dev/null +++ b/watttime/optimizer/README.md @@ -0,0 +1,264 @@ +# Optimizer README + +## Overview + +This code is built to implement and evaluate an algorithm to produce a charging schedule for devices that minimizes carbon emissions subject to a set of constraints. It is based on Watttime’s forecast of marginal emissions combined with inputs related to device capacity and energy needs. The project presents a few optimization algorithms that operate under different assumptions and produce different results. This optionality is part of the API and the results of different algorithms presented are evaluated using actual and forecasted data from power grids in the US. The evaluation section of the project includes a suite of functions to generate synthetic user data with a few behavioral assumptions that can serve to understand the benefits and limitations of our algorithms and evaluate the magnitude of emissions that would be saved if the algorithm were used. + +* **Running the model with constraints:**: + * Contiguous (single period, fixed length): + + + +```py +## AI model training - estimated runtime is 2 hours and it needs to complete by 12pm + +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +# Suppose that the time now is 12 midnight +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) + +usage_time_required_minutes=120 +usage_power_kw = 12.0 +region = "CAISO_NORTH" + +usage_plan = wt_opt.get_optimal_usage_plan( + region=region, + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=usage_time_required_minutes, + usage_power_kw=usage_power_kw, + charge_per_interval=[usage_time_required_minutes], + optimization_method="auto", +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` + +* Contiguous (multiple periods, fixed length): + +```py +## Dishwasher - there are two cycles of length 80 min and 40 min each, and they must be completed in that order. + +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +# Suppose that the time now is 12 midnight +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) + +usage_time_required_minutes=120 +usage_power_kw = 12.0 +region = "CAISO_NORTH" + +usage_plan = wt_opt.get_optimal_usage_plan( + region=region, + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=usage_time_required_minutes, + usage_power_kw=usage_power_kw, + charge_per_interval=[80,40], + optimization_method="auto", +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` + + * Contiguous (multiple periods, variable length): + + + +```py +## Compressor - needs to run 120 minutes over the next 12 hours; each cycle needs to be at least 20 minutes long, and any number of contiguous intervals (from one to six) is okay. + +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +# Suppose that the time now is 12 midnight +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) + +usage_time_required_minutes=120 +usage_power_kw = 12.0 +region = "CAISO_NORTH" + +usage_plan = wt_opt.get_optimal_usage_plan( + region=region, + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=usage_time_required_minutes, + usage_power_kw=usage_power_kw, + # Here _None_ implies that there is no upper bound, and replacing None by 120 would have the exact same effect. + charge_per_interval=[(20,None),(20,None),(20,None),(20,None),(20,None),(20,None)], + optimization_method="auto", + use_all_intervals=False +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` + +* Partial charging guarantee: + +```py +## I would like to charge 75% by 8am in case of any emergencies (airport, kid bus, roadtrip) + +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +# Suppose that the time now is 12 midnight +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) +usage_time_required_minutes = 240 +constraint_time = now + timedelta(minutes=480) +constraint_usage_time_required_minutes = 180 +constraints = {constraint_time:constraint_usage_time_required_minutes} +usage_power_kw = 12.0 +region = "CAISO_NORTH" + +usage_plan = wt_opt.get_optimal_usage_plan( + region=region, + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=240, + usage_power_kw=usage_power_kw, + constraints=constraints, + optimization_method="auto", +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) + +``` +## Optimizer: basic principles and options + +The **basic intuition of the algorithm** is that when a device is plugged in for longer than the time required to fully charge it there exist ways to pick charging vs. non-charging time intervals such that the device draws power from the grid during cleaner intervals and thus minimizes emissions. **The algorithm takes as inputs** user and device parameters such as: the plug-in and plug-out times of the device, as well as the charging curve that determines the time it takes to charge it as well as the power that it needs to draw. **As an output, it produces** a charging schedule that divides the time between plug-in and plug-out time into charging and non-charging intervals such that emissions are minimized. Watttime’s forecast provides the basic building block for these algorithms as it forecasts when those relatively cleaner grid periods occur. + +There are **three different optimization algorithms** that are implemented in the API (alongside a baseline algorithm that just charges the device from the moment it’s plugged in to when it is fully charged, which is what devices do out of the box). We first start with **a simple algorithm** that, under full information about plug out time, uses the forecast to find the lowest possible emission interval that charges the device and outputs a charge schedule based on that. We then follow with a **sophisticated** version of the algorithm which takes into account variable charging curves and implements a dynamic optimization algorithm to adjust for the fact that device charging curves are non-linear. We provide additional functionality in the **fixed contiguous** and **contiguous** versions of the algorithms, which can enforce the charging schedule to be composed of several contiguous intervals; the length of each interval is either fixed or falls in a provided range. + +| optimization\_method | ASAP | Charging curve | Time constraint | Contiguous | +| :---- | :---- | :---- | :---- | :---- | +| baseline | Yes | Constant | No | No | +| simple | No | Constant | No | No | +| sophisticated | No | Variable | Yes | No | +| contiguous | No | Variable | Yes | Intervals at fixed lengths | +| Variable contiguous | No | Variable | Yes | Intervals at variable lengths | +| auto | No | Chooses the fastest algorithm that can still process all inputs | | | + +Evaluating the effectiveness of the algorithm, as well as the conditions that maximize emissions savings, we have implemented a suite of functions that generate synthetic user data that can be evaluated on data from the largest electrical grids in the US. The code here also contains these functions, which can be modified and are meant to capture behavioral assumptions of how users charge devices. + +A final note on device types (this is focused for now on EVs, but altering some of the behavioral assumptions of usage \+ the device charging curves can extend this functionality to other devices.) + +### Raw Inputs + +*What we simulate for each use case* + +- Capacity C + - Might also need init battery capacity if we don’t start from 0% + - Unit: kWh + - Type: energy +- Power usage curve from capacity Q:cp + - Marginal power usage to charge battery when it’s currently at capacity c + - Unit: kW + - Type: power +- Marginal emission rate M:tm + - Unit: lb/MWh + - Type: emission per energy + - We convert this to lb/kWh by multiplying M by 0.001 +- OPT\_INTERVAL + - Smallest interval on which we have constant charging behavior and emissions. + - Currently set to 5 minutes + - We have now discretized time into L=T/ intervals of length . The l-th interval is lt\<(l+1). +- Contiguity +- Constraints + +### API Inputs + +*When calling the API* + +- usage\_time\_required\_minutes Tr + - We compute this using C and Q. See example below. + - Unit: mins +- usage\_power\_kw P:tp + - Marginal power usage to charge battery when it has been charged for t minutes. Converted from Q. + - Unit: kW +- usage\_window\_start, usage\_window\_end + - These are timestamps to specify the charging window + +### Algorithm + +Find schedule s0,...,sL-1 that minimizes total emission 60l=0L-1slPl'=0l-1sl' Ml1000subject to + +* sl0,1 + * sl=1 if we charge on interval l + * sl=0 if we do not charge on interval l + * As an extension for future use cases, suppose we can supercharge the battery by consuming up to K times as much power. The DP algorithm will also be able to handle this optimization and output a schedule with sl0,1,...,K +* l=0L-1sl=Tr + * This just means that we charge for a total of Tr minutes according to this schedule. + +### API Output + + A data frame with \-spaced timestamp index and charging usage. For example, + +| time | usage (min) | energe\_use\_mwh | emissions\_co2e\_lb | +| :---- | :---- | :---- | :---- | +| 2024-7-26 15:00:00+00:00 | 5 | 0.0001 | 1.0 | +| 2024-7-26 15:05:00+00:00 | 5 | 0.0001 | 1.0 | +| 2024-7-26 15:10:00+00:00 | 0 | 0\. | 0.0 | +| 2024-7-26 15:15:00+00:00 | 5 | 0.00005 | 0.5 | + +This would mean that we charge from 15:00-15:10 and then from 15:15-15:20. Note that the last column reflects **forecast emissions** based on forecast emission rate rather than the actuals. To compute actual emissions, you can take the dot product of energey\_use\_mwh and actual emission rates. + +In mathematical terms, we compute these three columns as follows. For the l-th interval tl,l+1, we have + +* usage: sl +* energy\_use\_mwh: 1100060slPl'=0l-1sl', where 60 reflects interval length in hours and Pl'=0l-1sl' is the power. 11000 is a conversion factor from kWh to mWh +* emissions\_co2e\_lb: energy\_us\_mwh \* Mt. + +# FAQs + +## How much co2 can we expect to avoid by using the optimizer? + +The amount of emission you can avoid will vary significantly based on a range of factors. For example: + +* The grid where the charging is occurring. +* The amount of “slack time” available, that is, possible charging time beyond the minimum amount required for charging. diff --git a/watttime_optimizer/Optimizer README.md b/watttime_optimizer/Optimizer README.md new file mode 100644 index 00000000..cb5a19c2 --- /dev/null +++ b/watttime_optimizer/Optimizer README.md @@ -0,0 +1,261 @@ +# About the Optimizer Module + +WattTime data users use WattTime electricity grid-related data for real-time, evidence-based emissions reduction strategies. These data, served programmatically via API, support automation strategies that minimize carbon emissions and human health impacts. In particular, the Marginal Operating Emissions Rate (MOER) can be used to avoid emissions via time- or place-based optimizations, and to calculate the reductions achieved by project-level interventions in accordance with GHG Protocol Scope 4. + +Energy generation sources meet different energy demands throughout the day, and the WattTime forecast anticipates the order in which the generators dispatch energy based on anticipated changes in demand. So, the MOER data signal represents the emissions rate of the electricity generator(s) that dispatch energy in direct response to changes in load on the grid. + +![CO2 Avoided](https://github.com/jbadsdata/watttime-python-client/blob/optimizer/watttime_optimizer/notebooks/cumulative_avoided_emissions.png) + +# Using the Optimizer Class + +`WattTimeOptimizer` produces a proposed power usage schedule that minimizes carbon emissions subject to user and device constraints. + +The `WattTimeOptimizer` class requires 4 things: + +- Watttime’s forecast of marginal emissions (MOER) +- device capacity and energy needs +- region +- window start +- window end + +# Synthetic Data Module +- To simulate the optimizer's potential impact, we tested it on synthetic user data, an incredibly useful approach when device-level data is not yet available or too sensitive to share. +- Working with synthetic data, we can replicate device scope 2 emissions avoidance potential with and without an automated marginal emissions reduction solution. + +The `SessionsGenerator` class creates a unique synthetic dataset by drawing from distributions generated based on these inital inputs: + + - Maximum power output rate: power rating of equipment + - Maximum percent capacity: highest level of charge achieved by battery + - Power output efficiency: power loss + - Minimum batter starting capacity: lowest starting percent charged + - Minimum usage window start time: session can start as early as 8am + - Maximum usage window start time: session can start as late as 9pm + +Here is an example of how to generate synthetic data and test optimization strategies on historic observations. [synthetic data notebook](https://github.com/jbadsdata/watttime-python-client/edit/optimizer/watttime_optimizer/Optimizer%20README.md#:~:text=ev_variable_charge.ipynb-,synthetic_data,-.ipynb) + +![Example Image](https://github.com/jbadsdata/watttime-python-client/blob/optimizer/watttime_optimizer/notebooks/evaluation_plot.png) + + +## Optimization Strategies, Example Code, Notebooks + +### Model Parameters +| optimization\_method | ASAP | Charging curve | Time constraint | Contiguous | +| :---- | :---- | :---- | :---- | :---- | +| auto | No | auto | No | Chooses appropriate algorithm based on input complexity: simple for basic cases, sophisticated for constraints/variable power, contiguous for segmented charging | | | +| baseline | Yes | Constant | No | No | +| simple | No | Constant | No | No | +| sophisticated | No | Variable | Yes | No | +| contiguous | No | Variable | Yes | Segments at fixed lengths | +| Variable contiguous | No | Variable | Yes | Segments at variable lengths | + +**1. Naive Smart Device Charging [EV L2 or pluggable battery-powered device]** + +[Naive Smart device notebook example](https://github.com/jbadsdata/watttime-python-client/edit/optimizer/watttime_optimizer/Optimizer%20README.md#:~:text=ev.-,ipynb,-ev_variable_charge.ipynb) + +L2 charging needs 30 minutes total time to reach full charge, expected plug out time within the next 4 hours. Simple use case. + +```py +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime_optimizer import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +# 12 hour charge window (720/60 = 12) +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) + +usage_plan = wt_opt.get_optimal_usage_plan( + region="CAISO_NORTH", + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=240, + usage_power_kw=12, + optimization_method="auto", +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` + +**2.Partial Charging Guarantee - Introducing Constraints** + * Sophisticated - total charge window 12 hours long, 75% charged by hour 8. + +```py +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime_optimizer import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +# 12 hour charge window (720/60 = 12) +# Minute 480 is time context when the constraint, i.e. 75% charge, must be satisfied +# 75% of 240 (required charge expressed in minutes) is 180 + +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) +usage_time_required_minutes = 240 +constraint_time = now + timedelta(minutes=480) +constraint_usage_time_required_minutes = 180 +usage_power_kw = 12.0 + +# map the constraint to the time context +constraints = {constraint_time:constraint_usage_time_required_minutes} + +usage_plan = wt_opt.get_optimal_usage_plan( + region="CAISO_NORTH", + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=240, + usage_power_kw=12, + constraints=constraints, + optimization_method="auto", +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` + +**3.Variable Charging Curve (L3) - EV** + +[Example usage notebook](https://github.com/jbadsdata/watttime-python-client/edit/optimizer/watttime_optimizer/Optimizer%20README.md#:~:text=ev.ipynb-,ev_variable_charge,-.ipynb) + +[Battery class](https://github.com/jbadsdata/watttime-python-client/edit/optimizer/watttime_optimizer/Optimizer%20README.md#:~:text=battery-,.,-py) + +I know the model of my vehicle and want to match device characteristics. If we have a 10 kWh battery which initially charges at 20kW, the charge rate then linearly decreases to 10kW as the battery is 50% charged, and then remains at 10kW for the rest of the charging. This is the charging curve. + +```py +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime_optimizer import WattTimeOptimizer +from watttime_optimizer.battery import Battery +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) + +battery = Battery( + initial_soc=0.0, + charging_curve=pd.DataFrame( + columns=["SoC", "kW"], + data=[ + [0.0, 20.0], + [0.5, 10.0], + [1.0, 10.0], + ] + ), + capacity_kWh=10.0, +) + +variable_usage_power = battery.get_usage_power_kw_df() + +usage_plan = wt_opt.get_optimal_usage_plan( + region="CAISO_NORTH", + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=240, + usage_power_kw=variable_usage_power, + optimization_method="auto", +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` + +* **4.Data Center Workload 1**: + * (single segment, fixed length) - charging schedule to be composed of a single contiguous, i.e. "block" segment of fixed length + +[example notebook](https://github.com/jbadsdata/watttime-python-client/edit/optimizer/watttime_optimizer/Optimizer%20README.md#:~:text=datacenter_workloads) + +```py +## AI model training - estimated runtime is 2 hours and it needs to complete within 12 hours + +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime_optimizer import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) + +usage_power_kw = 12.0 +region = "CAISO_NORTH" + +# by passing a single interval of 120 minutes to charge_per_segment, the Optimizer will know to fit call the fixed contigous modeling function. +usage_plan = wt_opt.get_optimal_usage_plan( + region=region, + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=120, + usage_power_kw=12, + charge_per_segment=[120], + optimization_method="auto", + verbose = False +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` + +**5.Data Center Workload 2**: + * (multiple segments, fixed length) - runs over two usage periods of lengths 80 min and 40 min. The order of the segments is immutable. + +```py +## there are two cycles of length 80 min and 40 min each, and they must be completed in that order. + +from datetime import datetime, timedelta +import pandas as pd +from pytz import UTC +from watttime_optimizer import WattTimeOptimizer +import os + +username = os.getenv("WATTTIME_USER") +password = os.getenv("WATTTIME_PASSWORD") +wt_opt = WattTimeOptimizer(username, password) + +# Suppose that the time now is 12 midnight +now = datetime.now(UTC) +window_start = now +window_end = now + timedelta(minutes=720) + +# Pass two values to charge_per_segment instead of one. +usage_plan = wt_opt.get_optimal_usage_plan( + region="CAISO_NORTH", + usage_window_start=window_start, + usage_window_end=window_end, + usage_time_required_minutes=120, # 80 + 40 + usage_power_kw=12, + charge_per_segment=[80,40], + optimization_method="auto", +) + +print(usage_plan.head()) +print(usage_plan["usage"].tolist()) +print(usage_plan.sum()) +``` diff --git a/watttime_optimizer/__init__.py b/watttime_optimizer/__init__.py new file mode 100644 index 00000000..3f5ce00d --- /dev/null +++ b/watttime_optimizer/__init__.py @@ -0,0 +1,4 @@ +from watttime.api import * +from watttime_optimizer.api_opt import * +from watttime_optimizer.api_opt import * +from watttime_optimizer.evaluator import * \ No newline at end of file diff --git a/watttime_optimizer/alg/__init__.py b/watttime_optimizer/alg/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/watttime_optimizer/alg/moer.py b/watttime_optimizer/alg/moer.py new file mode 100644 index 00000000..f4398945 --- /dev/null +++ b/watttime_optimizer/alg/moer.py @@ -0,0 +1,128 @@ +# moer.py + +import numpy as np + + +class Moer: + """ + Represents Marginal Operating Emissions Rate (MOER) for electricity grid emissions modeling. + + This class handles calculations related to emissions and utilities based on + MOER data, supporting both diagonal and non-diagonal penalty matrices. + + Attributes: + ----------- + __mu : numpy.ndarray + Mean emissions rate for each time step. + __T : int + Total number of time steps. + + Methods: + -------- + __len__() + Returns the number of time steps. + get_emission_at(i, usage) + Calculates emission at a specific time step. + get_emission_interval(start, end, usage) + Calculates sum of emissions for a time interval. + get_emissions(x) + Calculates emissions per interval for a given schedule. + get_total_emission(x) + Calculates total emission for a given schedule. + + """ + + def __init__(self, mu): + """ + Initializes the Moer object. + + Parameters: + ----------- + mu : array-like + Emissions rate for each time step. + """ + self.__mu = np.array(mu).flatten() + self.__T = self.__mu.shape[0] + + def __len__(self): + """ + Returns the length of the time series. + + Returns: + -------- + int + The number of time steps in the series. + """ + return self.__T + + def get_emission_at(self, i, usage): + """ + Calculates the emission at a specific time step. + + Parameters: + ----------- + i : int + The time step index. + usage : float, optional + The power usage. + + Returns: + -------- + float + The calculated emission value. + """ + return self.__mu[i] * usage + + def get_emission_interval(self, start, end, usage): + """ + Calculates emissions for a given time interval. + + Parameters: + ----------- + start : int + The start index of the interval. + end : int + The end index of the interval. + usage : float, optional + The emission multiplier. Default is 1. + + Returns: + -------- + numpy.ndarray + An array of emission values for the specified interval. + """ + return np.dot(self.__mu[start:end], usage) + + def get_emissions(self, usage): + """ + Calculates emissions for a given set of emission multipliers. + + Parameters: + ----------- + usage : array-like + The emission multipliers. + + Returns: + -------- + numpy.ndarray + An array of calculated emission values. + """ + usage = np.array(usage).flatten() + return self.__mu[: usage.shape[0]] * usage + + def get_total_emission(self, usage): + """ + Calculates the total emission for a given set of emission multipliers. + + Parameters: + ----------- + usage : array-like + The emission multipliers. + + Returns: + -------- + float + The total calculated emission. + """ + usage = np.array(usage).flatten() + return np.dot(self.__mu[: usage.shape[0]], usage) \ No newline at end of file diff --git a/watttime_optimizer/alg/optCharger.py b/watttime_optimizer/alg/optCharger.py new file mode 100644 index 00000000..51b128dd --- /dev/null +++ b/watttime_optimizer/alg/optCharger.py @@ -0,0 +1,727 @@ +# optCharger.py +import warnings +import numpy as np +from .moer import Moer + +TOL = 1e-4 # tolerance +EMISSION_FN_TOL = 1e-9 # emissions functions tolerance in kw + + +class OptCharger: + """ + Represents an Optimal Charger for managing charging schedules. + + This class handles the optimization of charging schedules based on various parameters + such as charge rates, emission overheads, and other constraints. + + Methods: + -------- + __init__() + Initializes the OptCharger object with the given parameters. + """ + + def __init__(self, verbose): + """ + Initializes the OptCharger object. + """ + self.__optimal_charging_emission = None + self.__optimal_charging_schedule = None + self.__verbose = verbose + + def __collect_results(self, moer: Moer): + """ + Translates the optimal charging schedule into a series of emission multiplier values and calculates various emission-related metrics. + + This function processes the optimal charging schedule to generate emission multipliers, + calculates energy and emissions over time, and computes the total emissions including + overhead from starting, stopping, and maintaining the charging process. + + Parameters: + ----------- + moer : Moer + An object representing Marginal Operating Emissions Rate, used for emissions calculations. + + Returns: + -------- + None + The function updates several instance variables with the calculated results. + + Side Effects: + ------------- + Updates the following instance variables: + - __optimal_charging_energy_over_time + - __optimal_charging_emissions_over_time + - __optimal_charging_emission + + The function also populates the emission_multipliers list, which is used in the calculations. + """ + emission_multipliers = [] + current_charge_time_units = 0 + for i in range(len(self.__optimal_charging_schedule)): + if self.__optimal_charging_schedule[i] == 0: + emission_multipliers.append(0.0) + else: + old_charge_time_units = current_charge_time_units + current_charge_time_units += self.__optimal_charging_schedule[i] + power_rate = self.emission_multiplier_fn( + old_charge_time_units, current_charge_time_units + ) + emission_multipliers.append(power_rate) + + self.__optimal_charging_energy_over_time = np.array( + self.__optimal_charging_schedule + ) * np.array(emission_multipliers) + self.__optimal_charging_emissions_over_time = moer.get_emissions( + self.__optimal_charging_energy_over_time + ) + self.__optimal_charging_emission = ( + self.__optimal_charging_emissions_over_time.sum() + ) + + def verbose_on(self, statement:str): + if self.__verbose: + print(statement) + + @staticmethod + def __sanitize_emission_multiplier(emission_multiplier_fn, total_charge): + """ + Sanitizes the emission multiplier function to handle edge cases and ensure valid outputs. + + This function wraps the original emission_multiplier_fn to handle cases where the + end charge (ec) exceeds the total charge or when the start charge (sc) is beyond + the total charge limit. + + Parameters: + ----------- + emission_multiplier_fn : callable + The original emission multiplier function to be sanitized. + total_charge : int or float + The maximum total charge value. + + Returns: + -------- + callable + A new lambda function that sanitizes the inputs before calling the original + emission_multiplier_fn. + + Behavior: + --------- + - If sc < total_charge: + - Calls the original function with ec capped at total_charge. + - If sc >= total_charge: + - Returns 1.0, assuming no additional emissions beyond total charge. + + Note: + ----- + This function is useful for preventing out-of-bounds errors and ensuring + consistent behavior when dealing with charge values near or beyond the total + charge limit. + """ + return lambda sc, ec: ( + emission_multiplier_fn(sc, min(ec, total_charge)) + if (sc < total_charge) + else 0.0 + ) + + @staticmethod + def __check_constraint(t_start, c_start, dc, constraints): + # assuming constraints[t] is the bound on total charge after t intervals + for t in range(t_start + 1, t_start + dc): + if (t in constraints) and ( + (c_start + t - t_start < constraints[t][0]) + or (c_start + t - t_start > constraints[t][1]) + ): + return False + return True + + def __greedy_fit(self, total_charge: int, total_time: int, moer: Moer): + """ + Performs a "greedy" fit for charging schedule optimization. + + It charges at the maximum possible rate until the total charge is reached or + the time limit is hit. + + Parameters: + ----------- + total_charge : int + The total amount of charge needed. + total_time : int + The total time available for charging. + moer : Moer + An object representing Marginal Operating Emissions Rate. + + Calls __collect_results to process the results. + """ + self.verbose_on("== Baseline fit! ==") + schedule = [1] * min(total_charge, total_time) + [0] * max( + 0, total_time - total_charge + ) + self.__optimal_charging_schedule = schedule + self.__collect_results(moer) + + def __simple_fit(self, total_charge: int, total_time: int, moer: Moer): + """ + Performs a "simple" fit for charging schedule optimization. + + This method implements a straightforward optimization strategy. It sorts + time intervals by MOER (Marginal Operating Emissions Rate) and charges + during the cleanest intervals until the total charge is reached. + + Parameters: + ----------- + total_charge : int + The total amount of charge needed. + total_time : int + The total time available for charging. + moer : Moer + An object representing Marginal Operating Emissions Rate. + + Calls __collect_results to process the results. + """ + self.verbose_on("== Simple fit! ==") + sorted_times = np.argsort(moer.get_emission_interval(0, total_time, 1)) + + charge_to_do = total_charge + schedule, t = [0] * total_time, 0 + while (charge_to_do > 0) and (t < total_time): + charge_to_do -= 1 + schedule[sorted_times[t]] = 1 + t += 1 + self.__optimal_charging_schedule = schedule + self.__collect_results(moer) + + def __diagonal_fit( + self, + total_charge: int, + total_time: int, + moer: Moer, + emission_multiplier_fn, + constraints: dict = {}, + ): + """ + Performs a sophisticated diagonal fit for charging schedule optimization using dynamic programming. + + This method implements a more complex optimization strategy using dynamic programming. + It considers various factors such as emission rates, charging constraints, and overhead costs + to find an optimal charging schedule. + + Parameters: + ----------- + total_charge : int + The total amount of charge needed. + total_time : int + The total time available for charging. + moer : Moer + An object representing Marginal Operating Emissions Rate. + emission_multiplier_fn : callable + A function that calculates emission multipliers. + constraints : dict, optional + A dictionary of charging constraints for specific time steps. + + Calls __collect_results to process the results. + + Raises: + ------- + Exception + If no valid solution is found. + """ + self.verbose_on("== Sophisticated fit! ==") + # This is a matrix with size = number of charge states x number of actions {not charging = 0, charging = 1} + max_util = np.full((total_charge + 1), np.nan) + max_util[0] = 0.0 + path_history = np.full((total_time, total_charge + 1), -1, dtype=int) + for t in range(1, total_time + 1): + if t in constraints: + min_charge, max_charge = constraints[t] + min_charge = 0 if min_charge is None else max(0, min_charge) + max_charge = ( + total_charge + if max_charge is None + else min(max_charge, total_charge) + ) + else: + min_charge, max_charge = 0, total_charge + new_max_util = np.full(max_util.shape, np.nan) + for c in range(min_charge, max_charge + 1): + ## not charging + init_val = True + if not np.isnan(max_util[c]): + new_max_util[c] = max_util[c] + path_history[t - 1, c] = c + init_val = False + ## charging + if (c > 0) and not np.isnan(max_util[c - 1]): + # moer.get_emission_at gives lbs/MWh. emission function needs to be how many MWh the interval consumes + # which would be power_in_kW * 0.001 * 5/60 + new_util = max_util[c - 1] - moer.get_emission_at( + t - 1, emission_multiplier_fn(c - 1, c) + ) + if init_val or (new_util > new_max_util[c]): + new_max_util[c] = new_util + path_history[t - 1, c] = c - 1 + init_val = False + max_util = new_max_util + + if np.isnan(max_util[total_charge]): + raise Exception( + "Solution not found! Please check that constraints are satisfiable." + ) + curr_state, t_curr = total_charge, total_time + + schedule_reversed = [] + schedule_reversed.append(curr_state) + while t_curr > 0: + curr_state = path_history[t_curr - 1, curr_state] + schedule_reversed.append(curr_state) + t_curr -= 1 + optimal_path = np.array(schedule_reversed)[::-1] + self.__optimal_charging_schedule = list(np.diff(optimal_path)) + self.__collect_results(moer) + + def __contiguous_fit( + self, + total_charge: int, + total_time: int, + moer: Moer, + emission_multiplier_fn, + charge_per_segment: list = [], + constraints: dict = {}, + ): + """ + Performs a contiguous fit for charging schedule optimization using dynamic programming. + + This method implements a sophisticated optimization strategy that considers contiguous + charging intervals. It uses dynamic programming to find an optimal charging schedule + while respecting the specified length of each charging interval. + + Parameters: + ----------- + total_charge : int + The total amount of charge needed. + total_time : int + The total time available for charging. + moer : Moer + An object representing Marginal Operating Emissions Rate. + emission_multiplier_fn : callable + A function that calculates emission multipliers. + charge_per_segment : list of int + The exact charging amount per interval. + constraints : dict, optional + A dictionary of charging constraints for specific time steps. Constraints are one-indexed: t:(a,b) means that after t minutes, we have to have charged for between a and b minutes inclusive, so that 1<=t<=total_time + + Calls __collect_results to process the results. + + Raises: + ------- + Exception + If no valid solution is found. + + Note: + ----- + This is the __diagonal_fit() algorithm with further constraint on contiguous charging intervals and their respective length + """ + self.verbose_on("== Fixed contiguous fit! ==") + total_interval = len(charge_per_segment) + # This is a matrix with size = number of time states x number of intervals charged so far + max_util = np.full((total_time + 1, total_interval + 1), np.nan) + max_util[0, 0] = 0.0 + path_history = np.full((total_time, total_interval + 1), False, dtype=bool) + cum_charge = [0] + for c in charge_per_segment: + cum_charge.append(cum_charge[-1] + c) + + charge_array_cache = [ + emission_multiplier_fn(x, x + 1) for x in range(0, total_charge + 1) + ] + # ("Cumulative charge", cum_charge) + for t in range(1, total_time + 1): + if t in constraints: + min_charge, max_charge = constraints[t] + min_charge = 0 if min_charge is None else max(0, min_charge) + max_charge = ( + total_charge + if max_charge is None + else min(max_charge, total_charge) + ) + constraints[t] = (min_charge, max_charge) + else: + min_charge, max_charge = 0, total_charge + for k in range(0, total_interval + 1): + # print(t,k) + ## not charging + init_val = True + if not np.isnan(max_util[t - 1, k]): + max_util[t, k] = max_util[t - 1, k] + init_val = False + ## charging + if (k > 0) and (charge_per_segment[k - 1] <= t): + dc = charge_per_segment[k - 1] + if not np.isnan( + max_util[t - dc, k - 1] + ) and OptCharger.__check_constraint( + t - dc, cum_charge[k - 1], dc, constraints + ): + marginal_cost = moer.get_emission_interval( + t - dc, + t, + charge_array_cache[cum_charge[k - 1] : cum_charge[k]], + ) + new_util = max_util[t - dc, k - 1] - marginal_cost + if init_val or (new_util > max_util[t, k]): + max_util[t, k] = new_util + path_history[t - 1, k] = True + init_val = False + + if np.isnan(max_util[total_time, total_interval]): + raise Exception( + "Solution not found! Please check that constraints are satisfiable." + ) + curr_state, t_curr = total_interval, total_time + + schedule_reversed = [] + interval_ids_reversed = [] + while t_curr > 0: + delta_interval = path_history[t_curr - 1, curr_state] + if not delta_interval: + ## did not charge + schedule_reversed.append(0) + interval_ids_reversed.append(-1) + t_curr -= 1 + else: + ## charge + dc = charge_per_segment[curr_state - 1] + t_curr -= dc + curr_state -= 1 + if dc > 0: + schedule_reversed.extend([1] * dc) + interval_ids_reversed.extend([curr_state] * dc) + optimal_path = np.array(schedule_reversed)[::-1] + self.__optimal_charging_schedule = list(optimal_path) + self.__interval_ids = list(interval_ids_reversed[::-1]) + self.__collect_results(moer) + + def __variable_contiguous_fit( + self, + total_charge: int, + total_time: int, + moer: Moer, + emission_multiplier_fn, + charge_per_segment: list = [], + use_all_segments: bool = True, + constraints: dict = {}, + ): + """ + Performs a contiguous fit for charging schedule optimization using dynamic programming. + + This method implements a sophisticated optimization strategy that considers contiguous + charging intervals. It uses dynamic programming to find an optimal charging schedule + while respecting constraints on the length of each charging interval. + + Parameters: + ----------- + total_charge : int + The total amount of charge needed. + total_time : int + The total time available for charging. + moer : Moer + An object representing Marginal Operating Emissions Rate. + emission_multiplier_fn : callable + A function that calculates emission multipliers. + charge_per_segment : list of (int, int) + The minimium and maximum (inclusive) charging amount per interval. + use_all_segments : bool + If true, use all intervals provided by charge_per_segment; if false, can use the first few intervals and skip the rest. + constraints : dict, optional + A dictionary of charging constraints for specific time steps. Constraints are one-indexed: t:(a,b) means that after t minutes, we have to have charged for between a and b minutes inclusive, so that 1<=t<=total_time + + Calls __collect_results to process the results. + + Raises: + ------- + Exception + If no valid solution is found. + + Note: + ----- + This is the __diagonal_fit() algorithm with further constraint on contiguous charging intervals and their respective length + """ + self.verbose_on("== Variable contiguous fit! ==") + total_interval = len(charge_per_segment) + # This is a matrix with size = number of time states x number of charge states x number of intervals charged so far + max_util = np.full( + (total_time + 1, total_charge + 1, total_interval + 1), np.nan + ) + max_util[0, 0, 0] = 0.0 + path_history = np.full( + (total_time, total_charge + 1, total_interval + 1, 2), 0, dtype=int + ) + + charge_array_cache = [ + emission_multiplier_fn(x, x + 1) for x in range(0, total_charge + 1) + ] + + for t in range(1, total_time + 1): + if t in constraints: + min_charge, max_charge = constraints[t] + min_charge = 0 if min_charge is None else max(0, min_charge) + max_charge = ( + total_charge + if max_charge is None + else min(max_charge, total_charge) + ) + constraints[t] = (min_charge, max_charge) + else: + min_charge, max_charge = 0, total_charge + for k in range(0, total_interval + 1): + for c in range(min_charge, max_charge + 1): + ## not charging + init_val = True + if not np.isnan(max_util[t - 1, c, k]): + max_util[t, c, k] = max_util[t - 1, c, k] + path_history[t - 1, c, k, :] = [0, 0] + init_val = False + ## charging + if k > 0: + for dc in range( + charge_per_segment[k - 1][0], + min(charge_per_segment[k - 1][1], t, c) + 1, + ): + if not np.isnan( + max_util[t - dc, c - dc, k - 1] + ) and OptCharger.__check_constraint( + t - dc, c - dc, dc, constraints + ): + marginal_cost = moer.get_emission_interval( + t - dc, t, charge_array_cache[c - dc : c] + ) + new_util = ( + max_util[t - dc, c - dc, k - 1] - marginal_cost + ) + if init_val or (new_util > max_util[t, c, k]): + max_util[t, c, k] = new_util + path_history[t - 1, c, k, :] = [dc, 1] + init_val = False + optimal_interval, optimal_util = ( + total_interval, + max_util[total_time, total_charge, total_interval], + ) + if not use_all_segments: + for k in range(0, total_interval): + if np.isnan(max_util[total_time, total_charge, optimal_interval]) or ( + not np.isnan(max_util[total_time, total_charge, k]) + and max_util[total_time, total_charge, k] + > max_util[total_time, total_charge, optimal_interval] + ): + optimal_interval = k + if np.isnan(max_util[total_time, total_charge, optimal_interval]): + raise Exception( + "Solution not found! Please check that constraints are satisfiable." + ) + curr_state, t_curr = [total_charge, optimal_interval], total_time + + schedule_reversed = [] + interval_ids_reversed = [] + while t_curr > 0: + dc, delta_interval = path_history[ + t_curr - 1, curr_state[0], curr_state[1], : + ] + if delta_interval == 0: + ## did not charge + schedule_reversed.append(0) + interval_ids_reversed.append(-1) + t_curr -= 1 + else: + ## charge + t_curr -= dc + curr_state = [curr_state[0] - dc, curr_state[1] - delta_interval] + if dc > 0: + schedule_reversed.extend([1] * dc) + interval_ids_reversed.extend([curr_state[1]] * dc) + optimal_path = np.array(schedule_reversed)[::-1] + self.__optimal_charging_schedule = list(optimal_path) + self.__interval_ids = list(interval_ids_reversed[::-1]) + self.__collect_results(moer) + + def fit( + self, + total_charge: int, + total_time: int, + moer: Moer, + charge_per_segment=None, + use_all_segments: bool = True, + constraints: dict = {}, + emission_multiplier_fn=None, + optimization_method: str = "auto", + ): + """ + Fits an optimal charging schedule based on the given parameters and constraints. + + This method serves as the main entry point for the charging optimization process. + It selects the appropriate optimization method based on the input parameters and + constraints. + + Parameters: + ----------- + total_charge : int + The total amount of charge needed. + total_time : int + The total time available for charging. + moer : Moer + An object representing Marginal Operating Emissions Rate. + charge_per_segment : list of int or (int,int), optional + The minimium and maximum (inclusive) charging amount per interval. If int instead of tuple, interpret as both min and max. + use_all_segments : bool + If true, use all intervals provided by charge_per_segment; if false, can use the first few intervals and skip the rest. This can only be false if charge_per_segment is provided as a range. + constraints : dict, optional + A dictionary of charging constraints for specific time steps. + emission_multiplier_fn : callable, optional + A function that calculates emission multipliers. If None, assumes constant 1kW power usage. + optimization_method : str, optional + The optimization method to use. Can be 'auto', 'baseline', 'simple', or 'sophisticated'. + Default is 'auto'. + + Raises: + ------- + Exception + If the charging task is impossible given the constraints, or if an unsupported + optimization method is specified. + + Note: + ----- + This method chooses between different optimization strategies based on the input + parameters and the characteristics of the problem. + """ + assert len(moer) >= total_time + assert optimization_method in ["baseline", "simple", "sophisticated", "auto"] + + if emission_multiplier_fn is None: + warnings.warn( + "Warning: No emission_multiplier_fn given. Assuming that device uses constant 1kW of power" + ) + emission_multiplier_fn = lambda sc, ec: 1.0 + constant_emission_multiplier = True + else: + constant_emission_multiplier = ( + np.std( + [ + emission_multiplier_fn(sc, sc + 1) + for sc in list(range(total_charge)) + ] + ) + < EMISSION_FN_TOL + ) + self.emission_multiplier_fn = emission_multiplier_fn + + if total_charge > total_time: + raise Exception( + f"Solution not found! Impossible to charge {total_charge} within {total_time} intervals." + ) + if optimization_method == "baseline": + self.__greedy_fit(total_charge, total_time, moer) + elif ( + not constraints + and not charge_per_segment + and constant_emission_multiplier + and optimization_method == "auto" + ) or (optimization_method == "simple"): + if not constant_emission_multiplier: + warnings.warn( + "Warning: Emissions function is non-constant. Using the simple algorithm is suboptimal." + ) + self.__simple_fit(total_charge, total_time, moer) + elif not charge_per_segment: + self.__diagonal_fit( + total_charge, + total_time, + moer, + OptCharger.__sanitize_emission_multiplier( + emission_multiplier_fn, total_charge + ), + constraints, + ) + else: + # cpi stands for charge per interval + single_cpi, tuple_cpi, use_fixed_alg = [], [], True + + def convert_input(c): + ## Converts the interval format + if isinstance(c, int): + return c, (c, c), True + if c[0] == c[1]: + return c[0], c, True + return None, c, False + + for c in charge_per_segment: + if use_fixed_alg: + sc, tc, use_fixed_alg = convert_input(c) + single_cpi.append(sc) + tuple_cpi.append(tc) + else: + tuple_cpi.append(convert_input(c)[1]) + if use_fixed_alg: + assert ( + use_all_segments + ), "Must use all intervals when interval lengths are fixed!" + self.__contiguous_fit( + total_charge, + total_time, + moer, + OptCharger.__sanitize_emission_multiplier( + emission_multiplier_fn, total_charge + ), + single_cpi, + constraints, + ) + else: + self.__variable_contiguous_fit( + total_charge, + total_time, + moer, + OptCharger.__sanitize_emission_multiplier( + emission_multiplier_fn, total_charge + ), + tuple_cpi, + use_all_segments, + constraints, + ) + + def get_energy_usage_over_time(self) -> list: + """ + Returns list of the energy due to charging at each interval in MWh. + """ + return self.__optimal_charging_energy_over_time + + def get_charging_emissions_over_time(self) -> list: + """ + Returns list of the emissions due to charging at each interval in lbs. + """ + return self.__optimal_charging_emissions_over_time + + def get_total_emission(self) -> float: + """ + Returns the summed emissions due to charging in lbs. + """ + return self.__optimal_charging_emission + + def get_schedule(self) -> list: + """ + Returns list of the optimal charging schedule of units to charge for each interval. + """ + return self.__optimal_charging_schedule + + def get_interval_ids(self) -> list: + """ + Returns list of the interval ids for each interval. Has a value of -1 for non-charging intervals. + Intervals are labeled starting from 0 to n-1 when there are n intervals + + Only defined when charge_per_segment variable is given to some fit function + """ + return self.__interval_ids + + def summary(self): + print("-- Model Summary --") + print( + "Expected charging emissions: %.2f lbs" % self.__optimal_charging_emission + ) + print("Optimal charging schedule:", self.__optimal_charging_schedule) + print("=" * 15) \ No newline at end of file diff --git a/watttime_optimizer/api_convert.py b/watttime_optimizer/api_convert.py new file mode 100644 index 00000000..048c6a64 --- /dev/null +++ b/watttime_optimizer/api_convert.py @@ -0,0 +1,194 @@ +import pandas as pd +import numpy as np + + +# This file contains utility functions for converting formats for now +def convert_soc_to_soe(soc_power_df, voltage_curve, battery_capacity_coulombs): + """ + Convert State of Charge (SoC) to State of Energy (SoE) by integrating voltage over SoC. + + Parameters: + soc_power_df (pd.DataFrame): DataFrame with 'SoC' and 'power_kw' columns. + voltage_curve (function): Voltage as a function of SoC. + battery_capacity_coulombs (float): Maximum current capacity of the battery in coulombs. + + Returns: + pd.DataFrame: DataFrame with 'SoE' and 'power_kw' columns. + """ + soc = soc_power_df["SoC"] + + # Voltage at each SoC + voltage = voltage_curve(soc) + + # Calculate differential SoC for numerical integration + delta_soc = np.diff(soc, prepend=0) + charge_per_segment = delta_soc * battery_capacity_coulombs + # Energy is voltage * charge + energy_kwh = np.cumsum(voltage * charge_per_segment * 0.001 / 3600) + + # Normalize so that State of energy goes from 0 to 1 + soe_array = energy_kwh / energy_kwh.iloc[-1] + + # Create a new DataFrame with 'SoE' and 'power_kw' + soe_power_df = pd.DataFrame( + {"SoE": soe_array, "power_kw": soc_power_df["power_kw"]} + ) + + return soe_power_df + + +def convert_soe_to_time(soe_power_df, battery_capacity): + """ + Convert Power vs SoE DataFrame to a Power vs Time DataFrame. + + Parameters: + soe_power_df (pd.DataFrame): DataFrame with 'SoE' and 'power_kw' columns. + battery_capacity (float): Maximum energy capacity of the battery in kWh. + + Returns: + pd.DataFrame: DataFrame with 'time' (in minutes) and 'power_kw' columns. + """ + time_list = [0] # Starting at t = 0 minutes + previous_time = 0 + + for i in range(len(soe_power_df) - 1): + # Calculate the delta SoE + delta_soe = soe_power_df["SoE"].iloc[i + 1] - soe_power_df["SoE"].iloc[i] + + # Energy transferred for this delta SoE + delta_energy = delta_soe * battery_capacity # in kWh + + # Power to use during this step + power_to_use = soe_power_df["power_kw"].iloc[i] + + # Time step for this segment + delta_time_minutes = delta_energy / power_to_use * 60 + + # Add the time to the previous time to get cumulative time + current_time = previous_time + delta_time_minutes + time_list.append(current_time) + previous_time = current_time + + # Convert SoE dataframe to Time dataframe + time_power_df = pd.DataFrame( + {"time": time_list, "power_kw": soe_power_df["power_kw"]} + ) + + return time_power_df + + +def get_usage_power_kw_df(soe_power_df, capacity_kWh): + """ + Output the variable charging curve in the format that optimizer accepts. + That is, dataframe with index "time" in minutes and "power_kw" which + tells us the average power consumption in a five minute interval + after an elapsed amount of time of charging. + + Assumes df is sorted by SoE + """ + + def get_kW_at_SoE(df, soe): + """Linear interpolation to get charging rate at any SoE""" + before_df = df[df["SoE"] <= soe] + # print("Before_df", before_df) + prev_row = before_df.iloc[-1] if len(before_df) > 0 else None + after_df = df[df["SoE"] >= soe] + # print("After_df", after_df) + next_row = after_df.iloc[0] if len(after_df) > 0 else None + if prev_row is None: + return next_row["power_kw"] + if next_row is None: + return prev_row["power_kw"] + + m1 = prev_row["SoE"] + p1 = prev_row["power_kw"] + m2 = next_row["SoE"] + p2 = next_row["power_kw"] + + if m1 == m2: + return 0.5 * (p1 + p2) + + return p1 + (soe - m1) / (m2 - m1) * (p2 - p1) + + # iterate over seconds + result = [] + secs_elapsed = 0 + sub_interval_seconds = 60 + # For now, we assume the starting capacity is 0.0 + charged_kWh = 0.0 + kW_by_second = [] + while charged_kWh < capacity_kWh: + secs_elapsed += sub_interval_seconds + curr_soe = charged_kWh / capacity_kWh + curr_kW = get_kW_at_SoE(soe_power_df, curr_soe) + # print("Debug:", curr_kW, curr_soe, secs_elapsed) + kW_by_second.append(curr_kW) + charged_kWh += curr_kW * sub_interval_seconds / 3600 + + if secs_elapsed % 300 == 0: + result.append((int(secs_elapsed / 60 - 5), pd.Series(kW_by_second).mean())) + kW_by_second = [] + + return pd.DataFrame(columns=["time", "power_kw"], data=result) + + +# Example usage: +soe_power_df = pd.DataFrame( + { + "SoE": np.linspace(0.0, 1.0, 11), # SoE from 0% to 100% + "power_kw": [ + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + ], # Example power values in kW + } +) + +battery_capacity = 100 # Max energy capacity in kWh +result_df = convert_soe_to_time(soe_power_df, battery_capacity) + +print("Old:", result_df) +print("New:", get_usage_power_kw_df(soe_power_df, battery_capacity)) + + +# Example voltage curve for testing +def voltage_curve_test(soc): + return 3.0 + 0.5 * soc + + +# Example SoC dataframe (with SoC ranging from 0.1 to 1.0) +soc_power_df = pd.DataFrame( + { + "SoC": np.linspace(0.0, 1.0, 11), + "power_kw": [ + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + ], # Example power values in kW + } +) + +battery_capacity_coulombs = 1_000_000 # Max energy capacity in kWh + +# Convert SoC to SoE +soe_power_df = convert_soc_to_soe( + soc_power_df, voltage_curve_test, battery_capacity_coulombs +) + +# print(soe_power_df) diff --git a/watttime_optimizer/api_opt.py b/watttime_optimizer/api_opt.py new file mode 100644 index 00000000..2007074b --- /dev/null +++ b/watttime_optimizer/api_opt.py @@ -0,0 +1,751 @@ +import os +import math +from datetime import datetime, timedelta +from typing import Any, Literal, Optional, Union + +import pandas as pd +from dateutil.parser import parse +from pytz import UTC, timezone +from watttime_optimizer.alg import optCharger, moer +from itertools import accumulate +import bisect + +from watttime.api import WattTimeForecast + + +OPT_INTERVAL = 5 +MAX_PREDICTION_HOURS = 72 + + +class WattTimeOptimizer(WattTimeForecast): + """ + This class inherits from WattTimeForecast, with additional methods to generate + optimal usage plans for energy consumption based on various parameters and + constraints. + + Additional Methods: + -------- + get_optimal_usage_plan(region, usage_window_start, usage_window_end, + usage_time_required_minutes, usage_power_kw, + usage_time_uncertainty_minutes, optimization_method, + moer_data_override) + Generates an optimal usage plan for energy consumption. + """ + + OPT_INTERVAL = 5 + MAX_PREDICTION_HOURS = 72 + MAX_INT = 99999999999999999 + + def get_optimal_usage_plan( + self, + region: str, + usage_window_start: datetime, + usage_window_end: datetime, + usage_time_required_minutes: Optional[Union[int, float]] = None, + usage_power_kw: Optional[Union[int, float, pd.DataFrame]] = None, + energy_required_kwh: Optional[Union[int, float]] = None, + usage_time_uncertainty_minutes: Optional[Union[int, float]] = 0, + charge_per_segment: Optional[list] = None, + use_all_segments: bool = True, + constraints: Optional[dict] = None, + optimization_method: Optional[ + Literal["baseline", "simple", "sophisticated", "auto"] + ] = "baseline", + moer_data_override: Optional[pd.DataFrame] = None, + verbose=True, + ) -> pd.DataFrame: + """ + Generates an optimal usage plan for energy consumption based on given parameters. + + This method calculates the most efficient energy usage schedule within a specified + time window, considering factors such as regional data, power requirements, and + optimization methods. + + You should pass in exactly 2 of 3 parameters of (usage_time_required_minutes, usage_power_kw, energy_required_kwh) + + Parameters: + ----------- + region : str + The region for which forecast data is requested. + usage_window_start : datetime + Start time of the window when power consumption is allowed. + usage_window_end : datetime + End time of the window when power consumption is allowed. + usage_time_required_minutes : Optional[Union[int, float]], default=None + Required usage time in minutes. + usage_power_kw : Optional[Union[int, float, pd.DataFrame]], default=None + Power usage in kilowatts. Can be a constant value or a DataFrame for variable power. + energy_required_kwh : Optional[Union[int, float]], default=None + Energy required in kwh + usage_time_uncertainty_minutes : Optional[Union[int, float]], default=0 + Uncertainty in usage time, in minutes. + charge_per_segment : Optional[list], default=None + Either a list of length-2 tuples representing minimium and maximum (inclusive) charging minutes per interval, + or a list of ints representing both the min and max. [180] OR [(180,180)] + use_all_segments : Optional[bool], default=False + If true, use all intervals provided by charge_per_segment; if false, can use the first few intervals and skip the rest. + constraints : Optional[dict], default=None + A dictionary containing contraints on how much usage must be used before the given time point + optimization_method : Optional[Literal["baseline", "simple", "sophisticated", "auto"]], default="baseline" + The method used for optimization. + moer_data_override : Optional[pd.DataFrame], default=None + Pre-generated MOER (Marginal Operating Emissions Rate) DataFrame, if available. + verbose : default = True + If false, suppresses print statements in the opt charger class. + + Returns: + -------- + pd.DataFrame + A DataFrame representing the optimal usage plan, including columns for + predicted MOER, usage, CO2 emissions, and energy usage. + + Raises: + ------- + AssertionError + If input parameters do not meet specified conditions (e.g., timezone awareness, + valid time ranges, supported optimization methods). + + Notes: + ------ + - The method uses WattTime forecast data unless overridden by moer_data_override. + - It supports various optimization methods and can handle both constant and variable power usage. + - The resulting plan aims to minimize emissions while meeting the specified energy requirements. + """ + + def is_tz_aware(dt): + return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None + + def minutes_to_units(x, floor=False): + """Converts minutes to forecase intervals. Rounds UP by default.""" + if x: + if floor: + return int(x // self.OPT_INTERVAL) + else: + return int(math.ceil(x / self.OPT_INTERVAL)) + return x + + assert is_tz_aware(usage_window_start), "Start time is not tz-aware" + assert is_tz_aware(usage_window_end), "End time is not tz-aware" + + if constraints is None: + constraints = {} + else: + # Convert constraints to a standardized format + raw_constraints = constraints.copy() + constraints = {} + + for ( + constraint_time_clock, + constraint_usage_minutes, + ) in raw_constraints.items(): + constraint_time_minutes = ( + constraint_time_clock - usage_window_start + ).total_seconds() / 60 + constraint_time_units = minutes_to_units(constraint_time_minutes) + constraint_usage_units = minutes_to_units(constraint_usage_minutes) + + constraints.update( + {constraint_time_units: (constraint_usage_units, None)} + ) + + num_inputs = 0 + for input in (usage_time_required_minutes, usage_power_kw, energy_required_kwh): + if input is not None: + num_inputs += 1 + assert ( + num_inputs == 2 + ), "Exactly 2 of 3 inputs in (usage_time_required_minutes, usage_power_kw, energy_required_kwh) required" + if usage_power_kw is None: + usage_power_kw = energy_required_kwh / usage_time_required_minutes * 60 + print("Implied usage_power_kw =", usage_power_kw) + if usage_time_required_minutes is None: + if type(usage_power_kw) in (float, int) and type(energy_required_kwh) in ( + float, + int, + ): + usage_time_required_minutes = energy_required_kwh / usage_power_kw * 60 + print("Implied usage time required =", usage_time_required_minutes) + else: + # TODO: Implement and test + raise NotImplementedError( + "When usage_time_required_minutes is None, only float or int usage_power_kw and energy_required_kwh is supported." + ) + + # Perform these checks if we are using live data + if moer_data_override is None: + datetime_now = datetime.now(UTC) + assert ( + usage_window_end > datetime_now + ), "Error, Window end is before current datetime" + assert usage_window_end - datetime_now < timedelta( + hours=self.MAX_PREDICTION_HOURS + ), "End time is too far in the future" + assert optimization_method in ("baseline", "simple", "sophisticated", "auto"), ( + "Unsupported optimization method:" + optimization_method + ) + if moer_data_override is None: + forecast_df = self.get_forecast_pandas( + region=region, + signal_type="co2_moer", + horizon_hours=self.MAX_PREDICTION_HOURS, + ) + else: + forecast_df = moer_data_override.copy() + forecast_df = forecast_df.set_index("point_time") + forecast_df.index = pd.to_datetime(forecast_df.index) + + relevant_forecast_df = forecast_df[forecast_df.index >= usage_window_start] + relevant_forecast_df = relevant_forecast_df[ + relevant_forecast_df.index < usage_window_end + ] + relevant_forecast_df = relevant_forecast_df.rename( + columns={"value": "pred_moer"} + ) + result_df = relevant_forecast_df[["pred_moer"]] + moer_values = relevant_forecast_df["pred_moer"].values + + m = moer.Moer(mu=moer_values) + + model = optCharger.OptCharger(verbose=verbose) + + total_charge_units = minutes_to_units(usage_time_required_minutes) + if optimization_method in ("sophisticated", "auto"): + # Give a buffer time equal to the uncertainty + buffer_time = usage_time_uncertainty_minutes + if buffer_time > 0: + buffer_periods = minutes_to_units(buffer_time) if buffer_time else 0 + buffer_enforce_time = max( + total_charge_units, len(moer_values) - buffer_periods + ) + constraints.update({buffer_enforce_time: (total_charge_units, None)}) + else: + assert ( + usage_time_uncertainty_minutes == 0 + ), "usage_time_uncertainty_minutes is only supported in optimization_method='sophisticated' or 'auto'" + + if type(usage_power_kw) in (int, float): + # Convert to the MWh used in an optimization interval + # expressed as a function to meet the parameter requirements for OptC function + emission_multiplier_fn = ( + lambda sc, ec: float(usage_power_kw) * 0.001 * self.OPT_INTERVAL / 60.0 + ) + else: + usage_power_kw = usage_power_kw.copy() + # Resample usage power dataframe to an OPT_INTERVAL frequency + usage_power_kw["time_step"] = usage_power_kw["time"] / self.OPT_INTERVAL + usage_power_kw_new_index = pd.DataFrame( + index=[float(x) for x in range(total_charge_units + 1)] + ) + usage_power_kw = pd.merge_asof( + usage_power_kw_new_index, + usage_power_kw.set_index("time_step"), + left_index=True, + right_index=True, + direction="backward", + allow_exact_matches=True, + ) + + def emission_multiplier_fn(sc: float, ec: float) -> float: + """ + Calculate the approximate mean power in the given time range, + in units of MWh used per optimizer time unit. + + sc and ec are float values representing the start and end time of + the time range, in optimizer time units. + """ + value = ( + usage_power_kw[sc : max(sc, ec - 1e-12)]["power_kw"].mean() + * 0.001 + * self.OPT_INTERVAL + / 60.0 + ) + return value + + if charge_per_segment: + # Handle the charge_per_segment input by converting it from minutes to units, rounding up + converted_charge_per_segment = [] + for c in charge_per_segment: + if isinstance(c, int): + converted_charge_per_segment.append(minutes_to_units(c)) + else: + assert ( + len(c) == 2 + ), "Length of tuples in charge_per_segment is not 2" + interval_start_units = minutes_to_units(c[0]) if c[0] else 0 + interval_end_units = ( + minutes_to_units(c[1]) if c[1] else self.MAX_INT + ) + converted_charge_per_segment.append( + (interval_start_units, interval_end_units) + ) + else: + converted_charge_per_segment = None + model.fit( + total_charge=total_charge_units, + total_time=len(moer_values), + moer=m, + constraints=constraints, + charge_per_segment=converted_charge_per_segment, + use_all_segments=use_all_segments, + emission_multiplier_fn=emission_multiplier_fn, + optimization_method=optimization_method, + ) + + optimizer_result = model.get_schedule() + result_df = self._reconcile_constraints( + optimizer_result, + result_df, + model, + usage_time_required_minutes, + charge_per_segment, + ) + + return result_df + + def _reconcile_constraints( + self, + optimizer_result, + result_df, + model, + usage_time_required_minutes, + charge_per_segment, + ): + # Make a copy of charge_per_segment if necessary + if charge_per_segment is not None: + charge_per_segment = charge_per_segment[::] + for i in range(len(charge_per_segment)): + if type(charge_per_segment[i]) == int: + charge_per_segment[i] = ( + charge_per_segment[i], + charge_per_segment[i], + ) + assert len(charge_per_segment[i]) == 2 + processed_start = ( + charge_per_segment[i][0] + if charge_per_segment[i][0] is not None + else 0 + ) + processed_end = ( + charge_per_segment[i][1] + if charge_per_segment[i][1] is not None + else self.MAX_INT + ) + + charge_per_segment[i] = (processed_start, processed_end) + + if not charge_per_segment: + # Handle case without charge_per_segment constraints + total_usage_intervals = sum(optimizer_result) + current_usage_intervals = 0 + usage_list = [] + for to_charge_binary in optimizer_result: + current_usage_intervals += to_charge_binary + if current_usage_intervals < total_usage_intervals: + usage_list.append(to_charge_binary * float(self.OPT_INTERVAL)) + else: + # Partial interval + minutes_to_trim = ( + total_usage_intervals * self.OPT_INTERVAL + - usage_time_required_minutes + ) + usage_list.append( + to_charge_binary * float(self.OPT_INTERVAL - minutes_to_trim) + ) + result_df["usage"] = usage_list + else: + # Process charge_per_segment constraints + result_df["usage"] = [ + x * float(self.OPT_INTERVAL) for x in optimizer_result + ] + usage = result_df["usage"].values + sections = [] + interval_ids = model.get_interval_ids() + + def get_min_max_indices(lst, x): + # Find the first occurrence of x + min_index = lst.index(x) + # Find the last occurrence of x + max_index = len(lst) - 1 - lst[::-1].index(x) + return min_index, max_index + + for interval_id in range(0, max(interval_ids) + 1): + assert ( + interval_id in interval_ids + ), "interval_id not found in interval_ids" + sections.append(get_min_max_indices(interval_ids, interval_id)) + + # Adjust sections to satisfy charge_per_segment constraints + for i, (start, end) in enumerate(sections): + section_usage = usage[start : end + 1] + total_minutes = section_usage.sum() + + # Get the constraints for this section + if isinstance(charge_per_segment[i], int): + min_minutes, max_minutes = ( + charge_per_segment[i], + charge_per_segment[i], + ) + else: + min_minutes, max_minutes = charge_per_segment[i] + + # Adjust the section to fit the constraints + if total_minutes < min_minutes: + raise ValueError( + f"Cannot meet the minimum charging constraint of {min_minutes} minutes for section {i}." + ) + elif total_minutes > max_minutes: + # Reduce usage to fit within the max_minutes + excess_minutes = total_minutes - max_minutes + for j in range(len(section_usage)): + if section_usage[j] > 0: + reduction = min(section_usage[j], excess_minutes) + section_usage[j] -= reduction + excess_minutes -= reduction + if excess_minutes <= 0: + break + usage[start : end + 1] = section_usage + result_df["usage"] = usage + + # Recalculate these values approximately, based on the new "usage" column + # Note: This is approximate since it assumes that + # the charging emissions over time of the unrounded values are similar to the rounded values + result_df["emissions_co2_lb"] = ( + model.get_charging_emissions_over_time() + * result_df["usage"] + / self.OPT_INTERVAL + ) + result_df["energy_usage_mwh"] = ( + model.get_energy_usage_over_time() * result_df["usage"] / self.OPT_INTERVAL + ) + + return result_df + + +class WattTimeRecalculator: + """A class to manage and update charging schedules over time. + + This class maintains a list of charging schedules and their associated time contexts, + allowing for updates and recalculations of remaining charging time required. + + Attributes: + all_schedules (list): List of tuples containing (schedule, time_context) pairs + total_time_required (int): Total charging time needed in minutes + end_time (datetime): Final deadline for the charging schedule + charge_per_segment (list): List of charging durations per interval + is_contiguous (bool): Flag indicating if charging must be contiguous + sleep_delay(bool): Flag indicating if next query time must be delayed + contiguity_values_dict (dict): Dictionary storing contiguity-related values + """ + + def __init__( + self, + initial_schedule: pd.DataFrame, + start_time: datetime, + end_time: datetime, + total_time_required: int, + contiguous=False, + charge_per_segment: Optional[list] = None, + ) -> None: + """Initialize the Recalculator with an initial schedule. + + Args: + initial_schedule (pd.DataFrame): Starting charging schedule + start_time (datetime): Start time for the schedule + end_time (datetime): End time for the schedule + total_time_required (int): Total charging time needed in minutes + charge_per_segment (list): List of charging durations per interval + """ + self.OPT_INTERVAL = 5 + self.all_schedules = [(initial_schedule, (start_time, end_time))] + self.end_time = end_time + self.total_time_required = total_time_required + self.charge_per_segment = charge_per_segment + self.is_contiguous = contiguous + self.sleep_delay = False + self.contiguity_values_dict = { + "delay_usage_window_start": None, + "delay_in_minutes": None, + "delay_in_intervals": None, + "remaining_time_required": None, + "remaining_units_required": None, + "num_segments_complete": None, + } + + self.total_available_units = self.minutes_to_units( + int(int((self.end_time - start_time).total_seconds()) / 60) + ) + + def is_tz_aware(dt): + return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None + + def minutes_to_units(self, x, floor=False): + """Converts minutes to forecase intervals. Rounds UP by default.""" + if x: + if floor: + return int(x // self.OPT_INTERVAL) + else: + return int(math.ceil(x / self.OPT_INTERVAL)) + return x + + def get_remaining_units_required(self, next_query_time): + _minutes = self.get_remaining_time_required(next_query_time) + return self.minutes_to_units(_minutes) + + def get_remaining_time_required(self, next_query_time: datetime): + """Calculate remaining charging time needed at a given query time. + + Args: + next_query_time (datetime): Time from which to calculate remaining time + + Returns: + int: Remaining charging time required in minutes + """ + if len(self.all_schedules) == 0: + return self.total_time_required + + combined_schedule = self.get_combined_schedule() + t = next_query_time - timedelta(minutes=5) + + usage_in_minutes = combined_schedule.loc[:t]["usage"].sum() + + return self.total_time_required - usage_in_minutes + + def set_last_schedule_end_time(self, next_query_time: datetime): + """Update the end time of the most recent schedule. + + Args: + next_query_time (datetime): New end time for the last schedule + + Raises: + AssertionError: If new end time is before start time + """ + if len(self.all_schedules) > 0: + schedule, ctx = self.all_schedules[-1] + self.all_schedules[-1] = (schedule, (ctx[0], next_query_time)) + assert ctx[0] < next_query_time + + def update_charging_schedule( + self, + next_query_time: datetime, + next_new_schedule_start_time=None, + new_schedule: Optional[pd.DataFrame] = None, + ): + """ + Update charging schedule and contiguity values. + + Args: + next_query_time: Current query time + next_new_schedule_start_time: Start time for next schedule + new_schedule: New charging schedule to add + """ + + def _protocol_no_new_schedule(next_new_schedule_start_time): + """ + 1. Confirm that charging is not in progress and sleep delay is not required + """ + if self.is_contiguous is True: + self.sleep_delay = self.check_if_contiguity_sleep_required( + self.all_schedules[0][0], next_new_schedule_start_time + ) + else: + pass + + def _protocol_new_schedule( + new_schedule, next_query_time, next_new_schedule_start_time + ): + """ + 1. Modify previous schedule to end at "next_query_time" + 2. Append new schedule to record of existing schedules + 3. Confirm that charging is not in progress and sleep delay is not required + """ + self.set_last_schedule_end_time(next_query_time) + self.all_schedules.append((new_schedule, (next_query_time, self.end_time))) + if self.is_contiguous is True: + self.sleep_delay = self.check_if_contiguity_sleep_required( + new_schedule, next_new_schedule_start_time + ) + + def _protocol_sleep_delay(next_new_schedule_start_time): + print("sleep protocol activated...") + assert ( + next_new_schedule_start_time is not None + ), "Sleep delay next new time is None" + s = ( + self.get_combined_schedule().loc[next_new_schedule_start_time:]["usage"] + == 0 + ) + delay_time = ( + self.end_time + if s[s == True].empty == True + else s[s == True].index.min() + ) + self.contiguity_values_dict = { + "delay_usage_window_start": delay_time, + "delay_in_minutes": len(s[s == False]) * 5, + "delay_in_intervals": len(s[s == False]), + "remaining_units_required": self.get_remaining_units_required( + delay_time + ), + "remaining_time_required": self.get_remaining_time_required(delay_time), + } + + self.contiguity_values_dict["num_segments_complete"] = ( + self.number_segments_complete( + next_query_time=self.contiguity_values_dict[ + "delay_usage_window_start" + ] + ) + ) + + if new_schedule is None: + _protocol_no_new_schedule(next_new_schedule_start_time) + else: + _protocol_new_schedule( + new_schedule, next_query_time, next_new_schedule_start_time + ) + + if self.sleep_delay is True: + _protocol_sleep_delay(next_new_schedule_start_time) + else: + self.contiguity_values_dict = { + "delay_usage_window_start": None, + "delay_in_minutes": None, + "delay_in_intervals": None, + "remaining_units_required": self.get_remaining_units_required( + next_query_time + ), + "remaining_time_required": self.get_remaining_time_required( + next_query_time + ), + "num_segments_complete": self.number_segments_complete( + next_query_time=next_query_time + ), + } + + def get_combined_schedule(self, end_time: datetime = None) -> pd.DataFrame: + """Combine all schedules into a single DataFrame. + + Args: + end_time (datetime, optional): Optional cutoff time for the combined schedule + + Returns: + pd.DataFrame: Combined schedule of all charging segments + """ + schedule_segments = [] + for s, ctx in self.all_schedules: + schedule_segments.append(s[s.index < ctx[1]]) + combined_schedule = pd.concat(schedule_segments) + + if end_time: + last_segment_start_time = end_time + combined_schedule = combined_schedule.loc[:last_segment_start_time] + + return combined_schedule + + def check_if_contiguity_sleep_required(self, usage_plan, next_query_time): + """Check if charging needs to be paused for contiguity. + + Args: + usage_plan (pd.DataFrame): Planned charging schedule + next_query_time (datetime): Time of next schedule update + + Returns: + bool: True if charging needs to be paused + """ + return bool( + usage_plan.loc[(next_query_time - timedelta(minutes=5))]["usage"] > 0 + ) + + def number_segments_complete(self, next_query_time: datetime = None): + """Calculate number of completed charging segments. + + Args: + next_query_time (datetime, optional): Time to check completion status + + Returns: + int: Number of completed charging segments + """ + if self.is_contiguous is True: + combined_schedule = self.get_combined_schedule() + completed_schedule = combined_schedule.loc[:next_query_time] + charging_indicator = completed_schedule["usage"].astype(bool).sum() + return bisect.bisect_right( + list(accumulate(self.charge_per_segment)), (charging_indicator * 5) + ) + else: + return None + + +class RequerySimulator: + def __init__( + self, + moers_list, + requery_dates, + region="CAISO_NORTH", + window_start=datetime(2025, 1, 1, hour=21, second=1, tzinfo=UTC), + window_end=datetime(2025, 1, 2, hour=8, second=1, tzinfo=UTC), + usage_time_required_minutes=240, + usage_power_kw=2, + charge_per_segment=None, + ): + self.moers_list = moers_list + self.requery_dates = requery_dates + self.region = region + self.window_start = window_start + self.window_end = window_end + self.usage_time_required_minutes = usage_time_required_minutes + self.usage_power_kw = usage_power_kw + self.charge_per_segment = charge_per_segment + + self.username = os.getenv("WATTTIME_USER") + self.password = os.getenv("WATTTIME_PASSWORD") + self.wt_opt = WattTimeOptimizer(self.username, self.password) + + def _get_initial_plan(self): + return self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=self.window_start, + usage_window_end=self.window_end, + usage_time_required_minutes=self.usage_time_required_minutes, + usage_power_kw=self.usage_power_kw, + charge_per_segment=self.charge_per_segment, + optimization_method="simple", + moer_data_override=self.moers_list[0][["point_time", "value"]], + ) + + def simulate(self): + initial_plan = self._get_initial_plan() + recalculator = WattTimeRecalculator( + initial_schedule=initial_plan, + start_time=self.window_start, + end_time=self.window_end, + total_time_required=self.usage_time_required_minutes, + charge_per_segment=self.charge_per_segment, + ) + + # check to see the status of my segments to know if I should requery at all + # if I do need to requery, then I need time required + segments remaining + # if I don't then I store the state of my recalculator as is + + for i, new_window_start in enumerate(self.requery_dates[1:], 1): + new_time_required = recalculator.get_remaining_time_required( + new_window_start + ) + if new_time_required > 0.0: + next_plan = self.wt_opt.get_optimal_usage_plan( + region=self.region, + usage_window_start=new_window_start, + usage_window_end=self.window_end, + usage_time_required_minutes=new_time_required, + usage_power_kw=self.usage_power_kw, + charge_per_segment=self.charge_per_segment, + optimization_method="simple", + moer_data_override=self.moers_list[i][["point_time", "value"]], + ) + recalculator.update_charging_schedule( + new_schedule=next_plan, + next_query_time=new_window_start, + next_new_schedule_start_time=None, + ) + else: + return recalculator diff --git a/watttime_optimizer/battery.py b/watttime_optimizer/battery.py new file mode 100644 index 00000000..07ecd12b --- /dev/null +++ b/watttime_optimizer/battery.py @@ -0,0 +1,314 @@ +# encode the variable power curves +from dataclasses import dataclass +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt + +@dataclass +class Battery: + capacity_kWh: float + charging_curve: pd.DataFrame # columns SoC and kW + initial_soc: float = 0.2 + + def plot_charging_curve(self, ax=None): + """Plot the variabel charging curve of the battery""" + ax = self.charging_curve.set_index("SoC").plot( + ax=ax, + grid=True, + ylabel="kW", + legend=False, + title=f"Charging curve \nBattery capacity: {self.capacity_kWh} kWh" + ) + if ax is None: + plt.show() + + def get_usage_power_kw_df(self, max_capacity_fraction=0.95): + """ + Output the variable charging curve in the format that optimizer accepts. + That is, dataframe with index "time" in minutes and "power_kw" which + tells us the average power consumption in a five minute interval + after an elapsed amount of time of charging. + """ + capacity_kWh = self.capacity_kWh + initial_soc = self.initial_soc + # convert SoC column to numpy array for faster access + soc_array = self.charging_curve["SoC"].values + kW_array = self.charging_curve["kW"].values + + def get_kW_at_SoC(soc): + """Linear interpolation to get charging rate at any SoC.""" + idx = np.searchsorted(soc_array, soc) + if idx == 0: + return kW_array[0] + elif idx >= len(soc_array): + return kW_array[-1] + m1, m2 = soc_array[idx - 1], soc_array[idx] + p1, p2 = kW_array[idx - 1], kW_array[idx] + return p1 + (soc - m1) / (m2 - m1) * (p2 - p1) + + # iterate over seconds + result = [] + secs_elapsed = 0 + charged_kWh = capacity_kWh * initial_soc + kW_by_second = [] + while charged_kWh < capacity_kWh * max_capacity_fraction: + secs_elapsed += 1 + curr_soc = charged_kWh / capacity_kWh + curr_kW = get_kW_at_SoC(curr_soc) + kW_by_second.append(curr_kW) + charged_kWh += curr_kW / 3600 + + if secs_elapsed % 300 == 0: + result.append((int(secs_elapsed / 60 - 5), pd.Series(kW_by_second).mean())) + kW_by_second = [] + + return pd.DataFrame(columns=["time", "power_kw"], data=result) + + +CARS_L3 = { + # pulled data from https://www.fastnedcharging.com/en/brands-overview + # this is a subset of the cars + "audi": [ # 71kWh, https://www.fastnedcharging.com/en/brands-overview/audi + [0.0, 120.0], + [0.6, 120.0], + [1.0, 30.0], + ], + "bmw": [ # 42.2kWh, https://www.fastnedcharging.com/en/brands-overview/bmw + [0.0, 40.0], + [0.85, 50.0], + [1.0, 5.0], + ], + 'bolt':[ + [0.0, 50.0], + [0.5, 50.0], + [0.93, 20.0], + [1.0, 0.5], + ], + "honda": [ # 35.5kWh, https://www.fastnedcharging.com/en/brands-overview/honda + [0.0, 40.0], + [0.4, 40.0], + [0.41, 30.0], + [0.70, 30.0], + [0.71, 20.0], + [0.95, 20.0], + [1.0, 10.0], + ], + "lucid": [ # 112kWh https://www.fastnedcharging.com/en/brands-overview/lucid + [0.0, 300.0], + [1.0, 50.0], + ], + "mazda": [ #35.5kWh https://www.fastnedcharging.com/en/brands-overview/mazda + [0.0, 50.0], + [0.2, 50.0], + [0.21, 40.0], + [1.0, 10.0], + ], + "subaru": [ # 75kWh https://www.fastnedcharging.com/en/brands-overview/subaru + [0.0, 150.0], + [0.25, 150.0], + [0.85, 30.0], + [1.00, 30.0], + ], + "tesla": [ # ??kWh https://www.fastnedcharging.com/en/brands-overview/tesla + [0.0, 180.0], + [0.4, 190.0], + [0.9, 40.0], + [1.0, 40.0], + ], + "volkswagen": [ # 24.2kWh https://www.fastnedcharging.com/en/brands-overview/volkswagen?model=e-Golf + [0.0, 40.0], + [0.1, 40.0], + [0.75, 45.0], + [0.81, 23.0], + [0.92, 17.0], + [0.95, 9.0], + [1.0, 9.0], + ] +} + +TZ_DICTIONARY = { + "AECI": "America/Chicago", + "AVA": "America/Los_Angeles", + "AZPS": "America/Phoenix", + "BANC": "America/Los_Angeles", + "BPA": "America/Los_Angeles", + "CAISO_ESCONDIDO": "America/Los_Angeles", + "CAISO_LONGBEACH": "America/Los_Angeles", + "CAISO_NORTH": "America/Los_Angeles", + "CAISO_PALMSPRINGS": "America/Los_Angeles", + "CAISO_REDDING": "America/Los_Angeles", + "CAISO_SANBERNARDINO": "America/Los_Angeles", + "CAISO_SANDIEGO": "America/Los_Angeles", + "CHPD": "America/Los_Angeles", + "CPLE": "America/New_York", + "CPLW": "America/New_York", + "DOPD": "America/Los_Angeles", + "DUK": "America/New_York", + "ELE": "America/Denver", + "ERCOT_AUSTIN": "America/Chicago", + "ERCOT_COAST": "America/Chicago", + "ERCOT_EASTTX": "America/Chicago", + "ERCOT_HIDALGO": "America/Chicago", + "ERCOT_NORTHCENTRAL": "America/Chicago", + "ERCOT_PANHANDLE": "America/Chicago", + "ERCOT_SANANTONIO": "America/Chicago", + "ERCOT_SECOAST": "America/Chicago", + "ERCOT_SOUTHTX": "America/Chicago", + "ERCOT_WESTTX": "America/Chicago", + "FMPP": "America/New_York", + "FPC": "America/New_York", + "FPL": "America/New_York", + "GVL": "America/New_York", + "IID": "America/Los_Angeles", + "IPCO": "America/Boise", + "ISONE_CT": "America/New_York", + "ISONE_ME": "America/New_York", + "ISONE_NEMA": "America/New_York", + "ISONE_NH": "America/New_York", + "ISONE_RI": "America/New_York", + "ISONE_SEMA": "America/New_York", + "ISONE_VT": "America/New_York", + "ISONE_WCMA": "America/New_York", + "JEA": "America/New_York", + "LDWP": "America/Los_Angeles", + "LGEE": "America/New_York", + "MISO_INDIANAPOLIS": "America/Indiana/Indianapolis", + "MISO_N_DAKOTA": "America/North_Dakota/Center", + "MPCO": "America/Denver", + "NEVP": "America/Los_Angeles", + "NYISO_NYC": "America/New_York", + "PACE": "America/Denver", + "PACW": "America/Los_Angeles", + "PGE": "America/Los_Angeles", + "PJM_CHICAGO": "America/Chicago", + "PJM_DC": "America/New_York", + "PJM_EASTERN_KY": "America/New_York", + "PJM_EASTERN_OH": "America/New_York", + "PJM_ROANOKE": "America/New_York", + "PJM_NJ": "America/New_York", + "PJM_SOUTHWEST_OH": "America/New_York", + "PJM_WESTERN_KY": "America/New_York", + "PNM": "America/Denver", + "PSCO": "America/Denver", + "PSEI": "America/Los_Angeles", + "SC": "America/New_York", + "SCEG": "America/New_York", + "SCL": "America/Los_Angeles", + "SEC": "America/New_York", + "SOCO": "America/Chicago", + "SPA": "America/Chicago", + "SPP_FORTPECK": "America/Denver", + "SPP_KANSAS": "America/Chicago", + "SPP_KC": "America/Chicago", + "SPP_MEMPHIS": "America/Chicago", + "SPP_ND": "America/North_Dakota/Beulah", + "SPP_OKCTY": "America/Chicago", + "SPP_SIOUX": "America/Chicago", + "SPP_SPRINGFIELD": "America/Chicago", + "SPP_SWOK": "America/Chicago", + "SPP_TX": "America/Chicago", + "SPP_WESTNE": "America/Chicago", + "SRP": "America/Phoenix", + "TAL": "America/New_York", + "TEC": "America/New_York", + "TEPC": "America/Phoenix", + "TID": "America/Los_Angeles", + "TPWR": "America/Los_Angeles", + "TVA": "America/Chicago", + "WACM": "America/Denver", + "WALC": "America/Phoenix", + "WAUW": "America/Denver", +} + +MOER_REGION_LIST = [ + "AECI", + "AVA", + "AZPS", + "BANC", + "BPA", + "CAISO_ESCONDIDO", + "CAISO_LONGBEACH", + "CAISO_NORTH", + "CAISO_PALMSPRINGS", + "CAISO_REDDING", + "CAISO_SANBERNARDINO", + "CAISO_SANDIEGO", + "CHPD", + "CPLE", + "CPLW", + "DOPD", + "DUK", + "ELE", + "ERCOT_AUSTIN", + "ERCOT_COAST", + "ERCOT_EASTTX", + "ERCOT_HIDALGO", + "ERCOT_NORTHCENTRAL", + "ERCOT_PANHANDLE", + "ERCOT_SANANTONIO", + "ERCOT_SECOAST", + "ERCOT_SOUTHTX", + "ERCOT_WESTTX", + "FMPP", + "FPC", + "FPL", + "GVL", + "IID", + "IPCO", + "ISONE_CT", + "ISONE_ME", + "ISONE_NEMA", + "ISONE_NH", + "ISONE_RI", + "ISONE_SEMA", + "ISONE_VT", + "ISONE_WCMA", + "JEA", + "LDWP", + "LGEE", + "MISO_INDIANAPOLIS", + "MISO_N_DAKOTA", + "MPCO", + "NEVP", + "NYISO_NYC", + "PACE", + "PACW", + "PGE", + "PJM_CHICAGO", + "PJM_DC", + "PJM_EASTERN_KY", + "PJM_EASTERN_OH", + "PJM_NJ", + "PJM_SOUTHWEST_OH", + "PJM_WESTERN_KY", + "PNM", + "PSCO", + "PSEI", + "SC", + "SCEG", + "SCL", + "SEC", + "SOCO", + "SPA", + "SPP_FORTPECK", + "SPP_KANSAS", + "SPP_KC", + "SPP_MEMPHIS", + "SPP_ND", + "SPP_OKCTY", + "SPP_SIOUX", + "SPP_SPRINGFIELD", + "SPP_SWOK", + "SPP_TX", + "SPP_WESTNE", + "SRP", + "TAL", + "TEC", + "TEPC", + "TID", + "TPWR", + "TVA", + "WACM", + "WALC", + "WAUW", +] \ No newline at end of file diff --git a/watttime_optimizer/evaluator/__init__.py b/watttime_optimizer/evaluator/__init__.py new file mode 100644 index 00000000..faf2b222 --- /dev/null +++ b/watttime_optimizer/evaluator/__init__.py @@ -0,0 +1 @@ +from watttime.api import * \ No newline at end of file diff --git a/watttime_optimizer/evaluator/analysis.py b/watttime_optimizer/evaluator/analysis.py new file mode 100644 index 00000000..c2e22b92 --- /dev/null +++ b/watttime_optimizer/evaluator/analysis.py @@ -0,0 +1,87 @@ + +from watttime_optimizer.evaluator.evaluator import RecalculationOptChargeEvaluator +from watttime_optimizer.evaluator.evaluator import OptChargeEvaluator +from watttime_optimizer.evaluator.evaluator import ImpactEvaluator +import numpy as np +import tqdm + + +def plot_predicated_moer(df): + df.pred_moer.plot( + title = "Predicted MOER", + ylabel="co2/lb", + xlabel="Time of Day" + ) + +def plot_charging_units(df): + df.usage.plot( + title = "Scheduled Units of Charge", + xlabel="Time of Day", + ylabel="Minutes" + ) + +def plot_scheduled_moer(df): + df.emissions_co2_lb.plot( + title = "MOER - Forecasted Usage", + xlabel="Time of Day", + ylabel="co2/lb" + ) + +# 4 seconds per row, mostly API call +def analysis_loop(region, input_dict,username,password): + oce = OptChargeEvaluator(username=username,password=password) + results = {} + for key,value in tqdm.tqdm(input_dict.items()): + value.update({'region':region,'tz_convert':True, "verbose":False}) + df = oce.get_schedule_and_cost_api(**value) + m, b = np.polyfit(np.arange(len(df.pred_moer.values)),df.pred_moer.values, 1) + stddev = df.pred_moer.std() + r = ImpactEvaluator(username,password,df).get_all_emissions_metrics(region=region) + r.update({'m':m,'b':b,'stddev':stddev}) + results.update({key:r}) + return results + +# 4 seconds per row, mostly API call +def analysis_loop_requery(region, input_dict, interval,username,password): + roce = RecalculationOptChargeEvaluator(username,password) + results = {} + for key,value in tqdm.tqdm(input_dict.items()): + value.update( + {'region':region, + 'tz_convert':True, + "optimization_method": "auto", + "verbose":False, + "interval":interval, + "charge_per_segment":None} + ) + df = roce.fit_recalculator(**value).get_combined_schedule() + m, b = np.polyfit(np.arange(len(df.pred_moer.values)),df.pred_moer.values, 1) + stddev = df.pred_moer.std() + r = ImpactEvaluator(username,password,df).get_all_emissions_metrics(region=region) + r.update({'m':m,'b':b,'stddev':stddev}) + results.update({key:r}) + return results + +# 4 seconds per row, mostly API call +def analysis_loop_requery_contiguous(region, input_dict, interval,username,password): + roce = RecalculationOptChargeEvaluator(username,password) + results = {} + for key,value in tqdm.tqdm(input_dict.items()): + charge_per_segment = [int(value["time_needed"])] + value.update( + {'region':region, + 'tz_convert':True, + "optimization_method": "auto", + "verbose":False, + "interval":interval, + "contiguous":True, + "charge_per_segment":charge_per_segment + } + ) + df = roce.fit_recalculator(**value).get_combined_schedule() + m, b = np.polyfit(np.arange(len(df.pred_moer.values)),df.pred_moer.values, 1) + stddev = df.pred_moer.std() + r = ImpactEvaluator(username,password,df).get_all_emissions_metrics(region=region) + r.update({'m':m,'b':b,'stddev':stddev}) + results.update({key:r}) + return results \ No newline at end of file diff --git a/watttime_optimizer/evaluator/evaluator.py b/watttime_optimizer/evaluator/evaluator.py new file mode 100644 index 00000000..198e5eb8 --- /dev/null +++ b/watttime_optimizer/evaluator/evaluator.py @@ -0,0 +1,372 @@ +from watttime.api import WattTimeForecast, WattTimeHistorical +from watttime_optimizer.api_opt import WattTimeOptimizer, WattTimeRecalculator +import pandas as pd +from watttime_optimizer.evaluator.utils import convert_to_utc, get_timezone_from_dict +import numpy as np +from typing import Optional +from datetime import timedelta +import matplotlib.pyplot as plt + +class ImpactEvaluator: + def __init__(self, username:str, password:str, obj: pd.DataFrame, region:Optional[str] = 'CAISO_NORTH'): + """ + Evaluates the impact of a charging schedule. + + Parameters: + ----------- + username : str + API username + password : str + API password + obj: pd.DataFrame + Watttime Optimizer results frame. + """ + self.actuals = WattTimeHistorical(username,password) + self.obj = obj + self.region=region + + def get_historical_actual_data(self, region:str = None): + """ + Retrieve historical actual data for a specific plug-in time, horizon, and region. + + Parameters: + ----------- + region : str + The region for which to retrieve the actuals data. + + Returns: + -------- + pd.DataFrame + A DataFrame containing historical actuals data. + """ + + if region is None: + region = self.region + + session_start_time = self.obj.index[0] + session_end_time = self.obj.index[-1] + + return self.actuals.get_historical_pandas( + start=session_start_time, + end=session_end_time, + region=region, + ) + + def get_historical_forecast_data(self): + """ + Retrieve historical actual data for a specific plug-in time, horizon, and region. + + Parameters: + ----------- + region : str + The region for which to retrieve the actuals data. + + Returns: + -------- + pd.DataFrame + A DataFrame containing historical actuals data. + """ + + return self.obj["pred_moer"] + + def get_charging_schedule(self): + """ + Extract and flatten usage values from input data + Args: + x: Input dictionary containing 'usage' key + Returns: + Flattened array of usage values + """ + return self.obj["usage"].values.flatten() + + def get_energy_usage(self): + """ + Extract and flatten usage values from input data + Args: + x: Input dictionary containing 'usage' key + Returns: + Flattened array of usage values + """ + return self.obj["energy_usage_mwh"].values.flatten() + + def get_actual_emissions(self,region:str): + """ + Calculate total CO2 emissions in pounds + Args: + region: eGrid region for API + Returns: + Sum of CO2 emissions + """ + moer = self.get_historical_actual_data(region)['value'].values + energy_usage_mwh = self.get_energy_usage() + + return np.multiply(moer, energy_usage_mwh) + + def get_forecast_emissions(self): + """ + Calculate total CO2 emissions in pounds + Args: + x: Input dictionary containing 'emissions_co2_lb' key + Returns: + Sum of CO2 emissions + """ + return self.obj["emissions_co2_lb"] + + def get_baseline_emissions(self,region:str): + """ + Calculate total CO2 emissions in pounds. + Assumes device did not follow an optimized schedule. + """ + energy_usage_mwh = self.get_energy_usage() + N = len(energy_usage_mwh[energy_usage_mwh<=0]) + moer = self.get_historical_actual_data(region)['value'].values + + return np.multiply(moer, np.pad(energy_usage_mwh[energy_usage_mwh>0], (0, N), 'constant')) + + def get_all_emissions_metrics(self,region:str): + return { + 'baseline': self.get_baseline_emissions(region).sum(), + 'forecast': self.get_forecast_emissions().sum(), + 'actual':self.get_actual_emissions(region).sum() + } + + def get_all_emissions_values(self,region:str): + df = pd.DataFrame(self.get_forecast_emissions()).rename({"emissions_co2_lb":"forecast"},axis=1) + df["baseline"] = self.get_baseline_emissions(region) + df["actual"] = self.get_actual_emissions(region) + return df + + def plot_predicated_moer(self): + self.obj["pred_moer"].plot() + + def plot_usage_schedule(self): + self.obj['usage'].plot() + + def get_timeseries_stats(self,df: pd.DataFrame, col:str = "pred_moer"): + ''' Dispersion, slope, and intercept of the moer forecast''' + m, b = np.polyfit(np.arange(len(df[col].values)),df[col].values, 1) + stddev = df[col].std() + mean = df[col].mean() + return { + 'm':m, + 'b':b, + 'stddev':stddev, + 'mean': mean + } + + def plot_impact(self, region:str): + act = self.get_historical_actual_data(region=region).set_index("point_time") + df = self.get_all_emissions_values(region=region) + + x = df.index + y0 = (df['actual'] > 0).astype(int).values + y1 = (df['baseline'] > 0).astype(int).values + y2 = act.value.values + + # Create the main plot + fig, ax1 = plt.subplots() + + # Plot the first data set + ax1.plot(x, y1, 'b-', alpha=.2, label="ASAP Schedule") + ax1.plot(x,y0,'g-',alpha=.2, label="Optimized Schedule") + ax1.set_xlabel('Time') + ax1.set_ylabel('Usage Fraction (5 minute interval)', color='blue') + ax1.tick_params('y', colors='b') + ax1.fill_between(x,y0,0, where=y0>0,color='green', alpha=.2) + ax1.fill_between(x,y1,0, where=y1>0,color='blue', alpha=.2) + + # Create the second y-axis + ax2 = ax1.twinx() + + # Plot the second data set + ax2.plot(x, y2, 'r-') + ax2.set_ylabel('Actual Historic MOER (co2/lb)', color='r') + ax2.tick_params('y', colors='r') + + # Display the plot + ax1.legend(loc = "best", bbox_to_anchor=(0.5, 0., 0.5, 0.5)) + plt.show() + + +class OptChargeEvaluator(WattTimeOptimizer): + """ + This class inherits from WattTimeOptimizer + + Additional Methods: + [] + """ + def moer_data_override(self, start_time, end_time, region, local_tz = None): + if local_tz: + time_zone = get_timezone_from_dict(local_tz) + start_time = pd.Timestamp(convert_to_utc(start_time, time_zone)) + end_time = pd.Timestamp(convert_to_utc(end_time, time_zone)) + + forecast_history = WattTimeForecast(self.username,self.password) + df = forecast_history.get_historical_forecast_pandas( + start=start_time, + end=end_time, + region=region + ) + return df[df.generated_at == df.generated_at.min()] + + def tz_conversion(self,time,region): + return pd.Timestamp(convert_to_utc(time,get_timezone_from_dict(region))) + + def get_schedule_and_cost_api( + self, + usage_window_start: pd.Timestamp, + usage_window_end: pd.Timestamp, + usage_power_kw: float, + time_needed: float, + region:str = 'CAISO_NORTH', + optimization_method: str = "auto", + constraints: Optional[dict] = None, + charge_per_segment: Optional[list] = None, + tz_convert: bool = False, + verbose:bool=False + ) -> pd.DataFrame: + """ + Generate optimal charging schedule based on MOER forecasts. + + Parameters: + ----------- + usage_power_kw : float + Power usage in kilowatts + time_needed : float + Required charging time in minutes + total_time_horizon : int + Total scheduling horizon in intervals + moer_data : pd.DataFrame + MOER forecast data + optimization_method : str, optional + Optimization method (default: "auto") + charge_per_segment : list, optional + List of charging constraints per interval + + Returns: + -------- + pd.DataFrame + Optimal charging schedule with emissions data + """ + + if tz_convert is True: + usage_window_start = self.tz_conversion(usage_window_start,region) + usage_window_end = self.tz_conversion(usage_window_end, region) + + # Generate optimal usage plan + schedule = self.get_optimal_usage_plan( + region=None, + usage_window_start=usage_window_start, + usage_window_end=usage_window_end, + usage_time_required_minutes=time_needed, + usage_power_kw=usage_power_kw, + optimization_method=optimization_method, + moer_data_override=self.moer_data_override(start_time = usage_window_start, end_time = usage_window_end, region=region), + charge_per_segment=charge_per_segment, + constraints=constraints, + verbose=verbose + ) + + # Validate emissions data + if schedule["emissions_co2_lb"].sum() == 0.0: + self._log_zero_emissions_warning( + usage_power_kw, + time_needed, + schedule["usage"].sum() + ) + + return schedule + + def _log_zero_emissions_warning( + self, + power: float, + time_needed: float, + total_usage: float + ) -> None: + """Log warning when zero emissions are detected.""" + print( + "Warning using 0.0 lb of CO2e:", + power, + time_needed, + total_usage + ) +class RecalculationOptChargeEvaluator(OptChargeEvaluator): + ''' + TODO add notes on compatibility. + ''' + + def next_query_time(self,time,interval): + return time + timedelta(minutes=interval) + + def fit_recalculator( + self, + usage_window_start: pd.Timestamp, + usage_window_end: pd.Timestamp, + usage_power_kw: float, + time_needed: float, + interval: int = 60, + region:str = 'CAISO_NORTH', + optimization_method: str = "auto", + constraints: Optional[dict] = None, + charge_per_segment: Optional[list] = None, + tz_convert: bool = False, + verbose:bool=False, + contiguous:bool=False + ): + if tz_convert is True: + print('tz converting...') + usage_window_start = self.tz_conversion(usage_window_start,region) + usage_window_end = self.tz_conversion(usage_window_end, region) + + initial_usage_plan = self.get_schedule_and_cost_api( + region = region, + usage_window_start=usage_window_start, + usage_window_end=usage_window_end, + time_needed=time_needed, + usage_power_kw=usage_power_kw, + charge_per_segment=charge_per_segment, + optimization_method=optimization_method, + constraints=constraints, + verbose=verbose, + tz_convert=False + ) + + recalculator = WattTimeRecalculator( + initial_schedule = initial_usage_plan, + start_time=usage_window_start, + end_time=usage_window_end, + total_time_required=time_needed, + charge_per_segment=charge_per_segment, + contiguous=contiguous + ) + + recalculator.update_charging_schedule( + next_query_time=usage_window_start, + next_new_schedule_start_time=self.next_query_time(usage_window_start, interval) + ) + + optimization_outcomes = recalculator.contiguity_values_dict + start_time = self.next_query_time(usage_window_start, interval) + while optimization_outcomes["remaining_units_required"] >= recalculator.total_available_units: + new_usage_plan = self.get_optimal_usage_plan( + region = region, + usage_window_start=start_time, + usage_window_end=usage_window_end, + usage_time_required_minutes=optimization_outcomes["remaining_time_required"], + usage_power_kw=usage_power_kw, + charge_per_segment=[int(optimization_outcomes["remaining_time_required"])] if recalculator.is_contiguous else None, + optimization_method=optimization_method, + moer_data_override=self.moer_data_override(start_time,usage_window_end,region), + verbose=verbose + ) + + recalculator.update_charging_schedule( + new_schedule = new_usage_plan, + next_query_time=start_time, + next_new_schedule_start_time = self.next_query_time(start_time,interval) + ) + + optimization_outcomes = recalculator.contiguity_values_dict + start_time = self.next_query_time(start_time,interval) + + return recalculator \ No newline at end of file diff --git a/watttime_optimizer/evaluator/sessions.py b/watttime_optimizer/evaluator/sessions.py new file mode 100644 index 00000000..cd573cc4 --- /dev/null +++ b/watttime_optimizer/evaluator/sessions.py @@ -0,0 +1,324 @@ +from typing import List, Any +from datetime import datetime, timedelta, date +import pandas as pd +import random +import numpy as np +import tqdm + +class SessionsGenerator: + def __init__( + self, + max_percent_capacity: float = 0.95, + power_output_efficiency: float = 0.75, + minimum_battery_starting_capacity: float = 0.2, + minimum_usage_window_start_time: str = "17:00:00", + maximum_usage_window_start_time: str = "21:00:00", + max_power_output_rates: List[Any] = [11, 7.4, 22] + ): + """ Initialize with user behavior + device characteristics""" + self.max_percent_capacity = max_percent_capacity + self.power_output_efficiency = power_output_efficiency + self.minimum_battery_starting_capacity = minimum_battery_starting_capacity + self.minimum_usage_window_start_time = minimum_usage_window_start_time + self.maximum_usage_window_start_time = maximum_usage_window_start_time + self.max_power_output_rates = max_power_output_rates + self.distinct_dates = None + + def return_kwargs(self): + return self.__dict__ + + def generate_start_time(self, date, start_hour: str, end_hour: str) -> datetime: + """ + Generate a random datetime on the given date between two times. + + Parameters: + ----------- + date : datetime.date + The date for which to generate the random time. + start_hour: string + The earliest possible start time (HH:MM:SS format). + end_hour: string + The latest possible start time (HH:MM:SS format). + + Returns: + -------- + datetime + Generated random datetime on the given date. + """ + start_time = datetime.combine( + date, + datetime.strptime(start_hour, "%H:%M:%S").time() + ) + end_time = datetime.combine( + date, + datetime.strptime(end_hour, "%H:%M:%S").time() + ) + + total_seconds = int((end_time - start_time).total_seconds()) + random_seconds = random.randint(0, total_seconds) + return start_time + timedelta(seconds=random_seconds) + + def generate_end_time( + self, + start_time: datetime, + mean: float = None, + stddev: float = None, + ) -> pd.Timestamp: + """ + Generate session end time based on start time using specified distribution. + + Parameters: + ----------- + start_time : datetime + Initial plug-in time. + mean : float, optional + Normal distribution mean (required if method='normal'). + stddev : float, optional + Normal distribution standard deviation (required if method='normal'). + elements : List[Any], optional + Options for uniform distribution in seconds (required if method='random_choice'). + + Returns: + -------- + pd.Timestamp + Generated end time. + """ + random_seconds = abs(np.random.normal(loc=mean, scale=stddev)) + random_timedelta = timedelta(seconds=random_seconds) + new_datetime = start_time + random_timedelta + if not isinstance(new_datetime, pd.Timestamp): + new_datetime = pd.Timestamp(new_datetime) + return new_datetime + + def synthetic_user_data(self, distinct_date_list, **kwargs) -> pd.DataFrame: + """ + Generate synthetic data for a single user. + + This function creates a DataFrame with synthetic data for EV charging sessions, + including plug-in times, unplug times, initial charge, and other relevant metrics. + + Parameters: + ----------- + distinct_date_list : List[Any] + A list of distinct dates for which to generate charging sessions. + max_percent_capacity : float, optional + The maximum percentage of battery capacity to charge to (default is 0.95). + minimum_battery_starting_capacity: float + The minimum percent charged at session start. + user_charge_tolerance : float, optional + The minimum acceptable charge percentage for users (default is 0.8). + power_output_efficiency : float, optional + The efficiency of power output (default is 0.75). + start_hour: string + The earliest possible random start time generated. Formatted as HH:MM:SS. + end_hour: + The latest possible random start time generated. Formatted as HH:MM:SS. + + Returns: + -------- + pd.DataFrame + A DataFrame containing synthetic user data for EV charging sessions. + """ + + power_output_efficiency = round(random.uniform(0.5, 0.9), 3) + power_output_max_rate = random.choice(self.max_power_output_rates) * power_output_efficiency + total_capacity = round(random.uniform(21, 123)) + mean_length_charge = round(random.uniform(20000, 30000)) + std_length_charge = round(random.uniform(6800, 8000)) + + user_df = ( + pd.DataFrame(distinct_date_list, columns=["distinct_dates"]) + .sort_values(by="distinct_dates") + .copy() + ) + + # Unique user type given by the convo of 4 variables. + user_df["user_type"] = ( + "r" + + str(power_output_max_rate) + + "_tc" + + str(total_capacity) + + "_avglc" + + str(mean_length_charge) + + "_sdlc" + + str(std_length_charge) + ) + + user_df["usage_window_start"] = user_df["distinct_dates"].apply( + self.generate_start_time, args=(self.minimum_usage_window_start_time, self.maximum_usage_window_start_time) + ) + user_df["usage_window_end"] = user_df["usage_window_start"].apply( + lambda x: self.generate_end_time( + x, mean_length_charge, std_length_charge + ) + ) + + user_df["usage_window_start"] = user_df["usage_window_start"].dt.round('5min') + user_df["usage_window_end"] = user_df["usage_window_end"].dt.round('5min') + + + # Another random parameter, this time at the session level, + # it's the initial charge of the battery as a percentage. + user_df["initial_charge"] = user_df.apply( + lambda _: random.uniform(self.minimum_battery_starting_capacity, 0.8), axis=1 + ) + user_df["time_needed"] = user_df["initial_charge"].apply( + lambda x: int(total_capacity + * (self.max_percent_capacity - x) + / power_output_max_rate + * 60) + ) + + # What time will the battery reach max capacity + user_df["expected_baseline_charge_complete_timestamp"] = user_df["usage_window_start"] + pd.to_timedelta( + user_df["time_needed"], unit="m" + ) + user_df["window_length_in_minutes"] = ( + user_df.usage_window_end - user_df.usage_window_start + ) / pd.Timedelta(seconds=60) + + user_df["final_charge_time"] = user_df[ + ["expected_baseline_charge_complete_timestamp", "usage_window_end"] + ].min(axis=1) + + user_df["total_capacity"] = total_capacity + user_df["usage_power_kw"] = power_output_max_rate + + user_df["total_intervals_plugged_in"] = ( + user_df["window_length_in_minutes"] / 5 + ) + + user_df["MWh_fraction"] = user_df["usage_power_kw"] / 12 / 1000 + + user_df["early_session_stop"] = user_df["usage_window_end"] < user_df["expected_baseline_charge_complete_timestamp"] + + return user_df + + def generate_synthetic_dataset( + self, distinct_date_list: List[Any], number_of_users: int = 1 + ): + """ + Execute the synthetic data generation process for multiple users. + + This function generates synthetic charging data for a specified number of users + across the given distinct dates. + + Parameters: + ----------- + distinct_date_list : List[Any] + A list of distinct dates for which to generate charging sessions. + number_of_users : int, optional + The number of users to generate data for (default is 1). + + Returns: + -------- + pd.DataFrame + A concatenated DataFrame containing synthetic data for all users. + """ + dfs = [] + for i in tqdm.tqdm(range(number_of_users)): + df_temp = self.synthetic_user_data( + distinct_date_list=distinct_date_list, **self.__dict__ + ) + dfs.append(df_temp) + df_all = pd.concat(dfs) + df_all.reset_index(inplace=True) + return df_all + + def assign_random_dates(self, years: List[int]): + all_dates = [] + for year in years: + y = self.generate_random_dates(year) + all_dates = all_dates + y + return all_dates + + def _get_date_from_week_and_day(self, year, week_number, day_number): + """ + Return the date corresponding to the year, week number, and day number provided. + + This function calculates the date based on the ISO week date system. It assumes + the first week of the year is the first week that fully starts that year, and + the last week of the year can spill into the next year. + + Parameters: + ----------- + year : int + The year for which to calculate the date. + week_number : int + The week number (1-52). + day_number : int + The day number (1-7 where 1 is Monday). + + Returns: + -------- + datetime.date + The corresponding date as a datetime.date object. + + Notes: + ------ + The function checks that all returned dates are before today and cannot + return dates in the future. + """ + # Calculate the first day of the year + first_day_of_year = date(year, 1, 1) + + # Calculate the first Monday of the eyar (ISO calendar) + first_monday = first_day_of_year + timedelta( + days=(7 - first_day_of_year.isoweekday()) + 1 + ) + + # Calculate the target date + target_date = first_monday + timedelta(weeks=week_number - 1, days=day_number - 1) + + # if the first day of the year is Monday, adjust the target date + if first_day_of_year.isoweekday() == 1: + target_date -= timedelta(days=7) + + return target_date + + def generate_random_dates(self, year): + """ + Generate a list containing two random dates from each week in the given year. + + Parameters: + ----------- + year : int + The year for which to generate the random dates. + + Returns: + -------- + list + A list of dates, with two random dates from each week of the specified year. + """ + random_dates = [] + for i in range(1, 53): + days = random.sample(range(1, 8), 2) + days.sort() + random_dates.append(self._get_date_from_week_and_day(year, i, days[0])) + random_dates.append(self._get_date_from_week_and_day(year, i, days[1])) + random_dates = [date for date in random_dates if date < date.today()] + random_dates = self._remove_duplicates(random_dates) + + return random_dates + + def _remove_duplicates(self, input_list): + """ + Remove duplicate items from a list while maintaining the order of the first occurrences. + + Parameters: + ----------- + input_list : list + List of items that may contain duplicates. + + Returns: + -------- + list + A new list with duplicates removed, maintaining the order of first occurrences. + """ + seen = set() + output_list = [] + for item in input_list: + if item not in seen: + seen.add(item) + output_list.append(item) + return output_list \ No newline at end of file diff --git a/watttime_optimizer/evaluator/utils.py b/watttime_optimizer/evaluator/utils.py new file mode 100644 index 00000000..c6266ef2 --- /dev/null +++ b/watttime_optimizer/evaluator/utils.py @@ -0,0 +1,164 @@ +import math +from datetime import datetime +import pytz + + +TZ_DICTIONARY = { + "AECI": "America/Chicago", + "AVA": "America/Los_Angeles", + "AZPS": "America/Phoenix", + "BANC": "America/Los_Angeles", + "BPA": "America/Los_Angeles", + "CAISO_ESCONDIDO": "America/Los_Angeles", + "CAISO_LONGBEACH": "America/Los_Angeles", + "CAISO_NORTH": "America/Los_Angeles", + "CAISO_PALMSPRINGS": "America/Los_Angeles", + "CAISO_REDDING": "America/Los_Angeles", + "CAISO_SANBERNARDINO": "America/Los_Angeles", + "CAISO_SANDIEGO": "America/Los_Angeles", + "CHPD": "America/Los_Angeles", + "CPLE": "America/New_York", + "CPLW": "America/New_York", + "DOPD": "America/Los_Angeles", + "DUK": "America/New_York", + "ELE": "America/Denver", + "ERCOT_AUSTIN": "America/Chicago", + "ERCOT_COAST": "America/Chicago", + "ERCOT_EASTTX": "America/Chicago", + "ERCOT_HIDALGO": "America/Chicago", + "ERCOT_NORTHCENTRAL": "America/Chicago", + "ERCOT_PANHANDLE": "America/Chicago", + "ERCOT_SANANTONIO": "America/Chicago", + "ERCOT_SECOAST": "America/Chicago", + "ERCOT_SOUTHTX": "America/Chicago", + "ERCOT_WESTTX": "America/Chicago", + "FMPP": "America/New_York", + "FPC": "America/New_York", + "FPL": "America/New_York", + "GVL": "America/New_York", + "IID": "America/Los_Angeles", + "IPCO": "America/Boise", + "ISONE_CT": "America/New_York", + "ISONE_ME": "America/New_York", + "ISONE_NEMA": "America/New_York", + "ISONE_NH": "America/New_York", + "ISONE_RI": "America/New_York", + "ISONE_SEMA": "America/New_York", + "ISONE_VT": "America/New_York", + "ISONE_WCMA": "America/New_York", + "JEA": "America/New_York", + "LDWP": "America/Los_Angeles", + "LGEE": "America/New_York", + "MISO_INDIANAPOLIS": "America/Indiana/Indianapolis", + "MISO_N_DAKOTA": "America/North_Dakota/Center", + "MPCO": "America/Denver", + "NEVP": "America/Los_Angeles", + "NYISO_NYC": "America/New_York", + "PACE": "America/Denver", + "PACW": "America/Los_Angeles", + "PGE": "America/Los_Angeles", + "PJM_CHICAGO": "America/Chicago", + "PJM_DC": "America/New_York", + "PJM_EASTERN_KY": "America/New_York", + "PJM_EASTERN_OH": "America/New_York", + "PJM_ROANOKE": "America/New_York", + "PJM_NJ": "America/New_York", + "PJM_SOUTHWEST_OH": "America/New_York", + "PJM_WESTERN_KY": "America/New_York", + "PNM": "America/Denver", + "PSCO": "America/Denver", + "PSEI": "America/Los_Angeles", + "SC": "America/New_York", + "SCEG": "America/New_York", + "SCL": "America/Los_Angeles", + "SEC": "America/New_York", + "SOCO": "America/Chicago", + "SPA": "America/Chicago", + "SPP_FORTPECK": "America/Denver", + "SPP_KANSAS": "America/Chicago", + "SPP_KC": "America/Chicago", + "SPP_MEMPHIS": "America/Chicago", + "SPP_ND": "America/North_Dakota/Beulah", + "SPP_OKCTY": "America/Chicago", + "SPP_SIOUX": "America/Chicago", + "SPP_SPRINGFIELD": "America/Chicago", + "SPP_SWOK": "America/Chicago", + "SPP_TX": "America/Chicago", + "SPP_WESTNE": "America/Chicago", + "SRP": "America/Phoenix", + "TAL": "America/New_York", + "TEC": "America/New_York", + "TEPC": "America/Phoenix", + "TID": "America/Los_Angeles", + "TPWR": "America/Los_Angeles", + "TVA": "America/Chicago", + "WACM": "America/Denver", + "WALC": "America/Phoenix", + "WAUW": "America/Denver", + "NL": "Europe/Amsterdam" +} + +def sanitize_time_needed(x,y): + return int(math.ceil(min(x, y) / 300.0) * 5) + +def sanitize_total_intervals(x): + return math.ceil(x) + +def intervalize_power_rate(kW_value: float, convert_to_MWh=True) -> float: + """ + Calculate the energy used in an interval from a power rate in kilowatts + This will return a value in units of MWh by default. + If convert_to_MWh is false, it will convert to kWh units instead. + """ + five_min_rate = kW_value / 12 + if convert_to_MWh: + five_min_rate = five_min_rate / 1000 + return five_min_rate + + +def get_timezone_from_dict(key, dictionary=TZ_DICTIONARY): + """ + Retrieve the timezone value from the dictionary based on the given key. + + Parameters: + ----------- + key : str + The key whose corresponding timezone value is to be retrieved. + dictionary : dict, optional + The dictionary from which to retrieve the value (default is TZ_DICTIONARY). + + Returns: + -------- + str or None + The timezone value corresponding to the given key if it exists, otherwise None. + """ + return dictionary.get(key) + + +def convert_to_utc(local_time_str, local_tz_str): + """ + Convert a time expressed in any local time to UTC. + + Parameters: + ----------- + local_time_str : str + The local time as a pd.Timestamp. + local_tz_str : str + The timezone of the local time as a string, e.g., 'America/New_York'. + + Returns: + -------- + str + The time in UTC as a datetime object in the format 'YYYY-MM-DD HH:MM:SS'. + + Example: + -------- + >>> convert_to_utc(pd.Timestamp('2023-08-29 14:30:00'), 'America/New_York') + '2023-08-29 18:30:00' + """ + local_time = datetime.strptime( + local_time_str.strftime("%Y-%m-%d %H:%M:%S"), "%Y-%m-%d %H:%M:%S" + ) + local_tz = pytz.timezone(local_tz_str) + local_time = local_tz.localize(local_time) + return local_time.astimezone(pytz.utc) \ No newline at end of file diff --git a/watttime_optimizer/notebooks/cumulative_avoided_emissions.png b/watttime_optimizer/notebooks/cumulative_avoided_emissions.png new file mode 100644 index 00000000..b2e85525 Binary files /dev/null and b/watttime_optimizer/notebooks/cumulative_avoided_emissions.png differ diff --git a/watttime_optimizer/notebooks/datacenter_workloads.ipynb b/watttime_optimizer/notebooks/datacenter_workloads.ipynb new file mode 100644 index 00000000..9a381e80 --- /dev/null +++ b/watttime_optimizer/notebooks/datacenter_workloads.ipynb @@ -0,0 +1,251 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Center Workloads" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.chdir(path=os.path.dirname(os.path.dirname(os.path.abspath(os.curdir))))\n", + "\n", + "from watttime_optimizer.evaluator.analysis import plot_predicated_moer, plot_charging_units, plot_scheduled_moer\n", + "from datetime import datetime, timedelta\n", + "import pandas as pd\n", + "from pytz import UTC\n", + "from watttime_optimizer import WattTimeOptimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Single Segment - Fixed Length" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By passing a single interval of 120 minutes to charge_per_segment, the Optimizer will know to fit call the fixed contigous modeling function." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "username = os.getenv(\"WATTTIME_USER\")\n", + "password = os.getenv(\"WATTTIME_PASSWORD\")\n", + "wt_opt = WattTimeOptimizer(username, password)\n", + "\n", + "# 12 hour charge window (720/60 = 12)\n", + "now = datetime.now(UTC)\n", + "window_start = now\n", + "window_end = now + timedelta(minutes=720)\n", + "\n", + "usage_plan = wt_opt.get_optimal_usage_plan(\n", + " region=\"CAISO_NORTH\",\n", + " usage_window_start=window_start,\n", + " usage_window_end=window_end,\n", + " usage_time_required_minutes=120,\n", + " usage_power_kw=12,\n", + " charge_per_segment=[120],\n", + " optimization_method=\"auto\",\n", + " verbose = False\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Charging schedule to be composed of a single contiguous, i.e. \"block\" segment of fixed length" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_charging_units(usage_plan)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlQAAAHVCAYAAAA3nGXJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABcNklEQVR4nO3deVxU5f4H8M8wwIAs4wKypCCZiriluACG2r2JaZre8idWFzMl49qi0aZppd4S7ZbR4pJdlVaim1be0pTKNbnmApZpZqXhAiIqIC4sM8/vDzyHGWZhmYMDh8/79ZrXvZw588xzTgzz9fs8z/fRCCEEiIiIiKjBXJzdASIiIqLmjgEVERERkYMYUBERERE5iAEVERERkYMYUBERERE5iAEVERERkYMYUBERERE5iAEVERERkYMYUBERERE5iAEVkYLS0tKg0Wig0WiwdetWi+eFELjpppug0WgwbNgwi+fPnTuH2bNnIyIiAq1atYKvry+ioqKwdOlSVFRUWJwvvZe1x+TJk+Xz5s2bZ/acm5sbQkJC8OCDDyI/P1/BO1Bl69atNvs1fvx4xd+vqdm1axfmzZuHoqIixduePHkyOnXqVOt5nTp1wujRo60+t3fvXmg0GqSlpSnbOaIWzNXZHSBSIx8fH6xatcoiaNq2bRt+//13+Pj4WLzml19+QVxcHEpLS/HEE08gJiYGV65cwZdffokZM2bgP//5DzZs2IBWrVqZvW78+PF44oknLNrz9/e3OPb1119Dr9ejtLQUmzdvxquvvopdu3YhJycHbm5ujl20FQsXLsStt95qdqxdu3aKv09Ts2vXLsyfPx+TJ09G69atnd0dIroOGFARNYL4+Hh8+OGHWLp0KXx9feXjq1atQnR0NEpKSszONxgMuPvuu1FSUoIffvgBXbt2lZ8bNWoUhg4diokTJyI5ORkrVqwwe21AQACioqLq1K/IyEj4+fkBAG677TYUFhZizZo12Llzp0Xgo4QuXbrUuW/1ceXKFXh4eECj0SjeNhFRQ3DIj6gR3HPPPQCA9PR0+VhxcTHWrl2LKVOmWJz/2Wef4dChQ5g1a5ZZMCWJj49HXFwcVq1apegQXf/+/QEAZ86cUazN+ti5cyf++te/wsfHB61atUJMTAy++uors3OkYdTNmzdjypQp8Pf3R6tWrVBWVgYAyMjIQHR0NLy8vODt7Y0RI0YgOzvb4r12796NMWPGoF27dvDw8EDnzp0xc+ZM+fnffvsNDzzwALp06YJWrVrhhhtuwJgxY/DTTz+ZtWM0GvHiiy+iW7du8PT0ROvWrdG7d2+8/vrrAKqGV5966ikAQFhYmNUh4Lr2OS0tDd26dYNOp0P37t3x3nvvNeg+18Uff/yBiRMnIjg4GDqdDgEBAfjrX/+KnJwcs37HxcUhKCgInp6e6N69O2bNmoVLly5ZtPfOO++ga9eu0Ol0iIiIwEcffWR1uLK8vBwvvvgiwsPDodPp4O/vjwceeABnz55ttGslagwMqIgaga+vL8aPH4/Vq1fLx9LT0+Hi4oL4+HiL8zMzMwEA48aNs9nmuHHjUFlZaTE3SwiByspKi4cQotZ+Hjt2DACsBnFKMBqNFv2SbNu2DX/5y19QXFyMVatWIT09HT4+PhgzZgwyMjIs2poyZQrc3Nzw/vvv49NPP4WbmxsWLlyIe+65BxEREfjkk0/w/vvv4+LFi4iNjcWhQ4fk127atAmxsbHIzc3FkiVLsHHjRsydO9cskDx9+jTatWuHRYsW4euvv8bSpUvh6uqKQYMG4ciRI/J5L7/8MubNm4d77rkHX331FTIyMjB16lR5vlRiYiIeffRRAMC6deuQlZWFrKws9OvXDwDq3Oe0tDQ88MAD6N69O9auXYu5c+fin//8J7777jtl/uPUMGrUKOzbtw8vv/wyMjMzsXz5cvTt29dsHtjRo0cxatQorFq1Cl9//TVmzpyJTz75BGPGjDFra+XKlZg2bRp69+6NdevWYe7cuZg/f77F767RaMTYsWOxaNEi3Hvvvfjqq6+waNEiZGZmYtiwYbhy5UqjXCtRoxBEpJg1a9YIAGLPnj1iy5YtAoA4ePCgEEKIAQMGiMmTJwshhOjRo4cYOnSo/Lrbb79dABBXr1612fbGjRsFALF48WL5GACbj/fff18+74UXXhAARH5+vqioqBAXLlwQn3zyifDy8hL33HOPwndByNdu7XH06FEhhBBRUVGiffv24uLFi/LrKisrRc+ePUWHDh2E0WgUQlTf00mTJpm9R25urnB1dRWPPvqo2fGLFy+KwMBAMWHCBPlY586dRefOncWVK1fqfA2VlZWivLxcdOnSRTz++OPy8dGjR4ubb77Z7mv/9a9/CQDi2LFjDeqzwWAQwcHBol+/fvJ9EEKI48ePCzc3NxEaGlpr/0NDQ8Udd9xh9bk9e/YIAGLNmjVCCCEKCwsFAJGamlpruxKj0SgqKirEtm3bBABx4MABue+BgYFi0KBBZuf/+eefFn1PT08XAMTatWut9m/ZsmV17g+RszFDRdRIhg4dis6dO2P16tX46aefsGfPHqvDfXUlrmWcas4bmjBhAvbs2WPxGDVqlEUbgYGBcHNzQ5s2bTBhwgRERkbi3XffrdN728o02bN48WKLfnXs2BGXLl3C7t27MX78eHh7e8vna7VaJCQk4OTJk2ZZIQC4++67zX7etGkTKisrMWnSJLN+eXh4YOjQoXI25Ndff8Xvv/+OqVOnwsPDw2ZfKysrsXDhQkRERMDd3R2urq5wd3fH0aNHcfjwYfm8gQMH4sCBA5g+fTo2bdpkMR/Onrr2+ciRIzh9+jTuvfdes//eoaGhiImJqfP71VXbtm3RuXNn/Otf/8KSJUuQnZ0No9Focd4ff/yBe++9F4GBgdBqtXBzc8PQoUMBQL5HR44cQX5+PiZMmGD22pCQEAwePNjs2JdffonWrVtjzJgxZvfj5ptvRmBgoNWVskRNFSelEzUSjUaDBx54AG+88QauXr2Krl27IjY21uq5ISEhAKqG4MLDw62ec/z4cQBAx44dzY77+/vLc6Fq880330Cv1+P8+fNYuXIl1q5di0cffdRiontN7777Lh544AGzY6IOQ4o33nij1b6dPXsWQggEBQVZPBccHAygqoSEqZrnSsN1AwYMsPreLi4u8nsBQIcOHez2NTk5GUuXLsUzzzyDoUOHok2bNnBxcUFiYqLZ0NPs2bPh5eWFDz74ACtWrIBWq8WQIUOwePHiWv871LXP0rUHBgZanBMYGCj/Ltjj6uoKg8Fg9TkpIJZWdmo0Gnz77bdYsGABXn75ZTzxxBNo27Yt7rvvPrz00kvw8fFBaWkpYmNj4eHhgRdffBFdu3ZFq1atcOLECdx1113yPZL6HhAQYPG+AQEB8jCzdD+Kiorg7u5utZ+FhYW1XidRU8GAiqgRTZ48Gc8//zxWrFiBl156yeZ5w4cPx8qVK/H5559j1qxZVs/5/PPP4erqarV+VV316dNHXuU3fPhwjBgxAitXrsTUqVNtfskDwJgxY7Bnz54Gv29NUrCSl5dn8dzp06cBQO6npGZmTnr+008/RWhoqM33kspHnDx50m6fPvjgA0yaNAkLFy40O15YWGhW+sDV1RXJyclITk5GUVERvvnmGzz77LMYMWIETpw4YVHWoiF9lkpLWFuAUNdFCQEBATh16pTV56TjpkFPaGgoVq1aBaAqq/fJJ59g3rx5KC8vx4oVK/Ddd9/h9OnT2Lp1q5yVAmBRa0vqu7WFDjX77ufnh3bt2uHrr7+22k9r5UWImiznjjgSqYvpHCrJM888I8aOHStOnz4tH6s5h6qyslJEREQIvV4vjhw5YtHuxx9/LACIpKQks+MAxMMPP1xrv6Q5VGfPnjU7/uuvvwpXV1cRFxdX10usE2kO1X/+8x+b50RHR4vAwEBx+fJl+ZjBYBC9evWyOofK9J4KIcSxY8eEq6ur2ZwyWzp37ixuuukmu3PU2rZtKx566CGzY19++aUAYPbfyprU1FQBQPz8889CCCHeeOMNAUAcOnSoQX02GAwiKChIREZGNngO1fPPPy80Go3cJ1MTJkwQ3t7eoqSkxG4bN998sxgwYIAQQoj169cLACIrK8vsnPHjx5vNx6rPHKoPPvhAABD/+9//ar0eoqaOGSqiRrZo0aJaz9FqtVi7di2GDx+O6OhoPPHEE4iOjkZZWRn++9//YuXKlRg6dCheffVVi9eeOXMG//vf/yyO+/r6IiIiwu77dunSBdOmTcOyZcuwc+dO3HLLLXW/MAelpKRg+PDhuPXWW/Hkk0/C3d0dy5Ytw8GDB5Genl5rjalOnTphwYIFmDNnDv744w/cfvvtaNOmDc6cOYMffvgBXl5emD9/PgBg6dKlGDNmDKKiovD4448jJCQEubm52LRpEz788EMAwOjRo5GWlobw8HD07t0b+/btw7/+9S+LocIxY8agZ8+e6N+/P/z9/fHnn38iNTUVoaGh6NKlCwCgV69eAIDXX38d999/P9zc3NCtW7c699nFxQX//Oc/kZiYiL/97W948MEHUVRUhHnz5lkdBrRmxowZeO+99zBs2DA8++yz6NWrFy5cuICMjAx8+umnWLJkiZwB+vHHH/HII4/g//7v/9ClSxe4u7vju+++w48//ihnTGNiYtCmTRskJSXhhRdegJubGz788EMcOHDA7H1dXFwwf/58PPTQQxg/fjymTJmCoqIizJ8/H0FBQfKwJgBMnDgRH374IUaNGoUZM2Zg4MCBcHNzw8mTJ7FlyxaMHTsWf/vb3+p0vURO5+yIjkhNbGVTaqqZoZIUFhaKWbNmifDwcOHh4SG8vb3FwIEDxVtvvSXKy8stzoedVX6DBw+Wz7OVoRJCiDNnzghvb29x66231v+CbahLhkoIIXbs2CH+8pe/CC8vL+Hp6SmioqLEf//7X7Nzarunn3/+ubj11luFr6+v0Ol0IjQ0VIwfP1588803ZudlZWWJkSNHCr1eL3Q6nejcubPZ6r0LFy6IqVOnivbt24tWrVqJW265RezYsUMMHTrU7L/Vq6++KmJiYoSfn59wd3cXISEhYurUqeL48eNm7zd79mwRHBwsXFxcBACxZcuWevf53//+t+jSpYtwd3cXXbt2FatXrxb3339/nTJUQgiRn58v/vGPf4iQkBDh6uoqfHx8xC233GLx3+XMmTNi8uTJIjw8XHh5eQlvb2/Ru3dv8dprr4nKykr5vF27dono6GjRqlUr4e/vLxITE8X+/fvNMlSSlStXiptuusms72PHjhV9+/Y1O6+iokK88sorok+fPvLvfHh4uHjooYfkFaFEzYFGiDrMLCUiInJAUVERunbtinHjxmHlypXO7g6R4jjkR0REisrPz8dLL72EW2+9Fe3atcOff/6J1157DRcvXsSMGTOc3T2iRsGAioiIFKXT6XD8+HFMnz4d58+fR6tWrRAVFYUVK1agR48ezu4eUaPgkB8RERGRg1gpnYiIiMhBDKiIiIiIHMSAioiIiMhBnJRuhdFoxOnTp+Hj41NrcUEiIiJqGoQQuHjxIoKDg82KyF4PDKisOH36tMUGtERERNQ8nDhxotYN0ZXGgMoKaTuGEydOwNfX18m9ISIiorooKSlBx44dnbKxNgMqK6RhPl9fXwZUREREzYwzputwUjoRERGRgxhQERERETmIARURERGRgxhQERERETnI6QHVsmXLEBYWBg8PD0RGRmLHjh02z925cycGDx6Mdu3awdPTE+Hh4Xjttdcszlu7di0iIiKg0+kQERGBzz77rDEvgYiIiFo4pwZUGRkZmDlzJubMmYPs7GzExsZi5MiRyM3NtXq+l5cXHnnkEWzfvh2HDx/G3LlzMXfuXKxcuVI+JysrC/Hx8UhISMCBAweQkJCACRMmYPfu3dfrsoiIiKiF0QghhLPefNCgQejXrx+WL18uH+vevTvGjRuHlJSUOrVx1113wcvLC++//z4AID4+HiUlJdi4caN8zu233442bdogPT29Tm2WlJRAr9ejuLiYZROIiIiaCWd+fzstQ1VeXo59+/YhLi7O7HhcXBx27dpVpzays7Oxa9cuDB06VD6WlZVl0eaIESPstllWVoaSkhKzBxEREVFdOS2gKiwshMFgQEBAgNnxgIAA5Ofn231thw4doNPp0L9/fzz88MNITEyUn8vPz693mykpKdDr9fKD284QERFRfTh9UnrNaqZCiFornO7YsQN79+7FihUrkJqaajGUV982Z8+ejeLiYvlx4sSJel4FERERtWRO23rGz88PWq3WInNUUFBgkWGqKSwsDADQq1cvnDlzBvPmzcM999wDAAgMDKx3mzqdDjqdriGXQUREROS8DJW7uzsiIyORmZlpdjwzMxMxMTF1bkcIgbKyMvnn6OhoizY3b95crzaJiIiI6sOpmyMnJycjISEB/fv3R3R0NFauXInc3FwkJSUBqBqKO3XqFN577z0AwNKlSxESEoLw8HAAVXWpXnnlFTz66KNymzNmzMCQIUOwePFijB07Fl988QW++eYb7Ny58/pfIFEjKr5cgRMXLqPnDXpnd4WIqMVzakAVHx+Pc+fOYcGCBcjLy0PPnj2xYcMGhIaGAgDy8vLMalIZjUbMnj0bx44dg6urKzp37oxFixbhoYceks+JiYnBxx9/jLlz5+K5555D586dkZGRgUGDBl336yNqTDMzsrHlyFlsnBGL7kEs70FE5ExOrUPVVLEOFTUHgxd9h1NFV7D8vn4Y2SvI2d0hInK6FlmHiogcc/5SOQDg4tVKJ/eEiIgYUBE1Q1fKDbhSYQAAlFytcHJviIiIARVRM3TuUvXKVmaoiIicjwEVUTN04VJ1VooBFRGR8zGgImqGzDNUHPIjInI2BlREzZA0IR1ghoqIqClgQEXUDJkFVGXMUBERORsDKqJm6BwzVERETQoDKqJm6HwpAyoioqaEARVRM9RYGaqvD+bhP3tPKNYeEVFL4dS9/IioYS5cNg2olJlDZTAKzPg4B+UGI/7aPQBtvdwVaZeIqCVghoqoGTKdlF5WaUR5pdHhNosul6Os0gghgIKLVx1uj4ioJWFARdQMnSstM/tZiSzVhcvVbZjO0SIiotoxoCJqZioMRpTUmDelxDyqIpNhxPOXGVAREdUHAyqiZubCteE+Fw3g76MDoExAZTqMaPr/iYiodgyoiJoZaYVfm1bu0Hu6AVBmyK/IdMiPARURUb1wlR9RMyMFO2293OHtUfURrjkE2KB2LzNDRUTUUAyoiJoZ04BK56YFoNSkdAZUREQNxYCKqJmRgp123u7QaDQAFJqUfolDfkREDcWAiqiZOWeSoTIYBQCFJqUzQ0VE1GAMqIiamfOXqmpQtW3ljqvXCnqWlikxKZ0BFRFRQ3GVH1EzYzqHykdX9W8ipcsmXLhcDiGEw20SEbUUDKiImplz16qYt/XWwcdDuYDKtGxChUHgYplymy4TEakdAyqiJsRgFPjnl4fw1Y95Ns+RJ6V7ucPHo6oOVYmDq/yMRoGiK+ZtcPsZIqK6Y0BF1IT8eLIIq3Yew3NfHLQ55CaVN2jr5a5Yhuri1Up5gnv7a9XXuf0MEVHdMaAiakIKr2WFzl8qR17xVYvnjUYhb2LczqSwp6N1qKQgzctdiyC9R1UfmKEiIqozBlRETYhpcc2Dp4otni++UiFnktp4ucPXQ9p6xrEMlZSNat3KHW283KuOcaUfEVGdMaAiakJMSxccPF1i8bxUg8rHwxVuWhfFhvyk923j5Ya2UkDFIT8iojpjQEXUhJw3qVZ+6LRlhsp0QjoAeVL6lQoDKgzGBr/vhWvv26aVO9q2YoaKiKi+GFARNSFmGapTlhkquainHFBV1+YtdSBLJQ01tmnljrbeDKiIiOqLARVRE2I6hyq/5CoKS8vMnq/edqZqJZ6b1gUeblUf41IH6kaZrhxkhoqIqP4YUBE1IRcuma/W+7nGPCpp5Z005AdAkVpU0lBj61Ymc6gUCqj2Hj+PE+cvK9IWEVFTxYCKqAmRMkV+3lUZqJor/aSJ4tKwHABFJqYXmQ75KRhQnbxwGf/3dhYefG+vw20RETVlDKiImhCpxtQtN7UDAPxcY2J6zUnpQHWGypGASp5D5aVsQHW88DKEqK6vRUSkVgyoiJoIIYScKbqliz8AK0N+l6ozSRJfBYp7Vq/yc0O7a/OzSssqUVZpkM8pLaus93ucuzaJ3siNlolI5RhQETURF8sqUXmtaGdsFz8AwJ/nLqPYZI+96o2RlR3yM13l5+PhCq2Lpur4tUDraoUBcUu24fbUHbhcXvf3OXuxKqCSipESEakVAyqiJqLoWvDi6aZFgK8HbmjtCQA4ZJKlsjbk561zLEMlhDAb8nNx0cgZMOn9juRfxOniqzhVdAVr952sc9vSUJ+RARURqRwDKqImojpLVDUnqucNvgCq51EJIeQAp62Cc6gulRtQYRBm793Wq+p/pfc7aDKXa/X3x+scIJ27VvbBwCE/IlI5BlRETcR5kywRAPQM1gOonkdVWlaJ8mvV0KV5TkD1kF9JAwOqC9eCJp2rCzzdtABgsf2MaZHRY4WXsOVIQZ3alupocciPiNSOARVRE2FaugAAelzLUEmlEy6YDAl6umvl11VnqBo25Gc6f0qjqZo7JQdU1wIiKUt2o78XAGDVzmN1alsqRMpJ6USkdgyoiJqICybFNYHqDNXvZ0uRc6II6XtyAZgP9wHVGaqGVkqXSjW0MWm3OkNVgQqDEb/kXQQAvDSuF7QuGuz6/ZzZ3C5bCjkpnYhaCAZURE3EhRoZqva+HvD30cEogHFLv8fyrb8DAELbtTJ7na+Dq/wuXDKfuwVUb21z/lIZjp4pRbnBCB8PV0Td2Ba39wwEAKz+3n6WSgiBQjlDVfUzEZFaMaAiaiIu1JhDBQBDrtWj8nTTYmhXfzw7KhyvT+xr9jolh/wkbVtVT0qXJqT3DNZDo9Eg8ZYwAMD6nNMouHjVZrsXyypRXmmUf2aSiojUzLX2U4joepCH3kwyRS/9rSemDbkRYX5ecHe1/u8fR+tQVQ/5mWSovKUMVTl+vjaHS1p12DekDfqFtMb+3CKs238KSUM7W233XI3q6AajkOtbERGpDTNURE3EBStV0D3ctOgW6GMzmAIcL5tg7X3bmtShOnhtrlTPG/Ty86N6BQEA9v95wWa70go/CSemE5GaMUNF1ERYmxxeF6aT0huSBbI65HetD4Wl5Thx/goAoEdwdUDVu0NrAMCPJ833GjR1rkZAxYnpRKRmTs9QLVu2DGFhYfDw8EBkZCR27Nhh89x169Zh+PDh8Pf3h6+vL6Kjo7Fp0yazc9LS0qDRaCweV6/anutB1BQUXbacHF4XUkAFNGylX/XcLdNJ6dUZqisVBrRy1yLMz0t+vucNvnDRAPklV3GmxPpn62zNIT9mqIhIxZwaUGVkZGDmzJmYM2cOsrOzERsbi5EjRyI3N9fq+du3b8fw4cOxYcMG7Nu3D7feeivGjBmD7Oxss/N8fX2Rl5dn9vDw8Lgel0TUYNY2Pq4LnatWHhJsyMT06nIN1e9rGlwBQESQr1nmq5W7K7oG+AAADpwostquVDJBwu1niEjNnBpQLVmyBFOnTkViYiK6d++O1NRUdOzYEcuXL7d6fmpqKp5++mkMGDAAXbp0wcKFC9GlSxf897//NTtPo9EgMDDQ7EHUlF0pN6Ds2oq41vXMUAGAj67hE9OlzFhbk4BK56qV2wTM509J+lwb9jtwsshqu+cucciPiFoOpwVU5eXl2LdvH+Li4syOx8XFYdeuXXVqw2g04uLFi2jbtq3Z8dLSUoSGhqJDhw4YPXq0RQarprKyMpSUlJg9iK4nadjNTauRNzuuD0dW+p23MocKMJ/L1SPY1+J1vTtWBVm25lEVXuSQHxG1HE4LqAoLC2EwGBAQEGB2PCAgAPn5+XVq49VXX8WlS5cwYcIE+Vh4eDjS0tKwfv16pKenw8PDA4MHD8bRo0dttpOSkgK9Xi8/Onbs2LCLImogKaBqbbL9S31IK/1Ky+o35Hel3ICrFVWZsZrDfG3NAio7GaoTRVaLdtbMUDGeIiI1c/qk9JpfHkKIOn2hpKenY968ecjIyED79u3l41FRUfj73/+OPn36IDY2Fp988gm6du2KN99802Zbs2fPRnFxsfw4ceJEwy+IqAGkeUz1nZAuaWiGSgrkXF0sM2NSQOWudUGXAG+L10rlHEquVuL4ucsWzxdaqUNFRKRWTguo/Pz8oNVqLbJRBQUFFlmrmjIyMjB16lR88sknuO222+ye6+LiggEDBtjNUOl0Ovj6+po9iK4na6UL6kMKqEoaGFBZy4xJAVV4kA/ctJZ/Kty0LvJQoLWJ6TXrUDGgIiI1c1odKnd3d0RGRiIzMxN/+9vf5OOZmZkYO3aszdelp6djypQpSE9Pxx133FHr+wghkJOTg169einSb2p5Vu08hvU5p1B8pQIlV6u2U7nz5mA8FddNnmd0tcKAVTuP4dN9J3HxaiXKKqommQ/t5o93JvWv9T2KHA6ozLefEULAYBRwtRIImb9v1fltvSwzY+19qqql97IyIV3Sp0NrZOcW4cDJIozre4N8/GqFwSJbxsKeRKRmTi3smZycjISEBPTv3x/R0dFYuXIlcnNzkZSUBKBqKO7UqVN47733AFQFU5MmTcLrr7+OqKgoObvl6ekJvb7qj/78+fMRFRWFLl26oKSkBG+88QZycnKwdOlS51wkNXuvbj6Cy+UGs2Mf7c7FVz/m4cm4rvD2cMW/vj6C08WW9ZgyD53B2Ytl8L8WnNhy/pLl9i/1YTrkV3y5Aonv7cHPp0uQEBWKxNgbbb6/VKqhtZVA7u9RoSirNGJyTCeb79vHxsR0qV03rQYeblpcvFrJDBURqZpTA6r4+HicO3cOCxYsQF5eHnr27IkNGzYgNDQUAJCXl2dWk+rtt99GZWUlHn74YTz88MPy8fvvvx9paWkAgKKiIkybNg35+fnQ6/Xo27cvtm/fjoEDB17XayP1kDb4XfH3SNzo74UzJVfx0leH8Uv+RTz3xc/yecF6DyTHdUOPYF94uGkxec0P+PPcZfySXwJ/H3+772E69NYQUobqeOElTHznfzicV7VS9e3tf+DdrOO4b1AoRvQIRJf23mjj5Y4KgxF7jp/HFzmnAZiXTJCvp7UnnhsdYfd9pYrpB08Vo8JglIcGpeG+dl46lFVWBaPMUBGRmjl965np06dj+vTpVp+TgiTJ1q1ba23vtddew2uvvaZAz4iqSMv9+4W0RntfD3QN8MGXj7bDRz/k4pVNR2AUwD+GdcbUW8Lg4aaVX9c90Bd/nruMI/kXEdvFfkBlrRZUffhey1BtPFiVtfX30eHJuK746IcTOHCiCKt2HsOqnccAAH7e7iirMOKiSVX1m9pbTjqvi7B2XvDxcMXFq5X49cxFeTWgtDFyO2935F/L3BmMDXoLIqJmwekBFVFTJoSQl/u7mFQKd9W6YFJ0J/xfZEcYhYCXldpR4UE++PrnfPySf7HW9zl/WapW7tiQH1CVKfvwwSiE+XlhQv+O2H60EO9n/Ylf8ktw8sIVefVdOy93DOvWHn/t3h5xEfYXgtji4qJB7w56fP/bORw4USwHVGevZaj8vHUouFYxnUN+RKRmDKiI7DANArRWynl4umstjknCA6u2Zvklv/ZCsY5OSg/zq8owdWrXCh8+GIUbWnsCqCpLMrSrP4Z2rcqQXS6vxG8FpdBAgx7BvmZBYkP17tAa3/92Dj+eLMK9g0IAmAz5ebvL941DfkSkZgyoiOwwre6t1dYv+OgWWFVS4OiZUhiMwmwvvJqqNyhuWEA1oFMb/PeRW3Cjv5fVbJmklburPO9JKVKBzxyT0gnSkJ+/t06+bmaoiEjNnF7Yk6gpqy1DZU9I21bwdNOirNKI4+cu2T3X0cKeGo0GvTro7QZTjaVvSGsAwK9nLuLCtdV9phkql2t/Zbj1DBGpGQMqIjvMAqp6Do9pXTToeq3C+C95tudRlVcaUXptgnhDh/ycKcDXA+GBPjAKYNuvZwFUZ6j8vHXVQ37MUBGRijGgIrLDaLIyzaUBe+yFXxv2O2JnHlXRlargQ6MBfD0blqFytr+EV23/9O0vBQCqM1R+3jp5nhaH/IhIzRhQEdlhNoeqARO4u8kT021nqKThvtaebg16j6bgr92rAqptRwpQaTBWryQ0mZTOIT8iUjMGVER2mGZVGhLrhNcloHJwhV9TcHPHNmjTyg0lVyvxw/HzOH+pKkNlOindyDpURKRiDKiI7JCW+mtdNBabB9eFlKHKPX8Zl8qsb1xcJFdJb57DfUDV/RnWrSpLtW7/KUhxaBsvd3molBkqIlIzBlREdlReiwzqu8JP0s5bJ++j9+sZ61mqC/IGxc03QwVUz6Pa8FMegKoVi25aF5MMFQMqIlIvBlREdkhBgIsDn5Tahv3sbVDcnAzp6g+ti0beSLqdd1UgKU1KZ2FPIlIzBlREdhgczFAB1QHVERsBVXWV9OY75AcAek839A9tI//s510VIEr1ULnKj4jUjJXSieyQ5v04skWLVDH9cF5V6YTiyxV4Yf1B/Ha2FB6uWuSevwyg+WeogKrVfruPnQdQVTIBqF4dyQwVEakZAyoiO6QhP0fKGcgZqjMXUXS5HH9ftRsHT1nWpQrz82rwezQVfwkPwMINvwCoDqjkSelc5UdEKsaAisgOKUPl6kBAdVN7b7hogKLLFbhr+S78cfYS2nm5Y/7YHnB10eBqhRHeOlfcem1Sd3PW2d8LIW1bIff85eohPxeu8iMi9WNARWRHpeHakJ8Dc6g83LQI8/PC72cv4Y+zl+DnrUP6g4PQJcBHqW42GRqNBg8M7oSUDb/gli7+AKrvHVf5EZGaMaAissO0DpUjugf54vezl9DeR4ePHozCTe29lehek/TA4DBMjukk1+3i1jNE1BIwoCKyQwoCHMlQAcAjf7kJrVu5IfGWG9FJBXOlamNaBFVe5cchPyJSMQZURHYolaEKD/TFi+N6KdGlZoeFPYmoJWAdKiI7pJVpzXXT4qaAW88QUUvAgIrIDoMCZRNaOmaoiKglYEBFZIcSldJbOk5KJ6KWgAEVkR1KVEpv6bTykJ+TO0JE1IgYUBHZUV0p3ckdacY45EdELQG/Jojs4JCf4zgpnYhaAgZURHZwyM9xUnaPc6iISM0YUBHZIQ1TObKXX0snDfkJZqiISMUYUBHZUalQpfSWTB7yMzq5I0REjYgBFZEdSlVKb8mke8c5VESkZgyoiOxgYU/HSRkqrvIjIjVjQEVkh1KbI7dkzFARUUvAgIrIDg75OY51qIioJWBARWQHN0d2nJTcY9kEIlIzBlREdhiMVREVC3s2nJaFPYmoBWBARWQHJ6U7jkN+RNQSMKAiskPa0JeV0huOW88QUUvAgIrIDnlzZMZTDSav8mNhTyJSMQZURHZwLz/HcciPiFoCBlREdhi4l5/DOORHRC0BAyoiOzgp3XHaa39lmKEiIjVjQEVkByulO44ZKiJqCRhQEdnBSumOq56UzoCKiNSLARWRHcxQOU6elM4MFRGpGAMqIjsMzFA5TApGjSybQEQqxoCKyA4jV/k5TB7yY4aKiFSMARWRHVIxStahajithnWoiEj9nB5QLVu2DGFhYfDw8EBkZCR27Nhh89x169Zh+PDh8Pf3h6+vL6Kjo7Fp0yaL89auXYuIiAjodDpERETgs88+a8xLIBXj5siOc2GGiohaAKcGVBkZGZg5cybmzJmD7OxsxMbGYuTIkcjNzbV6/vbt2zF8+HBs2LAB+/btw6233ooxY8YgOztbPicrKwvx8fFISEjAgQMHkJCQgAkTJmD37t3X67JIRVgp3XFSHSqu8iMiNdMI4bx/Ng4aNAj9+vXD8uXL5WPdu3fHuHHjkJKSUqc2evTogfj4eDz//PMAgPj4eJSUlGDjxo3yObfffjvatGmD9PT0OrVZUlICvV6P4uJi+Pr61uOKSG1mr/sJ6T/k4vHbumLGbV2c3Z1m6YucU5jxcQ4G39QOHyZGObs7RKRizvz+dlqGqry8HPv27UNcXJzZ8bi4OOzatatObRiNRly8eBFt27aVj2VlZVm0OWLECLttlpWVoaSkxOxBBJhsjuz0wfHmSy7syQwVEamY074mCgsLYTAYEBAQYHY8ICAA+fn5dWrj1VdfxaVLlzBhwgT5WH5+fr3bTElJgV6vlx8dO3asx5WQmlWXTWBE1VDVmyM7uSNERI3I6d8SmhqTfYUQFsesSU9Px7x585CRkYH27ds71Obs2bNRXFwsP06cOFGPKyA1Y4bKcdx6hohaAldnvbGfnx+0Wq1F5qigoMAiw1RTRkYGpk6div/85z+47bbbzJ4LDAysd5s6nQ46na6eV0AtQSUrpTuMW88QUUvgtH93u7u7IzIyEpmZmWbHMzMzERMTY/N16enpmDx5Mj766CPccccdFs9HR0dbtLl582a7bRLZwkrpjpOye9x6hojUzGkZKgBITk5GQkIC+vfvj+joaKxcuRK5ublISkoCUDUUd+rUKbz33nsAqoKpSZMm4fXXX0dUVJScifL09IRerwcAzJgxA0OGDMHixYsxduxYfPHFF/jmm2+wc+dO51wkNWvVQ34MqBqKk9KJqCVw6syQ+Ph4pKamYsGCBbj55puxfft2bNiwAaGhoQCAvLw8s5pUb7/9NiorK/Hwww8jKChIfsyYMUM+JyYmBh9//DHWrFmD3r17Iy0tDRkZGRg0aNB1vz5q/rg5suM45EdELYFTM1QAMH36dEyfPt3qc2lpaWY/b926tU5tjh8/HuPHj3ewZ0TVw1Tcy6/h5K1nOORHRCrGtUtEdsgZKgZUDebCDBURtQAMqIjskFb5cS+/hpPrUDGeIiIVY0BFZIeRq/wcxknpRNQSMKAisoNDfo6rzlAxoCIi9WJARWSHtF0Kh/waTp6UzgwVEakYAyoiO1jY03HSNojceoaI1IwBFZEdBhb2dFh1HSond4SIqBExoCKyw8DNkR3mwjpURNQC8GuCyA5WSnccV/kRUUvAgIrIDpZNcJy8yo8BFRGpGAMqIjsMLOzpMOnecVI6EakZAyoiO7jKz3HyKj9mqIhIxRhQEdlh5Co/h7GwJxG1BAyoiOyoZKV0h2k5KZ2IWgAGVER2GDmHymEuJpsjC2apiEilGFAR2cE5VI4zDUaZpCIitWJARWSHVN2bdagaznS4lMN+RKRWDKiI7JAmUrtqGVA1lGl2jxPTiUitGFAR2cFK6Y4zHfJjhoqI1IoBFZEd3BzZcS4mf2WYoSIitWJARWQHK6U7zmxSutGJHSEiakQMqIjskFb5ufCT0mCm2T1uP0NEasWvCSI7WCndcRqNBlKSinOoiEitGFAR2cE6VMqQJvVzDhURqRUDKiIbjEYB6fufc6gcw+1niEjtGFAR2WA634cZKsdIc9AYUBGRWjGgIrLB9MufmyM7RsshPyJSOQZURDaYfvlzyM8xUkDKDBURqRUDKiIbTL/8OeTnGOn+MUNFRGrFgIrIBtMilAyoHFM9Kd3JHSEiaiQMqIhsMHDITzEc8iMitWNARWRDpUmKipPSHcNJ6USkdgyoiGyQ4ikO9zlOywwVEakcAyoiG+Qq6Rzuc5hch4oZKiJSKdeGvtBgMOCzzz7D4cOHodFoEB4ejnHjxsHVtcFNEjUp0j5+3BjZcfKQHzNURKRSDYp+Dh48iLFjxyI/Px/dunUDAPz666/w9/fH+vXr0atXL0U7SeQM0vCUKyMqh3FSOhGpXYO+KRITE9GjRw+cPHkS+/fvx/79+3HixAn07t0b06ZNU7qPRE4hDU9xCpXjqielO7kjRESNpEEZqgMHDmDv3r1o06aNfKxNmzZ46aWXMGDAAMU6R+RMUjaFk9Idx8KeRKR2DcpQdevWDWfOnLE4XlBQgJtuusnhThE1BQyolOOi4ZAfEalbnQOqkpIS+bFw4UI89thj+PTTT3Hy5EmcPHkSn376KWbOnInFixc3Zn+Jrhvpy9+Fq/wcxlV+RKR2dR7ya926NTQmXyxCCEyYMEE+Jq79oRwzZgwMBoPC3SS6/qThKWaoHMdVfkSkdnUOqLZs2dKY/SBqcjjkpxyu8iMitatzQDV06NDG7AdRk8MMlXK49QwRqV2dA6off/yxzo327t27QZ0hakoqDayUrpTqDJWTO0JE1EjqHFDdfPPN0Gg08lwpWzQaDedQkSrIdaiYoXKYFJRyUjoRqVWdA6pjx441Zj+Imhx5c2RmqBwm16HiHCoiUqk6l00IDQ3F22+/jTNnziA0NNTuoz6WLVuGsLAweHh4IDIyEjt27LB5bl5eHu69915069YNLi4umDlzpsU5aWlp0Gg0Fo+rV6/Wq19EzFAph5PSiUjt6lXYMy8vD6NHj0ZQUBCmTZuGr776CmVlZQ1+84yMDMycORNz5sxBdnY2YmNjMXLkSOTm5lo9v6ysDP7+/pgzZw769Oljs11fX1/k5eWZPTw8PBrcT2qZjPJefgyoHKW9dgs55EdEalWvgGrNmjU4c+YMPvnkE7Ru3RpPPPEE/Pz8cNdddyEtLQ2FhYX1evMlS5Zg6tSpSExMRPfu3ZGamoqOHTti+fLlVs/v1KkTXn/9dUyaNAl6vd5muxqNBoGBgWYPovqSC3syoHIYh/yISO3qvfWMRqNBbGwsXn75Zfzyyy/44YcfEBUVhXfeeQc33HADhgwZgldeeQWnTp2y2055eTn27duHuLg4s+NxcXHYtWtXfbtlprS0FKGhoejQoQNGjx6N7Oxsu+eXlZWZVYIvKSlx6P1JHaRsipbxlMNcOCmdiFSuQXv5merevTuefvppfP/99zh58iTuv/9+7NixA+np6XZfV1hYCIPBgICAALPjAQEByM/Pb3B/wsPDkZaWhvXr1yM9PR0eHh4YPHgwjh49avM1KSkp0Ov18qNjx44Nfn9SDxb2VA4zVESkdnVe5VcX/v7+mDp1KqZOnVrn12hqrKASQlgcq4+oqChERUXJPw8ePBj9+vXDm2++iTfeeMPqa2bPno3k5GT555KSEgZVxL38FMRJ6USkdvXOUOXl5eGDDz7Ahg0bUF5ebvbcpUuXsGDBgjq14+fnB61Wa5GNKigosMhaOcLFxQUDBgywm6HS6XTw9fU1exCxUrpyqiulO7kjRESNpF4B1Z49exAREYGHH34Y48ePR8+ePfHzzz/Lz5eWlmL+/Pl1asvd3R2RkZHIzMw0O56ZmYmYmJj6dMsuIQRycnIQFBSkWJvUMnDITznykB/nUBGRStUroHr22Wdx11134cKFCzhz5gyGDx+OoUOH1jrp25bk5GT8+9//xurVq3H48GE8/vjjyM3NRVJSEoCqobhJkyaZvSYnJwc5OTkoLS3F2bNnkZOTg0OHDsnPz58/H5s2bcIff/yBnJwcTJ06FTk5OXKbRHXFgEo58qR0pqiISKXqNYdq3759WLp0KVxcXODj44OlS5ciNDQUf/3rX7Fp0yaEhITU683j4+Nx7tw5LFiwAHl5eejZsyc2bNggFwfNy8uzqEnVt29fs/589NFHCA0NxfHjxwEARUVFmDZtGvLz86HX69G3b19s374dAwcOrFffiOQhP86hcpj22j/duMqPiNSq3pPSa1Ycf/rpp+Hi4oK4uDisXr263h2YPn06pk+fbvW5tLQ0i2O17SX42muv4bXXXqt3P4hqqmQdKsVIGSqu8iMitapXQNWzZ0/s2rULvXv3Njv+5JNPQgiBe+65R9HOETmT9OXPDJXjqlf5ObkjRESNpF5zqCZNmoTvv//e6nNPPfUUFixYUO9hP6KminOolKNlYU8iUrl6BVSJiYl4//33bT7/9NNP49ixYw53iqgpMFz77mdA5TgW9iQitXOosOfZs2dx5MgRaDQadO3aFf7+/kr1i8jpjMxQKYZbzxCR2jVo65lLly5hypQpCA4OxpAhQxAbG4vg4GBMnToVly9fVrqPRE4hffmzUrrjpFV+zFARkVo1KKBKTk7Gtm3bsH79ehQVFaGoqAhffPEFtm3bhieeeELpPhI5RfUcKid3RAW49QwRqV2DhvzWrl2LTz/9FMOGDZOPjRo1Cp6enpgwYQKWL1+uVP+InIaT0pXDSelEpHYN+rf35cuXre631759ew75kWpwc2TlcFI6EaldgwKq6OhovPDCC2ZFPq9cuYL58+cjOjpasc4ROZNUKd2VGSqHcVI6Ealdg4b8UlNTMXLkSHTo0AF9+vSBRqNBTk4OdDodNm/erHQfiZzCwErpitGysCcRqVyDAqpevXrh6NGj+OCDD/DLL79ACIGJEyfivvvug6enp9J9JHIKA/fyUwyH/IhI7RoUUKWkpCAgIAAPPvig2fHVq1fj7NmzeOaZZxTpHJEzGQyclK4UDvkRkdo1aA7V22+/jfDwcIvjPXr0wIoVKxzuFFFTINehYkDlMLkOFQMqIlKpBgVU+fn5CAoKsjju7++PvLw8hztF1BRwc2TlSBkqDvkRkVo1KKDq2LGj1U2Sv//+ewQHBzvcKaKmQJ5DxQyVw+RJ6YyniEilGjSHKjExETNnzkRFRQX+8pe/AAC+/fZbPP3006yUTqohrUhjQOU4ZqiISO0aFFA9/fTTOH/+PKZPn47y8nIAgIeHB5555hnMnj1b0Q4SOQs3R1YOt54hIrVrUECl0WiwePFiPPfcczh8+DA8PT3RpUsX6HQ6pftH5DSVrJSuGG49Q0Rq16CASuLt7Y0BAwYo1ReiJsUouDmyUuRVfsxQEZFK8auCyAbu5acc1qEiIrVjQEVkg4F7+SlGyzlURKRyDKiIbOCkdOXIW88wQ0VEKsWAisgGbo6sHHnIjxkqIlIpBlRENhhYKV0x1ZsjO7kjRESNhAEVkQ3cy085nJRORGrHgIrIBmaolMNJ6USkdgyoiGyQJlC7ahlQOUquQ8UMFRGpFAMqIhtYh0o5nJRORGrHgIrIBiM3R1YMh/yISO0YUBHZUHktomKGynHSPDSO+BGRWjGgIrLBcO3Lnxkqx0krJbnKj4jUigEVkQ3VldKd3BEVkLJ83ByZiNSKXxVENshlE1z4MXGUFJQyQ0VEasVvCiIbpCX+rEPlOK7yIyK1Y0BFZEP1Xn5O7ogKVG89w4CKiNSJXxVENrBSunK49QwRqR0DKiIbpC9/rvJzXHUdKid3hIiokTCgIrKhesiPAZWj5CE/ZqiISKUYUBHZIM33cWVA5TBOSicitWNARWSDNOTHSumO46R0IlI7BlRENhi4l59itJyUTkQqx4CKyAbDtb38GFA5Tio9wSE/IlIrBlRENsiT0jnk5zBOSicitWNARWSDkZsjK0bLSelEpHIMqIhsMHCVn2Jc5AwVIJilIiIVYkBFZIO8yo8BlcNMq80zniIiNXJ6QLVs2TKEhYXBw8MDkZGR2LFjh81z8/LycO+996Jbt25wcXHBzJkzrZ63du1aREREQKfTISIiAp999lkj9Z7UzMitZxRjGpRypR8RqZFTA6qMjAzMnDkTc+bMQXZ2NmJjYzFy5Ejk5uZaPb+srAz+/v6YM2cO+vTpY/WcrKwsxMfHIyEhAQcOHEBCQgImTJiA3bt3N+alkApVcnNkxZgm+TiPiojUSCOcOKFh0KBB6NevH5YvXy4f6969O8aNG4eUlBS7rx02bBhuvvlmpKammh2Pj49HSUkJNm7cKB+7/fbb0aZNG6Snp9epXyUlJdDr9SguLoavr2/dL4hUw2gUuPHZDQCAfXNvQztvnZN71LxdLq9ExPObAACHFoxAK3dXJ/eIiNTImd/fTvu3d3l5Ofbt24e4uDiz43Fxcdi1a1eD283KyrJoc8SIEXbbLCsrQ0lJidmDWjbTYSmu8nOcaekJZqiISI2cFlAVFhbCYDAgICDA7HhAQADy8/Mb3G5+fn6920xJSYFer5cfHTt2bPD7kzqYfukzoHKc6T28Vi+ViEhVnD47RFNjwq8QwuJYY7c5e/ZsFBcXy48TJ0449P7U/BmZoVKU6cR+TkonIjVy2kQGPz8/aLVai8xRQUGBRYapPgIDA+vdpk6ng07HOTJUzTRDxUrpjjNb5cchPyJSIadlqNzd3REZGYnMzEyz45mZmYiJiWlwu9HR0RZtbt682aE2qeUxHZZihkoZ3H6GiNTMqUttkpOTkZCQgP79+yM6OhorV65Ebm4ukpKSAFQNxZ06dQrvvfee/JqcnBwAQGlpKc6ePYucnBy4u7sjIiICADBjxgwMGTIEixcvxtixY/HFF1/gm2++wc6dO6/79VHzVWkSUbEOlTK0Gg0MEMxQEZEqOTWgio+Px7lz57BgwQLk5eWhZ8+e2LBhA0JDQwFUFfKsWZOqb9++8v/ft28fPvroI4SGhuL48eMAgJiYGHz88ceYO3cunnvuOXTu3BkZGRkYNGjQdbsuav5M5/mwUroyXFwAGDjkR0Tq5NQ6VE0V61BRfvFVRKV8C1cXDX5bOMrZ3VGFHs9/jUvlBmx7ahhC23k5uztEpEItsg4VUVPGffyUJ91LZqiISI0YUBFZwX38lMdJ6USkZgyoiKyQsihc4accKTg1sLAnEakQAyoiK+SNkRlPKYZDfkSkZgyoiKyQhqWYoVKOlKHikB8RqREDKiIrqof8+BFRCudQEZGa8duCyIrqgMrJHVERKTblkB8RqRG/LoiskIf8uMpPMS4c8iMiFWNARWSFlEVhHSrlcJUfEakZAyoiK1g2QXlc5UdEasaAisgKAwt7Ko6r/IhIzRhQEVlhYNkExTFDRURqxoCKyArjtXk+DKiUI62YNDBDRUQqxICKyAp5c2QO+SlGHvJjhoqIVIgBFZEVRk5KVxyH/IhIzRhQEVlRybIJiuOkdCJSMwZURFZUr/JzckdUpDpD5eSOEBE1AgZURFZIWRRX7uWnGLmwJzNURKRC/LYgsqK6UrqTO6Ii8ubInENFRCrErwsiK4ysQ6U4TkonIjVjQEVkhZyhYtkExUjz0TjkR0RqxICKyIpKlk1QnHQvBQMqIlIhBlREVhi5l5/ipGwfV/kRkRoxoCKygnv5Kc+Fq/yISMUYUBFZwUrpyuMqPyJSMwZURFYYWCldcVzlR0RqxoCKyArDte98zqFSjrTKj1vPEJEaMaAissJgrJo5zSE/5TBDRURqxoCKyAppJRrrUCmHW88QkZoxoCKyonovPwZUSuGkdCJSMwZURFZwUrryqof8nNwRIqJGwICKyAqDXDbByR1REQ75EZGa8euCyAp5c2TOoVIMh/yISM0YUBFZUckhP8WxUjoRqRkDKiIruJef8qThU2aoiEiNGFARWSHPodIyoFIK61ARkZoxoCKywsA5VIrjpHQiUjMGVERWcHNk5XFSOhGpGQMqIiukLAorpStHupeMp4hIjRhQEVlhYIZKcVzlR0RqxoCKyAoGVMrjKj8iUjMGVERWSNujMKBSDlf5EZGaMaAisoKV0pXHVX5EpGYMqIis4ObIyuMqPyJSMwZURFZU16FyckdUpHpSupM7QkTUCBhQEVlhMHBSutKYoSIiNXN6QLVs2TKEhYXBw8MDkZGR2LFjh93zt23bhsjISHh4eODGG2/EihUrzJ5PS0uDRqOxeFy9erUxL4NURq5DxYBKMZyUTkRq5tSAKiMjAzNnzsScOXOQnZ2N2NhYjBw5Erm5uVbPP3bsGEaNGoXY2FhkZ2fj2WefxWOPPYa1a9eanefr64u8vDyzh4eHx/W4JFIJKYviyoBKMZyUTkRq5urMN1+yZAmmTp2KxMREAEBqaio2bdqE5cuXIyUlxeL8FStWICQkBKmpqQCA7t27Y+/evXjllVdw9913y+dpNBoEBgZel2sgdWKldOWxDhURqZnTMlTl5eXYt28f4uLizI7HxcVh165dVl+TlZVlcf6IESOwd+9eVFRUyMdKS0sRGhqKDh06YPTo0cjOzrbbl7KyMpSUlJg9qGVjYU/lsVI6EamZ0wKqwsJCGAwGBAQEmB0PCAhAfn6+1dfk5+dbPb+yshKFhYUAgPDwcKSlpWH9+vVIT0+Hh4cHBg8ejKNHj9rsS0pKCvR6vfzo2LGjg1dHzZ1ch4oBlWK0nENFRCrm9EnpmhpDKkIIi2O1nW96PCoqCn//+9/Rp08fxMbG4pNPPkHXrl3x5ptv2mxz9uzZKC4ulh8nTpxo6OWQSlQaOOSnNHmVHzNURKRCTptD5efnB61Wa5GNKigosMhCSQIDA62e7+rqinbt2ll9jYuLCwYMGGA3Q6XT6aDT6ep5BaRmzFApTx7yY4aKiFTIaRkqd3d3REZGIjMz0+x4ZmYmYmJirL4mOjra4vzNmzejf//+cHNzs/oaIQRycnIQFBSkTMepReAcKuVV16FyckeIiBqBU4f8kpOT8e9//xurV6/G4cOH8fjjjyM3NxdJSUkAqobiJk2aJJ+flJSEP//8E8nJyTh8+DBWr16NVatW4cknn5TPmT9/PjZt2oQ//vgDOTk5mDp1KnJycuQ2iepCqubNvfyUw0npRKRmTi2bEB8fj3PnzmHBggXIy8tDz549sWHDBoSGhgIA8vLyzGpShYWFYcOGDXj88cexdOlSBAcH44033jArmVBUVIRp06YhPz8fer0effv2xfbt2zFw4MDrfn3UfBmZoVKcdCs5h4qI1EgjBP+61VRSUgK9Xo/i4mL4+vo6uzvkBKNe34FDeSV4d8pADO3q7+zuqMK3h89g6rt70aeDHl88couzu0NEKuTM72+nr/IjaorkSekc8lOMvPUM/w1HRCrEgIrIikqjtJefkzuiIvLWM5yUTkQqxK8LIiuq9/LjR0Qp1av8mKEiIvXhtwWRFQa5DpWTO6IiXOVHRGrGrwsiK6Q6VKyUrhxmqIhIzRhQEVnBsgnKk7J9zFARkRoxoCKyQvrSZ4ZKOdx6hojUjAEVkRXcekZ5HPIjIjVjQEVkhUFe5ceASimclE5EasaAisgKeVI6AyrFSBkq1qEiIjViQEVkhZGbIytOHvJjhoqIVIgBFZEVnEOlPE5KJyI1Y0BFZIW8yo8BlWI4KZ2I1IwBFZEVcoaKQ36K0XJSOhGpGAMqIis45Kc8KTblHCoiUiMGVEQ1mA5JMaBSTvWQn5M7QkTUCBhQEdVgOiTFIT/lyGUTmKEiIhViQEVUg+kqNBd+QhTDVX5EpGb8uiCqwXSOD4f8lGN6L7nSj4jUhgEVUQ2VphkqDvkpxnT4lMN+RKQ2DKiIajDNnnAvP+WYDp9y2I+I1IYBFVENBq7yaxRmQ37MUBGRyjCgIqpBGo7SaAANh/wUYzp8ygwVEakNAyqiGqQ6SSyZoCzzSelO7AgRUSNgQEVUA/fxaxyclE5EasaAiqgGg4H7+DUG0wCVQ35EpDYMqIhqkLInXOGnPHn7GWaoiEhlGFAR1SBlTzjkpzwtq6UTkUoxoCKqQcqesGSC8qRaVAyoiEhtGFAR1SBnqDiHSnFShopDfkSkNgyoiGqQAiotPx2Kk4ZRmaEiIrXhVwZRDXJAxQyV4lzkDJWTO0JEpDAGVEQ1SKv8tFoGVErjKj8iUisGVEQ1GJmhajQuXOVHRCrFgIqoBpZNaDxarvIjIpViQEVUgzzkxwyV4rjKj4jUigEVUQ3y5sjMUCmOq/yISK0YUBHVUHktomIdKuVxUjoRqRUDKqIapC97V67yU1z11jNO7ggRkcIYUBHVIH3ZM0OlPA75EZFaMaAiqqG6UjoDKqVxUjoRqRUDKqIajFzl12iYoSIitWJARVRDdR0qJ3dEheQ6VMxQEZHK8CuDqAYO+TUeeciPGSoiUhkGVEQ1VAdU/HgojUN+RKRW/MYgqqG6UrqTO6JCnJRORGrl9IBq2bJlCAsLg4eHByIjI7Fjxw6752/btg2RkZHw8PDAjTfeiBUrVlics3btWkRERECn0yEiIgKfffZZY3WfVMjIIb9GU52hcnJHiIgU5tSAKiMjAzNnzsScOXOQnZ2N2NhYjBw5Erm5uVbPP3bsGEaNGoXY2FhkZ2fj2WefxWOPPYa1a9fK52RlZSE+Ph4JCQk4cOAAEhISMGHCBOzevft6XRY1c1KGinWolCfFqJyUTkRqoxHCeX/ZBg0ahH79+mH58uXyse7du2PcuHFISUmxOP+ZZ57B+vXrcfjwYflYUlISDhw4gKysLABAfHw8SkpKsHHjRvmc22+/HW3atEF6enqd+lVSUgK9Xo9Ps47Ay9unoZdHzdS2X88i/YcTGNkzEMv/Huns7qjKff/+H77/7RweGNwJg8LaOrs7RKQyl0ovYnx0NxQXF8PX1/e6vrfrdX03E+Xl5di3bx9mzZpldjwuLg67du2y+pqsrCzExcWZHRsxYgRWrVqFiooKuLm5ISsrC48//rjFOampqTb7UlZWhrKyMvnnkpISAMDjGQfgomtVn8siFXF3dfqIuOq4X6ubsOb741jz/XHndoaIVMdYdtlp7+20gKqwsBAGgwEBAQFmxwMCApCfn2/1Nfn5+VbPr6ysRGFhIYKCgmyeY6tNAEhJScH8+fMtjvft2Bpunl51vSRSEXdXFyREhTq7G6oz5ZYwXKkwoNLAIT8iUl7FFXeccNJ7Oy2gkmhqzFMRQlgcq+38msfr2+bs2bORnJws/1xSUoKOHTvi/cRB1z1lSKRmsV38EdvF39ndICKVKikpgf4J57y30wIqPz8/aLVai8xRQUGBRYZJEhgYaPV8V1dXtGvXzu45ttoEAJ1OB51O15DLICIiInLeKj93d3dERkYiMzPT7HhmZiZiYmKsviY6Otri/M2bN6N///5wc3Oze46tNomIiIgc5dQhv+TkZCQkJKB///6Ijo7GypUrkZubi6SkJABVQ3GnTp3Ce++9B6BqRd9bb72F5ORkPPjgg8jKysKqVavMVu/NmDEDQ4YMweLFizF27Fh88cUX+Oabb7Bz506nXCMRERGpn1MDqvj4eJw7dw4LFixAXl4eevbsiQ0bNiA0tGoycF5enllNqrCwMGzYsAGPP/44li5diuDgYLzxxhu4++675XNiYmLw8ccfY+7cuXjuuefQuXNnZGRkYNCgQdf9+oiIiKhlcGodqqZKqkPljDoWRERE1DDO/P5moR0iIiIiBzGgIiIiInIQAyoiIiIiBzGgIiIiInIQAyoiIiIiBzGgIiIiInIQAyoiIiIiBzGgIiIiInIQAyoiIiIiBzl165mmSioeX1JS4uSeEBERUV1J39vO2ASGAZUV586dAwB07NjRyT0hIiKi+jp37hz0ev11fU8GVFa0bdsWAJCbm3vd/4OoxYABA7Bnzx5nd0MVeC+VU1JSgo4dO+LEiRPcp1MB/N1UDu+lMoqLixESEiJ/j19PDKiscHGpmlqm1+v5R7eBtFot751CeC+V5+vry3uqAP5uKof3UlnS9/h1fc/r/o7UIjz88MPO7oJq8F5SU8XfTeXwXjZ/GuGMmVtNXElJCfR6PYqLi/kvBiIV4WebSN2c+RlnhsoKnU6HF154ATqdztldISIF8bNNpG7O/IwzQ0VERETkIGaoiIiIiBzEgIpkKSkpGDBgAHx8fNC+fXuMGzcOR44cMTtHCIF58+YhODgYnp6eGDZsGH7++eda2/7pp58wdOhQeHp64oYbbsCCBQssCq9t27YNkZGR8PDwwI033ogVK1Yoen3XU233sqKiAs888wx69eoFLy8vBAcHY9KkSTh9+nStbbe0e0mNY9myZQgLC4OHhwciIyOxY8cOAPzdbAhb97Kmhx56CBqNBqmpqbW22VLvZbMmiK4ZMWKEWLNmjTh48KDIyckRd9xxhwgJCRGlpaXyOYsWLRI+Pj5i7dq14qeffhLx8fEiKChIlJSU2Gy3uLhYBAQEiIkTJ4qffvpJrF27Vvj4+IhXXnlFPuePP/4QrVq1EjNmzBCHDh0S77zzjnBzcxOffvppo15zY6ntXhYVFYnbbrtNZGRkiF9++UVkZWWJQYMGicjISLvttsR7Scr7+OOPhZubm3jnnXfEoUOHxIwZM4SXl5f4888/+btZT/bupanPPvtM9OnTRwQHB4vXXnvNbpst9V42dwyoyKaCggIBQGzbtk0IIYTRaBSBgYFi0aJF8jlXr14Ver1erFixwmY7y5YtE3q9Xly9elU+lpKSIoKDg4XRaBRCCPH000+L8PBws9c99NBDIioqSslLcpqa99KaH374QQCw+ENsiveSlDBw4ECRlJRkdiw8PFzMmjXL6vn83bStLvfy5MmT4oYbbhAHDx4UoaGhtQZULfVeNncc8iObiouLAVRXjj927Bjy8/MRFxcnn6PT6TB06FDs2rVLPjZ58mQMGzZM/jkrKwtDhw41W3UxYsQInD59GsePH5fPMW1XOmfv3r2oqKhQ+tKuu5r30tY5Go0GrVu3lo/xXlazN6wiOBRdZ+Xl5di3b5/F70hcXJzZ59gUfzetq8u9NBqNSEhIwFNPPYUePXpYbYf3slptw6eHDx/GnXfeCb1eDx8fH0RFRSE3N9dum9frc86AiqwSQiA5ORm33HILevbsCQDIz88HAAQEBJidGxAQID8HAEFBQQgJCZF/zs/Pt/oa0zZtnVNZWYnCwkKFrso5rN3Lmq5evYpZs2bh3nvvNaudwntZJSMjAzNnzsScOXOQnZ2N2NhYjBw5Uv5D+vLLL2PJkiV46623sGfPHgQGBmL48OG4ePGizTZLSkowfPhwBAcHY8+ePXjzzTfxyiuvYMmSJfI5x44dw6hRoxAbG4vs7Gw8++yzeOyxx7B27dpGv+bGUlhYCIPBUOvnWMLfTdvqci8XL14MV1dXPPbYYzbb4b2sUtvn/Pfff8ctt9yC8PBwbN26FQcOHMBzzz0HDw8Pm21ez885t54hqx555BH8+OOP2Llzp8VzGo3G7GchhNmxlJSUOr2m5vG6nNMc2buXQNUk4IkTJ8JoNGLZsmVmz/FeVlmyZAmmTp2KxMREAEBqaio2bdqE5cuXY+HChUhNTcWcOXNw1113AQDeffddBAQE4KOPPsJDDz1ktc0PP/wQV69eRVpaGnQ6HXr27Ilff/0VS5YsQXJyMjQaDVasWIGQkBB5EnH37t2xd+9evPLKK7j77ruvy7U3lto+xwB/N+vK1r3ct28fXn/9dezfv9/u9fFeVrH3OU9JScGcOXMwatQovPzyy/JrbrzxRrttXs/POTNUZOHRRx/F+vXrsWXLFnTo0EE+HhgYCAAW/4otKCiw+JeSqcDAQKuvAar/1WXrHFdXV7Rr167hF+Nktu6lpKKiAhMmTMCxY8eQmZlZa2XflngvaxtW4VB0/fj5+UGr1db6OebvZu1qu5c7duxAQUEBQkJC4OrqCldXV/z555944okn0KlTJ5vttsR7Wdvn3Gg04quvvkLXrl0xYsQItG/fHoMGDcLnn39udr4zP+cMqEgmhMAjjzyCdevW4bvvvkNYWJjZ82FhYQgMDERmZqZ8rLy8HNu2bUNMTIzNdqOjo7F9+3aUl5fLxzZv3ozg4GD5j0p0dLRZu9I5/fv3h5ubmwJXd33Vdi+B6i+so0eP4ptvvqnTH8GWeC9rG1bhUHT9uLu7IzIy0uJ3JDMzU/4c83ezbmq7lwkJCfjxxx+Rk5MjP4KDg/HUU09h06ZNNtttifeyts95QUEBSktLsWjRItx+++3YvHkz/va3v+Guu+7Ctm3b5POd+jm/3rPgqen6xz/+IfR6vdi6davIy8uTH5cvX5bPWbRokdDr9WLdunXip59+Evfcc49F2YRZs2aJhIQE+eeioiIREBAg7rnnHvHTTz+JdevWCV9fX6tLgB9//HFx6NAhsWrVqma9BLi2e1lRUSHuvPNO0aFDB5GTk2N2TllZmdwO76UQp06dEgDErl27zI6/+OKLolu3buL7778XAMTp06fNnk9MTBQjRoyw2e7w4cPFtGnTzI6dPHlSABBZWVlCCCG6dOkiFi5caHbOzp07BQCRl5fnyGU5lbTUf9WqVeLQoUNi5syZwsvLSxw/fpy/m/Vk715aY22VH+9l7Z9z6fl77rnH7PkxY8aIiRMn2mz3en7OGVCRDIDVx5o1a+RzjEajeOGFF0RgYKDQ6XRiyJAh4qeffjJr5/777xdDhw41O/bjjz+K2NhYodPpRGBgoJg3b568/FeydetW0bdvX+Hu7i46deokli9f3liX2uhqu5fHjh2zec6WLVvkdngvhSgrKxNarVasW7fO7Phjjz0mhgwZIn7//XcBQOzfv9/s+TvvvFNMmjTJZrsJCQnizjvvNDu2f/9+AUD88ccfQgghYmNjxWOPPWZ2zrp164Srq6soLy935LKcbunSpSI0NFS4u7uLfv36ySU9+LtZf7bupTXWAirey9o/52VlZcLV1VX885//NHv+6aefFjExMTbbvZ6fcwZURNTkDRw4UPzjH/8wO9a9e3cxa9YsuT7a4sWL5efKysrqVB+tdevWZlmXRYsWWdT66d69u9nrkpKSWOuHqBHY+5wLIUR0dLT4+9//bvb8uHHjLLJWpq7n55wBFRE1ebUNq3Aomqj5q+1zvm7dOuHm5iZWrlwpjh49Kt58802h1WrFjh075Dac+TlnQEVEzYK9YRUORROpQ23Dp6tWrRI33XST8PDwEH369BGff/652fPO/JxrhKhRLpSIiIiI6oVlE4iIiIgcxICKiIiIyEEMqIiIiIgcxICKiIiIyEEMqIiIiIgcxICKiJqs7du3Y8yYMQgODoZGo7HYCHXdunUYMWIE/Pz8oNFokJOTU6d2t27dCo1Gg6KiIsX7TEQtEwMqImqyLl26hD59+uCtt96y+fzgwYOxaNGi69wzIiJzrs7uABGRLSNHjsTIkSNtPp+QkAAAOH78uEPvM2/ePHz++edmGa7U1FSkpqbKbU+ePBlFRUW45ZZb8Oqrr6K8vBwTJ05Eamoq3NzcHHp/Imr+GFAREdXRli1bEBQUhC1btuC3335DfHw8br75Zjz44IPO7hoRORmH/IiI6qhNmzZ46623EB4ejtGjR+OOO+7At99+6+xuEVETwICKiFQrKSkJ3t7e8sNRPXr0gFarlX8OCgpCQUGBw+0SUfPHIT8iUq0FCxbgySefrPU8FxcX1NzWtKKiwuK8mnOlNBoNjEajY50kIlVgQEVEqtW+fXu0b9++1vP8/f2Rn58PIQQ0Gg0A1LkEAxERwICKiJqw0tJS/Pbbb/LPx44dQ05ODtq2bYuQkBCcP38eubm5OH36NADgyJEjAIDAwEAEBgbW+X2GDRuGs2fP4uWXX8b48ePx9ddfY+PGjfD19VX2gohItTiHioiarL1796Jv377o27cvACA5ORl9+/bF888/DwBYv349+vbtizvuuAMAMHHiRPTt2xcrVqyw2640TOfqWvVvyu7du2PZsmVYunQp+vTpgx9++KFOQ4VERBKNqDlxgIhI5T7++GMkJiaitLTU2V0hIpXgkB8RtRhlZWX4/fff8dZbb+G2225zdneISEU45EdELcbGjRsxaNAgeHl54Y033nB2d4hIRTjkR0REROQgZqiIiIiIHMSAioiIiMhBDKiIiIiIHMSAioiIiMhBDKiI6LqaN28ebr75Zmd3wyohBKZNm4a2bdtCo9Fw+xkiqjMGVESkGI1GY/cxefJkPPnkk/j222+d3VWrvv76a6SlpeHLL79EXl4eevbsaXHO1q1b5etxcXGBXq9H37598fTTTyMvL88JvSaipoCFPYlIMaYBRUZGBp5//nl5fz0A8PT0hLe3N7y9vZ3RvVr9/vvvCAoKQkxMTK3nHjlyBL6+vigpKcH+/fvx8ssvY9WqVdi6dSt69ep1HXpLRE0JM1REpBhpU+LAwEDo9XpoNBqLYzWH/CZPnoxx48Zh4cKFCAgIQOvWrTF//nxUVlbiqaeeQtu2bdGhQwesXr3a7L1OnTqF+Ph4tGnTBu3atcPYsWNx/Phxu/3btm0bBg4cCJ1Oh6CgIMyaNQuVlZVyPx599FHk5uZCo9GgU6dOdttq3749AgMD0bVrV0ycOBHff/89/P398Y9//EM+Z8+ePRg+fDj8/Pyg1+sxdOhQ7N+/X35+ypQpGD16tFm7lZWVCAwMtLheImraGFARkdN99913OH36NLZv344lS5Zg3rx5GD16NNq0aYPdu3cjKSkJSUlJOHHiBADg8uXLuPXWW+Ht7Y3t27dj586d8Pb2xu23347y8nKr73Hq1CmMGjUKAwYMwIEDB7B8+XKsWrUKL774IgDg9ddfx4IFC9ChQwfk5eVhz5499boGT09PJCUl4fvvv0dBQQEA4OLFi7j//vuxY8cO/O9//0OXLl0watQoXLx4EQCQmJiIr7/+2iyzt2HDBpSWlmLChAn1vo9E5ESCiKgRrFmzRuj1eovjL7zwgujTp4/88/333y9CQ0OFwWCQj3Xr1k3ExsbKP1dWVgovLy+Rnp4uhBBi1apVolu3bsJoNMrnlJWVCU9PT7Fp0yar/Xn22WctXrN06VLh7e0tv/drr70mQkND7V7Xli1bBABx4cIFi+c2btwoAIjdu3dbfW1lZaXw8fER//3vf+VjERERYvHixfLP48aNE5MnT7bbByJqepihIiKn69GjB1xcqv8cBQQEmM1D0mq1aNeunZz52bdvH3777Tf4+PjIc7Latm2Lq1ev4vfff7f6HocPH0Z0dDQ0Go18bPDgwSgtLcXJkycVuQ5xbScv6T0KCgqQlJSErl27Qq/XQ6/Xo7S0FLm5ufJrEhMTsWbNGvn8r776ClOmTFGkP0R0/XBSOhE5nZubm9nPGo3G6jGj0QgAMBqNiIyMxIcffmjRlr+/v9X3EEKYBVPSMaltJRw+fBgA5PlXkydPxtmzZ5GamorQ0FDodDpER0ebDUtOmjQJs2bNQlZWFrKystCpUyfExsYq0h8iun4YUBFRs9OvXz9kZGSgffv28PX1rdNrIiIisHbtWrPAateuXfDx8cENN9zgcJ+uXLmClStXYsiQIXJQt2PHDixbtgyjRo0CAJw4cQKFhYVmr2vXrh3GjRuHNWvWICsrCw888IDDfSGi649DfkTU7Nx3333w8/PD2LFjsWPHDhw7dgzbtm3DjBkzbA7fTZ8+HSdOnMCjjz6KX375BV988QVeeOEFJCcnmw031lVBQQHy8/Nx9OhRfPzxxxg8eDAKCwuxfPly+ZybbroJ77//Pg4fPozdu3fjvvvug6enp0VbiYmJePfdd3H48GHcf//99e4LETkfAyoianZatWqF7du3IyQkBHfddRe6d++OKVOm4MqVKzYzVjfccAM2bNiAH374AX369EFSUhKmTp2KuXPnNqgP3bp1Q3BwMCIjI7Fo0SLcdtttOHjwICIiIuRzVq9ejQsXLqBv375ISEjAY489hvbt21u0ddtttyEoKAgjRoxAcHBwg/pDRM6lEdIkAiIicorLly8jODgYq1evxl133eXs7hBRA3AOFRGRkxiNRuTn5+PVV1+FXq/HnXfe6ewuEVEDMaAiInKS3NxchIWFoUOHDkhLS4OrK/8kEzVXHPIjIiIichAnpRMRERE5iAEVERERkYMYUBERERE5iAEVERERkYMYUBERERE5iAEVERERkYMYUBERERE5iAEVERERkYMYUBERERE56P8BOzQZ3kQ+lYMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_scheduled_moer(usage_plan)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_predicated_moer(usage_plan)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Multiple segments - fixed length" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "== Fixed contiguous fit! ==\n" + ] + } + ], + "source": [ + "# Pass two values to charge_per_segment instead of one.\n", + "\n", + "usage_plan = wt_opt.get_optimal_usage_plan(\n", + " region=\"CAISO_NORTH\",\n", + " usage_window_start=window_start,\n", + " usage_window_end=window_end,\n", + " usage_time_required_minutes=200, # 150 + 50\n", + " usage_power_kw=12,\n", + " charge_per_segment=[150,50],\n", + " optimization_method=\"auto\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pred_moer 92915.7000\n", + "usage 200.0000\n", + "emissions_co2_lb 10.4163\n", + "energy_usage_mwh 0.0400\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "print(usage_plan.sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_scheduled_moer(usage_plan)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_predicated_moer(usage_plan)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "watttime", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.21" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/watttime_optimizer/notebooks/ev_simple.ipynb b/watttime_optimizer/notebooks/ev_simple.ipynb new file mode 100644 index 00000000..b3b900dd --- /dev/null +++ b/watttime_optimizer/notebooks/ev_simple.ipynb @@ -0,0 +1,140 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# EV \"Simple\" Smart Scheduling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.chdir(path=os.path.dirname(os.path.dirname(os.path.abspath(os.curdir))))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "== Simple fit! ==\n" + ] + } + ], + "source": [ + "from watttime_optimizer.evaluator.analysis import plot_predicated_moer, plot_charging_units, plot_scheduled_moer\n", + "from datetime import datetime, timedelta\n", + "from pytz import UTC\n", + "from watttime_optimizer import WattTimeOptimizer\n", + "\n", + "username = os.getenv(\"WATTTIME_USER\")\n", + "password = os.getenv(\"WATTTIME_PASSWORD\")\n", + "wt_opt = WattTimeOptimizer(username, password)\n", + "\n", + "# 12 hour charge window (720/60 = 12)\n", + "now = datetime.now(UTC)\n", + "window_start = now\n", + "window_end = now + timedelta(minutes=720)\n", + "\n", + "usage_plan = wt_opt.get_optimal_usage_plan(\n", + " region=\"CAISO_NORTH\",\n", + " usage_window_start=window_start,\n", + " usage_window_end=window_end,\n", + " usage_time_required_minutes=240,\n", + " usage_power_kw=12,\n", + " optimization_method=\"auto\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_charging_units(usage_plan)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_scheduled_moer(usage_plan)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_predicated_moer(usage_plan)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "watttime", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.21" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/watttime_optimizer/notebooks/ev_variable_charge.ipynb b/watttime_optimizer/notebooks/ev_variable_charge.ipynb new file mode 100644 index 00000000..1c0550fc --- /dev/null +++ b/watttime_optimizer/notebooks/ev_variable_charge.ipynb @@ -0,0 +1,181 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Variable Charging Curve (L3) - EV" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.chdir(path=os.path.dirname(os.path.dirname(os.path.abspath(os.curdir))))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime, timedelta\n", + "import pandas as pd\n", + "from pytz import UTC\n", + "from watttime_optimizer import WattTimeOptimizer\n", + "from watttime_optimizer.battery import Battery, CARS_L3\n", + "from watttime_optimizer.evaluator.analysis import plot_predicated_moer, plot_charging_units, plot_scheduled_moer" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "== Sophisticated fit! ==\n" + ] + } + ], + "source": [ + "username = os.getenv(\"WATTTIME_USER\")\n", + "password = os.getenv(\"WATTTIME_PASSWORD\")\n", + "wt_opt = WattTimeOptimizer(username, password)\n", + "\n", + "# 12 hour charge window (720/60 = 12)\n", + "now = datetime.now(UTC)\n", + "window_start = now\n", + "window_end = now + timedelta(minutes=720)\n", + "\n", + "battery = Battery(\n", + " initial_soc=.5,\n", + " charging_curve=pd.DataFrame(\n", + " columns=[\"SoC\", \"kW\"],\n", + " data=CARS_L3['audi']\n", + " ),\n", + " capacity_kWh=71,\n", + ")\n", + "\n", + "variable_usage_power = battery.get_usage_power_kw_df()\n", + "\n", + "usage_plan = wt_opt.get_optimal_usage_plan(\n", + " region=\"CAISO_NORTH\",\n", + " usage_window_start=window_start,\n", + " usage_window_end=window_end,\n", + " usage_time_required_minutes=240,\n", + " usage_power_kw=variable_usage_power,\n", + " optimization_method=\"auto\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pred_moer 91710.600000\n", + "usage 240.000000\n", + "emissions_co2_lb 64.521660\n", + "energy_usage_mwh 0.240331\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "print(usage_plan.sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_charging_units(usage_plan)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_scheduled_moer(usage_plan)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_predicated_moer(usage_plan)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "watttime", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.21" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/watttime_optimizer/notebooks/evaluation_plot.png b/watttime_optimizer/notebooks/evaluation_plot.png new file mode 100644 index 00000000..4417aeae Binary files /dev/null and b/watttime_optimizer/notebooks/evaluation_plot.png differ diff --git a/watttime_optimizer/notebooks/synthetic_data.ipynb b/watttime_optimizer/notebooks/synthetic_data.ipynb new file mode 100644 index 00000000..a3421b1b --- /dev/null +++ b/watttime_optimizer/notebooks/synthetic_data.ipynb @@ -0,0 +1,1905 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing the Optimizer with Synthetic Data\n", + "\n", + "\n", + "- To validate the base model’s performance, we tested it on synthetic user data, an incredibly useful approach when device-level data is not yet available or too sensitive to share.\n", + "- Working with synthetic data, we can replicate device scope 2 emissions avoidance potential with and without an automated marginal emissions reduction solution." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.chdir(path=os.path.dirname(os.path.dirname(os.path.abspath(os.curdir))))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from watttime_optimizer.evaluator.sessions import SessionsGenerator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example: At home EV charging\n", + "\n", + "Ideally, the base solution’s short-term impact will be in shortening the product development lifecycle of custom software solutions designed to support AER features. To shape the base model, we worked with WattTime to isolate a common set of functional behaviors for potential low-carbon devices and translate these patterns and users’ behavior into mathematical functions that can be optimized. This first set is intended to serve as a base model for more complex solutions. \n", + "\n", + "\n", + "### Functional Behavior + Device Characteristics\n", + "- Covers a 5.5 - 8.5 hour variable length window\n", + "- The vehicle has a BMW and has an average power draw of 42.5\n", + "- Battery is usually typically 50% charged at plug in time.\n", + "- Charging occurs during the workdayz" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "ev_kwargs = {\n", + " \"max_power_output_rates\": [42.5],\n", + " \"max_percent_capacity\": 0.95, # highest level of charge achieved by battery\n", + " \"power_output_efficiency\": 0.75, # power loss. 1 = no power loss.\n", + " \"minimum_battery_starting_capacity\": 0.2, # minimum starting percent charged\n", + " \"minimum_usage_window_start_time\": \"08:00:00\", # session can start as early as 8am\n", + " \"maximum_usage_window_start_time\": \"22:00:00\", # session can start as late as 9pm\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "s_ev = SessionsGenerator(**ev_kwargs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can generate synthetic data for users and devices with the attributes set above." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# the class has a helper function to generate a random list of unique dates\n", + "distinct_date_list = s_ev.assign_random_dates(years=[2025])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can generate data for a *single* user for each distinct date" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0
distinct_dates2025-01-10
user_typer21.4625_tc91_avglc27109_sdlc7283
usage_window_start2025-01-10 21:40:00
usage_window_end2025-01-11 07:10:00
initial_charge0.55324
time_needed100
expected_baseline_charge_complete_timestamp2025-01-10 23:20:00
window_length_in_minutes570.0
final_charge_time2025-01-10 23:20:00
total_capacity91
usage_power_kw21.4625
total_intervals_plugged_in114.0
MWh_fraction0.001789
early_session_stopFalse
\n", + "
" + ], + "text/plain": [ + " 0\n", + "distinct_dates 2025-01-10\n", + "user_type r21.4625_tc91_avglc27109_sdlc7283\n", + "usage_window_start 2025-01-10 21:40:00\n", + "usage_window_end 2025-01-11 07:10:00\n", + "initial_charge 0.55324\n", + "time_needed 100\n", + "expected_baseline_charge_complete_timestamp 2025-01-10 23:20:00\n", + "window_length_in_minutes 570.0\n", + "final_charge_time 2025-01-10 23:20:00\n", + "total_capacity 91\n", + "usage_power_kw 21.4625\n", + "total_intervals_plugged_in 114.0\n", + "MWh_fraction 0.001789\n", + "early_session_stop False" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s_ev.synthetic_user_data(distinct_date_list=[distinct_date_list[0]]).T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or for *multiple* users." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [00:00<00:00, 335.21it/s]\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexdistinct_datesuser_typeusage_window_startusage_window_endinitial_chargetime_neededexpected_baseline_charge_complete_timestampwindow_length_in_minutesfinal_charge_timetotal_capacityusage_power_kwtotal_intervals_plugged_inMWh_fractionearly_session_stop
002025-01-10r28.687500000000004_tc118_avglc20546_sdlc79202025-01-10 12:15:002025-01-10 18:10:000.3809631402025-01-10 14:35:00355.02025-01-10 14:35:0011828.687571.00.002391False
102025-01-10r24.735_tc112_avglc24834_sdlc77082025-01-10 21:40:002025-01-11 05:50:000.5359001122025-01-10 23:32:00490.02025-01-10 23:32:0011224.735098.00.002061False
202025-01-10r30.7275_tc45_avglc23403_sdlc70302025-01-10 08:55:002025-01-10 15:35:000.793005132025-01-10 09:08:00400.02025-01-10 09:08:004530.727580.00.002561False
302025-01-10r34.765_tc38_avglc28725_sdlc72302025-01-10 08:55:002025-01-10 16:10:000.326142402025-01-10 09:35:00435.02025-01-10 09:35:003834.765087.00.002897False
402025-01-10r33.32_tc34_avglc22081_sdlc71952025-01-10 10:05:002025-01-10 17:45:000.676138162025-01-10 10:21:00460.02025-01-10 10:21:003433.320092.00.002777False
502025-01-10r24.735_tc32_avglc20715_sdlc69022025-01-10 08:05:002025-01-10 13:30:000.525689322025-01-10 08:37:00325.02025-01-10 08:37:003224.735065.00.002061False
602025-01-10r32.8525_tc76_avglc29495_sdlc72742025-01-10 08:10:002025-01-10 16:25:000.647882412025-01-10 08:51:00495.02025-01-10 08:51:007632.852599.00.002738False
702025-01-10r34.3825_tc107_avglc23121_sdlc72972025-01-10 19:15:002025-01-11 01:00:000.608428632025-01-10 20:18:00345.02025-01-10 20:18:0010734.382569.00.002865False
802025-01-10r35.2325_tc67_avglc24281_sdlc71012025-01-10 15:10:002025-01-10 23:45:000.628492362025-01-10 15:46:00515.02025-01-10 15:46:006735.2325103.00.002936False
902025-01-10r28.900000000000002_tc70_avglc24076_sdlc77982025-01-10 21:10:002025-01-11 02:35:000.659718422025-01-10 21:52:00325.02025-01-10 21:52:007028.900065.00.002408False
\n", + "
" + ], + "text/plain": [ + " index distinct_dates user_type \\\n", + "0 0 2025-01-10 r28.687500000000004_tc118_avglc20546_sdlc7920 \n", + "1 0 2025-01-10 r24.735_tc112_avglc24834_sdlc7708 \n", + "2 0 2025-01-10 r30.7275_tc45_avglc23403_sdlc7030 \n", + "3 0 2025-01-10 r34.765_tc38_avglc28725_sdlc7230 \n", + "4 0 2025-01-10 r33.32_tc34_avglc22081_sdlc7195 \n", + "5 0 2025-01-10 r24.735_tc32_avglc20715_sdlc6902 \n", + "6 0 2025-01-10 r32.8525_tc76_avglc29495_sdlc7274 \n", + "7 0 2025-01-10 r34.3825_tc107_avglc23121_sdlc7297 \n", + "8 0 2025-01-10 r35.2325_tc67_avglc24281_sdlc7101 \n", + "9 0 2025-01-10 r28.900000000000002_tc70_avglc24076_sdlc7798 \n", + "\n", + " usage_window_start usage_window_end initial_charge time_needed \\\n", + "0 2025-01-10 12:15:00 2025-01-10 18:10:00 0.380963 140 \n", + "1 2025-01-10 21:40:00 2025-01-11 05:50:00 0.535900 112 \n", + "2 2025-01-10 08:55:00 2025-01-10 15:35:00 0.793005 13 \n", + "3 2025-01-10 08:55:00 2025-01-10 16:10:00 0.326142 40 \n", + "4 2025-01-10 10:05:00 2025-01-10 17:45:00 0.676138 16 \n", + "5 2025-01-10 08:05:00 2025-01-10 13:30:00 0.525689 32 \n", + "6 2025-01-10 08:10:00 2025-01-10 16:25:00 0.647882 41 \n", + "7 2025-01-10 19:15:00 2025-01-11 01:00:00 0.608428 63 \n", + "8 2025-01-10 15:10:00 2025-01-10 23:45:00 0.628492 36 \n", + "9 2025-01-10 21:10:00 2025-01-11 02:35:00 0.659718 42 \n", + "\n", + " expected_baseline_charge_complete_timestamp window_length_in_minutes \\\n", + "0 2025-01-10 14:35:00 355.0 \n", + "1 2025-01-10 23:32:00 490.0 \n", + "2 2025-01-10 09:08:00 400.0 \n", + "3 2025-01-10 09:35:00 435.0 \n", + "4 2025-01-10 10:21:00 460.0 \n", + "5 2025-01-10 08:37:00 325.0 \n", + "6 2025-01-10 08:51:00 495.0 \n", + "7 2025-01-10 20:18:00 345.0 \n", + "8 2025-01-10 15:46:00 515.0 \n", + "9 2025-01-10 21:52:00 325.0 \n", + "\n", + " final_charge_time total_capacity usage_power_kw \\\n", + "0 2025-01-10 14:35:00 118 28.6875 \n", + "1 2025-01-10 23:32:00 112 24.7350 \n", + "2 2025-01-10 09:08:00 45 30.7275 \n", + "3 2025-01-10 09:35:00 38 34.7650 \n", + "4 2025-01-10 10:21:00 34 33.3200 \n", + "5 2025-01-10 08:37:00 32 24.7350 \n", + "6 2025-01-10 08:51:00 76 32.8525 \n", + "7 2025-01-10 20:18:00 107 34.3825 \n", + "8 2025-01-10 15:46:00 67 35.2325 \n", + "9 2025-01-10 21:52:00 70 28.9000 \n", + "\n", + " total_intervals_plugged_in MWh_fraction early_session_stop \n", + "0 71.0 0.002391 False \n", + "1 98.0 0.002061 False \n", + "2 80.0 0.002561 False \n", + "3 87.0 0.002897 False \n", + "4 92.0 0.002777 False \n", + "5 65.0 0.002061 False \n", + "6 99.0 0.002738 False \n", + "7 69.0 0.002865 False \n", + "8 103.0 0.002936 False \n", + "9 65.0 0.002408 False " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s_ev.generate_synthetic_dataset(distinct_date_list=[distinct_date_list[0]], number_of_users=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example: AI Model Training\n", + "\n", + "\n", + "### Functional Behavior\n", + "- Worloads can run at any time of day\n", + "- Our 3 server models consume 24, 31, and 64 kWh on average\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "ai_kwargs = {\n", + " \"max_percent_capacity\":1.0, # job must run to completion\n", + " \"max_power_output_rates\": [24,31,64],\n", + " \"minimum_usage_window_start_time\": \"00:00:00\", # earliest session can start\n", + " \"maximum_usage_window_start_time\": \"23:59:00\", # latest session can start\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "s_ai = SessionsGenerator(**ai_kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [00:00<00:00, 280.14it/s]\n" + ] + } + ], + "source": [ + "df_ai = s_ai.generate_synthetic_dataset(distinct_date_list=distinct_date_list, number_of_users=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01234
index01234
distinct_dates2025-01-102025-01-122025-01-172025-01-182025-01-23
user_typer42.048_tc97_avglc23328_sdlc6978r42.048_tc97_avglc23328_sdlc6978r42.048_tc97_avglc23328_sdlc6978r42.048_tc97_avglc23328_sdlc6978r42.048_tc97_avglc23328_sdlc6978
usage_window_start2025-01-10 01:10:002025-01-12 16:50:002025-01-17 17:35:002025-01-18 11:35:002025-01-23 22:45:00
usage_window_end2025-01-10 05:45:002025-01-12 21:00:002025-01-18 00:35:002025-01-18 20:40:002025-01-24 05:10:00
initial_charge0.7137980.4215670.281110.5613540.706594
time_needed3980996040
expected_baseline_charge_complete_timestamp2025-01-10 01:49:002025-01-12 18:10:002025-01-17 19:14:002025-01-18 12:35:002025-01-23 23:25:00
window_length_in_minutes275.0250.0420.0545.0385.0
final_charge_time2025-01-10 01:49:002025-01-12 18:10:002025-01-17 19:14:002025-01-18 12:35:002025-01-23 23:25:00
total_capacity9797979797
usage_power_kw42.04842.04842.04842.04842.048
total_intervals_plugged_in55.050.084.0109.077.0
MWh_fraction0.0035040.0035040.0035040.0035040.003504
early_session_stopFalseFalseFalseFalseFalse
\n", + "
" + ], + "text/plain": [ + " 0 \\\n", + "index 0 \n", + "distinct_dates 2025-01-10 \n", + "user_type r42.048_tc97_avglc23328_sdlc6978 \n", + "usage_window_start 2025-01-10 01:10:00 \n", + "usage_window_end 2025-01-10 05:45:00 \n", + "initial_charge 0.713798 \n", + "time_needed 39 \n", + "expected_baseline_charge_complete_timestamp 2025-01-10 01:49:00 \n", + "window_length_in_minutes 275.0 \n", + "final_charge_time 2025-01-10 01:49:00 \n", + "total_capacity 97 \n", + "usage_power_kw 42.048 \n", + "total_intervals_plugged_in 55.0 \n", + "MWh_fraction 0.003504 \n", + "early_session_stop False \n", + "\n", + " 1 \\\n", + "index 1 \n", + "distinct_dates 2025-01-12 \n", + "user_type r42.048_tc97_avglc23328_sdlc6978 \n", + "usage_window_start 2025-01-12 16:50:00 \n", + "usage_window_end 2025-01-12 21:00:00 \n", + "initial_charge 0.421567 \n", + "time_needed 80 \n", + "expected_baseline_charge_complete_timestamp 2025-01-12 18:10:00 \n", + "window_length_in_minutes 250.0 \n", + "final_charge_time 2025-01-12 18:10:00 \n", + "total_capacity 97 \n", + "usage_power_kw 42.048 \n", + "total_intervals_plugged_in 50.0 \n", + "MWh_fraction 0.003504 \n", + "early_session_stop False \n", + "\n", + " 2 \\\n", + "index 2 \n", + "distinct_dates 2025-01-17 \n", + "user_type r42.048_tc97_avglc23328_sdlc6978 \n", + "usage_window_start 2025-01-17 17:35:00 \n", + "usage_window_end 2025-01-18 00:35:00 \n", + "initial_charge 0.28111 \n", + "time_needed 99 \n", + "expected_baseline_charge_complete_timestamp 2025-01-17 19:14:00 \n", + "window_length_in_minutes 420.0 \n", + "final_charge_time 2025-01-17 19:14:00 \n", + "total_capacity 97 \n", + "usage_power_kw 42.048 \n", + "total_intervals_plugged_in 84.0 \n", + "MWh_fraction 0.003504 \n", + "early_session_stop False \n", + "\n", + " 3 \\\n", + "index 3 \n", + "distinct_dates 2025-01-18 \n", + "user_type r42.048_tc97_avglc23328_sdlc6978 \n", + "usage_window_start 2025-01-18 11:35:00 \n", + "usage_window_end 2025-01-18 20:40:00 \n", + "initial_charge 0.561354 \n", + "time_needed 60 \n", + "expected_baseline_charge_complete_timestamp 2025-01-18 12:35:00 \n", + "window_length_in_minutes 545.0 \n", + "final_charge_time 2025-01-18 12:35:00 \n", + "total_capacity 97 \n", + "usage_power_kw 42.048 \n", + "total_intervals_plugged_in 109.0 \n", + "MWh_fraction 0.003504 \n", + "early_session_stop False \n", + "\n", + " 4 \n", + "index 4 \n", + "distinct_dates 2025-01-23 \n", + "user_type r42.048_tc97_avglc23328_sdlc6978 \n", + "usage_window_start 2025-01-23 22:45:00 \n", + "usage_window_end 2025-01-24 05:10:00 \n", + "initial_charge 0.706594 \n", + "time_needed 40 \n", + "expected_baseline_charge_complete_timestamp 2025-01-23 23:25:00 \n", + "window_length_in_minutes 385.0 \n", + "final_charge_time 2025-01-23 23:25:00 \n", + "total_capacity 97 \n", + "usage_power_kw 42.048 \n", + "total_intervals_plugged_in 77.0 \n", + "MWh_fraction 0.003504 \n", + "early_session_stop False " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_ai.head().T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from watttime_optimizer.evaluator.evaluator import OptChargeEvaluator\n", + "from watttime_optimizer.evaluator.evaluator import ImpactEvaluator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The WattTimeOptimizer class requires 4 things:\n", + "\n", + "- Watttime’s forecast of marginal emissions (MOER) - be ready to provide your username and password\n", + "- device capacity and energy needs\n", + "- region\n", + "- window start\n", + "- window end" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "username = os.getenv(\"WATTTIME_USER\")\n", + "password = os.getenv(\"WATTTIME_PASSWORD\")\n", + "region = \"PJM_CHICAGO\"\n", + "oce = OptChargeEvaluator(username=username,password=password)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# single instance\n", + "df_ev_sample = s_ev.synthetic_user_data(distinct_date_list=[distinct_date_list[0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "input_dict = df_ev_sample[['usage_window_start',\n", + " 'usage_window_end',\n", + " 'time_needed',\n", + " 'usage_power_kw'\n", + " ]].T.to_dict()\n", + "\n", + "value = input_dict[0]\n", + "value.update({'region':region,'tz_convert':True, \"verbose\":False})" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "df = oce.get_schedule_and_cost_api(**value)\n", + "rr = ImpactEvaluator(username,password,df).get_all_emissions_values(region=region)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rr.cumsum().plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "rr_metrics = ImpactEvaluator(username,password,df).get_all_emissions_metrics(region=region)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'baseline': 26.349219416666664,\n", + " 'forecast': 22.1546754,\n", + " 'actual': 22.807821208333333}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rr_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pred_moer 97714.900000\n", + "usage 44.000000\n", + "emissions_co2_lb 22.154675\n", + "energy_usage_mwh 0.020913\n", + "dtype: float64" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Requery\n", + "\n", + "- The intuition behind requerying is that more recent forecasts more accurately reflect what is likely to happen on the grid within the session window. \n", + "- An extension of this assumption is that the higher the update frequency, the greater the improvement in overall results. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from watttime_optimizer.evaluator.evaluator import RecalculationOptChargeEvaluator" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "roce = RecalculationOptChargeEvaluator(username,password)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "value.update({\"optimization_method\": \"simple\", \"interval\":15, \"charge_per_segment\":None})" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.39 s ± 368 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "%%capture\n", + "df_requery = roce.fit_recalculator(**value).get_combined_schedule()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pred_moer 97714.900000\n", + "usage 44.000000\n", + "emissions_co2_lb 22.154675\n", + "energy_usage_mwh 0.020913\n", + "dtype: float64" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_requery.sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Vizualizing Results" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "impact_evaluator = ImpactEvaluator(username=username,password=password,obj=df)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "impact_evaluator.plot_predicated_moer()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "impact_evaluator.plot_usage_schedule()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAngAAAGwCAYAAAA6xBh+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACyX0lEQVR4nO2debxM9f/HX2fmrrgu9+Lea9+3KFsJFSpSCW20CNEilZAlXxXKUioUSWWrvhVt31L5KUkkSYkWhFC2e+07d5mZ8/vjfc+s58ycM9v5zMz76XEeZs6cOedzzznz+bzO+/NeJFmWZTAMwzAMwzBxg8XsBjAMwzAMwzDhhQUewzAMwzBMnMECj2EYhmEYJs5ggccwDMMwDBNnsMBjGIZhGIaJM1jgMQzDMAzDxBks8BiGYRiGYeKMJLMbEG1sNhs2bdqEnJwcWCysbxmGYRgmFnA4HDh06BBatmyJpKSEky+GSbgztGnTJlx22WVmN4NhGIZhmCDYsGEDLr30UrObITwJJ/BycnIA0A2Sl5dncmsYhmEYhtFDfn4+LrvsMuc4zvgn4QSeMi2bl5eH6tWrm9wahmEYhmGMwO5V+uCzxDAMwzAME2ewwGMYhmEYhokzWOAxDMMwDMPEGSzwGIZhGIZh4gwWeAzDMAzDMHEGCzyGYRiGYZg4gwUewzAMwzBMnMECj2EYhmEYJs5ggccwDMMwDBNnsMBjGIZhGIaJM0wVeGvWADfdBFStCkgS8Omngb+zejXQujWQlgbUrQvMnRvxZjIMwzAMw8QUpgq8c+eASy4BZs/Wt/2ePcANNwBXXgls2gT85z/A0KHAxx9Htp0MwzAMwzCxRJKZB7/+elr0MncuULMmMHMmvW/SBPjlF+DFF4Fbb41IE3Ujy0BJibltCIbkZLKeMtHDITtgkdg7wggl9hLIkH3WJ1uSIYX7Brbb6X+rNeCmDtkBm8Pms94qWWG1BP6+KIh6T4raLlEQ8fzIsoxiezEskgXJ1mSzm5PQmCrwjPLjj0DXrp7rrrsOmD+fxFWyyr1UVESLwpkzkWmbzQb88QdQXAw4HJE5RiTIyAAuvtjsViQOR84dwb7T+1A/qz7Kp5Y3uzkxweFzh7Hr+C44ZN8fVmZqJprlNAvfwU6dAi66CGjQAPj2W79PPw7ZgT8P/4lzxed82maVrLioykXISM0IX9sixKGzh3DgzAE0zG6IcinlzG6OE4fswB+H/kCZ5DJokN3A7OYIR8HZAhw8cxCNshuhbEpZs5vjpNBWiK1HtiLZmoyLc3hwMZOYEngFBUBOjue6nBwSV0ePAnl5vt+ZOhWYODE67bPZgC1bgMLC6BwvVGSZfBkbNQJSU81uTWJwsvAkDp87jMplKrPA08nxC8fx5+E/UWQv8lgvyzLSk9PRILsBUpPCdAN/+y1w4AAt27YBTZtqblpsL8a54nM+bZNlGWlJaaiaUTUmBJ5yT+aUzRFK4BXZilBoK8Shc4dQu0JttgZ5cfICXbfcsrlCCTwZMmwOG04WnkSJvYSvm4nElMADfB+oZVl9vcLYscCIEa73Bw747bODJjkZaN4cOHECSEkRXzDZbDR+FRa6ZqSYyFPiKMHRc0dRnF1sdlNiBrvDjkJbIaplVENOOXrCK7GX4K+jf6HQVgi7HMYbeM0a1+ulS/12FrIswyE7UOIoQdNKTZ0i89+T/+LYhWOwyb5TtyLivCftYt2TilA4ev4oShwsFLxxXjeHYNdN5usmCjEl8HJzyYrnzuHDQFISkJ2t/p3UVE+xdfp05Nrnfsy0tMgfJxTsdhKlJSUukcxEHlk52XzOdaP43qUkpSAtiX5YSZYkJFuTYbOFWUS5C7zPPgOeeCJguyRISE1KdbYtbNbEKKHck2o+jiIgcwelinK9RDs/ot5HiYhY3pkBaNcOWLHCc93XXwNt2qj73zHauFs8Besf4hpnp8ydoG6UAUyCr5k+rIPb6dPA5s2u9z/95PtEaeDYsXKNRb0nRRMuoiGqMPf3e2Wii6kC7+xZ6k+VPnXPHnq9dy+9HzsW6NfPtf3gwcC//9KU67ZtwIIFFGAxcmSUGx5ncD8aPXjQMo67pUzB/XXYzum6dRQhVa8ePTXKMvDllwG/5h3F62xbrF1qwdorqoVKFEQV5gphj25nDGOqwPvlF6BlS1oAEm4tWwJPP03v8/NdYg8A6tQBli0DvvsOaNECePZZ4JVXzE+REouwBc8ceNAKHq0BI2wDnDI9e9VVQM+e9PqzzzQ3VxOeEWlXhBHdEuT9mhGbQL8LJnqY6oPXqZN/cbFoke+6jh2BX3+NVIsSB364MhfRBlORURvc3cVe2AZ/d4HXqhXw1FPkE3L+PFCmjHa7vH5LSttiRZSIei+K2i5RENWf1zlFy4OM6cSUDx4TXpTfX4yMQ3GB01rCJ103gaZow8KFC8CGDfT6qqsoJL5WLQoz/+Ybv+3yRmlbrAgUUe9JDwtejJzLaCLqFK1o7UlkWOAlMMIKvK1bqQ7drFnA2rWRy05tAqJ2yiIT0IIXjnP5008UUl6tGvmCSFLAaVotZ/JYteCJdk+6tydWzmU0iQVhzphLTKVJYSKDUL/H776jgdU9n40kAfXrk4Nmv37AjTea1rxQEbVTFhmnBU8jmCEs59J9elY5To8e5OT7+eeUV8irdFm8+BrFwj0pmvgUAdGFeaz/LuIBtuCFEcv/fYFy/26BVOS/lIXlwjmk7/wdSSeORKll6kTVgnf0KPDnn/7ruH3yCdCtG4m7yy4Duncni4osAzt3Ah98ANx0k+aUWSwgWmccCwRKuxCWc6oIvCuvdK276iogMxM4csQ1fauCpvCMsWstWns5yMI/ogtz9sEzH7bghYuTJ5F22024AoAsSSjOqYGimg1QVKMBiitXRUrBXqTt3YnUfTuRcuQgAMCWmY3tb6xGYb2LTG162PuHI0eocPCvvwKbNtGybx99dtFFlP+mTx/KUK3w5puUB8fhAG6+GXjvPVe26MOHKX/OG28AH38M3Hkn7bN6deNtKyigrNgmJU4UNWIx6rz2GjBlCl1nd1HlBx8hFa6p0OJiSpECkKhTSE4GbrgBeP99mqZt187ja1rHjdkpWsHa6zFFm+i/lxiC8+CJA1vwwsXx47C3bI2SMuUhyTJSC/ai/IaVqPzxXFSb+zQqfzoPGb+udoo7R1Iykk4dQ4OHuyBl/y7N3aYc/AcNHroG9Ub0RPKh/WFtctgfsEpKgOeeA2rWpGnWiROp3JMi7lJTqVhv375UAPfNN4GiImDyZOCBB0jc3X8/8OGHnqVAqlQBunYF/vtfmqY9ehS4/XYamPVy9ixNueXlAeXKAa1bA/fdB7z6KolRI/sKA6INplHlhx+ARx8F9u8HHnqI6ub5IeLBDL/+SkEW2dlAkyaen/XoQf8vXarZrnhJkyIaorZLFISfomULnumwBS9c1K2LorW/YM1qGVn2Iyh/aCfS9u1E6t6dSD6aj+LcGiiq0QCFpVY9yDIaPdgJ6bv+RMOHrsH2eWtRkuNpkSq3cTXqjrkNySeP0vvf1uKfp+bjVKdeYWlyWKdof/gBePBBEnAA0Lgx0LatK9HhJZfQgV59FZgxA9i9m0Td6NHAyZP0nXHjKLmhVseQlgZ89BGJs/XrgVGjgJdfDty2gwdpunfTJnpfXEyDunu+ndatKaAjwjXmRO2Uo8axY2SBVQogb9lC2coffFDzK5oWAcnz86Bxn561eD3zXn89WZq3bSM3gQYNfNrlTVh9A6OAqPckB1n4R1jLq2DtSWTYghduJAklFavgXIsOOHbTABx8eDL+Hb8A+Q9OxPEb+uJ8s7awZ2bBXiEbO15dgcIa9ZGa/y8aDrkWSccPO3dT6aO5aDjkWiSfPIpzjVvhXNM2SDp1HPVH3oyaUwZDKjwfjqYCCFHgnThBg/MVV9BgXakS8PbbFAm7aBHw2GMuX6YKFUjE/fsvMH06ULWqS9y9/DIwaVJgs2LdurR/gBzgFy/2v/0ff5DQ3LQJqFyZpuJ27SKhOG4cDeDlygEbN5L1McKI7jcTUWQZuPdesug2aECWW4DyzfkpEh3Ighcy7gEW3mRmUsJOwMeKp2mpkDw/F51YEAqxci6jiajuHqK1J5FhgWcitkq52DnnGxTn1EDav9vR4JGuSDp+GDWnDEat5x6CZLfheNc7sH3e99g+/wcU9BsNAKj8yeto0u9SpO/8PSztMNyvHztGPkkjR9KU1htv0PpBg4C//gLuuce/UCtbFhg+nKx4//0vBU0MHar/+DfdRH58AE2zbtumvt3XXwMdOtBUYKNGZPVr145E4q23kqBctoxq3gHA1KlkpYkEBQXA7NlodOsDuP2qwSi38vvIHEdkZs6kiNTUVAqYGTUKaNiQfDanTtX8mqqQkmW0mbEEPYbNQbm7B5BwfPRRSq/z6qs05aoHu50st4C6wANc6VK8BV4AC16sIKpQcEc08SkCogvzWPsdxCM8RWsyxXm1sGPON2j0wFUos+M3NOtRB9bC85AlCQcenoJD/cc4xdKBoc/jdNsuqD2+H9J3b0WTu1vCkeabYV8vFztI3CWNhWc2fquVrF25ueSzlpcH5OSQ5eX7713TsAqNGwOvv649QGqRmgrcfXdwjX/mGRJsq1YBt9wCPPyw5+cFBWSRs9up/MknnwBZWer7uu028vH7+mvgkUeA5cvD46B49Cj5E37wAbB6NSDLKF/6UfXh44Hr7wQqVgz9OLHAhg3AmDH0esYMqjUIAC++SH5uM2aQJbh2bZ+vqg0YKfsO4qK3/6/03V++x0tLoweOQPzxB3DqFJCRQW4Eatx0E4nHtWvpmlaq5PGxTx68aE/Rnj5Nv6XU1JB2I5xQ4CALv4guzNkHz3xY4AlAUa2G2Dn7azR8sBOSTp+AvWwG9kx6D6eu7O6z7Zm212Lb+7+h1jODUOH7z2E9fzbo4zqzehWpfHjqFPD339pfbtKEBF3HjiSwQhxcDJOURNGNrVqR1fDRR9W369sXmDfPf/skiaw+zZqRyPvwQ6B379Dat307WQtPnHCtu/xy/NPlMlR850Nk/pNPFtD580M7jhmcOQPMmUNVHrp1A9q08ckR58HJkxQ1XVJCYnrwYNdn3bsD11wDrFxJVtn339fVBEsRBcUUp6egaNJEZJRI1K7//Y/cA44d0/e3KNOzHTp4RnW7U6sWib/ffqOo31Jrs2Z+PiWKNhoD744dwOWXk1V6wwZfH0IdCOuDF+9pUhR3EW8yM+l3EcS1FAHOgycOLPAE4UKDi7Fj7ipkL12Ao7cORmGdJprb2ipWxq4ZS5F8+ACkYjV1po/du2nsvf56ClR1UlJCqUny88kSpvxfsSKJuiuu8LFimEJODgmyl14Czp3z/bxjR4rS1PMkWb8+CYwJE4Bhw0i4lC8f6FvqnDtHU8AnTtDU8P33k7CpVQsF+9dje91MdB04CdKCBcAddwBdugR3HDP49FOych44QO8nTKDo027dKKXIVVdRxLL7vfP558A//1CFiDff9LwekkTXr2VL8qccOtQ3HYmakLJRkEZJeirOP3AvMsrl0PqCAhJ4ASJznfjzv3PnvvvoIeLJJ2nKtlatwPn5Ii1K7Haamj5xgnxIv/jCFfVrAFHFk2iCM6xs3kz9qNa5f/nlgG4rwk/RsgXPdFjgCcSFhpdg/0gdUaGllFSpFtLxzp0DTicB9loA8rw+bNQopH1HjYsucvnQhcqYMeQT+PffwNNPk8+YUWTZFU2cl0eVOXJzXR9DxpGWDXHk3j6osmAxRRL/8QcFeojMvn0kcJSyXXXrkihbsYKsZe++S4sWycnAkiUUaOPNJZcAAweSNXPECLJsuJciUxFSUqmAcyRZPYWAkt+wpCTw3yTL+gXeQw+RAP3hB5r6XbEioACJuECZOdOVvw+gae5gBJ7gQgGIQ7H3yit0/9WrRw+XCidPUtm855+nvsFfVL+s/Gfw3Jw9S33czp30lN+hA4nNMBF31yqGYYGXwAhbi9Ys0tJoqva666gObv/+JGKMMHcuCR2rlQSNm7gDXIPWwbEPo8rKH8myNW6cvnQvZmCzAbNnk+Xq3Dmaxhw9mt6np5OQ+vFHClZZtozEamamy39T+f/WW4FLL9U+zrPPkoBav558Fvv0cX6kNmA4BZ7VaxpLmWbVY8Hbvp0CPNLSaJrZH1YrsHAhidGVK4HXX4d8d0/VTaPig/fXX3TfAMD48RQw9N13ZBlS/Bv1EqxQiDBxmybl2DGa6gcoI0D79q7PiopI8O3fT1kI3N0Z3JBlGZlrf0Hn1xaivLUMkJoR+Ljnz5OwKyjwXF+mDP1u69bV/m5REf3mGzQg4emHuLpWMQ4LPIYFnjtdu5L/3QcfkNVm5UqK+tXDhg2UFgagJ3CVCg3KoGUvk07Rx4qY7NPHs6MXAVmmqcm33qL3HTpQMM1FbpVXkpPJ+nXVVRTUYrNp+7L5Iy8PeOIJSpkyYYKHwFPGefcpH0XgyVar54BixIKnWO8uv1yfD2mDBvQ3PvYYMHIkLB1aAJnaPngRw2ajh4+iIpoaHz+efPHef5+seMr1MojIA7OH+Jw/n6Kl9VxjgAJoPvyQyh/6Y/NmYNo0EmBnzpCl6+xZerDp1Yvu/XAwbx5du1atfNwRkJpKD1BDh9K9NmiQatUd+fgxNBw6ASnHTgbXhkqV6H4+dozunQceIGu81r37xBOuGY3jx+m9BuyDJw4s8BgWeN5Mn07WqJ9+oqnTjAxPi1SzZuRv1rKlyxFaqa5RUkJBJyNGqO/b/Vx37Uo+VAsXUke+aVPEEy0b4q23aLFYqLTYffcFdvwORtwp3H03Cbx//w24qVTqg+dIsngO/kYseD/9RP8bmZ565BEql7dmDSo8PAJ4+3ntKNpIWcReeokeJjIzXT6Nw4eTwHv/fRIGed4+F6WUlNA5UimnJpwFTy3I4uxZEkDHj+vf0YkTQL9+JOC0fl/Hj5Mzsrd1S+GNN0hUh/oQZrNRgBJALg9qguq++8gi+++/ZOnr399nE2nUaKQcO4mTdavi5PCHULtC7cDHTkkhP9gGDVyuEn//DVx8MT3ILligHnm+fLmnu8rYseSfPGSI6mHYB08cWOAlMDxFq0G1avSUPXgw+cScOUOLkiPvgw/IRy8nxxVcsGABsHcvdZ4LFwYM7HAOpi+9BPzf/9GU22OPUXk3r2ldU9i61ZV65tlnA07LhAXFUuEmztwHeQ8fvBJlilbDgqdH4J0tjUD3iDAKgMVC1/fii5H6/Y/Ifft/2N3Lcxo/orVot2yhew+gaX2lHvOll5KF9YcfyM1g0iTf727dSgE9lStTou/69YWeBlVNkzJ3LomxBg0oL2EgEaFYObdvp9RKU6aobzd0KIm7Ro1o6jsjgx7uypUjF4V336Xf5ldfhfZHff459RPZ2Z5WanfS0ynCfvRoam/fvp5R6qtWQVq4EACw/ulByOl6I2rnGXQlUahfn37fI0cCjz9OIrdqVdfnhw65BOajj9JDxaRJ1DeUK0fCWQO24JlPbMZhM2GBBZ4f+vShgeTUKRocvvuOrCMvvkjTNeXKUef31lu07VdfUcf88cea0beqFomKFV1P9G+8QeLy6qvJYnbokOcObDaKXv31V4pyNoIs0/7WriWBMns2WR3VOH+epqnPnydB4Gc6Jqy4T6+q5PjymKK1B7Dg6Zm+U0SgUatj3bo0lQeg9nOvIWOv+rUIu0WspIQG2+JiSqPhPbgqVuO5c+nauVNQQA8iBw9SupfLLqNAkViy4F24QL8/gKZoGzcmQeZvufhi1+9r2jRXuUJ3Pv2UBJzFQr/ne+6h3/i119L0/bPP0j3y9dfkIxoKs2bR//ffT/2FFoMHU97OHTtIjCsUFjrL+uX37YWjLRqGft2GDaP74dQpcktRzrtSeebwYZq1mDaNRLIS3XvvvdTfecG1aMWBBV4Cw7+/AEgSibWGDSnlyh130FPu//5HvisrV9L7pk1pAJg/H2jeXHN3molbb76ZHKrbtgUcDkrePGQIPUm3bUuO/VWq0BRL9epUN7daNZrS3LBB/WDFxTTNPGgQ+foogQ9XXkkRq48+Sp22EhXrzmOPkaUoNxd4553o5eNyF1oOBwA/FjxlitbbgmdkilYRgSo+TgEZPBiFV7aH9UIhevQajXYNr0bLuu3Rsm57XN30Rjxw7RjUGzCCxJaOKWdVTp2iBNkzZ5Kwu/hiSodSoQL5g3n/gHv2pCm4Y8fouimcO0fJmv/9lyw2bdvStGW3bsDLM4V9wvMRLvPn00NKrVrGEqT36kXuE3Y73fvu4v/oUVcd5NGj6dx4U6eOS0xPnGjob/Bgyxb6bVssJKT8kZFBwgsgi1np7wFTpgA7d0LOy8O/o6ndIVterVY6t8nJZBX94ANaP2sWzS6kptLDbVoa3XMzZpC4cziorrSXVVM0S3AiwwKPEbV/F5uUFLK0vfgiddxFRdTZ+cGvtaR/f7IO7NkDvPACTbk5HCTgfv+doj1l2VVlxGYj/5y2bcnK8P77ZLVZvpwGsZwc4MYbaep40yaaYpYkqhTRpQtZNw4dosHvnntcCZnfe4+mpyWJrBo5OeE9b/5wF1qlg7BmHVqtKFojQRbBWvAAwGLBsdnTUFIxExa7A5aiYudiLS5B6tkLqLjiexrIa9cmMT16NDmyK1PDamzZQkETF11EQq5TJ/Kve/ttmsZPTiZx5z6NpmC1uqwrM2fS/WO3kxj65ReaFly2jKzRAwYADgesI0ai/qipsBSXCDcwe/xeiosocAmgdEZGRfmsWWQR27zZZQUE6EHn8GE63xMmaH9/3Dg6v8uXaz9UBWL2bPq/Vy+gZs3A2z/6KD1g/vknTe1u3eqsl22bOR32TIqcDYvltVkzV1T2o4+SEB1NpTHx0kv0uYLFQr6fis/xTTfRg0OLFsAVV6DKbf3Q6KEn0WTC7NDbxYQE++AlMDxFG0Z0WLl0+TvVrk3+MCNHUo6qn36iaVylZFx2Ng00GzfSoPX++7TNXXdRG5QnfYAscLfdRlNNDRvS1KISLVpYSAPaCy9Q7r+VK0lYjBxJnz/1FAnYaOIutJQoWXcLnkqiY588eNGy4AGw1ayOX378GIf2bkW1jGpItdK5PV10Gvt3bUKHv86ixto/KFfdli20vPACXb9WrciaeuWVNNh//jlZTrZu9TxIjRoUzNOyJX3n0ku1AygAEvfjx5MY/OorWj77jK770qXkuwaQ8L/4YsgjRyLnw2Xosn0Hjo9+FOjdIujz4cHx4+SzeuYMRVinpIS0uzLvf0SpQ/LyyHpklJwcEr39+pEV7uab6XosXkzXY9Ei/5HUdevSg9CiRfT9L780dvyTJ0mkA9pVd7ypUIGCeqZMISteaqpTUDlu7gXkbwQQRovZ2LE0Hfznn9RnOBzkCqAWTGG1Ur9RWEj3rltFjvTSpTAnGw7fb0afNWvod7dxIyVe/9//SGQDdD6ffJIefHbvppmOa68lIe3+EFVURH3j+++Tq8A119DUv+IDC9BD8tChrprVPXpQH62W+zNKsMBjWOBFCcMdcd262rmpWremweb558mi89pr5GdVpQqJut69KTpUq4RYWhp1Yr16kTVn+3ZXzq2OHV2O/NFExYKn4JOKxJkmxRJ8kEUoFrxSHOlpOJ+bjeLMHFiSKEKzuDAdR5Jr4OC1l6HG1NLp0BUraBBZvZpyH/78My3Tp3vuMCWFUuf07k1TqEYrxpQvT1GY06eTEFL8ON95xzMCtDTy1ta4IaQ77kDl3/9G5b6PAUMnUhR4795A5876zk1+Pg18mzaRqNu50zPKtUYNYNQoapc/vzMvnL5cNjsypr9KK0eNCj7SvG9fslAvX05C759/aP3YsYHzIALk9/f223Qdf/nF9zv//ksioHx5EmbuOTQXLiQLe7Nm9PvSy7BhJEx/+YXelytHQTTuicDD5TuZkkJTte3akbjLzaUHAS1fnpQUenjYto0E7NmzwJkzOHxoN84cy0eRxYHa4WlZaJw7R24u995L+TjdOX+efJqfeoq2OXGCznmPHq5zDtC6zz+nB4LsbHLN6d6dRKPSx951Fz2ELF9O7x94gB4KPv88Gn+lKizwEhi24EWXiBRPz8khMfbEEzS9W7++/7qw3lx+OQ3MTz1FoqByZVei5mijZsELNEWrZcHTM0UbogUvUL4vj0Ca3r1d9Y337gW+/56WNWvoul1zDX3eo0foT/xDh5IoUMTdtGk0naaCo8u1+OPL+Sj/yuuo8+0mJB87TlP08+aRuFTKz115JVn/lE6jpISsWAsWkOApDXrxoFo18gXdt4/aNGkSBYI89JCuMoDK+av91Xok/7OX2hNKNLckufI4/vwzrbv4Yrr39dCgAU13v/MOBRsolhqArK8PPEB+kwCdlyuvJH/WHj1IlAEk/Iw4P1euTA9eyoPApElAjRqQbYXOTcIaHHPZZWShnD6dLHSVK/vfXpLIB9mNsyd2o+BMPi6UXBBD4F1/PS1qZGbSw5c7s2bRedi7l6zrp06R8H3nHbLuAXRuatQAvvmGHsi2bSNht369y4/zzTdJLG/fblplKPbBS2BY4JlH2P2dUlKoEwlGmKWnk1/Srl2U0b5aaCXwgkaSXO1XfPA06r06o2i9LXhGpmhDtOAFyvelOfDWrElCYe5cmpK9cIHqyPbrF57pnFq1KCAIIHGgTLtrtLGoZjVsGHcvfvnlM5qqf/BBElNHj5LF6r776N7KyyOh+OijNDV1881knbDbyTo4ZQpN8f32G1lz9u+nQfK118j14PBhehCpVYuEinekr0rb4HCg2bxSITVihP6k41rUrOny5UtKIiu4kenjJ58kV4jPPyfLz9mzNC3epw8JgcsvJ1/cpCQS8LfdRlN9u3bRte3b13ibR46kc3/11SQQEeFAhiefJAvsNdcE9fWo5ME7cwY4fdq1FAVfk92HU6eoL1J+ixs3Un/Utatrm6pVyRqrlAr88UcSi+5BOpdfTuvcywlGGbbgMUyUEDklBQCKFjSbpCQSDIEseCUuC54UbC3aMFnwfNoWyTx4enn9dUrFcdVVfi1GPuL46itJSMyeTdPJq1aRlXHDBrIIuqfsyMkhUTpwIKUsUSMtjUTmoEE0jTt1KvkHPvUUWTimTSPLpUobZVlG9v+tRuaeg7BnlodVycsYKoMHk2VRqadshIYNScC9+y5ZJQ8fpilpSaIghaefpvvphRdI2L7+uisd0cCBwQnUvDwSy4DT1zdW8hdGivJeVkOMH+8/SEYvhYX0EHLXXS4rc0EBPQRUrOi5bU6OKzG24h7jTZUq2smzowALvASG06REF4+OT6w+WRySk+lp3NuC5+2D55YHz8NmaYIFz5uIV7LQQ7lyFIEbAE2hkJREFhzFilNYSNOa339PvmY33ECLXnGcnExi8O67aTpzzBiy7t1xB4nJl1+mIBJqCLB7N8p8vwyZ0+cDAE4/0B8VdUzr6sJicaUgCYYnnyRfvh9+oPfVq9OUnbtvXbVqZKUcN46E7Z9/6p8K1mqzGyI/LEZDcJ7euhXl3Wca9JQaDERJCd2PDocrd6I/ZNlzEFUbUL23iTIs8BIYnqKNLqI9aQuJl0DT8nNzr2RhMdmC59O2GH1y8isU0tJcUb+hYLWSBaxnT3ILeO45Sr7dpg2tO36cUpmcPg0lVrikTBpOPdgfFf3tN5o0bkwWyXnzKCDlzTcpBYsa6elkuQszsWDBi2gli4wMXX6cuikpIUvynj3At9967js3lyy+J054WvEOH3YFLuXm+iamByi9VTRTTXnBPngMC7wo4T2AitYxC4HOKFiXBc/qaQ2NogXP2RYtQRcDl9fjHoxme8uUoenM7dtpOkyWqaLEmjXkU5WSgsIWzVBw501YMX8c7FkVotg4HcydS3VcP/pIW9xFkFiw4MXMg44i7nbupKCJ7GzPz1u3pn7JPRgjP5+ssorAa9eOfPfccyT+9BOtC7V+cQiwBS+BYQtedPEWdDJkrtfojVcUrOZgYXMLsjApD55mAIjbe1mWhR7o1B46otreGjXIn+2RR6hqQr165BfXpAn2nt6DI+eO4PiJPeKJZauV2ioCop2bUoTp286eJTGusGcPWYmzsihY4rbbKGDmiy/I/1fxmcvKIt+7zEyy2D7+OIm/rCwKfGne3BVV26QJpTW6/37yuwQoqrp7d9MiaAEWeAkNCzxzkWUZovSBwuBlwQs0RauZBy/SlSygz3IiuogXxorcrh0tbohspTIbkc+HcLVof/mFcjoqKDWb+/enwAwl3U2LFp7fW7XK5cc6Ywb1E717uxIdL1rkmbVACbxRom179HBVLzEJFngMEyV8rCUCd9KmoWHB88Z9itZsC55P2yRPC57A+k71nhRFkPLvQxuf2QCBLMXCPDQodOrk34qhp71paZQfb9Ys7W2ysijYRiDYBy+BYQtedFHrlBkvNCx43prDFWRhUi1aaFsqRBFIehD5nvSw4AnULhEQ+WFRpLYkOizwEhgWeNFF5E5ZGLR88HwSHbtVsgg20XGkfPAiUUYqQoh8T0ak8kucEAvCPJYedOIVFngMC7woIVInLCx6ffC0giyiWItWy7oICJLsOAhEba+o7TKLWBDmokwZJzIs8BIYtuBFF06TogONWrI+06A2Vx48VQteFPLgOdvix1Ih0sCrhlpktyhwkEVswxY882GBx7DAMwketFTwtuBpBTLYXJUsgg6yCFctWn8CT/Afl8j3oMjJfM0mJqZo2YJnOizwEhj+/UUXkTtlYfD2wdOcolXSpHhZ8PQGWdjtriebUCtZqPyQhChXpgOR70mR2iIasTBFy5gPC7wEhqdoo4vInbIweJcq07o5Sy149iSr53q9Fjz3z8NcixaIHeuFyPckB1low8Kc0QMLvASGBV50EblTFgYvC5xmKpLSPHhysEEW7ha+EC14ajgteIJfY5HvSU6Tok0sCHP2wTMfFngMC7woIVInLCw6LXjOPHhaaVICTdGG0YIXy0EW3ojaXlHbZRaxIMxjxYodz7DAY1jgRQmRIxaFQcOHTjMPXrC1aN33H6TAc7bFz0Am0sCrhsiR3RxkEduwBc98WOAlMDxFay48aKngbcHTmqJ1q2ShGWTh7/wqAtBioSUI/E7RSrEZZCESnCZFm5iYomULnumwwEtg+PcXXUTulIXB2wdPs5JFgFq0AOBwaB8nDDnw/E3RxowPnsD3pEhtEY1YmKJlzIcFXgLDFrzoInKnLAwaFjxvPCpZqFnwAP9+eCHmwPPXNmqgjm0EQOR7koMstBFVmLtfJ56iNZ+QBF5RUbiawZgBC7zoImqnLBQaFjxv3IMsPHAXbP788MJpwfOTB090YuWeFLVdZiGqMOfrJBaGBN5XXwEDBgD16lG/WKYMkJEBdOwITJ4MHDwYoVYyEUWQviHuEaUTFhqdPnhwpknxmqJ1F2z+BF4YLHgKsTxF640o7RVVwIhCLAhz9sEzH10C79NPgUaNgP79yR951Cjgk09I8M2fTwLvm2+AunWBwYOBI0ci3GomrHDfGR1EjlgUBr1RtFpBFlY3i56/KdoQLXh6r52IA687okZ2x4KAYXzhKVqx0PX4OmUK8OKLwI03qgec9e5N/x84ALz8MvD228Djj4ezmUwk4Clac+FBSwWtPHheY4VmkIUSFetwRNSC535M1SlaKTYseKLeg2zB84+o5yfQ74KJLrp6tw0b9O2sWjVg2rRQmsNEExZ40UXUTlkotCpZ6LXgKfsoKoqaBS+WEx2Lek+Kft7MRlQLp9YDGWMOHEWbwPADVnQRtVMWCr2VLLQseCr7UCWMFjzV9sWID56o96SoU8eiwMKc0YOu3m3ECP07nD492KYwZiFI3xD3iNopC4VeC57NZcHT3EcEo2g9LHh+pmhFJ1buSVHbZRaiC3P2vxMDXQJv0yZ9O4uRPo0phadoo4sonbDQaFjwfCpZKHnwkizaFrwI58Gjhvj/ONauuSjtFVXAiILowjxWHnDiHV2926pVkW4GYyaC9Q1xC0876UCP9Q1uFrwkq+/gpmeKNlQLnoZl0dm+WJ2iFaS9/FuJTQL9Lpjowj54CQxb8MxFlMFUKLysb4GmaH3y4AGaqVY8CNUHz0+SY4/tBBcmot6DogpPURDVwqn3d8FEh6B6t59/Bj78ENi7Fygu9vzsk0/C0SwmGvBvMLqI2ikLhZcFT3PAKJ2itSepRNFG0YKnRaymSRHlnmQLnn9EnaJlC55YGLbgLV4MdOgAbN0K/O9/1E9u3Qp8+y2QmRmJJjJMfCBqpywUGhY8byStShaAvmnecFnwAk3RCi5MRL0nRT9vZhMrwpwxF8MCb8oUYMYM4IsvgJQUSmy8bRslO65ZMxJNZCKFu1GEf5eRR9ROWSg0LHjeuOfB80FPkEW4fPBi3AweK/ckCwdPRBfmbMETA8MCb9cuqmgBAKmpwLlzJBSGDwfeeMN4A+bMAerUAdLSgNatge+/97/9u+8Cl1xCdXDz8oB77wWOHTN+XIYFXrRh/xQd6PXBc8uD56NJopAHz9kOLQtejEzRKojWXu+EuaIKT7PwfsAQ5fxwHycWhgVeVhZw5gy9rlYN+PNPen3yJHD+vLF9LVkCDBsGjBtHqViuvBK4/nry7VNj7VqgXz9g0CBgyxbyA/z5Z+C++4z+FYw3gvTrcY1Pp8wn3ReN6VWfNCleFjyPc6knyCJMefDiZYpWOKFQ2g6LZFFWMG74XDfB+hK24ImBYYF35ZXAihX0undv4LHHgPvvB+68E7jmGmP7mj6dxNp99wFNmgAzZwI1agCvvaa+/fr1QO3awNChZPW74grgwQeBX37RPkZREXD6tGtRxCnDFrxoo3TCltKfnSiDqVB4W/DUhJTDAcnhoJdJVtrO/VxGsZJFwChawX9YTiEFFaFsIs7fimTxWce4sAiWCCNeXBfiBcN3x+zZwB130OuxY4GRI4FDh4BbbgHmz9e/n+JiYONGoGtXz/VduwLr1ql/p317YP9+YNkyEiSHDgEffeSaMlZj6lQK/lCWpk31tzHe4d+gOYj61C0E3j54aiLY7nC+NNuCp0mMTC2KOqXGvlz+EX6Klq+bEAQ1RVu1aumXLcDo0cDSpWSNq1hR/36OHgXsdiAnx3N9Tg5QUKD+nfbtyQevTx8K8MjNBSpUAGbN0j7O2LHAqVOuZetW/W1MBDgXXvTwHrRE6ZSFQsOC547kZpmTrVbtfUTDghcniY5FuydVLXiCtE0EvIWUKPcZXyOxMCzwOncmS92pU+FpgPeDoyxrW5a2bqXp2aefJuvf8uXAnj3A4MHa+09NBcqXdy0ZGeFpd7whSP8Q13gPWqJ0ykKhYcFztzC5Czx7ksp0dxRr0WpZvmLFgiH6PclTtOp4+yiKIqxEtQgLz6lTwKJF5LN2zTVAu3ZAjx7A+PHaU5o6MCzwmjcHnnySrGe33gp8+qlvsmM9VKoEWK2+1rrDh32tegpTp1IOvlGjgIsvBq67jqJwFywA8vONt4FxwX1n5GH/FB3o8MFTAizct/cY/KNYizZgFK0gA28gRGuvmoVUlLaJgKhBFjy1bpD8fApiyMsDnnmG0pK0aEEir3p1qhPbpQv5li1ZYnj3hnu3V16hYIhvvgHeew/o35+E2m23AXffDXTsqG8/KSmUFmXFCuDmm13rV6wAevZU/8758779sTJDI8j9HXPwFG308JlW4QHLF63pVbfxwpnkWJIgW1UsGNGsRRsnQRbCTfVxkIVfRJ1aV+CHWJ1ccgmlBtmwAWjWTH2bCxfIkjZ9OrBvHwU+6CSox1eLhYIhunYF5s4FPv8cmDyZpm5L+15djBgB3HMP0KYNWSTfeINSpChTrmPHAgcOAG+/Te9vuonE7muvkfUuP5/SrFx2mcsvkDEGC7zo4TOtwifdF68ACTWLgFRapkxOcvnfGQ6yiHAlC+d2gg283vhM0QrSXncBLZp1USTcBbAIcJCFQbZsASpX9r9NejqlKbnzTuDIEUO7D2l+oqCASpf997/A778Dl15q7Pt9+lCS4meeIbHWrBlFyNaqRZ/n53vmxBswgNKczJ4NPP44BVhcfTXw/POh/BWJDT9oRR8esPzgZX1TnaJVPrNa1S0YItSiFcwipoWobgOinzezEX6KVrD7SVgCibsQtzcs8E6fBj7+mKZnv/sOqFsXuOsuEnr16xvdGzBkCC1qLFrku+7RR2lhwosg/UNcI2rkm1BoWPDccVrwkpPUB5Jo1qLVCrKIEREv6j3pbrkVTcSIgKhTtHyNQmT7dkoLsm0bWV8aNybB06hRULsz3Lvl5FA6lN69qS6tUasdIxY8RRs9RI18EwotC55KFK2HBc9okEW4fPBifCpK9HvS/bqL1jYzETX6OV5+F6bw0Uc0Dav4rAFU3aFZM7Ko3X674V0aEniyDLz8MtC3L9WCZeIHQfqHuEbUaRWh0GHBg5sFTyHalSwUAqVJEf0ai3pPulsWY+VcRhPhEx3zFK1xRo+mwINnnvFcP348MGZMUALPkIemLAOPPEKBD0x8wBa86MFPtzrQ44Nnd1nwFISrRSvYwBsI4ab63IMsBGubCIg6ta7AfVwQFBRQRK03fftqV38IgCGBZ7EADRpQYAQTXwjWP8QlokYsCoWGOPOYoi3NgycnWdWFFNei1Y2okd0eFjzBrIsiIVwULQdZBE+nTsD33/uuX7sWuPLKoHZpuHebNo0SDb/2mnbaFiZ24N9h9OEByw/eFjx/QRZJSeoWDAFq0caK1UnUKTXRz5vZCD9FyxY8fSxd6nrdowdNxW7cCFx+Oa1bvx748ENg4sSgdm9Y/vftSzn5LrmE0rNkZXkuTGzBU7TRQ9TIN6Hw9sELkCZFdRwRoBatczvBf1ii3pPuwlO0tomAqFO0Ql6jNWsoiW7VqjTgffqp5+eyDEyYQJ+np5MlbcsWz22KiiiatVIloGxZEmP793tuc+IEJfbNzKTlnnuAkyf9t61XL9cyZAhw9CiV5+rXj5Y5cyj33cMPB/WnG+7dZs4M6jiMoLDAix6iRr4JhRELXnKS+uAvQi1awSxiWoh6T6qWKhOkbWbjfh5Ec/cQ0iJ87hxZpO69l+qrejNtGlWJWLQIaNgQmDSJyoNt3+4qXj9sGFV0WLwYyM6mRLzdu5O1TfEFvusuEn3Ll9P7Bx4gkff559ptczjC+Zf6YFjg9e8fiWYwZsN9Z+QRdVpFKBTBJcuAw6GeJkUpVRZKmpQIW/Bizeok6j3JlSx8cT8Porl7CBlIdv31tKghy2S1GjcOuOUWWvfWW5QP7r33gAcfBE6dojJd77wDXHstbfPf/wI1alDN1uuuo7x1y5fTlGrbtrTNm29SupPt24POYxcqQfVuu3YBCxfS/y+/DFSpQn9bjRrARReFu4lMNBCkf4hr2D9FB+6Cy02geUzRugVZKES7koWzLVqWCqdlXNwflnvbhJvq4zQpuhD1QSLiFrwzZ6jqgkJqKi1G2bOHIlS7dvXcV8eOwLp1JPA2bqT+wn2bqlUpCGHdOhJ4P/5I07KKuAPIjy4zk7bREnivvKK/rUOHGvvbEITAW72axHCHDjS1PXkyCbzffwfmzaNcfUzswFO00Ue06TChcBNcspYFzu4WZKFmweBatLpwb5twU31ci1YTtSlaUYjWQ2z5pk09V4wfT350RlHSj+TkeK7PyQH+/de1TUoKVXjw3kb5fkEBCSFvqlTxn+Jkxgx97ZSk6Ai8J56gKeoRI1zT0wDQuTNZ85jYQiRXiXjGw1rCA5Y2boJLLil2vtZKk+LclmvRGkbtnhQFkc+b2cTCFG2kJylOb92K8tWquVYEY71zx/v+l+XAg6P3NmrbB9rPnj362xgEhuX/H38AN9/su75yZc6PF8sI0j/ELR6dcgwM/qbhIfA0pmjtbnnw1EYSEWrRCjp15o7I96RHLVrB2mY2qlPrgtxnUbtGGRlA+fKuJViBl5tL/3tb2Q4fdln1cnOB4mKKkvW3zaFDvvs/csTXOuhN+/YU6PHXX8bbHwDDAq9CBSA/33f9pk2Au6BmYgOeoo0OIke+CYXFQgs8LXjuqCY6FqwWrWgWMTVEviedbZPY4u2NmpVMFPErZJCFP+rUIXG2YoVrXXEx+aK1b0/vW7emfsJ9m/x84M8/Xdu0a0fBGBs2uLb56Sdap2yjxQMP0LaXXkpRvKNGUcLjMFxTw4+vd91Fufg+/JDEgcMB/PADMHKkepUNJjYQpH+IW0SeVhGO5GSgqIgseCm0Sj2K1rxatO4CRNd2IiMByukTrb2cJsUX1SofgohfIQPJzp4F/v7b9X7PHmDzZkrcW7MmpUCZMoXKdDVoQK/LlCGxA1CgxKBBlBolO5u+N3Ik0Ly5K6q2SROgWzfg/vuB11+ndQ88QKlUAkXQDhhAS1ERsHIl8NlnQJ8+9BB6441Az54UyFGmjOE/3bAFb/JkOifVqtF5a9oUuOoqEqlPPmn4+IzJsAUvOqhNqzAaeFvgvE6XKw+eebVonW2J4TQpHtOgogkFtSlaQdomCh5JoAXrwIWyYP/yC9CyJS0ABRC0bAk8/TS9Hz2aRN6QIUCbNsCBA8DXX3sGGcyYQcmIe/emCNMyZSi/nVs9bLz7Lom+rl1pufhiSq2il9RU4IYbSCAePAh88QUJraefpgTL3buTNc0Ahh9fk5Pp73j2WeDXX8mC17IlCV8m9mCBF2UkGrRkWeYBS4tS0SXbSIR5iyj3Shaqgz9XstCFux+h8lqU9npUsmCLtwdqwlwUhJyi7dTJ/wAnSRSB6y8KNy0NmDWLFi2ysig/Xrho25aWyZMpJ93Sper+cX4w3Ls98wxZJ+vWpUXhwgXghRdcopiJLbjvjCzsNG4ARXQVlwo8yVvg6UyTIkAlC5FFvHeQhUhtFaktoqF274lyvoSsZBEP1KsHDB9u+GuGp2gnTqSpWW/Onw+6Hi5jIvw7jA6qFglBOmXh8LLgeeO04GlF0UaxkkXA7QQW8bHiy8VTtJ6I/LAopAUvFvjyS+C++2i62Dua9sQJ4Oqrg9qtYYGnldblt9/IQsnEFjxFGx3UBidROmXhKBVdShStz2DhZsFTiHoevADO5LEgSjySCYsqFHiK1ge18yDKfcbXKAjee48CKQoKqCJGy5bkB6egRPUGge7H14oVSQxIEkXyuos8u52seoMHB9UGRgD4dxlZhIwuExWvKVbfKdoAaVKiUckC/qeiYmmKyn16VhShoOARRStY28zC2wdPlmVhhFWg3wWjwosvUhDHo4/S+48+Au69FygspOjdENDdu82cSSJg4ECais3MdH2WkgLUrk2pYJjYRJD+IW7xsEjInqkfuDP0wmuK1TfIQkmTIkAt2kAWPIF/WD5TtLI47fVwaYiBc2kGHudGEPHLD7JBsGMHRcgq3HYbRc326EH9lFplCZ3oFnj9+9P/depQSpQQ+0VGEHiKNrp4R77JkLkz9MY5RRsgijY5SX3wj2YtWh3iXFQR72FtEez3L3IKF7NRE+aiIeL9Lizly1MVjDp1XOs6daI0LN27A/v3B71rw71bx46UGmXHDqrU4XB4fn7VVUG3hTEBFnjRQc1p3Lme+0JPvASa5hSt1eo8d2bVotUjzkUV8f7uSbMHaI7G1EZtGlQU6yYHWQTBZZcB//d/wOWXe67v2NEl8oLEsMBbv54SPP/7r68okCTyx2NiB+4/o4OaQ7v7esYNxYKnGUWrJDoOYMGLRiULDXwGXwF/Z2rVVZT1Zg/QItfJNRsW5nHG8OHAunXqn3XqRAmP33orqF0b7t0GD6Zkz19+CeTlsUCIF7jvjCxagxMPWip4W/C8p2jtLh+8oNKkyHL4LHhaQRYiKjovPPzcZLEEqcgpXMxG6zyIJswZnXTsSIsWnTrREgSGBd7OnRTkUb9+UMdjBIOnaKODz9SF+OO/eXj74HlP0ZaoRNEamaJ19ysJ1QdPK8hCwCS0Wnj/DSK1V8RpSLNRy6npXC+QMGeCwG4HPv0U2LaNBucmTSiFintJNAMY7t3atqW6vSzw4gvuOyOLd1ko0aLfhKLUqqYIOZ/Bwq6SB89IkIX7+lCjaHUGWYiIWq45QIz2ci3awHhP0YoAp0kJgb//Bm68kYIqGjWiQXnHDqBGDZoyrVfP8C4NC7xHHwUef5xy8jVv7ts/Xnyx4TYwJsIWvOii5Bzj5K1+UCx49sAWPAVDFjz39ZGsRasWACIQPtYWgcZkrkWrjaYwF+g+E014xgRDh1L91x9/dFWNOHYM6NuXPvvyS8O7NNy73Xor/T9woGudJMFZ4YKDLGIT7jsji3dKCrZK+EF5aiwO4IOXFGSQRRgseHqcyUUPDvC2toh0T3I0pjZawlyE+4yDLEJg9WqKYnUvCZadDTz3HNChQ1C7NCzw9uwJ6jiMoPDvMDpo+aaI0CkLRwALnHuaFL8+eFpTtGG04PlD9OAA73tPJEuZextEEp4ioDUNKsL5YWEeAqmpwJkzvuvPnqVqEkFguHerVSuo4zCCwlO00cG78xV98DeVUquaZpCFzXeK1oNAU7SK8LNag37C0eNMLvogpzUYi3BPci1abXyEuUCWYhHaELN07w488AAwfz7lxgOAn36i1CU9egS1S10Cb+lS4Prrqd9dutT/tkG2gzEJFnjRwXvqQvTB31ScAi1AqbJAU7QlJS7fEXdCzIEH6HMmjxVh4jNFK1B7OWekL97CXKSHRQ6yCIFXXqGSYe3aebqZ9OgBvPxyULvU1cP16kVBFVWq0Gst2AcvdhGoT49LfDplAQdTYXB2btSZ+LPg+Z2iBSglineKgTDVoQX0WfBEGHjV8LZCCiUUuBatJloPiyKcH06TEgIVKgCffUbRtNu20aDctGlIKUt0CTz3tFHepcmY+ECAviEhcHbKAg2mwuH0oSsG4N+Cp6BqwQPoCdhb4IXDgmewFq2IaAVZiADXog2MtzAXCRHbFDPUrx+2PHSWsOyFiVl4ijY6+FhLBHrqFg6vKFifwcIp8KzqVjJ34aYWaBEGC54eZ/KYs+AJdE+qCWgR2iUCHP0cp9x2G0XMevPCC8Dttwe1SxZ4CQ4/aEUHkSPfhCNAFKx7FK2CXwueN2G04PlDdB88kQN/1GrRMoTIEfmcJiUEVq+mRMfedOsGrFkT1C5Z4DEA2IIXaUROSSEc3hY8rSna5CT1gcR9SjbSFjwdefBERWswFuGe5Fq02vgIc0EseCLcNzGNVjqU5GTg9OmgdskCL8HhKdrooBlkwYOWL14WPM0gC6vGFK3FQgsQcQue3ylawYVJLNyTPEXri0+QhSAPi2x1DZFmzYAlS3zXL15MwRZBEHwPx8QV3HdGFtVOmc+5Ot5RtBoWPEdyknYW/+RkoKgoYhY8Z1sCWPBkyKYPvIFwvydl2fz2eic5FlF4mkmsCXNGJ089RaXCdu0Crr6a1q1cCbz/PvDhh0HtMigL3q5dwJNPAnfeCRw+TOuWLwe2bAmqDYyJsAUvOnCaFAPotOC5T8X6DG7+kh2HaMFTq7Lgd3uBBl53NIMszJ7qc7cEcaJjTbwteGZj9HfBeNGjB/Dpp5QmZcgQ4PHHgf37gW++8Z+fzg+GBd7q1UDz5pRg+ZNPaNoYAH7/HRg/Pqg2MCbCAi+6cJoUHQT0wXPLg6cllP3Vow3RguctQLQQXZj4RGMKLhT4t0KIGv2s93fB+OHGG4EffgDOnQOOHgW+/Rbo2DHo3RkWeE88AUyaBKxY4ekP2Lkz8OOPQbeDYeIakSPfhCNQFG1pNnWHVpqUQPsIowXPH6JYxLQQteSVVhABQzjPj6Sx3iTMvm8SAoPn2LDA++MP4OabfddXrgwcO2Z0b4zZsAUvOoga+SYkpZY1SSMPnlTiEmialgJ/U7ThtODpCLIQFZFr0SrwFK0vokbkc5myIGjSBHjvPaC42P92O3cCDz0EPP+8od0bfoStUAHIzwfq1PFcv2kTUK2a0b0xZsMCLzqIGvkmJAFq0cLNgqegOUUbAQueO3rSpIh6jZ3tKv0TRLknNdO3CCQ8zUTUIAsuUxYEr74KjBkDPPww0LUr0KYNULUqkJYGnDgBbN0KrF1L/z/yCPnmGcBwD3fXXdSeDz8kceBw0JTxyJFAv35G98aIgqBjUNyg1SkzKjjFWakQ8zpVigVPs5IFEFkLns5krrHiZymcUOCAJL9o1hAW5PywBc8AV18N/PwzsG4dpUh57z3gn3+ACxeASpWAli1JWPXtS9Y1gxgWeJMnAwMGkLVOqYVrt5Pwe/JJw8dnBEGQviFu0bSWCD74m4KXOPMJsii14MGqUYsW8B9kEaoPnsFyTKIMvN74CClBhIKmtZt/Kx6IVkOYy5SFQPv2tIQZwz1ccjLw7rvAs88Cv/5KFryWLYEGDcLeNiYK8BRtdGGrhA5KhZcUoJKFI9mqPfj7C7IIkwUvEKJYxLTwEVKCDMxa54t/K4SmMDfb8splyoTDcJDFM88A588DdetSbdzevUncXbhAnzGxBf8Wo0MsOLQLgz//OSBwLVr3fUTSgqd3ilZQYSJqLVqtNCAMIWqJObPvG8YXwwJv4kRX7jt3zp+nz5jYgi140UHUyDchcU7Rllay8El0XFqLNilJe/CPggUvkPAQXZiImrpHKz8fCwhC1Ih8DrIQD8MCT5bVrT6//QZkZYWjSYxZsNaIHD6DliCdspA406SoRNHKstMHT07SMUUboVq0QOwHWYh+T7I7gzqiBllwmhTx0N3DVaxIwk6SgIYNPUWe3U5WvcGDI9FEJlpoiXcmdLQ6ZUYFfxa80nWAEkXroNcmVLLQa8Eze+ANhHBCgdOk+CVWhDljProF3syZJAAGDqSp2MxM12cpKUDt2kC7duFvIBNZJE/jCBMhNDtlPum+KBa8El8LnuQm2OSkJACuBKGyLLtEgZ4p2hArWegV6aIMvN5oBVmY3V7VIAKZfyveiPawyEEWEeLXX4Gnnwa++MLwV3X3cP370/916lA0b5APv4xg8G8xuogW+SYkfix4HgLPLcgCoHPpFIN6gizCUMnCH6JYxLTQisY0G1HPlyhoCnOzLa+cJiV4VqwAvv6a+qT77qMo1r/+otqwn38OdOkS1G4NP8LWqUOVLLSoWTOodjAmwRa86CBq5JuQ+PHBk9ynaJOTINlCCLII1YKnd4pWUBEvei1atfQtHlbaBEX0NCmMQd56C7j3XgpiOH4cmDcPmD6dqlbceisFODRrFtSuDfdwtWv7t/rY7dqfMWLDv8/IIWp5ISHxsuC5427Bg8XiM/g73+oJsgjVB09nkIWoiBqt6s9f1cNKm6CI+rDIQRZBMmMGMGUKWes++AC44w5at2kTUK9eSLs2LPA2bfJ8X1JC66ZPpyoXTOzCAi9y+HS+ksZ6xmd61XOK1hVBC7dC9ICXMPGXSy/aFjxBr7GoaVIUtCx4Ca7vOE1KvLFrF9CnD72+7TbAaiVBFaK4A4JIk3LJJZ5LmzbA/fcDL74IvPKK8QbMmUPTvmlpQOvWwPff+9++qAgYNw6oVQtITaVzsGCB8eMyLjgXXuTxN+3EeKFUsijxrWThSpHiK848hEkELXjOtgSyVCi/K8GttKIHWah9lsiImiZFgS14Bjl3Dihbll5bLCSGatQIy65DSwTlRsOGVDPXCEuWAMOGkcjr0AF4/XXg+uuBrVu1ffl69wYOHQLmzwfq1wcOH1bvwxn9sMCLPFrZ+XnAUkHxwbOrWPBKRZ+HwFMTUnrSpHAtWgBuf4cgVmWtWrTunzHiPSxykEUIfPWVKzWJwwGsXAn8+afnNj16GN6t4R7u9GnP97JMQRcTJhivRzt9OjBoEAWNAJSK5auvgNdeA6ZO9d1++XJg9Wpg925XUuXatf0fo6iIFoUzZ4y1MRFggRc9fPyd+KT74gyQUKlFq2LBU50K9RdkEaoPns50EKKL+JiqRStG04RAU5ibbXkVMU2KzUbi5N13gYICIC8PGDAAePJJspYBNPBNnAi88QZw4gTQti3w6qvARRe59lNUBIwcCbz/PtVlveYaskxVrx6edippShQefNDzvSQFFeBgeIq2QgVKeqwsWVlA06bAjz+SMNNLcTGwcSPQtavn+q5dgXXr1L+zdClNCU+bBlSrRlbDkSPpfGsxdSoJY2Vp2lR/GxMFkX6P8QoHWRjAacFTSZPitOC5UqSoDij+pmjDZMELhPA+eILek2q+XKK0TQRET5MiFM8/D8ydC8yeDWzbRuLhhReAWbNc20ybRtam2bNpGjI3l9KSuFuDhg0D/vc/YPFiYO1aquzQvXt4okodjsBLkMcx3MOtWuX53mIBKlem6VIj/eXRo9TmnBzP9Tk5JLTV2L2bzm1aGp3ro0cpkvj4cW0/vLFjgREjXO8PHGCR5w1b8CKPqJFvQuLlg+eOMm3rIfDUBn9/QRbhsuAFCrIQJCpVC1HrI6tFY4rSNhHQmgo1+z6LapDFmTOe04mpqbR48+OPQM+ewI030vvatckK98sv9F6Waepw3Djgllto3VtvkRB57z2ypJ06RT5h77wDXHstbfPf/5Kf3DffANddF6m/MmQMW/A6dvRcrrwSaNw4+LKO3g/f/splORz02bvvApddBtxwAwnvRYu0rXipqUD58q4lIyO4diYC3HdGDp/IN8EHf1PxjqJVyYPnMUWrNvhHwYKnd4pWVLT+DlHuSQ6yUCdW8hdGkvJNm3pOzan5dAHAFVeQP9uOHfT+t9/ISnTDDfR+zx6yKLlPJaamkrhRphI3bqQ+w32bqlUpN53WdKMRhgwhi6DCO+94vj950tVegwTVw+3YAXz3HQU4OByenz39tL59VKpE0cDe1rrDh32tegp5eTQ1614mrUkTEib79xv3AWQItuBFHq0gC0YFxYKnliZFZYpWQXeQRbiiaPVa8AT/YflM0ZotFFSs3aK0TQRiJX9hJDm9dSvKV6vmWqFmvQOAMWPIAte4MQkOu53yud15J32uCBC1qcR//3Vtk5JCPmne22hNNxrh9dfJT7BcOXr/8MMUdaq8Lyqi4IQgMCzw3nwTeOghEmi5uZ7WNknSL/BSUigtyooVwM03u9avWEEWVTU6dAA+/JDErfK379hB08Th8nVMRFjgRR7NTplPui/OShalPngB0qQYDrLgWrQAtKNVzW6v2hSkKG0TCVEfFqMSZJGRQVNygViyhKZT33uPgiY2byZ/uqpVPQMbjEwlGtlGD95jQBjHBMM93KRJJIDHjAn94CNGAPfcQ4ET7dpREMvevcDgwfT52LHkM/f22/T+rruAZ5+lqh4TJ5IP3qhRwMCBQHp66O1JVFjgRQ/RHNqFRLHglToYq1nwoNcHL5KVLGI90bFGkIXZqJ0vUdomAprC3GzLq4hpUkaNogoRd9xB75s3J8vc1Kkk8HJzab0SYavgPpWYm0tRoSdOeFrxDh8G2rePzt8RJIZ98E6cAG6/PTwH79OH/BufeQZo0QJYswZYtoySGAOUfmXvXtf25cqRhe/kSRKFd98N3HRTcAmWGRccRRt5RO2UhcRNeEk2e2ALnr8o2gha8AIhutVJ1HtSNchCcLEcTYSPfhZpQDl/3pUORcFqdfmW1alDAm7FCtfnxcWUj00Rb61bU5/kvk1+PuWpE1zgGe7hbr8d+Pprl5UtVIYMoUWNRYt81zVu7HmemdCRJLLecd8ZOUSNfBMSd/HmbYFzL1WmbONvitbMWrSCi5JYKnkluliOJqJG5At5bW66iaYca9akKVqlrurAgfS5JNGU7ZQp5MTfoAG9LlOGpgwBcvofNAh4/HEgO5tyw40cSdZAJao2VJ5+mo4JkMCcPNkVbHD+fNC7NSzw6tcHnnoKWL+e/j7vPnLo0KDbwpgET9FGHlEj34TEvVOx2b1q0ZYGWVg9LXiyLItXi1YkS4YKsVKL1h1R2mYWqtPXgohfIWvRzppFgmXIEJpSrVqVUp+4BwuMHk1pOIYMcSU6/vprz5QbM2ZQf9G7tyvR8aJFZA0MlauuArZvd71v355ywnlvEwSGe7g33qCp0tWraXFHkljgxTIJ3ndGFK0gC0YFLwueZ5qUUoGXLH4tWlEsYoGIiSCLGDmX0US46OcopknRTUYG+YHNnKm9jSRRFOuECdrbpKWRWHRPkBwuvvsu/PssxbDA27MnEs1gzIQteJGHa9EawGKhxeEggadqwfOcopWhYcEzsRatKD5tari3STihoJYmRbHSCnguo4n7PS6aMFcQyoIXixw9SoNydnbIuzIcZMHEHyzwoodoDu2iIrtVs1BNdJzsG2QhWi1a5/aCDLzu+BMKZuPPgpfo+BPmZiNkkEWscPIk5b+rVImid6tUodePPEKfBYmuR9gRIyg9SdmynmW/1Jg+Pei2MCbBv8fI4tdaIuDgLwRJSUBxMSS7lg9egDQpXIvWLyLfk5p+ZrL5bTMbvxY8sy2vIqZJiQWOH6c8cQcOUGoQpXrDtm3k57dyJVXM8E60rANdPdymTa4+cdMm7e1YKMQmbMGLLGqdsvMzPunqKMmOverRKhY8jzx4ah0P16L1i1qbhBMKnCbFB39/v9n3WaJfm6B55hmq/LBrl29FjWeeoRJpzzxDgR4G0SXwVq1Sf83EByzwIovIkW/CokzR2u3qU7R6K1lwLdqAcC3a2EFk8StkkEUs8OmnVK5MrUZrbi4wbRrlpQtC4LEPHuOEBV5k8LDgCebQLixuFjzVKVoVCx7XotWPyPVetYIs3D9LVETOEShkmpRYID+fcvRp0axZ0DVvDT/CFhZSpPCqVZRWRkkIrfDrr0G1gzERtuBFD9Ec2oXFvVyZOyoWPAXRatGK4tOmhsj1XjlNSmBEFOYK3LcZpFIl4J9/gOrV1T/fsyfoiFrDPdzAgVRJ4rbbgMsuY7+7eIAFXmTxay3hAUud0ihZi48PnooFT9BatM7tBfxhsQUvNvEnzM2GgyyCpFs3YNw4ElYpKZ6fFRVRouZu3YLatWGB9+WXVC+2Q4egjscIiCD9Q9zi11qS4AOWFnJSEiS4BVWU4hJ4IaRJ4Vq0foMszEa1bSwaAIj9sMhpUoJk4kSgTRsqk/bww1SPFQC2bgXmzCGR9847Qe3acA9XrZpnBQ8m9mELXmQROfJNWEqtaxa7l8CzawdZeMC1aP2i6sslmlAQcPrYbPz9/WbfZ4l+bYKmenXgxx+pVNrYsa6BWJKALl2A2bOBGjWC2rVhgffSS8CYMcDcuUCtWkEdkxEMFniRReTIN2EprTXrY8ErCUOQBdei9StSzb4nRW6b2YgsfjnIIgTq1AH+7/+oFu7OnbSufn0gKyuk3Rru4dq0oUCLunWBMmV8H4KPHw+pPYyJJHjfGTH8dcqMBooPnt0zyMKfBS9alSycx43hIAsFEYWCgojWRbMR+WGR06SEgYoVKbghTBgWeHfeSQmXp0yhtC18LWMftuBFB7VOGaCOmTtFT5ylyrwscM7Ex24WPOd39FjwZNm1jmvRiikUOMgiILEizBkdDByob7sFCwzv2nAPt24dTRdfconhYzGCwgIvsgSKfJMhc6foTSALnlVlilaPBc/dpy9KtWiV74gk4mMtGpMteIQ/YW42HGQRJIsWkb9by5ZhH4QNC7zGjYELF8LaBsZk+PcYWQJ1yrIsQ5A+WhicU7BeaVKcefCSVaZo9dSidRd8IQZZBMLjGgsm4lWrqwhiVfZX+SXRETkin9OkBMngwcDixcDu3WTN69s3ZN87BcOVLJ57Dnj8ceC774Bjx4DTpz0XJnZhC15kCCQIEt0qoUqpQLNopUlRseB5oFWL1l3wcZCF6jSo++dmILKfmdnoEeZmkejXJmjmzKFqFmPGAJ9/ThGzvXsDX30V8qBsuIdT8u1dc43nelkmS5BXVgMmBuAp2sgSKMiCO0ZfnD54du9Ex34seHpq0YbRgmekFq1oVtpAItXM9vprW6I/DAW698y0FHOQRQikplKAw513Av/+S9O2Q4ZQf7V1K1CuXFC7NSzwVq0K6jhMDMA6IzJodXySJLG400LJg2fz8sFTseAp45muIAv391bfQA0jGLHgiSpMNN0GBGgvB1n4outhUUBhzhhAkmiRZd9asAYxLPA6dgzpeIyAsAUvsmh1fBIkyKX/GC9KxZdPFK1KJQsFXUEW7jnwgrQ0BBtkIRIBA3/MnOrjIIuAiBhkocAWvCAoKgI++YQiZdeuBbp3pwTH3boBFsOedE6Cc0Jh4goWeNFBzYIHWbzBXwSUKVjfUmV+8uDpCbIIMUWK+3H0DKyKlVY0YaIlUkWwKqu2TfL8LFHRE5FvFhxkESRDhlCQRc2awL330uvs7LDsmgUew1G0ESZQxyfa4C8CmnnwbL558FR98NyDLBQHYeW9++fBtM2AyHBaaQUTJlr3nAhWZa5Fq00gYS5CkAVb8Awydy6Juzp1gNWraVHjk08M75oFHsMWvAij1elyZKAfkgxY8NQGFHcLncPh8rcLpwVPx0CmWGlFQ1eQhUmIXCfXbESOyE/0axM0/fpFzMrCAo9hgRdh/AVZuH/OuFBqzfoKPJVatGqDv7uFzmZzCbwwWvB0TdEKKkz83pOyGEKBgyx8CejPK4gwF+1+F5pFiyK26+C995i4I8H7zojhr1Nm1JFLBZjknXfJacHTWckC8Ay0MMOC5902gdC6J0VoL6dJ8UXkh0VOkyIeugXejh2eAmDtWqBXL+Cii4BrrwU++ywCrWOiAlvwIkvATplPvC+lAs7iVcnCWapMLYrWnwVPIQwWPGdbDAh00YSJP18uwGShIHCdXFEQ+WFRpLYkOroFXpMmwJEj9Pq77yhdisMB3H03UKECcMstlHiZiT1Y4EUHTWuJYIO/CLgSHXtN0Zb4maJ1v4Hdc9yF24JnwJlcVGGiFfgjwuDstxxXgv9WAgpzEaZo2YInDLp7Off7ZtIkKp/26quudWPHAlOmANddF87mMdGABV5kCdTxiTb4i4BWLVo1C57q4G+x0OJwhN2CZ0RkiCpMNAN/BBIK7oggPEUgkDAXYoqWr5UwBOWDt3UrBX64c889wJYt4WgSE234gSuyaHbKgg7+IiBbNYIsSnwTHWsOKGrVLMJpwTMQZCEamm4DIgkFDrLwQeSHRbbgiYchgXfmDHD6NJCeTqXT3ElJAS5cCGfTmGjBFrzIwmlSgiBZIw+eUpvWGiDIAlCvZhFGC14sB1lwmpTYRDN/ockPi6Ld3zHJ1KlUycKbBQuA558PapeGBF7DhkDFisCePcDGjZ6fbdkCVKsWVBsYk2GBF1kCBVkwvjgteN4+eEoUbXKAShaAUBY8UYWJiEEWCmq/j0QXEoEi8kU4P6JarYXn9deBxo191190ESVDDgLdvdyqVZ7v8/I83//zD3D//UG1gREEAfqGuCRgpyzAYCoazlJl3j54Sh489yAK5TtRsuA52xLlWrR2ux0l3rV1g6SkuASwAfZiO4osRYANKCosglwiO18XyoVhOZYRZJmOD1Abiu3F1M4SO/0v2VFYGP12iYKt2OY8H0WFbtfNRuetuKjYlOvmkB2u61ZUhCKbq20WuzFPsJSUFFhCqL8asxQU+AorAKhcGcjPD2qXugVex47+P3/ssaCOzwgAW/Cig4iRb6LiSnTsXUtWxYKnZXVSq0cbogXP/VrprUWr2jaDxywoKMDJkyeD3oc3NocNSXISzp45i/PSeSQ5knDw7EHYHXYkIQmHzx7GUelo2I6nFxkykux0bf499y9kWUaSIwmnz5xGkpwEG2zYc3JP1NslCsp1O3PmDM5J55zXzeFwIAlJKDhbAIsUfXGkXCeArptDdjjbZrQ9FosFderUQUpKSiSaKi41agA//EAly9z54QegatWgdhmRShbupR8Z8WGBF1m4Fq1xAtWidbfgaU5PudejVQjRgud+raKVJkURd1WqVEGZMmXCMrVfbC+GzW5DkjUJVsmKIlsRUpNSYbPbYJftSElKQZIl+oWOZFnGhRJy5k5PTodDdqDIVoRkazJK7CWwSBakJadFvV2iUGwrJpHndd1K7CVwyA4hrluZlDKwO+zOtlktvtZ2LRwOBw4ePIj8/HzUrFkzsdxY7rsPGDaM+qirr6Z1K1cCo0cDjz8e1C513QlNmgBPPQXcdhsFU2ixcycwfTpQqxbwxBNBtYcxgUT6DZmBZu4qgfxmRMMp4DRr0foGWfgQYQueHkIdoOx2u1PcZWdnh7Qvdyw2C0ocJUi2JsMqWQEbkJaUhhJHCewOO1KTUk0TCg6rAwCQlpzmnPpLsabAYrckvMCTbBKsDqvPdbPYLXDIDtOum0N2uK5bShrsDruzbUYEHgBUrlwZBw8ehM1mQ3IYXClihtGjgePHgSFDgOJiWpeWBowZQ3nogkDXnfDqq3SMhx8GunYF2rQhi2FaGnDiBKVNWbuW/n/kEWofEzuwBS+yiBr5JjJOHzy73ePsuGrRBhlkEU4LXhSCLBSfuzJlygT1fS1i4Z5T6uIygYmnwAZlatZutyeWwJMkipZ96ilg2zZKV9KggW/KEgPoEnhXXw38/DOwbh2wZAnw3nsUVHHhAlCpEtCyJeXF69uXqlowsQULvMjCtWiN44yiLSnxEnh+Eh3rCbIIQxSt93H1bBOqlTbqU1Um9QWxIDxFwKfvkCCEGA5Hn5ZQ07JqlCsHXHppWHZlqJdr354WJj5hgRcZuBatcZwWPO8pWrtvkIXzO9Gw4AWZzFVU4SKqX6io7RIes09Pgmszw9xyC7BoEVC+PL32xyefGN59AsYiM96wBS86cJoU/bh88LyCLJS0KXqCLCJgwTNajon9LOObCRMmoEWLFmHf73fffQdJkgxFTj9434O49ZZbw94WJoJkZroG4MxM/0sQsMBjWOBFGJELhIuKqgVPlt1q0apUstCTJiVMFjy9xJqfZSTcBtatWwer1Ypu3bqpfv7xxx+jbdu2yMzMRGb5TLRp0QZPjPGM0lPaddMNN8FqtWL9+vU++xkwYAAkSYIkSUhOTkbdunUxcuRInDt3TrNtu3fvxp133omqVasiLS0N1atXR8+ePbFjx44Q/mLzMO0+i43bWzwWLgQyMmjwnTCBAh4WLlRfgoAFHsNRtBGG06QYx2nBc7O+uYs91SALrTQp4YyiNVCmzG/bEogFCxbg0Ucfxdq1a7F3716Pz7755hvccccduO2227Bhwwb8/PPPGD9xPCVidkcC9u3dhw3rN+CRRx7B/PnzVY/VrVs35OfnY/fu3Zg0aRLmzJmDkSNHqm5bXFyMLl264PTp0/jkk0+wfft2LFmyBM2aNcOpU6fC8reHG1H7ClHbFTPIMgVUHDgQ1t2ywGPYghdhuBatcRzJvqXK3F8bSpMSzjx4BsqU+W2byURrQD537hw++OADPPTQQ+jevTsWLVrk8fkXX3yBK664AqNGjUKjRo3QsGFD3NTzJrw08yWffb3z9jvodkM3PPTQQ1iyZImqZS41NRW5ubmoUaMG7rrrLtx999349NNPVdu2detW7N69G3PmzMHll1+OWrVqoUOHDpg8eTIudXNy379/P+644w5kZWWhbNmyaNOmDX766SfPtr3zDmrXro3MzEzccccdOHPmjPMzWZYxbdo01K1bF+np6bjkkkvw0UcfeXx/2bJlaNiwIdLT09G5c2f8888/Hp+rTQW//PLLaNqwKQD1+1HPcRlBsFhI4B07Ft7dhnVvTEziPgax1gg/XIvWOO5RtAoBLXhRqkULBGHBC7OgcjjMWYyyZMkSNGrUCI0aNULfvn2xcOFCjwea3NxcbNmyBX/++ScA7fMkyzL++/Z/ceedd6Jx48Zo2LAhPvjgg4DHT09P1yzvVrlyZVgsFnz00Uewe9U8Vjh79iw6duyIgwcPYunSpfjtt98wevRoONxOxq5du/Dpp5/iiy++wBdffIHVq1fjueeec37+5JNPYuHChXjttdewZcsWDB8+HH379sXq1asBAPv27cMtt9yCG264AZs3b8Z9992HJwIkktXzgBHouJGAMwOEwLRpwKhRQOlvIRwE1cs5HMDffwOHD/v+6K+6KhzNYsyCq5CEH65FaxyngHMTde5VLciCR+8NpUkJUx48oxa8cFppHQ5g06bQ9lFkk+CQLUi2SJAkoNhuQYoVsDsk2GULkixAskp+2pYtydigl/nz56Nv374AaPr07NmzWLlyJa699loAwKOPPorvv/8ezZs3R61atdC2bVt0uqYT7rzrTpRJduX+W/nNSpw/fx7XdL0GANC3b1/Mnz8f9957r+axN2zYgPfeew/XXHON6ufVqlXDK6+8gtGjR2PixIlo06YNOnfujLvvvht169YFALz33ns4cuQIfv75Z2RlZQEA6tev77Efh8OBRYsWISMjAwBwzz33YOXKlZg8eTLOnTuH6dOn49tvv0W7du0AAHXr1sXatWvx+uuvo2PHjnjttddQt25dzJgxA5IkoVGjRvjjjz/w/PPPa5/YALefnuMmDAcOUCLf//s/yu3WsCEwfz7QujV9LsvAxInAG29QYt+2bckX7qKLXPsoKgJGjgTef5/2cc01wJw5QPXq4Wtn377A+fPAJZdQRYn0dM/Pjx83vEvDAm/9euCuu4B///W19kgSoPEgxAgMW/CiAwdZ6MdVi1bdggerFbDbvL8GWZZd5zmClSziJU1KJA0u27dvx4YNG/BJaXqHpKQk9OnTBwsWLHAKvLJly+LLL7/Erl27sGrVKvz444/4z5j/4LXZr2H9+vVITaMkrwsXLMStt92KpNLrduedd2LUqFHYvn07GjVq5DzmF198gXLlysFms6GkpAQ9e/bErFmzNNv48MMPo1+/fli1ahV++uknfPjhh5gyZQqWLl2KLl26YPPmzWjZsqVT3KlRu3Ztp7gDgLy8PBw+fBgATQMXFhaiS5cuHt8pLi5Gy5YtAQDbtm3D5Zdf7nFPKaIsWPQcNyE4cQLo0AHo3JkEXpUqwK5dngl7p02jElyLFpH4mzQJ6NIF2L6dAiAAKiH2+efA4sVAdjaVDuveHdi40SOiPyRmzgzPftww3MsNHkyVLL78EsjLY2tPPMDXMLJoWX3YgqeNPwuenGT1uGndz6sM2fU+wpUs9BAJP0uLhSxpoVBok2F3OJCaRBqv0OZAWhJgdwAlDgeSrTJSVMYto9Y7m82GatWqOdfJsozk5GScOHECFStWdK6vV68e6tWrh3sH3osRo0egRbMWWLJkCfr174fjx4/js88+Q0lJCea9Mc/5HbvdjgULFnhYujp37ozXXnsNycnJqFq1qq5KCBkZGejRowd69OiBSZMm4brrrsOkSZPQpUsXpHtbUVTwPoYkSc4pXOX/L7/80uM8AOQvqJyTQFgsFtrObVOtqWe9x41pzpwBTp92vU9NVa/48PzzQI0anlGotWu7XssyCatx41x56N56C8jJoYoODz4InDpFFr933gFKH0zw3//Sfr/5BrjuuvD8Tf37h2c/bhgWeDt3Ah99BHhZqZkYhi14kSWQ1YcteL44rKVKQsUHT/ayvhkKsgiXBc/oFG2YRbwRoaX6fQmQLbQfqXR/FgsgS+SYrbwPFpvNhrfffhsvvfQSunbt6vHZrbfeinfffRePPPKI6ndr1a6FMmXKOIMolry/BNWrV8d7H74HAEhPSockSVi5ciWmTp2KyZMnOy17ZcuW9ZlCNYIkSWjcuDHWrVsHALj44osxb948HD9+3K8VT4umTZsiNTUVe/fu1ZwWbdq0qU8giHcamMqVK6OgoIBq85by2+bfQjpuOIn2Q2r5pk09V4wfT2lGvFm6lATY7bcDq1cD1apRLdX776fP9+wBCgqoBqtCairQsSOV7nrwQbLSlZR4blO1KtCsGW0TLoEH0BTop59SqTJJApo2BXr0CNpKaLiXa9uW/O9Y4MUXkkTijrVG+OFatMZRRJz7tKwrB56XwHO34Mmya9oxghY8o0EWohHpe+6LL77AiRMnMGjQIGR6JWm97bbbMH/+fDzyyCOYMGECzp8/jxtuuAG1atXCsePH8PIrL6OkpMQ5vfj2ordxy6234KJSn6gyyWUgSRJq1aqFMWPG4Msvv0TPnj0Nt3Hz5s0YP3487rnnHjRt2hQpKSlYvXo1FixYgDFjxgCgqeApU6agV69emDp1KvLy8rBp0yZUrVpV1zRqRkYGRo4cieHDh8PhcOCKK67A6dOnsW7dOpQrVw79+/fH4MGD8dJLL2HEiBF48MEHsXHjRp9o406dOuHIkSOY/uJ09Ly5J1atXIXly5cjozxNIXrfZ3qOG8uc3roV5d0tk1pWyd27gddeA0aMAP7zH2DDBmDoUNq+Xz8SdwBZ7NzJySE/NIC2SUkB3CzOzm2U74eDv/8GbriBfAYbNaLBeMcOshR++SVQr57hXRp+Rnv0UZp+XrSIhO3vv3suTGzDAi/8BAyy4JPugyOptGty98ErcZuidcNdbHkIlwjWojUzyCIqhNjc+fPn49prr/URdwBZ8DZv3oxff/0VHTt2xO7du9GvXz80btwY3W/sjkMFh/D5ss/RqFEjbNy4EX/8/gduUSnjlJGRga5du2rmxAtE9erVUbt2bUycOBFt27ZFq1at8PLLL2PixIkYN24cACp8//XXX6NKlSq44YYb0Lx5czz33HOwGrCoPPvss3j66acxdepUNGnSBNdddx0+//xz1KlTBwBQs2ZNfPzxx/j8889xySWXYO7cuZgyZYrHPpo0aYI5c+bg9bmvo92l7fDLhl8w4vERrg1UbsdAx40EUXugycig8l7KoiXwHA6gVStgyhTya3jwQbLevfaa53beD2x6og3DHZE4dCiJuH37gF9/pUiqvXuBOnXosyAw3MvdWloJZeBA1zrF+sNBFrELW/AiB6dJMY6rkoXL+qZlwfP4nqwi8EysRSu6n2Wkkm9//vnnmp+1atXK4zp17tzZ+drmsKHIVgSrRAKqdevWOFt0FmlJaSi0Ffrsa+nSpc7X3lavQFSqVAkvv/xywO1q1aqlmT9uwoQJmOA1NThs2DAMGzbM+V6SJAwdOhRD/QzS3bt3R/fu3T3WeUcIDx48GP0H9YdDdiAtKQ0AMHzUcOfnr897HckW132t57hhR7QuLS+PpjndadIE+Phjep2bS/8XFNC2CocPu6x6ublAcTEFbLhb8Q4fBtq3D19bV6+mKFZ3V4DsbOC55yhQJAgMW/D27PFddu92/c/EJpzsOPJwkIV+ZItSycJN4GlY8ACN6W5FxJlYi9b5Pf5hGUM0ocDEJh06UDSsOzt2ALVq0es6dUjArVjh+ry4mMSWIt5at6a+xH2b/HzKVxdOgZeaSsEj3pw9S1PEQWC4l1POCxNfsDEpcnAtWuMolSygZsFTmR6TIEGGHDULnl5izc9SVJ9BdzwipRkPuBatF8OHkwibMgXo3Zt88N54gxaABr5hw+jzBg1omTIFKFOG8sEBQGYmMGgQ+aZlZ5OFbeRIoHlzV1RtOOjeHXjgAYrYvewyWvfTT5S6pEePoHYZ1GPsrl0UWawEejRpAjz2WFA+gIwgsAUvcnAtWuP4q0WrTN+6I0mS7yDDtWhjDz+nSRHxiYxmwJbJglfY63LppcD//geMHQs88wxZ7GbOBO6+27XN6NGUvHjIEFei46+/duXAA4AZM6jP6N3bleh40aLw5cADgFdeoVQp7dp59l09egSdI89wL/fVV3S8Fi3I+inLFCl80UWUB9ArryITI7DAixxci9Y4DiXRsVuNLKc/noYFD9ARZMG1aAGIOyCL2i4mhunenRYtJIlSrKilWVFISwNmzaIlUlSoAHz2GUXTbttGg3HTpiGlLDEs8J54gqyebqX2nOvHjGGBF+uw1gg/gYIseFDzxZkHD3Ba3QJa8OAlluO4Fm1CIkHcqcAoI6o102xLYkzzzDM09Vu/vqeou3ABeOEF4OmnDe/ScJDFtm00He3NwIHA1q2Gj485c8hqmpZGvozff6/vez/8QH10ixbGj8n4wha8yBEoTQqjgrsAcwq80iALP9MiEbfgCVCLNpyI6jbg9/yKeSqjC3cd8cfEiRRQ4c358/RZEBgWeJUrA5s3+67fvJnKvBlhyRLybxw3jlK+XHklcP31lPrFH6dOUY5CjRrSTBCwwIscAS14fNJ9cLhHypaKMq1KFoDGdDfXog1MDAoFYc8lw4SCVl69337zTJ1iAMO93P33U6DH7t0UnCJJwNq1VPLt8ceN7Wv6dLIG3ncfvZ85k3z8XnsNmDpV+3sPPkgBLlYrVfVgQkdQV6G4wntahafvtFGdovWTB89vmpQ4q0UbSdiqLDgBbiPuS2KQihVpAJYkoGFDz8HYbier3uDBQe3asMB76ikKLnnpJQpMAags24QJxpItFxdTJYwnnvBc37UrBW1osXAhRfH+97/ApEmBj1NURIuCWpoZhi14kcTd6qM20MfK4B9NZKsFsiRBkmWXBc9fHjw1YRLHtWhDRqs5Aus7Uf3OoglH0cYhM2fSwDtwIE3Fuld/SUkBatemyNogMDxFK0kUZLF/P02VnjpFrx97zJgV6OhREqdqJeC0yrvt3EmC8N139ffPU6fS+VIW76TWDMECL3JwLVrjyLLsFHLK1KwuC16gIAuuRQtA3HvOaLsmTJiAFiE6Yv/zzz+QJAmb1XyPwsSiRYtQoUKFiO0fALp16YaRI0aGfb/BnON6devh1VdeDXtb4pL+/YEBA4BVqyhVS//+ruXOO4MWd0AQAs+djAzPVDHBoLcEnN1O07ITJ5IVUy9jx7qE6KlTwQWCJBIs8MIP16I1jgzZJeS8gyz8WPC4Fm2YCFNz9+3bh0GDBqFq1apISUlBrVq18Nhjj+HYsWOG91UmpQw+/8yzBNrIkSOxcuXKkNpYo0YN5Ofno1mzZiHtJ1RWrVqFzp07IysrC2XKlEGDBg3Qv39/2JT73u0e8rn/BHmOEPWBJibIyKAoVoXPPgN69QL+8x+a8gwCXQKvVSvK/wdQvd5WrbQXvVSqRD503tY69xJw7pw5A/zyC/DII9Q3JyVRVPFvv9Hrb79VP05qqmdN4lAFabzCFrzIwbVojSPLMpDkmexYseT5Sy7KtWiNEcko2t27d6NNmzbYsWMH3n//ffz999+YO3cuVq5ciXbt2uH48eOG2+VNuXLlkJ2dHVI7rVYrcnNzkRSi6A+FLVu24Prrr8ell16KNWvW4I8//sCsWbOQnJwMR2keyJiAu7TgefBBKqMGUJBDnz5UUePDDykZcxDoEng9e5JQUl77W/SSkkJpUdzLuwH0Xq28W/nywB9/ULSusgweDDRqRK/bttV/bMYXFniRI6AFT9DB32w0LXj+8uBxLdqARKstDz/8MFJSUvD111+jY8eOqFmzJq6//np88803OHDgAMaNG+fctnbt2nj22WfRr28/5GTloHbN2pjlllS2Xl0qk3Rn7zuRZE1C7dq1AfhOHw4YMAC9evXClClTkJOTgwoVKmDixImw2WwYNWoUsrKyUL16dSxYsMD5He8p2gEDBkCSJJ/lu+++AwAUFxdj9OjRqFatGsqWLYu2bds6P1NYtGgRatasiTJlyuDmm28OaLFcsWIF8vLyMG3aNDRr1gz16tVDt27dMG/ePKS41SH9cd2PuO7a61C2bFlUyq6Enjf2xAnF+gLA4XBg9OjRyMrKQm5uLiZ4Je89deoUHnjgAVSpUgXly5fH1Vdfjd9++81jm+eeew45OTnIyMjAoEGDUFhY6PF5p06dMGzYMI91t91yGx6870HNv0/PcROeHTtced8+/BDo2BF47z2qmPHxx0HtUpfAGz+ehCRAwRTjx2svRhgxApg3D1iwgCyTw4dTihQlYGTsWEqHAgAWC9CsmedSpQrlz2vWDChb1tixGU9Y4EUeTpOiD+V8yF5TrM40Kf4qWSRILVqH7IjIIsuy38/1cvz4cXz11VcYMmQI0tPTPT7Lzc3F3XffjSVLlniczxdeeAHNmzfH2vVrMWrMKAwfPhwrSi0A639aDwCY++Zc7DuwDz///LPmsb/99lscPHgQa9aswfTp0zFhwgR0794dFStWxE8//YTBgwdj8ODB2Ldvn+r3X375ZeTn5zuXxx57DFWqVEHjxo0BAPfeey9++OEHLF68GL///jtuv/12dOvWDTt37gQA/PTTTxg4cCCGDBmCzZs3o3PnzpgUICIwNzcX+fn5WLNmjeY2mzdvRvdu3dGkSROsW7cOq9esxvU3Xg97qW8qALz7zrsoW7YsfvrpJ0ybNg3PPPOM8xzKsowbb7wRBQUFWLZsGTZu3IhWrVrhmmuucVpTP/jgA4wfPx6TJ0/GL7/8gry8PMyZM8dv2wOh57gMaPBVrLXffAPccAO9rlGDghaCwPBjbN26wM8/U81dd06epCna3bv176tPH+DYMZpqzc8nobZsGVCrFn2enx84Jx4THni2MDL49ZtRtmELngfK+XAKPLtXmhQ/FjwP4rQWrUN2YFP+pqC/L8syCm1klUlLSoMDDhTbipGSRJaiYlsxJElCWlKaz3db5rWERQpsF9i5cydkWUaTJk1UP2/SpAlOnDiBI0eOoEppAtUOHTpg1OhRKHGUoGmTpvjpx5/w8syXcWXnK1G5cmUAQGZmJk2nWrSvX1ZWFl555RVYLBY0atQI06ZNw/nz5/Gf//wHADB27Fg899xz+OGHH3DHHXf4fD8zMxOZpZGMn3zyCebOnYtvvvkGubm52LVrF95//33s378fVatWBUB+gMuXL8fChQsxZcoUvPzyy7juuuvwRGmKiIYNG2LdunVYvny5Zptvv/12fPXVV+jYsSNyc3Nx+eWX45prrkG/fv1Qvnx5ACSAW7VuhZmzZqJsSlnYHXbUa1TP4zo1a94M40stLQ0aNMDs2bOxcuVKdOnSBatWrcIff/yBw4cPI7V0Su7FF1/Ep59+io8++ggPPPAAZs6ciYEDB+K+0txlkyZNwjfffONjxTOCnuMyANq0odQg114LrF5N+eIAYM8edb81HRgOsvjnHwp48KaoiKJpjTJkCO2zqIjSplx1leuzRYsAL8u3BxMmqCddZozDFrzI4JH3ztuCx0EWqrgseKVRtKXpUZxpUrgWbcyj5svYrl07j+vXrl07/PXXX4b3fdFFF8FicQ1tOTk5aN68ufO91WpFdnY2Dh8+7Hc/mzZtQr9+/fDqq6/iiiuuAAD8+uuvkGUZDRs2RLly5ZzL6tWrsWvXLgDAtm3b0M4r8tH7vTdWqxULFy7E/v37MW3aNFStWhWTJ0/GRRddhPz8fABkwevYuaPf/TRr7hkokpeX5/w7N27ciLNnzyI7O9uj7Xv27Amp7YHQc1wGlC7l118p0GDcOFe5so8+Uvdb04Hux9ilS12vv/rKM1WL3Q6sXEklx5jYhrVGePEn3jhNin98fPDCkSYlDmrRWiQLWua1DPr7sizjfMl5AHBaggpthU5LUKGtEBbJgvTkdJ/v6rHeAUD9+vUhSRK2bt2KXr16+Xz+119/oWLFiqhUqZLf/QQjkJO9xLskSarr/AUvFBQUoEePHhg0aBAGudXmdDgcsFqt2LhxI6xeDxrlypUDENoDW7Vq1XDPPffgnnvuwaRJk9CwYUPMnTsXEydO9JnqVsPf3+lwOJCXl+fjLwjAUAoXi8Xi8zeWKG4UKg8+4Tpu3HPxxRRo4M0LL/gNLPOH7l5O+Y1KEqVncSc5mXLxvfRSUG1gBIAteJFBrXKF1nuGcE3RekXRlmgHWXh/F0Bc16LVK7TUcMDh/L5FskCWZFgki8c6SZJCOkZ2dja6dOmCOXPmYPjw4R7ipKCgAO+++y769evnIeDWr1/vfC1Bwvr169GoUSPnuuTkZNgd9ojXoi0sLETPnj3RuHFjTJ8+3eOzli1bwm634/Dhw7jyyitVv9+0aVOPvwWAz3s9VKxYEXl5eTh37hwAoPnFzbF61Wo89fRThvcFAK1atUJBQQGSklxBKt40adIE69evRz/F+V2l7ZUrV3ZaFQHAbrdjy5YtuKrjVVBDz3EZP6T5ukroRfcv2OGgpWZNSmWivHc4aHp1+3age/eg28GYDAu8yMNBFvpwTtEma1jwQgmy4Fq0TiL9gDF79mwUFRXhuuuuw5o1a7Bv3z4sX74cXbp0QbVq1TB58mSP7X/44Qe89OJL2LljJ16b8xo+/PBDPDr0UefntWrXwnfffof8gnyPyNFw8+CDD2Lfvn145ZVXcOTIERQUFKCgoADFxcVo2LAh7r77bvTr1w+ffPIJ9uzZg59//hnPP/88li1bBgAYOnQoli9fjmnTpmHHjh2YPXu2X/87AHj99dfx0EMP4euvv8auXbuwZcsWjBkzBlu2bMFNN90EAHjiiSew8ZeNGDZ0GH7//Xf89ddfePP1N3FUpwP+tddei3bt2qFXr1746quv8M8//2DdunV48skn8csvvwAAHnvsMSxYsAALFizAjh07MH78eGzZssVjP1dffTW+/PJLfPnll/jrr78wZMgQnDp5KqTjJixZWa4AiooV6b3WEgSGe7k9e4I6DiM4LPAigz9BwGlS1HGeD6u7BS/JFUVrNE0K16LVTThFX4MGDfDLL79gwoQJ6NOnD44dO4bc3Fz06tUL48ePR5bXoPX4449j06+bMPnZycjIyMBLL72E6667zhkQ8ty05zBm5BgsWrAI1apVwz///BO2trqzevVq5Ofno6lX2aNVq1ahU6dOWLhwISZNmoTHH38cBw4cQHZ2Ntq1a4cbSqMeL7/8csybNw/jx4/HhAkTcO211+LJJ5/Es88+q3nMyy67DGvXrsXgwYNx8OBBlCtXDhdddBE+/fRTdOxIfncNGzbEZ19+holPT8Rll12G9PR0tLm0De65+x7nfvzdn5IkYdmyZRg3bhwGDhyII0eOIDc3F1dddRVySp34+/Tpg127dmHMmDEoLCzErbfeioceeghfffWVcz8DBw7Eb7/9hn79+iEpKQnDhw9Hx07avoF6jpuwzJjhSs47c2bYdy/JBnueoUPJ98+77uzs2cDff0ekjWFl//79qFGjBvbt24fq1auHdd/nzwNr1tD1CsGqGjUKCymB9FVXAUeO0INEtWpAbq7ZLYsfiu3F+OPQH5AkCa3yWuF8yXlsO7INTSo3gVWy4s/Df4bsUxVvFNmK8OfhP9H4pgEo++ufKPrkQ6xqXg7NXnoH1ee+h0MP3I3944ej0FaIM8VncFWtq3Do7CEcv3AcNTJroEpZisrE6tVAp05A48aUh0mWKd8SABw6RHmWDLLnxB4cv3Ac1ctXR065HJwvOY81/65BRkqGhw+b0i6LZMGWw1tgtVjRIreF4eMVFhZiz549qFOnDtLC1Kk4ZAculFyAJEkok1zGwwdPkiSPz6JF7dq1MWzYMDz0yEOwOWxIsaYg2Zrs0Tabw+bxWaLhcDhwwaZx3SB5fBZtCm2FsDvsqtfNajHmP+bvno/k+B2PGHay+PhjoEMH3/Xt21OwBxObsAUvMviLuuQgC3WcPnhWjTx4aqXK9ARZuFvyErkWrcC3G/8WtOFzE6ecPq1vCQLDU7THjnlG0CqULx90Lj5GAFjgRQZ/giDWpu+ihfN8ePvg2fxE0epJk+Iu8EL1weNatIxICPIcIeQDjehUqOA/Ea0s0+dq+ekCYLiXq18fWL6cUrW483//R0mQmdgm1sYh0dFjwWPU8a1kURpFq2LBc37HX5CFezRtkBY8hViuRaunLdFur+JPp/jbsVDQxu+5Mfs248tmnFWrXK9lmSpYzJtH/lIhYljgjRhB4u7IEeDqq2ndypWUIkV0/ztGG7bgRRZ/FjyAhAkLPsIpLoLJg+cvyCIcFrw4qEWrILSI8qthxDuXosDnJgbp6BWgYrUCl18eFouZ4V5u4EBKizJ5MqAEBdWuTVU13FLnMDEGC7zI4E8QuAs6GbLYA24U8alF6zNFazBNimK5c7fgBZk41GiaFI9rHIKIj5ZA5HuQCYow3p4iPgzFKkE9xj70EC1HjgDp6UBpAm8mhmHjUWTQkybFuR1fAwBuQRalPniSt8CzalvwPNCy4CUlBX3DB5smJViUygTnz5/XVckgnJhiVfZzell8amP2uQmn5bC4uBgAfCqFMMYJqV5Paf1nJg5gC15k0Nvx8dSKC+cTvNWrkoXig6eWB09PkEWIOfDc2xZMLdpgrLRWqxUVKlRw1hMtU6ZMyKLL7rCjyFZEFSvskvM9kqiKRVFJEQDAYrdEXeAVlhTCITsgJ8lIsiR5tM0u22Gz22C32uGwapcZi1dsDhuKbcVCXreikiLN62YkTYrD4cCRI0dQpkwZJIVYTjCmCdP1C+oMfvQR8MEHwN69QKnYdvLrr+FoFhNtWOBFBg6yMI7LgudpgVMseGrTq6rRqt5BFmGoQxtKmpRgrbS5pYkpFZEXKg7ZAZvDBgkSkq3JzvdJliRIkoQSOwnhZEty1O/REnsJZJBIsEgWj7Y5ZAccMpVZS7Ik3uDv97pBQomj9LpZk6Nu0fN33YyWvLNYLKhZs2bi9I+33OL5vrAQGDwYKFvWc/0nnxjeteFfySuvAOPGUT3azz4D7r0X2LUL+Pln4OGHDR+fEQwWeOElkCCQJAmyLLPfiRreUbR27UoWCqpBFiUldGOHwYKnEKwFL6hjSRLy8vJQpUoVZ1H3UDhTdAZ7T+1FenI66lSsgwslF7D7xG7UrFgTaUlp2HpkKwCgXqV6URdSu47vQqGtENUqVEO5lHIebTtddBpHzx9FVnoW8jLyotouEThVeAr7T+9HmeQyPtctNSkV245sAwDUr1TfcHLhUNl5bCdK7CWoXqE6yqaU9WhberIx14KUlBRYLIZT9MYu3nnn+vYN264N/3rnzAHeeAO4807grbeA0aMp2OPpp4Hjx8PWLibKsAUvsmgJAgkS5NJ/DOEUu0owRanlTirRTpPiN8gCoKLZ4bDgBVmL1qdtQWC1WsPil1SIQpo6S7YiLS2NpjuTgNS0VBqMS09PWlpa1AWelEznNTU1FWmpnm1LRjJQDFhTrGGr6hFLXJAv0HVLUbluSZ7XLdoCz5JsASRqS1qKZ9vSkhPvWhli4cKI7dqwTN67l6pWABRgceYMvb7nHuD998PZNCaasMCLDIEEQcwmwo0gTrHrboGDmwXP3xStmgUPIHEXDh+8INKkiFaxROR7Um9QUiJiJCI/2gSbPoiJLIYFXm4uVbMAgFq1gPXr6fWePSwOYplEcXeINno7PlEGfxFwpkkpFXLOKNqSwEEWHrhb6kpKwmrBM4Jog16ge83M5Mz+jpnoD0N6rceiCXPGPAwLvKuvBj7/nF4PGgQMHw506QL06QPcfHO4m8dEC7bgRYZAnS2XK/PFx4LnnehYb5BFJC14BgYy0YSJ3khgU4WCmpVKwKog0SSgMDfRUpyo10R0DD/KvvEGubMAFOiRlQWsXQvcdBO9Z2ITFniRQU+Qhft2jFqiYyVNinaQherg7y4Ew2zBMzRFK5gw0XVPyiZP9fkR0KII5WgT6N5z+vMKJswZ8zDU09lsVMFi4ECgRg1a17s3LUx8kKB9Z8TQ0ykzGvikSSmdolVJdKzgMbhZLLQoARbhjKI1Icgi3AS6J81srz8/M1GEcrSJdWHORB9DAi8pCXjhBUqRwsQXbMGLLCI6tIuKqxatkujYKw+eWhSt1uCfnEy1FW228ObBS4AgCzPQE2SR6L8VkR8WRWhDTLF0qf5te/QwvHvDPd211wLffQcMGGD4WIzAsMCLDIEEgWjTdyLgHMC1LHgqAk1z8E9KIoFXUhLeShZGfPAEEyYi35N6I0UTkViNfmb80KuXvu0kCSj1QTaCYYF3/fXA2LHAn38CrVv7JlsOQmQyAsC/y8ggcuSbqDgrWZQKOck7TYpRCx4QdgueEUS14GkhglBQI9EfhkSOyOc0KUHiiGzJPcM93UMP0f/Tp/t+FqTIZASALXiRQeTIN1FxJTpWL1Xmz4Lng3s1DBNq0RrdNhro9ZcSzZcr0d0ZRI7IT9RrIjqGBV6EBSdjEizwIoPeIAvuIF240qR4lSqz+alkoTX4u9ejNaEWrd+2mYTI96QeAZ2oD0OiRuS73yc8RRsi584Bq1dTRYniYs/Phg41vDvdPV3NmsCmTUB2Nr2fPRvo1w8oX97wMRmBEWQMihv0dsqMCk4LXmmpMh0WPL9TtCbUovXbNpMRTSiotcFjXYI/DIkszL3bwATBpk3ADTcA58+T0MvKAo4eBcqUAapUCUrg6U50vH+/5/Trf/5Dx2biA7bgRRYRHdpFxRVkod+C5/NdBfcp2hivRRsu9AZZRBsPSxCnSdFEtIdF9+vBD6whMHw4JRQ+fpzqwK5fD/z7LwU7vPhiULs0XMlCQZC+igkTLPAig8iRb6LiFCClFjzJrsMHT0+QRYgWvEACRAvRhImo92QgoSCChcpMRI1+DvZ3wXixeTPw+OOUoN1qpej/GjWAadPIohYEQQs8Jr7gB6/IIHLkm6i4KlkoefBImFmCTZOi7CNEC16w10g0YSJqLVq90b2JSqwKc0YnycmugTgnh/zwACAz0/XaIIZ6unnzgHLl6LXNBixaBFSq5LlNENPEjACwBS8yiBz5JipatWihI9GxD5Gy4AURZCEKotai9RAKXIvWB71/t2jCnNFJy5bAL78ADRsCnTsDTz9NfnDvvAM0bx7ULnVb8GrWBN58E5gxg5bcXDqu8n7GDGDmzKDawAgAC7zIIGrkm8i40qQo1rfSKVp7EEEWYfbB8z6ekW1FucaxcE9yLVpfRA2yiKkyZVOn0mA3bJhrnSwDEyYAVauS71unTsCWLZ7fKyoCHn2ULFply1LC3/37w9u2KVOAvDx6/eyzFNH60EPA4cPAG28EtUvdPd0//wS1fybGSNC+M2JwLdrgkVJS6IXNBsgyLDYdiY79pUkJ1YIX5FSUqH6WwgkFvVOQggjlaCO6MBe+L/v5ZxJKF1/suX7aNErsu2gRWc8mTQK6dAG2bwcyMmibYcOAzz8HFi8m4fX440D37sDGjeQvFw7atHG9rlwZWLYs5F2yDx4DgC14kUY0vxmRcQ5QVpf1TbK7EnDKfjrUSFayCLUckyjCRNRatLqDCBL8tyLaw6IpZcrOnAFOn3YtRUX+tz97Frj7bpqGrFjRtV6Waepx3DjglluAZs2At96iVCXvvUfbnDoFzJ8PvPQS1Wpt2RL473+BP/4AvvkmYn9iOGCBxwBggRcpRI18ExnnAJ5SGkVrszlTpACAnBxkkEUYLXhGEE2YiHpP6i6hlqC/FdGDLKIpMMs3bUrBB8oydar/Lzz8MHDjjSTQ3NmzBygoALp2da1LTQU6dgTWraP3GzdS3+G+TdWqJAaVbcJBnTpA3braSxCE7ozCxAUs8CID16I1jnMAdxNnSooUQN2CF41atMGUKfPbNpMQtRZtwClI0acAI0ysCvNIcHrrVpSvVs21IjVVe+PFi4Fff6UpWm8KCuj/nBzP9Tk5lINO2SYlxdPyp2yjfD8cuPsFAiQqN20Cli8HRo0Kapcs8BgAnCYlUnAtWuP41qK1OwMsAP8WPB8iYMEzOhUlmjARtRZtQH/VBHdn0Pt3iybMI0JGhr4yWvv2AY89Bnz9NZCWpr2dd9tlOfCgqGcbIzz2mPr6V1+l6Nog4ClaBgBb8CKFqJFvIuNTi9ZW4gywAKDq1BytWrRACBY8Qa6x6PdkIAteoj4MiRpkEaxlOyps3EhRqK1b0+8+KYlqvb7yCr1WLHfelrjDh12f5eZSXdgTJ7S3iSTXXw98/HFQXw1K4O3aBTz5JHDnnfQ3AmRF9I4sZmIH9z5DkHEoLuBatMEjJbuiaJ1VLKxW1afmaNSiDdaZXFRhIpxQ0JsUPEE7qFgV5qZyzTUUDLF5s2tp04YCLjZvJt+23FxgxQrXd4qLSQS2b0/vW7emPsN9m/x84M8/XdtEko8+orq0QWD4UXb1ahKUHToAa9YAkydTHdzff6dEyB99FFQ7GIEIt+U5kdHdKQs2+JuJbx68ElcdWpXpWdXvKkSgkkWwlgpRhImo0aqcJkUfoj0smhFkoZuMDAqGcKdsWUp1oqwfNoxy0DVoQMuUKUCZMsBdd9HnmZnAoEGUGiU7m8TWyJGUfNg7aCMUWrb0tbQUFABHjgBz5gS1S8M93RNPUJqYESNcKWIASrz88stBtYERALbgRRbRIt9ExqcWrbcFTwX38yvLsut9hCpZGEE0YSJ6mhQtzLZQmY3oQRZCWvD0MHo0cOECMGQITcO2bUs+e+4CZ8YMejDs3Zu2veYaypsXrhx4ANCzp+dAbLFQPrxOnYDGjYPapWGB98cfrvQw7lSuDBw7FlQbGAGI1d+m6HAtWuM4a9Eq1roSGyylefC0LHi6gizCZcELdopWEGEiei3aQEEWiYroaVJihu++83wvSVTJYsIE7e+kpQGzZtESKfwdP0gM++BVqEDTz95s2gS4Ry0zsQVb8CID16I1jlNIuVnfnFO0eix47gNOOCtZhJgmRRREr0WrJ01KIv5eRK9FK+QUbSxhtbqCGtw5dixoS6FhgXfXXcCYMTQ1LEmAwwH88ANNSffrF1QbGMFIwL4zYoga+SYyzsFbLchCpUwZ4GfwD2MePOexYjzIQvR7Uo8FT5RzGU1EDbKIqVq0IqN13YqKKA9fEBju6SZPBgYMIGudLANNmwJ2Owm/J58Mqg2MIEgSXVMWeOGDa9Eax+WDpxJkoSHOAlrwwpkHL8bTpCgIJxQM+HLJsoxE++nEqjBnAvDKK/S/JFGkarlyrs/sdopmjZYPXnIy8O67wDPP0LSsw0HBHw0aBHV8RiBY4IUf3Z0yn3QflDQpkt3uyoOnYcFzJ1IWvESrRStamhQPK60g5zKaCGvBi/UgC7OZMYP+l2Vg7lzP6diUFKB2bVofBEHPVdSrRwsTP3Cy48ghWuSbyLimaF3dk6WomD7zI84kSYIsyxG34BlFND9LI0IqmugtoZboiBr9zBa8INmzh/7v3Bn45BPfkmghYFjgjRihvl6SKNCkfn2K9g0yLx9jItx/hh+uRWscV5CFy+/EWqgIPG0LngSJa9HqIFZr0SqfybKckL8X0dOkMCGyalXYd2m4p9u0ier22u1Ao0Zk7dm5k6yKjRtTPr7HHwfWriX/PCZ2YAte+AnYKQs2+IuAT6JjAJbCIvrM6t+CB9lrwOFatD7ojVYVMRpTEfGJ+HsR9WGRgyzCxG23UZWNJ57wXP/CC8CGDcCHHxrepeEo2p49KXnzwYNU5u3XX4EDB4AuXah02YEDwFVXAcOHG24LYzIs8MIPp0kxjnPAcIscsypTtH4qWagKkzDWog3ZgifINRY1TYqC7iCLBCNg/kKuRRvbrF4N3Hij7/pu3SjQIggMC7wXXgCefRYoX961rnx5ytE3bRpV+Hj6aRJ/TGySgH1nxOBatMZxDhgW13Ssy4IXQpBFiBY8hVhPk6IQa0EWQGJbvIUNsmALXng4e1Y9HUpyMnD6dFC7NCzwTp1Sz8V35IirDRUqUL1eJrZgC1744Vq0wSNZLE4xZi0icebXgqc2+HMtWh9itRYtkNgWb06TEuc0awYsWeK7fvHioP3dDPd0PXsCAwcCL70EXHopiYINGyjRca9etM2GDUDDhkG1hzERFniRg9Ok6MdDgCQlASUluix4qoM/16L1IVZr0QJsJQLEjX7maxMiTz0F3HorsGsXcPXVtG7lSuD994PyvwOCEHivv07+dXfc4flA3L+/K51L48aUr4+JLfj3GX5EjXwTGY8BIzkZuHDB6YPnLw+e6gDDtWh9EPWe1BtkASTm70X0WrRswQuRHj2ATz8FpkwBPvoISE8HLr4Y+OYboGPHoHZpuKcrVw54800Sc7t3k7WnXj3P5MstWgTVFsZk2IIXfkSNfBMZtSlWpwXPXx68QEEWXIsWQOynSQES8/eiV0hxmpQY5sYb1QMtNm8OSlgFnei4XDkSl0z8wAIv/Iga+SYyHkJK8cHTkwdPbfAPZx68UC14glxjvX+HyL5copzLaCJqRD4HWUSIU6eobNi8ecBvv1FuOoME1dP9/DNNCe/d6xtM8cknweyREQkWeOFD1Mg3kfEYMBQLno5KFt7fBxDWPHgK8Z4mhYMsxMP97xUtyILTpISZb78F5s8H/vc/oFYt8subPz+oXRmOol28GOjQAdi6lY5fUkKvv/0WyMw03oA5c4A6dagKRuvWwPffa2/7ySeUb69yZUrN0q4d8NVXxo/JqMMWvPDDaVKCx9OCp0zRhhBkwbVoPRBOKHCaFF2IJsydx+e+LHj27wcmTQLq1qWEwllZJK4+/pjWt2wZ1G4NC7wpU8j/7osvKGXLyy8D27YBvXsDNWsa29eSJcCwYcC4cVQh48orgeuvJ8ugGmvWkMBbtozy7HXuDNx0E32XCR0WeJFDNId2kfEQUk4fPH21aIHIWfCCdSY3e+B1x8MSFIPRmIlqJXK/p0V7WOQgixC54QZKg7J1KzBrFlWRmDUrLLs2LPB27XL5AKamAufOkTAYPhx44w1j+5o+HRg0CLjvPqBJE2DmTKBGDeC119S3nzkTGD2a0rM0aEBis0ED4PPPjf4VjBr8ABZ+RI18ExUfAeLMg6c/yMKDCFjwjCKS1cmIUDDLl8sfifp7MSLMTZui5QEkOL7+mkTQxIkkrnQkc9eLYYGXlQWcOUOvq1UD/vyTXp88CZw/r38/xcVkheva1XN9167AunX69uFwUFuysrS3KSqiBMzKorSd8YUteOFFT6fs3FaAwV8EfM6DjwXPYJCFQLVoRRAletpgulDgNCk+xLowZ/zw/fckTNq0Adq2BWbPpsoRYcCwwLvySmDFCnrduzfw2GPA/ffTtPE11+jfz9GjFBSSk+O5PicHKCjQt4+XXiILYu/e2ttMnUq+gcoSZELohIAFXnjRZZEQaPAXAR9nch8fvNitRSsCHkIh0EOHwNGYifZ7MfL3iijMGT+0a0e55/LzgQcfpECHatXIgrViRUhWKcMCb/ZsSnIMAGPHUgWLQ4eAW24JLtDD+7csy/qmCt9/n+rfLlkCVKmivd3YsRRtrCxbtxpvY6KRYH1nxBA58i0WcFaygCuK1l+iYwXVIIuSEleaAa5FC0Dce5KDLHzRlSOQ06TENmXKUJmwtWuBP/4AHn8ceO45Ejg9egS1y6CmaKtWLf2yhXzili4lf7qKFfXvp1Ilmmr2ttYdPuxr1fNmyRLy3fvgA+Daa/1vm5pKEbfKkpGhv42JBlvwIodoDu2i4jMV5fTBK52i9VeqzF+QxYULvuuCbFssp0kRORWJyG0TBZHFL/dlYaRRI2DaNIquff/9oHdjWOD9+iuJS4XPPqMatP/5j29OPH+kpFBaFGW6V2HFCqB9e+3vvf8+MGAA8N576gmfmeBhgRdeRPabERWfQd7bBy9ZxxStmgXPXeCFWskihtOkGElFEm1EbpvZiBxhzEEWEcRqJYG1dGlQXzcs8B58ENixg17v3g306UOWxQ8/JGueEUaMoCTNCxZQqpXhwylFyuDB9PnYsUC/fq7t33+f3r/0EnD55WT9KyigqVcmdPj3GV4MWSQEGPxFQCvIwumDJ4AFzygiWZ1iIcjCH4n6ezGUI5Br0TKlGBZ4O3a4SqJ9+CHVwH3vPWDRIsrJZ4Q+fSj1yTPP0D7XrKEcd7Vq0ef5+Z458V5/nfykH34YyMtzLY89ZvSvYNRgC154MTIIiTD4i4CPw3aptc1ZyUKHBc8DNYFnUi1aEUSJyPVeRW6b2YgsfhPtWsQShh9lZZmCOwDgm2+A7t3pdY0aFBlrlCFDaFFj0SLP9999Z3z/jH5Y4IUXXWkfBBr8RcBnkHda8Az44KlN0RYWutZZDD/XqrdNJyJZNoyIVJGjMRPt9yJyhDEHWYiL4Z6uTRuqnPHOO8Dq1S4/uD17AgdHMLEBC7zwIHLkm+h4W/Ck0qfKoGvRKiQnh+yLEMtBFgoi35Mit80sRH5Y5DQp4mJY4M2cSYEWjzxCJcbq16f1H33kPziCER+24EUGdhrXj1aQhfNzPXnw1Cx4CkH636m2TSci+Y2JXO9V5LaJgsjil/sy8TDc2118sWcUrcILL4S1wgZjAizwwovRyDdZlhO+k/QZ5H0EWpBBFgoh5MAL1ZlcBKtTrEdjJqqVSOQIYw6yEJfgH2e9SEsL154Ys0hwbRF2jHbKMuSE7yR9RJCAFjyjeFxjk0W8yPVeRW6b2Ygckc9pUsRF9xStxUIWOu+lYkVKWfLJJ5FsJhMN2IIXXowOQok2aKnh47foJdD01KL1IBIWvDgPsvC2KkcLrkWrjcjiN9GuRSyh+3H2f/9TX3/yJLBhA9C3L/DWW8Dtt4epZUzUYYEXXowEWbhvn8j4DPLeFjw9iY79TdGGwwcvhFq0ZltpjYrUaLZX5EhRszF670XTUsxBFuKiu7fr2VP7s/79gaZNgRdfZIEXDyRY3xkxjES+MZ5oWvCCTZOi9T6Utund3tsiJsAl1+02YEJ7OcjCl2AeFkUU5kx0CS4hlApdu7oqXDCxCVvwIkOgji9R/YrU8PFb9PHBCxzJFTELXoi1aH3aZgIiBzJwLdrAiPywyBY88QibwLtwgQMtYh0WeOFFryBIVL8iNXwGeR8fvBCDLELxwQuDM7nZwiSYwJ9owWlStAkmIj9acJCFuIRN4L35JtCyZbj2xpgBC7zwYrTjM3vwFwGtWrTOz/0JPLXB33tKNwwWvGAQRZjovcfMsCobKceVaMS6MGfMQXdvN2KE+vpTp4BffgF27QK+/z5czWLMgB/AwoveTlaSJEA2f/AXAa1atM7PdVjwPLBYaFHqK4bDghfEQCZBEuL6BhNkES24Fq02IkfkJ9q1iCV0C7xNm9TXly8PdOtG9WRr1QpXsxgzYAteeNErCBLdr8gdrVq0TvQkOvY+j8nJQFGR+v5CaZsBnCLe7ClaA/ekDFm4NCnObQUQy9FE770nSRJkWRZOmDPmoLu3W7Uqks1gRIAFXngx0ikznmha8PxF0Wr5MiYluQReOKJog7TgAeIIE133pElWZQ6y8CVehDkTXcLmg8fEDwnWd0YMwxY8QQZ/MwlYi9ZPHjzvfThxF3Um1KJV24dZGA78iaZQ4CCLgIj8sMgPquLBAo9xwha8yMBpUvQTqBatrjx4/gI1TKpFK4ow0StSzRisOU2KNiJH5HOQhbiwwGOcsMALL0Y7PrMHfxEIWItWTyULf/swoRYtII4w0R34Y6JQ8EeiWomMCnNOk1LK1KnApZcCGRlAlSpAr17A9u2e28gyMGECULUqkJ4OdOoEbNniuU1REfDoo0ClSkDZskCPHsD+/VH6I4KHBR7jRMTfZyyjOyWFIIO/CIS9Fq33PkyoRRvsdyJBMCWvogXXotXG6N8rmjA3jdWrgYcfBtavB1asAGw2qspw7pxrm2nTgOnTgdmzgZ9/BnJzgS5dgDNnXNsMG0b1WhcvBtauBc6eBbp3B+z2qP9JRgj+cZaJO9iCF16MBlkI3VFGiYC1aK0Ga9F678OEWrR+2xZlRL4nOU2KNiJH5AsdZLF8uef7hQvJkrdxI3DVVTTYzZwJjBsH3HILbfPWW0BODvDee8CDD1IuuPnzgXfeAa69lrb573+BGjWAb74Brrsuqn+SEdiCxzhhgRdejHbKjAtNC56/KVp/aVLUXofatiC+I4owEVEoeB/bH2YL5WgjsjD3PnZUOHMGOH3atShR8oE4dYr+z8qi//fsAQoKyKqnkJoKdOwIrFtH7zduBEpKPLepWhVo1sy1jaCwwGN8EGQMinkMd8p84n39Fr0tbn6CLLz34SRcFrwwOJObLUwM+3JF04LHQRaaiGrBcz9ONB9UyzdtCmRmupapUwN/SZapYsMVV5A4A0jcAWSxcycnx/VZQQGQkgJUrKi9jaDwFC3jhC14kUHEyDdRCViLNpggi3D54IXgTC6KMDEajRkt9AqFRHdnEC362f06RPPYp7duRflq1VwrUlMDf+mRR4DffycfOm+82y7LgZ3S9WxjMmzBY5ywwAsvXIvWOAFr0YaaJiVIC16o10YUYSJqLVqj0b2JhqhpUsyy4CEjg8poKUsggffoo8DSpVSxoXp11/rcXPrf2xJ3+LDLqpebCxQXAydOaG8jKCzwGCeCP4zEHLo7ZUEGfxEIXIs2cCULH8KQB8/DUhFCkIXZ6HYbMFMocJCFD6I+LJplwdONLJPl7pNPgG+/BerU8fy8Th0ScCtWuNYVF1P0bfv29L51a+o33LfJzwf+/NO1jaDwFC3jhC144YXTpBgnUC1a2Y8FjoMsAiNymhQFTpPii24LZ5QfFs2+nwPy8MMUDfvZZ2T1Uyx1mZmU806SKAXKlClAgwa0TJkClCkD3HWXa9tBg4DHHweysylAY+RIoHlzV1StoLDAY5ywwAsvsRD5JhoB06TosOBFeoqW06SEH6OWIOGFRZgRNsgihNyQUeG11+j/Tp081y9cCAwYQK9HjwYuXACGDKFp2LZtga+/JkGoMGMG9R29e9O211wDLFqkK+jLTFjgMT4kWN8ZMThNSvBoJzoOsRZtOKZoY7gWrYJwQkHg6F4REFWYO48rah+m5/6VJKpkMWGC9jZpacCsWbTEEOyDxzhhC15k4DQp+gmUJkXXFC0HWWgiai1awyXUEvS3ItrDotBlyhgWeIwLFnjhRdTIN5EJlCYFeqZo/dWiDdGCF+xAJoowEfWe1G3tTlAhIWot2nDkhmQiBws8xkmC9p0RQ9TIN5HxZ32TrVa/N6muWrQhWvCCHchEESaip0kRLbpXFEQX5oyYsMBjnLAFL7yIGvkmMv7SpPgLsHD/jt8pWrMteGZP0Rr8O0Tz5UpUdwajf69owpwxBxZ4jBMWeOFF1Mg3kfGXJiWgwNOTJiWEUmVA6BY8s6+xqPekYWt3gj0MiRpkEaplm4ksLPAYVVhrhI7RTplxoWrB05mSICIWvDA5k4siTIQTCkanIBOsgxJVmDuPy32YkLDAY5y4/0YTrP+MKKL5zYiMj5DysOD5t77pqkUbrA9eiNdGFGESC7Vo/ZHo7gyiPSxykIXYsMBjnPBDWHgRNfJNZHwGDCM+eFrnOZwWvFCnaM32wRP0njQaZJFoiB5kwRY8MWGBxzhhC154Mfp0a/bgLwL+UpzoDbLw2U848uCFKcjCbAznmxPMlytRH4ZEF+aMmLDAY5ywwAsvXIvWOD5Cys3i5gg0Ret2A3sMPOGoZBEuC57ZU7SC1qINxoJn9rmMJkaFlGjCnDEHFniMKgnUd0YMUSPfRMZvLVoTLXjOYyRImpRYKHll9rmMJqIGWXCaFLFhgcd4wKlSwgfXog0eNQue3ihaIAIWvDA5k4tidRJOKARRQk2UcxkN4kmYM9GDBR7jAQu88COa34zI+KtF60g2MEUbbh+8EJ3JRbHSil6Llh+G/CPa+eEgC7Fhgcd4wL/T8CFq5JvI+AwY7lY7HRY81YEmjJUsgkUUP0tR70mjaVKAxPq9iB5kkejCW1RY4DEesAUvfHAtWuP4DNqS5Mx/FyjIAtAQJgLVojVblMR6LVr3bRLp9xLrwpwxBxZ4jAcs8MIH16I1jqqQKhVogdKkABqDv0C1aM1G1Fq0wQjoRPq9cC1aJhhY4DGqsMALHVEj30RGdcBQBFo4giy4Fi0Ace9JXRa8BPy9iBpkwWlSxIYFHuMBW/DCB9eiDR41C16gIAv374XdghdqkIVgfpbCCQUDvlyJaPGOB2HORB8WeIwHLPDCj2h+MyKjKqRKp2b1pElRHfzDWckixtOkiBqtakRAJ7K1SLSHRQ6yEBsWeIwHLPDCh6iRbyKjNmDIig9esBa8MFayCBZRrE6i3pNGzksi/l5ED7JgC56YsMBjPODfafjgWrTGUR20S61uRix4at/3eW2kXWEKsjBblMR6LVr3bRLp9xIPwpyJPizwGA/Yghc+uBatcVSFVDAWvHBXsghTmhSzifVatB7fSaDfC9eiZYKBBR6jSgL1nRFD1Mg3kVEdMKzGLXhci1Yd0e9JDrJQR9QgC06TIjYs8BgP2IIXPrgWbfCoBlnoyIOnIFotWtH8xoQTCkEEWYhyLqNJLAtzJvqwwGM8YIEXfkTzmxEZVSHlTHQchjQpJtWide7HbAtejNeiBRLPWuR+L4v2sMhBFmLDAo/xgAVe+BA18k1k1AYMRdgZqmShlSYlgWvRBiMURCx5lWi/F/e/U7SHRU6TIjYs8BgP+EEsfHAtWmNo/v1BWPDUvg8goWvRipyKhGvRahMvwpyJPizwGA/YghceDFkkBBj8RcDDUuE+kAWRJoVr0friIRS4Fm3MEMzfKaIwZ6IPCzzGAxZ44UFTrKggwvSdaHimSTEwRRsoTUqC16JVEPWe5CALX4wIc65Fy7jDAo9RJUH6zqggmkO7qGhORRnwwVPbF9eihc+xhRMKXIs2ICKLX+7DxMR0gTdnDlCnDpCWBrRuDXz/vf/tV6+m7dLSgLp1gblzo9PORIEteOFBZL8ZUdEUIEkGfPD8BVlIEmAJrsuLh1q0IqciEbltZiOy+OUgC7ExVeAtWQIMGwaMGwds2gRceSVw/fXA3r3q2+/ZA9xwA223aRPwn/8AQ4cCH38c1WbHNSzwwoPIkW+iovX3G4qi9VeLNkjrnb+26UUEq1MwQRbRQuS2mU0w4jdacJoUsQnNISVEpk8HBg0C7ruP3s+cCXz1FfDaa8DUqb7bz50L1KxJ2wFAkybAL78AL74I3HprtFqtjizLKLaXoMQBlDgAq8Pc9uhBaWuxHUiye647XwScvWBu+2KZEnsJSkrodXGxa31xCVBSLKG4GEgqHdOKbUBJCeCwyDh7odh3ZwmCcs4kSfI4Z7CSMLNLSSgpdg0kJTbJ51yWlEgoKQHOF9lw1kI7kWwOlAUJxXNBnt8LRXaUlND+1a5nCSRYHVLAdsl2865xsb0YJSWARVL/G9Tb64hKewOdX7W2nSssQaoU/7+XIltxaf8QuC9Rzg0c0b1uxcVAsdvzk9I2xlxME3jFxcDGjcATT3iu79oVWLdO/Ts//kifu3PddcD8+TRAqj2gFxXRonDmTGjt1sLmsGHLkT/wzwUguQRITonMccJJSTFQYgOyjtCUNwDknwROngb+Pg1gp5mtiw8kSULyUdf7QpuEPSfSYT8kIa3011dsl7DrDADYsX3HH2Y0UygkSULSEdf7mueSUBnAoaMp2LrFNelQYktGiZyBrDOuc3ngvITTxcDfOAjgIAAg9cRx3Gqx4Hz5Cvh0XWjn93S6hCOprveFNgn/5GcgWUpGcpJFs11Fdgm7zwCADX+ZfI0tkgSr2/lVuyfNau+ZdAmHvc6vd9v2n5NwpgT4GwcAHIha28zGapFgOex6r3ZuCu0S9pwBgBJsQ/Su29l0CYe8rtu+M2m4uFrUmsCoYJrAO3oUsNuBnBzP9Tk5QEGB+ncKCtS3t9lof3l5vt+ZOhWYODE8bQ5EktWC9DSgsJDaFAukp1ElKEvpw1b5DODcWcCR2LOFYaN8ckUPt69kaxKqlMtGsjXJuT5VSkHZlHIotJ83p5GCUT45y+OcnezYEyl/rMO/F7fABds5j23Tk9OQZLE6t89MqYDz9lMeU362SpXw3QtzUFgxC1Zr8F4pFliRkVLeo21JFivSk1NRaCuEzeaymHi3K01KRZnksihymG8Wz/Q6v2r3pBnttUpJKJeSEbBtmakVcMFxOuF8ViukBL5u6VIa0pPLoNhRGLV2aV63jEpItgTvFsGEjqlTtIBvYl1Z9p9sV217tfUKY8cCI0a43h84ADRtarydgUi2JqNtrZZokUvCNVawWoFUtycv5AFoaFZrEoFkAFW81klohUZmNCY2aHkXikbfih6y7w/LKlmRmuRuLq9YunjRqWWEGpeCFrZmsHu1zbddElqhcYTaECpa96QI7VVrW1bpkuhoXbcmZjTGC7W2MdHGNIFXqRKJC29r3eHDvlY6hdxc9e2TkoDsbPXvpKZ6CpjTp4Nvsx48xBLDMGEhNUncH5bIbWMYJnExLYo2JYXSnaxY4bl+xQqgfXv177Rr57v9118DbdqEFCDHMAzDMAwTV5iaJmXECGDePGDBAmDbNmD4cEqRMngwfT52LNCvn2v7wYOBf/+l723bRt+bPx8YOdKc9jMMwzAMw4iIqT54ffoAx44BzzwD5OcDzZoBy5YBtWrR5/n5njnx6tShz4cPB159FahaFXjlFfNTpDAMwzAMw4iEJCdYdtX9+/ejRo0a2LdvH6pXr252cxiGYRiG0QGP38YwvVQZwzAMwzAME15Y4DEMwzAME78YLXofJ7DAYxiGYRgmPjFa9D6OYIHHMAzDMEx84l70vkkTKmZfowYVvY9zWOAxDMMwDBM7nDlDVQuUxb3gvDtK0XvvIvb+it7HESzwGIZhGIaJGco3bQpkZrqWqVPVNwym6H0cYXotWoZhGIZhGL2c3roV5atVc60IVCPUaNH7OIEFHsMwDMMwsUNGBlC+fODtgil6H0fwFC3DMAzDMPFHMEXv44iEs+A5HA4AQH5+vsktYRiGYRhGL8q4rYzjuhgxArjnHqBNG6BdO+CNNzyL3scxCSfwDh06BAC47LLLTG4JwzAMwzBGOXToEGrWrKlv40BF7+OYhKtFa7PZ8P333+Pqq6/G1q1bkZGRYXaTTOPMmTNo2rQpnwc+DwD4PCjweSD4PBB8HggRzoPD4cChQ4fQsmVLJCUlnH3KMAkn8ADg9OnTyMzMxKlTp1Bej6NmnMLngeDzQPB5IPg8EHweCD4PBJ+H2IODLBiGYRiGYeIMFngMwzAMwzBxRkIKvNTUVIwfPx6pgZIjxjl8Hgg+DwSfB4LPA8HngeDzQPB5iD0S0gePYRiGYRgmnklICx7DMAzDMEw8wwKPYRiGYRgmzmCBxzAMwzAME2ewwGMYhmEYhokzhBB4c+bMQZ06dZCWlobWrVvj+++/9/j8k08+wXXXXYdKlSpBkiRs3rxZ134nT56M9u3bo0yZMqhQoYLqNo899hhat26N1NRUtGjRQtd+i4qK8Oijj6JSpUooW7YsevTogf379xs+tjfxdh7++ecfDBo0CHXq1EF6ejrq1auH8ePHo7i42O9+4+08AECPHj1Qs2ZNpKWlIS8vD/fccw8OHjzod7/xeB7ct23RooWudsfjeahduzYkSfJYnnjiCb/7jcfzAABffvkl2rZti/T0dFSqVAm33HKL3/3G23n47rvvfO4FZfn555819xtv5wEAduzYgZ49e6JSpUooX748OnTogFWrVunaP+OL6QJvyZIlGDZsGMaNG4dNmzbhyiuvxPXXX4+9e/c6tzl37hw6dOiA5557ztC+i4uLcfvtt+Ohhx7S3EaWZQwcOBB9+vTRvd9hw4bhf//7HxYvXoy1a9fi7Nmz6N69O+x2u6FjuxOP5+Gvv/6Cw+HA66+/ji1btmDGjBmYO3cu/vOf/2juMx7PAwB07twZH3zwAbZv346PP/4Yu3btwm233aa5z3g9DwqjR49G1apVA+4zns/DM888g/z8fOfy5JNPau4zXs/Dxx9/jHvuuQf33nsvfvvtN/zwww+46667NPcZj+ehffv2HvdBfn4+7rvvPtSuXRtt2rRR3Wc8ngcAuPHGG2Gz2fDtt99i48aNaNGiBbp3746CggJDfwNTimwyl112mTx48GCPdY0bN5afeOIJn2337NkjA5A3bdpk6BgLFy6UMzMz/W4zfvx4+ZJLLgm4r5MnT8rJycny4sWLnesOHDggWywWefny5UEdW5bj/zwoTJs2Ta5Tp47m54lyHj777DNZkiS5uLhY9fN4Pg/Lli2TGzduLG/ZsiVgu+P1PNSqVUueMWOG7jbG43koKSmRq1WrJs+bN093G+PxPHhTXFwsV6lSRX7mmWc09xuP5+HIkSMyAHnNmjXObU6fPi0DkL/55htDbWcIUy14xcXF2LhxI7p27eqxvmvXrli3bp1JrfLPxo0bUVJS4tHmqlWrolmzZkG3OZHOw6lTp5CVlaX6WaKch+PHj+Pdd99F+/btkZyc7PN5PJ+HQ4cO4f7778c777yDMmXK+N1nPJ8HAHj++eeRnZ2NFi1aYPLkyZquC/F6Hn799VccOHAAFosFLVu2RF5eHq6//nps2bJFdZ/xeh68Wbp0KY4ePYoBAwaofh6v5yE7OxtNmjTB22+/jXPnzsFms+H1119HTk4OWrdubVbTYxpTBd7Ro0dht9uRk5PjsT4nJ0dYk2xBQQFSUlJQsWJFj/WhtDlRzsOuXbswa9YsDB48WPXzeD8PY8aMQdmyZZGdnY29e/fis88+U91nvJ4HWZYxYMAADB48WHPqyZ14PQ8A+TAtXrwYq1atwiOPPIKZM2diyJAhqvuM1/Owe/duAMCECRPw5JNP4osvvkDFihXRsWNHHD9+3Gef8XoevJk/fz6uu+461KhRQ/XzeD0PkiRhxYoV2LRpEzIyMpCWloYZM2Zg+fLluv3YGU9M98ED6MK6I8uyzzp/DB48GOXKlXMuZmC0zWrE83k4ePAgunXrhttvvx333Xef333E63kYNWoUNm3ahK+//hpWqxX9+vWD7KeQTLydh1mzZuH06dMYO3asoX3E23kAgOHDh6Njx464+OKLcd9992Hu3LmYP38+jh07prmPeDsPDocDADBu3DjceuutaN26NRYuXAhJkvDhhx9q7iPezoM7+/fvx1dffYVBgwYF3Ee8nQdZljFkyBBUqVIF33//PTZs2ICePXuie/fuyM/PN6V9sY6pAq9SpUqwWq0+Tx2HDx/2eTrxxzPPPIPNmzc7l0iSm5uL4uJinDhxwmO90Ta7E+/n4eDBg+jcuTPatWuHN954Q3Of8X4eKlWqhIYNG6JLly5YvHgxli1bhvXr1/vsM17Pw7fffov169cjNTUVSUlJqF+/PgCgTZs26N+/v88+4/U8qHH55ZcDAP7++2+fz+L1POTl5QEAmjZt6vw8NTUVdevW9QgWUIjX8+DOwoULkZ2djR49emjuM17Pw7fffosvvvgCixcvRocOHdCqVSvMmTMH6enpeOuttyLavnjFVIGXkpKC1q1bY8WKFR7rV6xYgfbt2+veT5UqVVC/fn3nEklat26N5ORkjzbn5+fjzz//NNRmd+L5PBw4cACdOnVCq1atsHDhQlgs2rdcPJ8HbxTLXVFRkc9n8XoeXnnlFfz222/OAWXZsmUAKCJw8uTJPvuM1/OgxqZNmwC4RI878XoelDQb27dvd25TUlKCf/75B7Vq1fLZZ7yeBwVZlrFw4UL069dP1TdXIV7Pw/nz5wHAZ4ywWCxOay9jjCSzGzBixAjcc889aNOmjdPCs3fvXg8/rePHj2Pv3r3OvGFKh5Cbm4vc3FzNfe/du9f5Xbvd7nxKqV+/vtMk/ffff+Ps2bMoKCjAhQsXnNs0bdoUKSkpPvvMzMzEoEGD8PjjjyM7OxtZWVkYOXIkmjdvjmuvvdbQseP9PBw8eBCdOnVCzZo18eKLL+LIkSPO72u1Nx7Pw4YNG7BhwwZcccUVqFixInbv3o2nn34a9erVQ7t27RLmPNSsWdPjO8qx6tWrh+rVqyfMefjxxx+xfv16dO7cGZmZmfj5558xfPhwZ67ERDkP5cuXx+DBgzF+/HjUqFEDtWrVwgsvvAAAuP322xPmPCh8++232LNnj67p2Xg8D+3atUPFihXRv39/PP3000hPT8ebb76JPXv24MYbbwx4ThgVohqzq8Grr74q16pVS05JSZFbtWolr1692uPzhQsXygB8lvHjx/vdb//+/VW/t2rVKuc2HTt2VN1mz549mvu9cOGC/Mgjj8hZWVlyenq63L17d3nv3r2Gjx3v50GrvYFuu3g7D7///rvcuXNnOSsrS05NTZVr164tDx48WN6/f39CnQdv9KZviLfzsHHjRrlt27ZyZmamnJaWJjdq1EgeP368fO7cuYQ6D7JMKUEef/xxuUqVKnJGRoZ87bXXyn/++WfCnQdZluU777xTbt++vd82xvt5+Pnnn+WuXbvKWVlZckZGhnz55ZfLy5Yt031OGE8kWfbj5c0wDMMwDMPEHEJE0TIMwzAMwzDhgwUewzAMwzBMnMECj2EYhmEYJs5ggccwDMMwDBNnsMBjGIZhGIaJM1jgMQzDMAzDxBks8BiGYRiGYeIMFngMwzAMwzBxBgs8hmFiigkTJqBFixZmN4NhGEZouJIFwzDCIEmS38/79++P2bNno6ioCNnZ2VFqFcMwTOzBAo9hGGEoKChwvl6yZAmefvppZ5F0AEhPT0dmZqYZTWMYhokpeIqWYRhhyM3NdS6ZmZmQJMlnnfcU7YABA9CrVy9MmTIFOTk5qFChAiZOnAibzYZRo0YhKysL1atXx4IFCzyOdeDAAfTp0wcVK1ZEdnY2evbsiX/++Se6fzDDMEyEYIHHMEzM8+233+LgwYNYs2YNpk+fjgkTJqB79+6oWLEifvrpJwwePBiDBw/Gvn37AADnz59H586dUa5cOaxZswZr165FuXLl0K1bNxQXF5v81zAMw4QOCzyGYWKerKwsvPLKK2jUqBEGDhyIRo0a4fz58/jPf/6DBg0aYOzYsUhJScEPP/wAAFi8eDEsFgvmzZuH5s2bo0mTJli4cCH27t2L7777ztw/hmEYJgwkmd0AhmGYULnoootgsbieV3NyctCsWTPne6vViuzsbBw+fBgAsHHjRvz999/IyMjw2E9hYSF27doVnUYzDMNEEBZ4DMPEPMnJyR7vJUlSXedwOAAADocDrVu3xrvvvuuzr8qVK0euoQzDMFGCBR7DMAlHq1atsGTJElSpUgXly5c3uzkMwzBhh33wGIZJOO6++25UqlQJPXv2xPfff489e/Zg9erVeOyxx7B//36zm8cwDBMyLPAYhkk4ypQpgzVr1qBmzZq45ZZb0KRJEwwcOBAXLlxgix7DMHEBJzpmGIZhGIaJM9iCxzAMwzAME2ewwGMYhmEYhokzWOAxDMMwDMPEGSzwGIZhGIZh4gwWeAzDMAzDMHEGCzyGYRiGYZg4gwUewzAMwzBMnMECj2EYhmEYJs5ggccwDMMwDBNnsMBjGIZhGIaJM1jgMQzDMAzDxBn/D8LgA7eAqSrYAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "impact_evaluator.plot_impact(region=region)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Baseline, i.e. 'asap' is lower than optimized results" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'baseline': 26.349219416666664,\n", + " 'forecast': 22.1546754,\n", + " 'actual': 22.807821208333333}" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "impact_evaluator.get_all_emissions_metrics(region=region)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Iterate over multiple rows of data" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from watttime_optimizer.evaluator.analysis import analysis_loop" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [00:00<00:00, 270.40it/s]\n" + ] + } + ], + "source": [ + "df_ev_samples = s_ev.generate_synthetic_dataset(distinct_date_list=distinct_date_list, number_of_users=10).sample(10)\n", + "\n", + "input_dict = df_ev_samples[['usage_window_start',\n", + " 'usage_window_end',\n", + " 'time_needed',\n", + " 'usage_power_kw'\n", + " ]].T.to_dict()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 3/10 [00:24<00:54, 7.77s/it]/Users/jen/watttime-python-client/watttime_optimizer/api_opt.py:195: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " forecast_df.index = pd.to_datetime(forecast_df.index)\n", + "/Users/jen/watttime-python-client/watttime/api.py:274: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " df[\"point_time\"] = pd.to_datetime(df[\"point_time\"])\n", + "/Users/jen/watttime-python-client/watttime/api.py:274: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " df[\"point_time\"] = pd.to_datetime(df[\"point_time\"])\n", + "100%|██████████| 10/10 [01:01<00:00, 6.20s/it]\n" + ] + } + ], + "source": [ + "results = analysis_loop(\n", + " region = \"PJM_CHICAGO\",\n", + " input_dict = input_dict,\n", + " username=username,\n", + " password=password\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "results_loop = pd.DataFrame.from_dict(\n", + " results,\n", + " orient=\"index\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
baselineforecastactualmbstddevpercent_difference
33519.37490017.3644385.772350-0.9659791221.49183536.1545090.702071
24847.11941045.36259846.8589061.1271391209.01041835.8138550.005529
18799.03605497.04382997.403682-0.9608451377.71643823.5583320.016483
12944.89136243.96528144.818082-0.1707191227.37302710.0853300.001632
34740.71627534.58973030.394725-2.4144551241.08767178.0581670.253499
14436.70289231.10367218.732846-2.8410391251.38233565.5686970.489608
25072.39971069.99538830.7883660.2289031195.54996638.8372570.574745
9950.24333745.00255246.479799-0.5461001247.55069865.5469050.074906
40067.92381561.15395165.680911-0.4301361206.43322438.3905730.033021
8719.17819517.08513717.947542-1.2614631271.07398349.7794450.064169
\n", + "
" + ], + "text/plain": [ + " baseline forecast actual m b stddev \\\n", + "335 19.374900 17.364438 5.772350 -0.965979 1221.491835 36.154509 \n", + "248 47.119410 45.362598 46.858906 1.127139 1209.010418 35.813855 \n", + "187 99.036054 97.043829 97.403682 -0.960845 1377.716438 23.558332 \n", + "129 44.891362 43.965281 44.818082 -0.170719 1227.373027 10.085330 \n", + "347 40.716275 34.589730 30.394725 -2.414455 1241.087671 78.058167 \n", + "144 36.702892 31.103672 18.732846 -2.841039 1251.382335 65.568697 \n", + "250 72.399710 69.995388 30.788366 0.228903 1195.549966 38.837257 \n", + "99 50.243337 45.002552 46.479799 -0.546100 1247.550698 65.546905 \n", + "400 67.923815 61.153951 65.680911 -0.430136 1206.433224 38.390573 \n", + "87 19.178195 17.085137 17.947542 -1.261463 1271.073983 49.779445 \n", + "\n", + " percent_difference \n", + "335 0.702071 \n", + "248 0.005529 \n", + "187 0.016483 \n", + "129 0.001632 \n", + "347 0.253499 \n", + "144 0.489608 \n", + "250 0.574745 \n", + "99 0.074906 \n", + "400 0.033021 \n", + "87 0.064169 " + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_loop" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "results_loop[\"percent_difference\"] = (results_loop[\"actual\"] - results_loop[\"baseline\"]) / results_loop[\"baseline\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# larger negative is better\n", + "results_loop[\"percent_difference\"].sort_index().plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Requery" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "from watttime_optimizer.evaluator.analysis import analysis_loop_requery" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "interval = 15\n", + "region = \"PJM_CHICAGO\"" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "results_requery = analysis_loop_requery(region=region, interval=interval, input_dict=input_dict, username=username, password=password)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "results_loop_requery = pd.DataFrame.from_dict(\n", + " results_requery,\n", + " orient=\"index\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Requery Contiguous" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "from watttime_optimizer.evaluator.analysis import analysis_loop_requery_contiguous" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/10 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
baselineforecastactualmbstddevpercent_difference
33519.37490017.3644385.772350-0.9659791221.49183536.154509-0.702071
24847.11941045.36259846.8589061.1271391209.01041835.813855-0.005529
18799.03605497.04382997.403682-0.9608451377.71643823.558332-0.016483
12944.89136243.96528144.818082-0.1707191227.37302710.085330-0.001632
34740.71627534.58973030.394725-2.4144551241.08767178.058167-0.253499
\n", + "" + ], + "text/plain": [ + " baseline forecast actual m b stddev \\\n", + "335 19.374900 17.364438 5.772350 -0.965979 1221.491835 36.154509 \n", + "248 47.119410 45.362598 46.858906 1.127139 1209.010418 35.813855 \n", + "187 99.036054 97.043829 97.403682 -0.960845 1377.716438 23.558332 \n", + "129 44.891362 43.965281 44.818082 -0.170719 1227.373027 10.085330 \n", + "347 40.716275 34.589730 30.394725 -2.414455 1241.087671 78.058167 \n", + "\n", + " percent_difference \n", + "335 -0.702071 \n", + "248 -0.005529 \n", + "187 -0.016483 \n", + "129 -0.001632 \n", + "347 -0.253499 " + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_loop.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "results_all = results_loop_requery[[\"baseline\",\"actual\"]].merge(results_loop_requery_c[\"actual\"], suffixes = ['_requery','_requery_c'], left_index=True, right_index=True).merge(results_loop[\"actual\"], left_index=True, right_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "results_all.sort_index().plot(kind=\"bar\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "watttime", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.21" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}