def test_wrong_record_type():
tariff = Tariff(
monthly_fee=900,
free_minutes=100,
numbers_free_of_charge={'+420732563345', '+420707325673'},
fee_for_minute_same_operator=Decimal(0),
fee_for_minute_different_operator=Decimal(0),
free_sms_count=0,
fee_for_sms_same_operator=Decimal(0),
fee_for_sms_different_operator=Decimal(0),
)
billing = Billing(tariff)
with pytest.raises(WrongRecordType):
billing.add_records_from_csv_file(
'test_billing_csvs/test_wrong_record_type.csv')
def collect_stats(site,
target_set,
peaks=True,
intervals=False,
max_baseline=False):
stat_set = []
max_peak = max([max(t['soc']) for t in target_set])
for target in target_set:
tariff = Tariff('pge')
target = tariff.apply_period(load=target)
stat_set.append(
get_target_stats(site,
target,
peaks=peaks,
intervals=intervals,
max_baseline=max_baseline,
max_peak=max_peak))
return stat_set
def get_demand_reductions(df, targets, config):
peak_demand_reductions = []
mid_peak_demand_reductions = []
non_coincident_demand_reductions = []
tariff = Tariff(config['site_id'])
bill_calculator = BillCalculator(config['site_id'])
for num, month in enumerate(targets):
baseline_demand = bill_calculator.demand_peaks(month,
load_column="baseline")
target_demand = bill_calculator.demand_peaks(month,
load_column="load_values")
season = tariff.season(month.timestamp.iloc[0])
if season == "summer":
nc_baseline = baseline_demand["summer"]["Non-Coincident"]
nc_target = target_demand["summer"]["Non-Coincident"]
mp_baseline = baseline_demand["summer"]["Mid-Peak"]
mp_target = target_demand["summer"]["Mid-Peak"]
op_baseline = baseline_demand["summer"]["On-Peak"]
op_target = target_demand["summer"]["On-Peak"]
non_coincident_demand_reductions.append(nc_baseline - nc_target)
mid_peak_demand_reductions.append(mp_baseline - mp_target)
peak_demand_reductions.append(op_baseline - op_target)
elif season == "winter":
nc_baseline = baseline_demand["winter"]["Non-Coincident"]
nc_target = target_demand["winter"]["Non-Coincident"]
mp_baseline = baseline_demand["winter"]["Mid-Peak"]
mp_target = target_demand["winter"]["Mid-Peak"]
non_coincident_demand_reductions.append(nc_baseline - nc_target)
mid_peak_demand_reductions.append(mp_baseline - mp_target)
peak_demand_reductions.append(0)
df = df.assign(peak_demand_reductions=peak_demand_reductions)
df = df.assign(midpeak_demand_reductions=mid_peak_demand_reductions)
df = df.assign(
non_coincident_demand_reductions=non_coincident_demand_reductions)
return df
def test_free_tariff():
tariff = Tariff(
monthly_fee=900,
free_minutes=100,
numbers_free_of_charge={'+420732563345', '+420707325673'},
fee_for_minute_same_operator=Decimal(0),
fee_for_minute_different_operator=Decimal(0),
free_sms_count=0,
fee_for_sms_same_operator=Decimal(0),
fee_for_sms_different_operator=Decimal(0),
)
billing = Billing(tariff)
billing.add_records_from_csv_file('test_billing_csvs/test_free_tariff.csv')
print(billing)
assert billing.charged_total == 0
assert pytest.approx(billing.paid_minutes_same_operator, 39.32)
assert billing.charged_for_minutes_same_operator == 0
assert pytest.approx(billing.paid_minutes_different_operator, 79.78)
assert billing.charged_for_minutes_different_operator == 0
assert billing.paid_sms_count_same_operator == 13
assert billing.paid_sms_count_different_operator == 15
from tariff import Tariff
from user import User
from comparator import Comparator
# Object For Electric Companies ( Name ,
Elect_Com = []
Elect_Com.append(
Tariff("ENTEGA", [
'Freiburg', 'Stuttgart', 'Karlsruhe', 'Frankfurt', 'Berlin', 'Munich'
], "GrunerTraum", 7.12, 9.12, "Green"))
Elect_Com.append(
Tariff("Eon", [
'Freiburg', 'Stuttgart', 'Karlsruhe', 'Frankfurt', 'Berlin', 'Munich'
], "Grun_Energien", 7.45, 9.45, "Green"))
Elect_Com.append(
Tariff("Badenova", ['Freiburg', 'Stuttgart', 'Karlsruhe', 'Frankfurt'],
"Express_Package", 6.25, 8.25, "Mixed"))
Elect_Com.append(
Tariff("EnBW", ['Freiburg', 'Stuttgart', 'Karlsruhe', 'Frankfurt'],
"EnBW_Package", 6.95, 8.95, "Mixed"))
## Object For Consumers ( USERId, Name , Occupants , Type of Consumer , Location , Generation Type Needed , Monthly Consumption , Month )
User_Profile = []
User_Profile.append(User("123", "Jack", 3, "Pvt", "Freiburg", "Green", 300, 1))
User_Profile.append(
User("125", "Jone", 100, "Com", "Freiburg", "Mixed", 1500, 1))
User_Profile.append(User("127", "Tom", 5, "Pvt", "Stuttgart", "Mixed", 450, 1))
User_Profile.append(User("129", "Julia", 1, "Pvt", "Karlsruhe", "ANY", 200, 1))
# Calculate Prices for Single Consumer based on its choice
def __init__(self, config, optimize_energy=True):
"""
Initialize the Optimizer object.
:param dict config: dictionary with input configurations
"""
self.tariff_id = config.get('tariff_id') or config['site_id']
self.tariff = Tariff(self.tariff_id)
self.start = config['start']
self.end = config['end']
self.optimize_energy = optimize_energy
# Load performance parameters from configuration
self.mcl = config['MCL']
self.mdl = config['MDL']
self.mrc = config['MRC']
self.rb_capacity = config['RB_capacity']
self.soc_init = config['SOC_initial']
self.soc_final = config.get('SOC_final', self.soc_init)
self.rb_min_soc = config.get('RB_min_soc', 0)
self.min_charge_offset = config['min_charge_offset']
self.min_discharge_offset = config['min_discharge_offset']
self.rte_setpoint = config.get('RTE_setpoint')
self.cop_dchg_coefficients = config['cop_dchg_coefficients']
self.cop_chg_coefficients = config['cop_chg_coefficients']
self.heat_leak_coefficients = config.get('heat_leak_coefficients')
self.chg_limit_curve = config.get('chg_limit_curve')
self.dchg_limit_curve = config.get('dchg_limit_curve')
self.demand_peaks = config.get('peaks')
# Create peak structure with zero values of all peaks if peaks are
# not included
if not self.demand_peaks:
self.demand_peaks = copy.deepcopy(self.tariff.demand_rates())
for season in self.demand_peaks:
for peak in self.demand_peaks[season]:
self.demand_peaks[season][peak] = 0
# Load selectable constraints and output
self.constraints = config.get('constraints')
self.outputs = config.get('outputs')
# Load big M variable value
self.big_m = config['M']
# Fetch dataframe wih 15 min interval timestamps and time labels
self.timestamp_df = time_ops.get_timestamps(self.start, self.end)
# Create list of time labels
self.time_labels = list(self.timestamp_df.time_label)
# Create mapping of time labels to timestamps
self.timestamp_labels = dict(
zip(self.timestamp_df.time_label, self.timestamp_df.timestamp))
# Define a frame & set it up as an LP Minimization problem
self.frame = pulp.LpProblem(
"Simple schedule optimization",
pulp.LpMinimize)
# Decision variables
self.soc = None
self.dof = None
self.cof = None
self.y = None
self.max_peaks = None
# Define a dictionary to hold the final values for the decision
# variables once the optimizer has solved the problem
self.decision_variables = {}
# Constraints
self.chg_limits = None
self.dchg_limits = None
self.cop_dchg = None
self.cop_chg = None
paid_minutes_same_operator=self.paid_minutes_same_operator,
charged_for_seconds_same_operator=self.charged_for_minutes_same_operator,
paid_sms_count_same_operator=self.paid_sms_count_same_operator,
charged_for_sms_same_operator=self.charged_for_sms_same_operator,
paid_minutes_different_operator=self.paid_minutes_different_operator,
charged_for_seconds_different_operator=self.charged_for_minutes_different_operator,
paid_sms_count_different_operator=self.paid_sms_count_different_operator,
charged_for_sms_different_operator=self.charged_for_sms_different_operator,
)
if __name__ == '__main__':
tariff = Tariff(
monthly_fee=900,
free_minutes=100,
numbers_free_of_charge={'+420732563345', '+420707325673'},
fee_for_minute_same_operator=Decimal(1.50),
fee_for_minute_different_operator=Decimal(3.50),
free_sms_count=10,
fee_for_sms_same_operator=Decimal(1.0),
fee_for_sms_different_operator=Decimal(2.0),
)
billing = Billing(tariff)
billing.add_records_from_csv_file('data.csv')
print(billing)
