Microgrid.py

# -*- coding: utf-8 -*-
import Tariff
from Tariff import _CostTariff, MicrogridExpTariff, MicrogridImpTariff
import pandas as pd
import pandas.api.types as ptypes
import numpy as np

PLACEHOLDER_COL = "PLACEHOLDER"

class Microgrid:
    """Microgrid object class with attributes required to define the optimisation opt_run.
    Created by Adam T. Deaney 2024 02 15"""
    def __init__(self, name, max_import_power, max_export_power):
        # Validation
        assert isinstance(name, str), "Name must be str type"

        # Attribute Assignment
        self.name = name      # Microgrid name string
        self.storage = {}     # Empty dict of microgrid storage objects
        self.generation = {}  # Empty dict of microgrid generation ob
        self.demand = {}      # Empty dict of microgrid demand objects

        self.PCC = _PCC(max_import_power, max_export_power)  # Point of Common Coupling Object

        self.df_non_disp = None   # Dataframe storing timeseries for aggregated non-dispatch data
        self.df_disp_cost = None  # Dataframe storing timseries of dispatchable costs
        self.df_disp_tariff = None # Datframe storing timeseries of aggregated tariffs
        self.df_opt_profile = None  # Dataframe storing microgrid timeseries data of component flows and storage SOE

    def add_component(self, new_component):
        # Add component to microgrid

        if isinstance(new_component, Generation):  # Append Generation
            self.generation.update({new_component.name: new_component})

        elif isinstance(new_component, Demand):    # Append Demand
            self.demand.update({new_component.name: new_component})

        elif isinstance(new_component, Storage):   # Append Storage
            self.storage.update({new_component.name: new_component})

        else:
            raise TypeError("Input argument not Generation, Demand, or Storage types")

    def _join_non_dispatch(self, start_date, end_date):
        # ToDo: Add QA for joining compatibility
        # Sum costs for non-dispatchable microgrid components
        COL_NAME = ["Flow_kWh", "ImportFlow_kWh", "ExportFlow_kWh", "Cost_£", "ImportCost_£", "ExportCost_£"]
        idx_ideal = gen_df_index(start_date=start_date,
                                 end_date=end_date)

        self.df_non_disp = pd.DataFrame(index=idx_ideal, columns=COL_NAME).fillna(0.0)

        df_list = [self._join_demand(start_date, end_date),
                   self._join_generation(start_date, end_date)]

        for df in df_list:
            self.df_non_disp = self.df_non_disp.merge(df, how="left",
                                                      right_index=True, left_index=True,
                                                      validate='one_to_one',
                                                      suffixes=(None, "_new"))
            self.df_non_disp["Flow_kWh"] += self.df_non_disp["Flow_kWh_new"].fillna(0)
            self.df_non_disp["ImportFlow_kWh"] += self.df_non_disp["ImportFlow_kWh_new"].fillna(0)
            self.df_non_disp["ExportFlow_kWh"] += self.df_non_disp["ExportFlow_kWh_new"].fillna(0)
            self.df_non_disp["Cost_£"] += self.df_non_disp["Cost_£_new"].fillna(0)
            self.df_non_disp["ImportCost_£"] += self.df_non_disp["ImportCost_£_new"].fillna(0)
            self.df_non_disp["ExportCost_£"] += self.df_non_disp["ExportCost_£_new"].fillna(0)

            self.df_non_disp = self.df_non_disp[COL_NAME]




    def _join_demand(self, start_date, end_date):
        COL_NAME = ["Flow_kWh", "ImportFlow_kWh", "ExportFlow_kWh", "Cost_£", "ImportCost_£", "ExportCost_£"]
        idx_ideal = gen_df_index(start_date=start_date,
                                 end_date=end_date)
        df_demand = pd.DataFrame(index=idx_ideal, columns=COL_NAME).fillna(0)

        for dem_obj in self.demand.values():

            if dem_obj.df_tariff_total is None: dem_obj._total_tariff(start_date, end_date)
            if dem_obj.df_cost is None: dem_obj._total_cost()

            df_demand = df_demand.merge(dem_obj.df_cost, how="left",
                                        right_index=True, left_index=True,
                                        validate='one_to_one',
                                        suffixes=(None, "_new"))
            df_demand["Flow_kWh"] += df_demand["Flow_kWh_new"].fillna(0)
            df_demand["ImportFlow_kWh"] += df_demand["ImportFlow_kWh_new"].fillna(0)
            df_demand["ExportFlow_kWh"] += df_demand["ExportFlow_kWh_new"].fillna(0)
            df_demand["Cost_£"] += df_demand["TotalCost_£"].fillna(0)
            df_demand["ImportCost_£"] += df_demand["ImportCost_£_new"].fillna(0)
            df_demand["ExportCost_£"] += df_demand["ExportCost_£_new"].fillna(0)

            df_demand = df_demand[COL_NAME]
        return df_demand


    def _join_generation(self, start_date, end_date):
        COL_NAME = ["Flow_kWh", "ImportFlow_kWh", "ExportFlow_kWh", "Cost_£", "ImportCost_£", "ExportCost_£"]
        idx_ideal = gen_df_index(start_date=start_date,
                                 end_date=end_date)
        df_gen = pd.DataFrame(index=idx_ideal, columns=COL_NAME).fillna(0)

        for gen_obj in self.generation.values():
            gen_obj._total_tariff(start_date, end_date)
            gen_obj._total_cost()

            df_gen = df_gen.merge(gen_obj.df_cost, how="left",
                                  right_index=True, left_index=True,
                                  validate='one_to_one',
                                  suffixes=(None, "_new"))
            df_gen["Flow_kWh"] += df_gen["Flow_kWh_new"].fillna(0)
            df_gen["ImportFlow_kWh"] += df_gen["ImportFlow_kWh_new"].fillna(0)
            df_gen["ExportFlow_kWh"] += df_gen["ExportFlow_kWh_new"].fillna(0)
            df_gen["Cost_£"] += df_gen["TotalCost_£"].fillna(0)
            df_gen["ImportCost_£"] += df_gen["ImportCost_£_new"].fillna(0)
            df_gen["ExportCost_£"] += df_gen["ExportCost_£_new"].fillna(0)

            df_gen = df_gen[COL_NAME]
        return df_gen


    def gen_microgrid_profile(self, start_date, end_date, start_SOE, storage_eff):
        # ToDo: Fix as start_SOE and storage_eff are uneeded
        # Generate timeseries index
        idx_ideal = gen_df_index(start_date=start_date,
                                 end_date=end_date)
        COL_NAME = "PLACEHOLDER"
        self.df_opt_profile = pd.DataFrame(index=idx_ideal, columns=[COL_NAME])

        # Loop through gen/demand objects and join. Edit Col name in form ObjectName_VariableName_Unit
        for gen_obj in self.generation.values():
            self.df_opt_profile = self.df_opt_profile.merge(
                gen_obj.df_profile_kWh.rename(gen_obj.name.replace(" ", "") + "_Flow_kWh"),
                how="left",
                right_index=True, left_index=True,
                validate="one_to_one")

        for demand_obj in self.demand.values():
            self.df_opt_profile = self.df_opt_profile.merge(
                demand_obj.df_profile_kWh.rename(demand_obj.name.replace(" ", "") + "_Flow_kWh"),
                how="left",
                right_index=True, left_index=True,
                validate="one_to_one")

        # Join PCC object and calculate net flow (import - export), assign_col_name
        series_PCC_opt = self.PCC.df_opt_profile["import_kWh"] - self.PCC.df_opt_profile["export_kWh"]

        self.df_opt_profile = self.df_opt_profile.merge(series_PCC_opt.rename("PCC_Flow_kWh"),
                                                        how="left",
                                                        right_index=True, left_index=True,
                                                        validate="one_to_one")

        # Loop through storage objects and join. Calculate battery SOE as per equation. Calc net flow
        for storage_obj in self.storage.values():
            name_edit = storage_obj.name.replace(" ", "_") + "_"
            df_storage = storage_obj.df_opt_profile
            old_col_name = ["Flow_kWh", "SOE_kWh"]
            new_col_name = [name_edit + old_col for old_col in old_col_name]

            for idx in range(len(old_col_name)):
                self.df_opt_profile = self.df_opt_profile.merge(df_storage[old_col_name[idx]].rename(new_col_name[idx]),
                                                                how="left",
                                                                right_index=True, left_index=True,
                                                                validate="one_to_one")

        self.df_opt_profile.drop(axis=1, labels=[COL_NAME], inplace=True)

        return self._push_join_disp_cost()

    def _push_join_disp_cost(self):
        # Calculating PCC costs
        self.PCC.calc_cost()

        # Calculating storage costs
        [storage.calc_cost for storage in self.storage.values()]

        # Calling method to join dispatch costs
        return self._join_disp_cost()

    def _join_disp_cost(self):
        # Creating cost dataframe
        idx = gen_df_index(self.df_opt_profile.index.min(), self.df_opt_profile.index.max())
        self.df_disp_cost = pd.DataFrame(data=0, index=idx, columns=[PLACEHOLDER_COL])

        # Appending PCC costs
        self.df_disp_cost = self.df_disp_cost.merge(right=self.PCC.df_cost.add_prefix("PCC_"),
                                                    how="left",
                                                    left_index=True, right_index=True)

        # Appending storage costs
        for storage in self.storage.values():
            storage_name = storage.name.replace(" ","_")
            if storage.df_cost is not None:
                self.df_disp_cost = self.df_disp_cost.merge(right=storage.df_cost.add_prefix(storage_name + "_"),
                                                            how="left",
                                                            left_index=True, right_index=True)
        # Dropping placeholder column
        self.df_disp_cost.drop(axis=1, labels=[PLACEHOLDER_COL], inplace=True)

        return self._join_disp_tariff()

    def _join_disp_tariff(self):
        # Creating tariff dataframe
        idx = gen_df_index(self.df_opt_profile.index.min(), self.df_opt_profile.index.max())
        self.df_disp_tariff = pd.DataFrame(data=0, index=idx, columns=[PLACEHOLDER_COL])

        # Appending PCC costs
        if self.PCC.df_tariff_total is not None:
            self.df_disp_tariff = self.df_disp_tariff.merge(right=self.PCC.df_tariff_total.add_prefix("PCC_"),
                                                            how="left",
                                                            left_index=True, right_index=True)

        # Appending storage costs
        for storage in self.storage.values():
            storage_name = storage.name.replace(" ", "_")
            if storage.df_tariff_total is not None:
                self.df_disp_tariff = self.df_disp_tariff.merge(right=storage.df_tariff_total.add_prefix(storage_name + "_"),
                                                                how="left",
                                                                left_index=True, right_index=True)
        # Dropping placeholder column
        self.df_disp_tariff = self.df_disp_tariff.drop(axis=1, labels=[PLACEHOLDER_COL])

    def agg_cycle(self, str_freq):
        # Creating tariff dataframe
        idx = gen_df_index(self.df_opt_profile.index.min(), self.df_opt_profile.index.max(), str_freq)
        df_cycle = pd.DataFrame(data=0, index=idx, columns=[PLACEHOLDER_COL])

        # Calculating and appending storage cycling
        for storage in self.storage.values():
            storage_name = storage.name.replace(" ", "_")
            if storage.df_opt_profile is not None:
                df_cycle = df_cycle.merge(right=storage.cycle_rate(str_freq).to_frame().add_prefix(storage_name + "_"),
                                          how="left",
                                          left_index=True, right_index=True)
        # Dropping placeholder column
        df_cycle = df_cycle.drop(axis=1, labels=[PLACEHOLDER_COL])
        return df_cycle

    def unit_supply_cost(self, start_date, end_date):
        load_kWh = self._join_demand(start_date, end_date).loc[:, "ExportFlow_kWh"].sum()
        cost = self.df_disp_cost[start_date:end_date].sum().sum()
        unit_supply_cost = load_kWh / cost
        return unit_supply_cost

    def net_supply_cost(self, start_date, end_date):
        return self.df_disp_cost.loc[start_date:end_date].sum().sum()

