325 lines
12 KiB
Ruby
325 lines
12 KiB
Ruby
require 'open-uri'
|
|
require 'gr/plot'
|
|
EASY_ENERGY_TARIFFS = {}
|
|
|
|
# See https://www.belastingdienst.nl/wps/wcm/connect/bldcontentnl/belastingdienst/zakelijk/overige_belastingen/belastingen_op_milieugrondslag/tarieven_milieubelastingen/tabellen_tarieven_milieubelastingen
|
|
# Without VAT
|
|
ENERGY_TAX_KWH = { 2020 => 0.09770, 2021 => 0.09428, 2022 => 0.03679}
|
|
ODE_KWH = { 2020 => 0.0273, 2021 => 0.0300, 2022 => 0.0305}
|
|
# merge by adding values
|
|
TAX_KWH = ENERGY_TAX_KWH.merge(ODE_KWH){|key, energy_tax, ode| energy_tax + ode}
|
|
|
|
|
|
class Cost
|
|
|
|
attr_accessor :max_charge_kwh
|
|
attr_reader :battery, :entsoe, :zone
|
|
|
|
def initialize(zone="Amsterdam", battery_capacity=10.0, max_charge=5.0, storage_cost=0.05)
|
|
@zone = zone
|
|
@entsoe = Entsoe.new(zone, storage_cost)
|
|
@max_charge_kwh = max_charge
|
|
@battery = Battery.new(battery_capacity)
|
|
end
|
|
|
|
# Government reduced VAT to 9% from 1 July 2022 until 31 Dec 2022
|
|
def vat_at(date)
|
|
jul22 = Date.parse("2022-09-01")
|
|
dec22 = Date.parse("2022-12-31")
|
|
if (date >= jul22 && date <= dec22)
|
|
0.09
|
|
else
|
|
0.21
|
|
end
|
|
end
|
|
|
|
def format_cost(cost)
|
|
cost ? "EUR %0.03f" % cost : "EUR ?"
|
|
end
|
|
|
|
# Assume: usage_kwh_cost, return_kwh_cost already includes vat
|
|
def add_tax(formatted_hour,usage_kwh,usage_kwh_cost,return_kwh, return_kwh_cost)
|
|
return nil if (usage_kwh.nil? || usage_kwh_cost.nil? || return_kwh.nil? || return_kwh_cost.nil?)
|
|
|
|
vat = 1 + vat_at(Date.parse(formatted_hour))
|
|
year = Date.parse(formatted_hour).year
|
|
# calculate tax per kwh - which the sum of energy_tax and ode
|
|
tax = TAX_KWH[year]*vat
|
|
|
|
usage_kwh * (usage_kwh_cost + tax) - return_kwh * (return_kwh_cost + tax)
|
|
|
|
end
|
|
|
|
######################################################
|
|
# Easy Energy - makes use of entsoe, adds EasyEnergy opslag
|
|
######################################################
|
|
|
|
def easy_energy_rate(formatted_hour)
|
|
year = Date.parse(formatted_hour).year
|
|
month = Date.parse(formatted_hour).month
|
|
|
|
case year
|
|
when 2020..2021
|
|
# opslag, zonder BTW
|
|
0.00800
|
|
when 2022
|
|
case month
|
|
when 1..11
|
|
# opslag, before increase
|
|
0.00800
|
|
when 12
|
|
# opslag, met BTW: 0,01962
|
|
0.018
|
|
end
|
|
when 2023
|
|
0.018
|
|
end
|
|
end
|
|
|
|
def easy_energy_cost(formatted_hour, usage_kwh, return_kwh)
|
|
return nil if (usage_kwh.nil? || return_kwh.nil?)
|
|
|
|
usage_kwh_cost = return_kwh_cost = (entsoe.price_at(formatted_hour)+easy_energy_rate(formatted_hour))*(1+vat_at(Date.parse(formatted_hour)))
|
|
add_tax(formatted_hour, usage_kwh, usage_kwh_cost, return_kwh, return_kwh_cost)
|
|
end
|
|
|
|
def easy_energy_hours(date)
|
|
hour_start = date.in_time_zone(zone).beginning_of_day
|
|
day_end = hour_start.advance(days: 1)
|
|
result = []
|
|
while(hour_start < day_end) do
|
|
formatted_hour = hour_start.strftime("%F %H")
|
|
result << easy_energy_cost(formatted_hour, 1, 0)
|
|
hour_start = hour_start.advance(:hours => 1)
|
|
end
|
|
result
|
|
end
|
|
|
|
def easy_energy_tariff_barplot(date)
|
|
hours = (0..23).to_a
|
|
costs = easy_energy_hours(date)
|
|
GR.barplot(hours,costs)
|
|
# make sure you have set GKS_WSTYPE=100 in the environment (for headless setup)
|
|
title = "Tarief per kwH (incl. belastingen en BTW) - %s" % date.strftime("%A, %e %B %Y")
|
|
xlabel = "uur"
|
|
ylabel = "EUR"
|
|
GR.savefig("plots/easy_tariff_%s.png" % date.strftime("%F"), title: title, xlabel: xlabel, ylabel: ylabel)
|
|
end
|
|
|
|
def easy_energy_cost_barplot(date)
|
|
hour_start = date.in_time_zone(zone).beginning_of_day
|
|
day_end = hour_start.advance(days: 1)
|
|
costs = []
|
|
while(hour_start < day_end) do
|
|
# get usage_kwh/return_kwh for one hour
|
|
hour_end = hour_start.end_of_hour
|
|
hour_readings = Reading.where("created_at > :begin AND created_at < :end", {:begin => hour_start, :end => hour_end})
|
|
hour_diff = hour_readings.last ? hour_readings.last.diff(hour_readings.first) : UNKNOWN_READING
|
|
usage_kwh = hour_diff[:total_kwh_consumed_high] + hour_diff[:total_kwh_consumed_low]
|
|
return_kwh = hour_diff[:total_kwh_produced_high] + hour_diff[:total_kwh_produced_low]
|
|
|
|
formatted_hour = hour_start.strftime("%F %H")
|
|
costs << easy_energy_cost(formatted_hour, usage_kwh, return_kwh)
|
|
# do the next hour
|
|
hour_start = hour_start.advance(:hours => 1)
|
|
end
|
|
|
|
# create plot
|
|
hours = (0..23).to_a
|
|
GR.barplot(hours,costs)
|
|
# make sure you have set GKS_WSTYPE=100 in the environment (for headless setup)
|
|
title = "Verbruikskosten (incl. belastingen en BTW) - %s" % date.strftime("%A, %e %B %Y")
|
|
xlabel = "uur"
|
|
ylabel = "EUR"
|
|
GR.savefig("plots/easy_cost_%s.png" % date.strftime("%F"), title: title, xlabel: xlabel, ylabel: ylabel)
|
|
|
|
# return the sum cost
|
|
costs.sum
|
|
end
|
|
|
|
|
|
######################################################
|
|
# Oxxio rates and cost
|
|
######################################################
|
|
|
|
def oxxio_rate(formatted_hour, high_tariff)
|
|
year = Date.parse(formatted_hour).year
|
|
case year
|
|
when 2020
|
|
high_tariff ? 0.07865 : 0.06215
|
|
when 2021
|
|
high_tariff ? 0.06782 : 0.05259
|
|
when 2022
|
|
high_tariff ? 0.23665 : 0.19408
|
|
end
|
|
end
|
|
|
|
def oxxio_energy_cost(formatted_hour, normaal_kwh, dal_kwh, year_shift=0)
|
|
return nil if (normaal_kwh.nil? || dal_kwh.nil?)
|
|
#year = Date.parse(formatted_hour).year+year_shift
|
|
date = Date.parse(formatted_hour).advance(years: year_shift)
|
|
case date.to_time.to_i
|
|
# Date.parse("2019-12-08").to_time.to_i
|
|
# From 8 Dec 2019 until 7 Dec 2020
|
|
when 1575763200..1607385599
|
|
#normaal_kwh * (0.07865 + 0.11822 + 0.03303) + dal_kwh * (0.06215 + 0.11822 + 0.03303)
|
|
normaal_kwh_cost = 0.07865
|
|
dal_kwh_cost = 0.06215
|
|
# From 8 Dec 2020 until 7 Dec 2021
|
|
when 1607385600..1638921599
|
|
#normaal_kwh * (0.06782 + 0.11408 + 0.03630) + dal_kwh * (0.05259 + 0.11408 + 0.03630)
|
|
normaal_kwh_cost = 0.06782
|
|
dal_kwh_cost = 0.05259
|
|
# From 8 Dec 2021 until 7 Sept 2022
|
|
when 1638921600..1662595199
|
|
# normaal_kwh * (0.23665 + 0.04452 + 0.03691) + dal_kwh * (0.19408 + 0.04452 + 0.03691)
|
|
normaal_kwh_cost = 0.23665
|
|
dal_kwh_cost = 0.19408
|
|
# From 8 Sept 2022 until 31 December 2025 (may need to extend this)
|
|
when 1662595200..1767139200
|
|
normaal_kwh_cost = 0.60824
|
|
dal_kwh_cost = 0.43701
|
|
else
|
|
# catch-all, incase 'formated_hour' is outside any of the cases
|
|
normaal_kwh_cost = 0.0
|
|
dal_kwh_cost = 0.0
|
|
end
|
|
normaal_cost = add_tax(formatted_hour, normaal_kwh,normaal_kwh_cost,0,0) # return_kwh already accounted for
|
|
dal_cost = add_tax(formatted_hour, dal_kwh, dal_kwh_cost,0,0)
|
|
# result
|
|
normaal_cost + dal_cost
|
|
end
|
|
|
|
#
|
|
# Entsoe
|
|
#
|
|
|
|
def entsoe_energy_cost(formatted_hour, usage_kwh, return_kwh)
|
|
return nil if (usage_kwh.nil? || return_kwh.nil?)
|
|
|
|
usage_kwh_cost = return_kwh_cost = entsoe.price_at(formatted_hour)*(1+vat_at(Date.parse(formatted_hour)))
|
|
add_tax(formatted_hour, usage_kwh, usage_kwh_cost, return_kwh, return_kwh_cost)
|
|
end
|
|
|
|
######################################################
|
|
# Calculate the per_hour usage and costs
|
|
######################################################
|
|
|
|
def hours(date, year_shift=0)
|
|
hour_start = date.in_time_zone(zone).beginning_of_day
|
|
day_end = hour_start.advance(days: 1)
|
|
result = []
|
|
lowest_hour, highest_hour,high_hours = entsoe.high_low_hours(date.advance(years: year_shift))
|
|
|
|
while(hour_start < day_end) do
|
|
hour_end = hour_start.end_of_hour
|
|
|
|
#p "Fetching meter readings between %s and %s" % [hour_start,hour_end]
|
|
hour_readings = Reading.where("created_at > :begin AND created_at < :end", {:begin => hour_start, :end => hour_end})
|
|
hour_diff = hour_readings.last ? hour_readings.last.diff(hour_readings.first) : UNKNOWN_READING
|
|
# calculate cost of this hour
|
|
usage_kwh = hour_diff[:total_kwh_consumed_high] + hour_diff[:total_kwh_consumed_low] rescue nil
|
|
return_kwh = hour_diff[:total_kwh_produced_high] + hour_diff[:total_kwh_produced_low] rescue nil
|
|
|
|
formatted_hour = hour_start.advance(years: year_shift).strftime("%F %H")
|
|
easy_cost = easy_energy_cost(formatted_hour, usage_kwh, return_kwh) # without battery use
|
|
|
|
#
|
|
# Make battery work
|
|
#
|
|
if !usage_kwh.nil?
|
|
# charge battery with return_kwh
|
|
return_kwh -= battery.charge(return_kwh)
|
|
|
|
if (lowest_hour.eql?(formatted_hour) || entsoe.price_at(formatted_hour) < 0) # lowest_hour = "" if small difference between high/low
|
|
# charge battery during lowest hour, or when prices are negative
|
|
usage_kwh += battery.charge(max_charge_kwh)
|
|
else
|
|
# if during expensive hours || more than <max_charge_kwh> kwh then discharge_battery
|
|
# if (battery.battery_kwh > max_charge_kwh) || high_hours.include?(formatted_hour)
|
|
if high_hours.include?(formatted_hour)
|
|
usage_kwh -= battery.discharge(usage_kwh)
|
|
end
|
|
end
|
|
end
|
|
easy_cost_with_battery = easy_energy_cost(formatted_hour, usage_kwh, return_kwh) # with battery use
|
|
|
|
#
|
|
# end of battery work
|
|
#
|
|
|
|
normal_usage_kwh = hour_diff[:total_kwh_consumed_low] - hour_diff[:total_kwh_produced_low] rescue nil
|
|
low_usage_kwh = hour_diff[:total_kwh_consumed_high] - hour_diff[:total_kwh_produced_high] rescue nil
|
|
oxxio_cost = oxxio_energy_cost(formatted_hour,normal_usage_kwh, low_usage_kwh, year_shift)
|
|
oxxio_rate = oxxio_rate(formatted_hour, (hour_readings.first.high_tarif rescue true))
|
|
|
|
one_hour = [formatted_hour,
|
|
hour_diff[:total_kwh_consumed_high],
|
|
hour_diff[:total_kwh_consumed_low],
|
|
hour_diff[:total_kwh_produced_high],
|
|
hour_diff[:total_kwh_produced_low],
|
|
usage_kwh,
|
|
return_kwh,
|
|
battery.battery_kwh,
|
|
entsoe.price_at(formatted_hour), # entsoe rate
|
|
easy_cost_with_battery,
|
|
easy_cost,
|
|
oxxio_rate,
|
|
oxxio_cost]
|
|
|
|
p "%s,%s,%s,%s,%s,%s,%s,%0.1f,%s,%s,%s,%s,%s" % (one_hour[0..7] + one_hour[8..12].map{|c| format_cost(c)})
|
|
result << one_hour
|
|
|
|
hour_start = hour_start.advance(:hours => 1)
|
|
end
|
|
result
|
|
end
|
|
|
|
def summarize_hours(hours)
|
|
usage_kwh = hours.map{|e| (e[1] && e[2]) ? (e[1] + e[2]) : nil}.compact.sum
|
|
return_kwh = hours.map{|e| (e[3] && e[4]) ? (e[3] + e[4]) : nil}.compact.sum
|
|
usage_kwh_with_battery = hours.map{|e| e[5]}.compact.sum
|
|
return_kwh_with_battery = hours.map{|e| e[6]}.compact.sum
|
|
entsoe_cost_with_battery = hours.map{|e| e[9]}.compact.sum
|
|
entsoe_cost = hours.map{|e| e[10]}.compact.sum
|
|
oxxio_cost = hours.map{|e| e[12]}.compact.sum
|
|
|
|
return usage_kwh, return_kwh, usage_kwh_with_battery, return_kwh_with_battery, format_cost(entsoe_cost_with_battery), format_cost(entsoe_cost), format_cost(oxxio_cost)
|
|
end
|
|
|
|
def hours_in_month(date, year_shift=0)
|
|
day = date.beginning_of_month
|
|
last_day = date.end_of_month
|
|
all_hours = []
|
|
while (day <= last_day)
|
|
all_hours += hours(day, year_shift)
|
|
day = day.advance(:days => 1)
|
|
end
|
|
all_hours
|
|
end
|
|
|
|
# heel2021 = hours_in(Date.parse("2021-01-01"), Date.parse("2021-12-31"), 1)
|
|
|
|
def hours_in(from,to, year_shift=0)
|
|
day = from.to_date
|
|
last_day = to.to_date
|
|
all_hours = []
|
|
while (day <= last_day)
|
|
all_hours += hours(day, year_shift)
|
|
day = day.advance(:days => 1)
|
|
end
|
|
all_hours
|
|
end
|
|
|
|
def write_csv(filename,hours)
|
|
CSV.open(filename, "wb") do |csv|
|
|
csv << ["hour", "kwh_consumed_low", "kwh_consumed_high", "kwh_produced_low", "kwh_produced_high", "easy_usage_rate", "easy_return_rate", "easy_cost", "oxxio_rate", "oxxio_cost"]
|
|
hours.each do |row|
|
|
csv << row
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
end
|