436 lines
14 KiB
PL/PgSQL
436 lines
14 KiB
PL/PgSQL
-- sloty pro LP: ceny, forecast, baseline, EV připojení + masky allow_charge / allow_discharge_export
|
||
|
||
create or replace function ems.fn_load_planning_slots_full(
|
||
p_site_id int,
|
||
p_from timestamptz,
|
||
p_to timestamptz,
|
||
p_current_soc_wh numeric
|
||
)
|
||
returns table (
|
||
slot_ord int,
|
||
interval_start timestamptz,
|
||
buy_price numeric,
|
||
sell_price numeric,
|
||
is_predicted_price boolean,
|
||
pv_a_forecast_w int,
|
||
pv_b_forecast_w int,
|
||
load_baseline_w int,
|
||
ev1_connected boolean,
|
||
ev2_connected boolean,
|
||
allow_charge boolean,
|
||
allow_discharge_export boolean
|
||
)
|
||
language plpgsql
|
||
volatile
|
||
as $fn$
|
||
declare
|
||
v_charge_buf numeric;
|
||
v_discharge_buf numeric;
|
||
v_usable numeric;
|
||
v_min_soc_wh numeric;
|
||
v_soc_max_wh numeric;
|
||
v_energy_to_fill numeric;
|
||
v_exportable numeric;
|
||
v_charge_eff numeric;
|
||
v_discharge_eff numeric;
|
||
v_max_charge_w numeric;
|
||
v_max_discharge_w numeric;
|
||
v_per_slot_charge_wh numeric;
|
||
v_per_slot_discharge_wh numeric;
|
||
v_grid_target_wh numeric;
|
||
v_discharge_target_wh numeric;
|
||
v_cum numeric;
|
||
r_slot record;
|
||
v_n_am int;
|
||
v_n_pm int;
|
||
v_chg_am_wh numeric;
|
||
v_chg_pm_wh numeric;
|
||
v_dis_am_wh numeric;
|
||
v_dis_pm_wh numeric;
|
||
begin
|
||
drop table if exists _ems_plan_slot_wk;
|
||
create temp table _ems_plan_slot_wk on commit drop as
|
||
with prof as (
|
||
select ems.fn_pv_forecast_delta_profile(
|
||
p_site_id,
|
||
greatest(p_from, now() - interval '120 days'),
|
||
now()
|
||
) as j
|
||
),
|
||
delta_unnest as (
|
||
select (kv.key)::int as pv_array_id,
|
||
(x->>'slot_of_day')::int as slot_of_day,
|
||
(x->>'delta_w')::int as delta_w
|
||
from prof
|
||
cross join lateral jsonb_each((prof.j)->'deltas_by_array') kv(key, value)
|
||
cross join lateral jsonb_array_elements(kv.value->'deltas') x
|
||
),
|
||
legacy_slot_delta as (
|
||
select (x->>'slot_of_day')::int as slot_of_day,
|
||
(x->>'delta_w')::int as delta_w
|
||
from prof
|
||
cross join lateral jsonb_array_elements((prof.j)->'deltas') x
|
||
),
|
||
slot_spine as (
|
||
select gs as interval_start
|
||
from generate_series(
|
||
p_from,
|
||
(p_to - interval '15 minutes')::timestamptz,
|
||
interval '15 minutes'
|
||
) as gs
|
||
)
|
||
select
|
||
(row_number() over (order by s.interval_start) - 1)::int as slot_ord,
|
||
s.interval_start,
|
||
coalesce(
|
||
ep.effective_buy_price_czk_kwh,
|
||
ems.fn_get_predicted_price(p_site_id, s.interval_start)
|
||
) as buy_price,
|
||
coalesce(
|
||
ep.effective_sell_price_czk_kwh,
|
||
ems.fn_get_predicted_price(p_site_id, s.interval_start) * 0.85
|
||
) as sell_price,
|
||
(ep.effective_buy_price_czk_kwh is null) as is_predicted_price,
|
||
coalesce(fpi_a.power_w, 0)::int as pv_a_forecast_w,
|
||
coalesce(fpi_b.power_w, 0)::int as pv_b_forecast_w,
|
||
coalesce(
|
||
(
|
||
select bs.avg_power_w
|
||
from ems.consumption_baseline_stats bs
|
||
where bs.site_id = p_site_id
|
||
and bs.day_of_week = extract(
|
||
dow from s.interval_start at time zone 'Europe/Prague'
|
||
)::int
|
||
and bs.hour_of_day = extract(
|
||
hour from s.interval_start at time zone 'Europe/Prague'
|
||
)::int
|
||
limit 1
|
||
),
|
||
500
|
||
)::int as load_baseline_w,
|
||
(coalesce(ev1.status, 'available') not in ('available', 'unavailable')) as ev1_connected,
|
||
(coalesce(ev2.status, 'available') not in ('available', 'unavailable')) as ev2_connected,
|
||
greatest(
|
||
0,
|
||
coalesce(fpi_a.power_w, 0) + coalesce(fpi_b.power_w, 0)
|
||
- coalesce(
|
||
(
|
||
select bs.avg_power_w
|
||
from ems.consumption_baseline_stats bs
|
||
where bs.site_id = p_site_id
|
||
and bs.day_of_week = extract(
|
||
dow from s.interval_start at time zone 'Europe/Prague'
|
||
)::int
|
||
and bs.hour_of_day = extract(
|
||
hour from s.interval_start at time zone 'Europe/Prague'
|
||
)::int
|
||
limit 1
|
||
),
|
||
500
|
||
)
|
||
)::int as pv_surplus_w,
|
||
false::boolean as allow_charge,
|
||
false::boolean as allow_discharge_export
|
||
from slot_spine s
|
||
left join ems.vw_site_effective_price ep
|
||
on ep.site_id = p_site_id and ep.interval_start = s.interval_start
|
||
left join lateral (
|
||
with uq as (
|
||
select distinct on (apa.id)
|
||
apa.id as pv_array_id,
|
||
fpi.power_w
|
||
from ems.asset_pv_array apa
|
||
join ems.forecast_pv_run fpr
|
||
on fpr.pv_array_id = apa.id
|
||
and fpr.site_id = apa.site_id
|
||
and fpr.status = 'ok'
|
||
join ems.forecast_pv_interval fpi
|
||
on fpi.run_id = fpr.id
|
||
and fpi.pv_array_id = apa.id
|
||
and fpi.interval_start = s.interval_start
|
||
where apa.site_id = p_site_id
|
||
and apa.controllable is true
|
||
order by apa.id, fpr.created_at desc
|
||
),
|
||
slot_of as (
|
||
select (
|
||
(extract(hour from (s.interval_start at time zone 'Europe/Prague'))::int * 60)
|
||
+ extract(minute from (s.interval_start at time zone 'Europe/Prague'))::int
|
||
) / 15 as slot_of_day
|
||
),
|
||
tot as (select coalesce(sum(uq.power_w), 0)::numeric as w from uq)
|
||
select coalesce(sum(
|
||
greatest(
|
||
0,
|
||
uq.power_w - coalesce(
|
||
du.delta_w,
|
||
case
|
||
when exists (select 1 from delta_unnest limit 1) then null
|
||
else round(
|
||
ld.delta_w::numeric * uq.power_w::numeric / nullif((select w from tot), 0)
|
||
)::int
|
||
end,
|
||
0
|
||
)
|
||
)
|
||
), 0)::int as power_w
|
||
from uq
|
||
cross join slot_of
|
||
cross join tot
|
||
left join delta_unnest du
|
||
on du.pv_array_id = uq.pv_array_id
|
||
and du.slot_of_day = slot_of.slot_of_day
|
||
left join legacy_slot_delta ld
|
||
on ld.slot_of_day = slot_of.slot_of_day
|
||
) fpi_a on true
|
||
left join lateral (
|
||
with uq as (
|
||
select distinct on (apa.id)
|
||
apa.id as pv_array_id,
|
||
fpi.power_w
|
||
from ems.asset_pv_array apa
|
||
join ems.forecast_pv_run fpr
|
||
on fpr.pv_array_id = apa.id
|
||
and fpr.site_id = apa.site_id
|
||
and fpr.status = 'ok'
|
||
join ems.forecast_pv_interval fpi
|
||
on fpi.run_id = fpr.id
|
||
and fpi.pv_array_id = apa.id
|
||
and fpi.interval_start = s.interval_start
|
||
where apa.site_id = p_site_id
|
||
and apa.controllable is false
|
||
order by apa.id, fpr.created_at desc
|
||
),
|
||
slot_of as (
|
||
select (
|
||
(extract(hour from (s.interval_start at time zone 'Europe/Prague'))::int * 60)
|
||
+ extract(minute from (s.interval_start at time zone 'Europe/Prague'))::int
|
||
) / 15 as slot_of_day
|
||
),
|
||
tot as (select coalesce(sum(uq.power_w), 0)::numeric as w from uq)
|
||
select coalesce(sum(
|
||
greatest(
|
||
0,
|
||
uq.power_w - coalesce(
|
||
du.delta_w,
|
||
case
|
||
when exists (select 1 from delta_unnest limit 1) then null
|
||
else round(
|
||
ld.delta_w::numeric * uq.power_w::numeric / nullif((select w from tot), 0)
|
||
)::int
|
||
end,
|
||
0
|
||
)
|
||
)
|
||
), 0)::int as power_w
|
||
from uq
|
||
cross join slot_of
|
||
cross join tot
|
||
left join delta_unnest du
|
||
on du.pv_array_id = uq.pv_array_id
|
||
and du.slot_of_day = slot_of.slot_of_day
|
||
left join legacy_slot_delta ld
|
||
on ld.slot_of_day = slot_of.slot_of_day
|
||
) fpi_b on true
|
||
left join lateral (
|
||
select t.status
|
||
from ems.telemetry_ev_charger t
|
||
join ems.asset_ev_charger ch on ch.id = t.charger_id
|
||
where t.site_id = p_site_id and ch.code = 'ev-charger-1'
|
||
order by t.measured_at desc
|
||
limit 1
|
||
) ev1 on true
|
||
left join lateral (
|
||
select t.status
|
||
from ems.telemetry_ev_charger t
|
||
join ems.asset_ev_charger ch on ch.id = t.charger_id
|
||
where t.site_id = p_site_id and ch.code = 'ev-charger-2'
|
||
order by t.measured_at desc
|
||
limit 1
|
||
) ev2 on true;
|
||
|
||
if not exists (select 1 from _ems_plan_slot_wk) then
|
||
raise exception 'No planning slots available – check market prices and horizon settings';
|
||
end if;
|
||
|
||
select
|
||
coalesce(ab.charge_slot_buffer, 0::numeric),
|
||
coalesce(ab.discharge_slot_buffer, 0::numeric),
|
||
ab.usable_capacity_wh::numeric,
|
||
(ab.min_soc_percent / 100.0 * ab.usable_capacity_wh)::numeric,
|
||
(coalesce(ab.planner_max_soc_percent, ab.max_soc_percent) / 100.0 * ab.usable_capacity_wh)::numeric,
|
||
greatest(coalesce(ab.charge_efficiency, 1::numeric), 0.0001::numeric),
|
||
least(
|
||
coalesce(ai.max_battery_charge_w, ai.max_charge_power_w),
|
||
coalesce(
|
||
ab.bms_max_charge_w,
|
||
case when ab.max_charge_c_rate is not null
|
||
then (ab.max_charge_c_rate * ab.usable_capacity_wh)::bigint
|
||
end,
|
||
coalesce(ai.max_battery_charge_w, ai.max_charge_power_w)
|
||
)
|
||
)::numeric,
|
||
least(
|
||
coalesce(ai.max_battery_discharge_w, ai.max_discharge_power_w),
|
||
coalesce(
|
||
ab.bms_max_discharge_w,
|
||
case when ab.max_discharge_c_rate is not null
|
||
then (ab.max_discharge_c_rate * ab.usable_capacity_wh)::bigint
|
||
end,
|
||
coalesce(ai.max_battery_discharge_w, ai.max_discharge_power_w)
|
||
)
|
||
)::numeric,
|
||
greatest(coalesce(ab.discharge_efficiency, 1::numeric), 0.0001::numeric)
|
||
into
|
||
v_charge_buf,
|
||
v_discharge_buf,
|
||
v_usable,
|
||
v_min_soc_wh,
|
||
v_soc_max_wh,
|
||
v_charge_eff,
|
||
v_max_charge_w,
|
||
v_max_discharge_w,
|
||
v_discharge_eff
|
||
from ems.asset_battery ab
|
||
join ems.asset_inverter ai on ai.id = ab.inverter_id and ai.site_id = ab.site_id
|
||
where ab.site_id = p_site_id
|
||
order by ab.id
|
||
limit 1;
|
||
|
||
if v_usable is null then
|
||
raise exception 'No asset_battery for site_id=%', p_site_id;
|
||
end if;
|
||
|
||
v_per_slot_charge_wh := v_max_charge_w * v_charge_eff * 0.25;
|
||
v_per_slot_discharge_wh := v_max_discharge_w * v_discharge_eff * 0.25;
|
||
v_energy_to_fill := v_soc_max_wh - p_current_soc_wh;
|
||
v_exportable := v_soc_max_wh - v_min_soc_wh;
|
||
v_grid_target_wh := v_energy_to_fill * v_charge_buf;
|
||
v_discharge_target_wh := v_exportable * v_discharge_buf;
|
||
|
||
-- Rozpočet na půl dne (Europe/Prague): 00:00–12:00 vs 12:00–24:00; chybějící segment dostane celý budget.
|
||
select
|
||
coalesce(
|
||
count(*) filter (
|
||
where extract(hour from wk.interval_start at time zone 'Europe/Prague') < 12
|
||
),
|
||
0
|
||
)::int,
|
||
coalesce(
|
||
count(*) filter (
|
||
where extract(hour from wk.interval_start at time zone 'Europe/Prague') >= 12
|
||
),
|
||
0
|
||
)::int
|
||
into v_n_am, v_n_pm
|
||
from _ems_plan_slot_wk wk;
|
||
|
||
if v_n_am <= 0 then
|
||
v_chg_am_wh := 0;
|
||
v_chg_pm_wh := v_grid_target_wh;
|
||
v_dis_am_wh := 0;
|
||
v_dis_pm_wh := v_discharge_target_wh;
|
||
elsif v_n_pm <= 0 then
|
||
v_chg_am_wh := v_grid_target_wh;
|
||
v_chg_pm_wh := 0;
|
||
v_dis_am_wh := v_discharge_target_wh;
|
||
v_dis_pm_wh := 0;
|
||
else
|
||
v_chg_am_wh := v_grid_target_wh / 2.0;
|
||
v_chg_pm_wh := v_grid_target_wh - v_chg_am_wh;
|
||
v_dis_am_wh := v_discharge_target_wh / 2.0;
|
||
v_dis_pm_wh := v_discharge_target_wh - v_dis_am_wh;
|
||
end if;
|
||
|
||
-- charge mask (sloupce temp tabulky kvalifikujeme: RETURNS TABLE dělá PL proměnné stejných jmen)
|
||
if v_charge_buf <= 0 then
|
||
update _ems_plan_slot_wk wk set allow_charge = true;
|
||
elsif v_energy_to_fill <= 0 then
|
||
update _ems_plan_slot_wk wk set allow_charge = false;
|
||
else
|
||
update _ems_plan_slot_wk wk set allow_charge = (wk.pv_surplus_w > 0);
|
||
v_cum := 0;
|
||
for r_slot in
|
||
select wk.slot_ord
|
||
from _ems_plan_slot_wk wk
|
||
where wk.pv_surplus_w <= 0
|
||
and extract(hour from wk.interval_start at time zone 'Europe/Prague') < 12
|
||
order by wk.buy_price, wk.slot_ord
|
||
loop
|
||
exit when v_cum >= v_chg_am_wh;
|
||
exit when v_per_slot_charge_wh <= 0;
|
||
update _ems_plan_slot_wk wk set allow_charge = true where wk.slot_ord = r_slot.slot_ord;
|
||
v_cum := v_cum + v_per_slot_charge_wh;
|
||
end loop;
|
||
v_cum := 0;
|
||
for r_slot in
|
||
select wk.slot_ord
|
||
from _ems_plan_slot_wk wk
|
||
where wk.pv_surplus_w <= 0
|
||
and extract(hour from wk.interval_start at time zone 'Europe/Prague') >= 12
|
||
order by wk.buy_price, wk.slot_ord
|
||
loop
|
||
exit when v_cum >= v_chg_pm_wh;
|
||
exit when v_per_slot_charge_wh <= 0;
|
||
update _ems_plan_slot_wk wk set allow_charge = true where wk.slot_ord = r_slot.slot_ord;
|
||
v_cum := v_cum + v_per_slot_charge_wh;
|
||
end loop;
|
||
end if;
|
||
|
||
-- discharge-export mask
|
||
if v_discharge_buf <= 0 then
|
||
update _ems_plan_slot_wk wk set allow_discharge_export = true;
|
||
elsif v_exportable <= 0 then
|
||
update _ems_plan_slot_wk wk set allow_discharge_export = false;
|
||
else
|
||
update _ems_plan_slot_wk wk set allow_discharge_export = false;
|
||
v_cum := 0;
|
||
for r_slot in
|
||
select wk.slot_ord
|
||
from _ems_plan_slot_wk wk
|
||
where extract(hour from wk.interval_start at time zone 'Europe/Prague') < 12
|
||
order by wk.sell_price desc, wk.slot_ord desc
|
||
loop
|
||
exit when v_cum >= v_dis_am_wh;
|
||
exit when v_per_slot_discharge_wh <= 0;
|
||
update _ems_plan_slot_wk wk set allow_discharge_export = true where wk.slot_ord = r_slot.slot_ord;
|
||
v_cum := v_cum + v_per_slot_discharge_wh;
|
||
end loop;
|
||
v_cum := 0;
|
||
for r_slot in
|
||
select wk.slot_ord
|
||
from _ems_plan_slot_wk wk
|
||
where extract(hour from wk.interval_start at time zone 'Europe/Prague') >= 12
|
||
order by wk.sell_price desc, wk.slot_ord desc
|
||
loop
|
||
exit when v_cum >= v_dis_pm_wh;
|
||
exit when v_per_slot_discharge_wh <= 0;
|
||
update _ems_plan_slot_wk wk set allow_discharge_export = true where wk.slot_ord = r_slot.slot_ord;
|
||
v_cum := v_cum + v_per_slot_discharge_wh;
|
||
end loop;
|
||
end if;
|
||
|
||
return query
|
||
select
|
||
w.slot_ord,
|
||
w.interval_start,
|
||
w.buy_price,
|
||
w.sell_price,
|
||
w.is_predicted_price,
|
||
w.pv_a_forecast_w,
|
||
w.pv_b_forecast_w,
|
||
w.load_baseline_w,
|
||
w.ev1_connected,
|
||
w.ev2_connected,
|
||
w.allow_charge,
|
||
w.allow_discharge_export
|
||
from _ems_plan_slot_wk w
|
||
order by w.slot_ord;
|
||
end;
|
||
$fn$;
|
||
|
||
comment on function ems.fn_load_planning_slots_full(int, timestamptz, timestamptz, numeric) is
|
||
'15min sloty s cenami, forecastem, baseline a maskami proti mikro-cyklu (charge/discharge-export). '
|
||
'Masky charge/discharge-export se berou zvlášť pro 00–12 a 12–24 Europe/Prague (polovina budgetu na segment). '
|
||
'Strop SoC pro výpočet energie k dobití: coalesce(planner_max_soc_percent, max_soc_percent).';
|