class _Component:
    """Component object parent class with attributes required to define child component objects.
       Created by Adam T. Deaney 2024 02 16"""

    def __init__(self, name):
        # Validation
        assert isinstance(name, str), "Name must be str type"

        # Attribute Assignment
        self.name = name.title()   # Component name string
        self.tariff = {}  # Empty dict of tariff objects
        self.QA = {}  # Empty dict of object QA issues
        self.df_tariff_total = None  # df of aggregated tariffs

    def add_tariff(self, tariff):
        # Add tariff obj to microgrid component
        if isinstance(tariff, _CostTariff):  # Append tariff
            self.tariff.update({tariff.name: tariff})
        else:
            raise TypeError("Input argument not _CostTariff (Throughput etc.) type")

    def _total_tariff(self, start_date, end_date):
        # Aggregates component import and export tariffs between specified start_date and end_date
        idx_ideal = gen_df_index(start_date=start_date,
                                 end_date=end_date)
        COL_NAME = ["Import_£/kWh", "Export_£/kWh"]
        self.df_tariff_total = pd.DataFrame(index=idx_ideal, columns=COL_NAME).fillna(0)

        # Iterate through each tariff
        for tariff in self.tariff.values():
            self.df_tariff_total = self.df_tariff_total.merge(tariff.value_profile, how='left',
                                                              left_index=True, right_index=True,
                                                              validate='one_to_one')

            if self.df_tariff_total['Value_£/kWh'].isna().any():
                self.QA.update({"Tariff object (%s) has missing data for optimisation period specified" % (tariff.name):
                                self.df_tariff_total.loc[self.df_tariff_total['Value_£/kWh'].isna()]})
                self.df_tariff_total['Value_£/kWh'] = self.df_tariff_total['Value_£/kWh'].fillna(0)

            if isinstance(tariff, (Tariff.MicrogridImpTariff, Tariff.ThroughputTariff)):
                self.df_tariff_total["Import_£/kWh"] = self.df_tariff_total["Import_£/kWh"] + \
                                                       self.df_tariff_total['Value_£/kWh']
            elif isinstance(tariff, (Tariff.MicrogridExpTariff, Tariff.ThroughputTariff)):
                self.df_tariff_total["Export_£/kWh"] = self.df_tariff_total["Export_£/kWh"] + \
                                                       self.df_tariff_total['Value_£/kWh']

            self.df_tariff_total = self.df_tariff_total[COL_NAME]


class NonDispatch(_Component):
    """Non Dispatchable object class with attributes required to define microgrid embedded generation or load.

    INPUTS
     - name = Name of Component
     - profile_kWh = Component energy flow timeseries in kWh, where...
                     +Ve = Energy flow from component to microgrid (e.g. Generation)
                     -Ve = Energy flow from microgrid to component (e.g. Demand)

    Created by Adam T. Deaney 2024 02 22"""
    def __init__(self, name, df_profile_kWh):
        # Validation
        assert isinstance(df_profile_kWh, pd.core.series.Series), "Profile must be series type"
        assert df_profile_kWh.index._is_all_dates, "Profile index must be datetime"
        assert ptypes.is_numeric_dtype(df_profile_kWh), "Profile values must be float"

        # Cleaning
        df_profile_kWh.rename('Flow_kWh', inplace=True)

        # Attribute Assignment
        _Component.__init__(self, name)
        self.df_profile_kWh = df_profile_kWh
        self.df_cost = None  # Used to store cost timeseries

        # QA
        self._QA_df_profile_kWh()  # Run QA script on df_profile_kWh

    def _QA_df_profile_kWh(self):
        idx_ideal = gen_df_index(start_date=self.df_profile_kWh.index.min(),
                                 end_date=self.df_profile_kWh.index.max())

        df_idx_ideal = pd.DataFrame(index=idx_ideal)
        if not self.df_profile_kWh.index.equals(df_idx_ideal):
            self.df_profile_kWh = df_idx_ideal.merge(self.df_profile_kWh, how='left',
                                                     left_index=True, right_index=True,
                                                     validate='one_to_one').squeeze()
            self.QA.update({"df_profile_kWh has missing half hourly data":
                            self.df_profile_kWh.loc[self.df_profile_kWh.isna()]})
            self.df_profile_kWh = self.df_profile_kWh.fillna(0)

    def _total_cost(self):
        # Calculates total cost of electricity flows for non dispatchable components
        #   Energy Flow Sign Convention:
        #   +Ve = Energy flow from component to microgrid (e.g. Generation)
        #   -Ve = Energy flow from microgrid to component (e.g. Demand)
        #   UNLESS flow direction is specified by column names such as import or export and the flow values are absolute

        # Validation
        assert self.df_tariff_total.index.equals(self.df_profile_kWh.index), "Index of df_tariff_total must be the" \
                                                                          "same as profile_kWh"
        # Merge df_profile_kWh and df_tariff_total for subsequent calculations
        self.df_cost = self.df_profile_kWh.to_frame().merge(self.df_tariff_total, how='left',
                                                            left_index=True, right_index=True,
                                                            validate='one_to_one')

        # Separating export (+Ve flow) and import (-Ve flow) flows from component to microgrid for cost calculation
        self.df_cost['ExportFlow_kWh'] = self.df_cost['Flow_kWh'].loc[self.df_cost['Flow_kWh'] < 0]
        self.df_cost['ImportFlow_kWh'] = self.df_cost['Flow_kWh'].loc[self.df_cost['Flow_kWh'] > 0]
        self.df_cost['ExportFlow_kWh'] = self.df_cost['ExportFlow_kWh'].fillna(0)
        self.df_cost['ImportFlow_kWh'] = self.df_cost['ImportFlow_kWh'].fillna(0)
        self.df_cost['ExportFlow_kWh'] = self.df_cost['ExportFlow_kWh'].abs()
        self.df_cost['ImportFlow_kWh'] = self.df_cost['ImportFlow_kWh'].abs()

        # Aggregating Cost
        self.df_cost['ExportCost_£'] = self.df_cost['ExportFlow_kWh'] * self.df_cost['Export_£/kWh']
        self.df_cost['ImportCost_£'] = self.df_cost['ImportFlow_kWh'] * self.df_cost['Import_£/kWh']
        self.df_cost['TotalCost_£'] = self.df_cost['ExportCost_£'] + self.df_cost['ImportCost_£']


class Generation(NonDispatch):
    """Generation object class with attributes required to define a source of microgrid embedded generation.
    Created by Adam T. Deaney 2024 02 15"""

    #   Energy Flow Sign Convention:
    #   +Ve = Energy flow from component to microgrid (e.g. Generation)
    #   -Ve = Energy flow from microgrid to component (e.g. Demand)
    #   UNLESS flow direction is specified by column names such as import or export and the flow values are absolute
    def __init__(self, name, profile_kWh):
        # Validation
        if not profile_kWh.apply(lambda x: np.sign(x)).nunique() in [1, 2]:
            raise ValueError("""Generation input profile_kWh should have values with the same sign, as generation
                                is assumed to only export electricity to the Microgrid. Use the NonDispatch object 
                                if this component both imports electricity from and exports electricity to the 
                                microgrid.""")

        # Attribute Assignment
        NonDispatch.__init__(self, name, profile_kWh.abs())  # Passing values to Non-Dispatch parent class


class Demand(NonDispatch):
    """Demand object class with attributes required to define a component of microgrid electricity demand.
    Created by Adam T. Deaney 2024 02 15"""

    #   Energy Flow Sign Convention:
    #   +Ve = Energy flow from component to microgrid (e.g. Generation)
    #   -Ve = Energy flow from microgrid to component (e.g. Demand)
    #   UNLESS flow direction is specified by column names such as import or export and the flow values are absolute

    def __init__(self, name, profile_kWh):
        # Validation
        if not profile_kWh.apply(lambda x: np.sign(x)).nunique() in [1, 2]:
            raise ValueError("""Demand input profile_kWh should have values with the same sign, as demand
                                is assumed to only import electricity from the Microgrid. Use the NonDispatch object 
                                if this component both imports electricity from and exports electricity to the 
                                microgrid.""")

        # Attribute Assignment
        NonDispatch.__init__(self, name, -profile_kWh.abs())  # Passing values to Non-Dispatch parent class


class Dispatch(_Component):
    """Dispatch object class with attributes used to define a dispatchable microgrid component.
       Created by Adam T. Deaney 2024 03 02"""
    def __init__(self, name):
        # Attribute Assignment
        _Component.__init__(self, name)
        self.df_opt_profile = None  # Optimised profile df
        self.df_cost = None  # Component cost data (tariff granularity)

    def append_sol(self, df_opt_profile):
        # Validation
        assert isinstance(df_opt_profile, (pd.core.series.Series, pd.DataFrame)), "Dataframe or Series Input"

        # Attribute Assignment
        self.df_opt_profile = df_opt_profile

        # Calculate net component flow
        self.calc_flow()

    def calc_flow(self):
        # Calculate net flow in optimised profile
        self.df_opt_profile["Flow_kWh"] = self.df_opt_profile["import_kWh"] - self.df_opt_profile["export_kWh"]

    def calc_cost(self):
        # Creating cost dataframe
        idx = gen_df_index(self.df_opt_profile.index.min(), self.df_opt_profile.index.max())
        self.df_cost = pd.DataFrame(data=0, index=idx, columns=[PLACEHOLDER_COL])

        # Iterating through tariffs
        for tariff in self.tariff.values():
            tariff_name = tariff.name.replace(" ", "_") + "_£"

            df_merge = self.df_opt_profile.merge(right=tariff.value_profile,
                                                 how="left",
                                                 left_index=True, right_index=True)
            # Import
            if isinstance(tariff, (MicrogridImpTariff)):
                df_merge[tariff_name] = df_merge["import_kWh"] * df_merge["Value_£/kWh"]
            elif isinstance(tariff, (MicrogridExpTariff)):
                df_merge[tariff_name] = df_merge["export_kWh"] * df_merge["Value_£/kWh"]
            elif isinstance(tariff, (ThroughputTariff)):
                df_merge[tariff_name] = (df_merge["import_kWh"] + df_merge["export_kWh"]) * df_merge["Value_£/kWh"]

            # Merging into cost_df
            self.df_cost = self.df_cost.merge(right=df_merge[[tariff_name]],
                                              how="left",
                                              left_index=True, right_index=True)
        # Dropping Placeholder Col
        self.df_cost.drop(axis=1, labels=[PLACEHOLDER_COL], inplace=True)

    def avg_tariff(self, str_freq="D"):
        """Calculates weighted average tariffs over period specified"""
        df_avg = (self.df_cost
                  .merge(right=self.df_opt_profile, how="left",
                         right_index=True, left_index=True)
                  .resample(str_freq).sum()
                  )

        df_avg["Avg_Export_Tariff_£/kWh"] = df_avg["Export_Cost_£"] / df_avg["export_kWh"]
        df_avg["Avg_Import_Tariff_£/kWh"] = df_avg["Import_Cost_£"] / df_avg["import_kWh"]
        df_avg["Avg_Unit_Net_Gain_£/kWh"] = - df_avg["Avg_Export_Tariff_£/kWh"].fillna(0.0)\
                                            - df_avg["Avg_Import_Tariff_£/kWh"].fillna(0.0)

        return df_avg

class _PCC(Dispatch):
    """Point of Common Coupling (PCC) object class with attributes to define optimisation opt_run
       Created by Adam T. Deaney 2024 02 16"""
    def __init__(self, max_import_power, max_export_power):
        # Validation
        assert isinstance(max_import_power, (float, int)), "Max Import Power must be numeric type"
        assert isinstance(max_export_power, (float, int)), "Max Export Power must be numeric type"

        # Attribute Assignment
        Dispatch.__init__(self, "PCC")
        self.max_import_power = abs(max_import_power)
        self.max_export_power = abs(max_export_power)


class Storage(Dispatch):
    """Storage object class with attributes used to define a component of microgrid electricity storage.
    Created by Adam T. Deaney 2024 02 15"""
    def __init__(self, name, max_SOE, min_SOE, max_charge_power, max_discharge_power, storage_eff):
        # Validation
        assert isinstance(max_SOE, (float, int)), "Max SOE must be numeric type"
        assert isinstance(min_SOE, (float, int)), "Min SOE must be numeric type"
        assert isinstance(max_charge_power, (float, int)), "Max charge power must be numeric type"
        assert isinstance(max_discharge_power, (float, int)), "Max discharge power must be numeric type"
        assert abs(max_SOE) > abs(min_SOE), "max_SOE must be greater than min_SOE"
        assert isinstance(storage_eff, (float, int)), "Round trip storage efficiency must be numeric type"
        assert abs(storage_eff) <= 1, "Round trip storage efficiency must be less than or equal to 1"

        # Attribute Assignment
        Dispatch.__init__(self, name)
        self.max_SOE = abs(max_SOE)
        self.min_SOE = abs(min_SOE)
        self.max_charge_power = abs(max_charge_power)
        self.max_discharge_power = abs(max_discharge_power)
        self.storage_eff = abs(storage_eff)

    def cycle_rate(self, str_freq="D", roll_window=None):
        """Calculate the cycle rate frequency over the frequency specified (Defaults to day)"""
        # Verify df_profile exists, else raise assertion error
        assert self.df_opt_profile is not None, "Optimised profile must exist to calculate battery cycling"
        assert roll_window is None or isinstance(roll_window, int), "Roll window, if specfied must correspond to integer multiple of freq_str "

        # Initial Aggregation
        df_cycle = (self
                    .df_opt_profile
                    .loc[:,"import_kWh"] # Select import_kWh flows (battery discharge = microgrid imports)
                    .resample(str_freq)  # Resample on input specified for aggregation
                    .sum()               # Sum discharge flows
                    / self.dSOE_max())   # Divide by maximum change in state of energy


        # If roll_window specified, calculate rolling average over period specified
        if roll_window is not None:
            df_cycle = df_cycle.rolling(roll_window).mean()

        return df_cycle.rename("cycles")

    def dSOE_max(self):
        """Calculate maximum change in SOE over a charging cycle"""
        return self.max_SOE - self.min_SOE

def gen_df_index(start_date, end_date, str_freq="30min"):
    "Helper function that generates df indexes of settlement periods between start and end datetime"
    idx_ideal = pd.date_range(start=start_date,
                              end=end_date,
                              freq=str_freq)

    if idx_ideal.tz is None:
        idx_ideal = idx_ideal.tz_localize('UTC')

    return idx_ideal