From a0fbc2306a45e1bf0360419f539b40724e8c77bd Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 9 Jan 2025 14:57:24 +0000 Subject: [PATCH 01/74] #1132 raw_segments table definition --- .../create-table-congestion_raw_segments.sql | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 here/traffic/sql/create-table-congestion_raw_segments.sql diff --git a/here/traffic/sql/create-table-congestion_raw_segments.sql b/here/traffic/sql/create-table-congestion_raw_segments.sql new file mode 100644 index 000000000..037275267 --- /dev/null +++ b/here/traffic/sql/create-table-congestion_raw_segments.sql @@ -0,0 +1,42 @@ +-- Table: gwolofs.congestion_raw_segments + +-- DROP TABLE IF EXISTS gwolofs.congestion_raw_segments; + +CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments +( + time_grp timestamp without time zone NOT NULL, + segment_id integer NOT NULL, + bin_range tsrange NOT NULL, + dt_start timestamp without time zone, + dt_end timestamp without time zone, + tt numeric, + unadjusted_tt numeric, + total_length numeric, + length_w_data numeric, + num_obs integer, + CONSTRAINT dynamic_bins_unique EXCLUDE USING gist ( + segment_id WITH =, + bin_range WITH &&, + time_grp WITH = + ) +) + +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments +OWNER TO gwolofs; + +REVOKE ALL ON TABLE gwolofs.congestion_raw_segments FROM bdit_humans; + +GRANT SELECT ON TABLE gwolofs.congestion_raw_segments TO bdit_humans; + +GRANT ALL ON TABLE gwolofs.congestion_raw_segments TO gwolofs; +-- Index: dynamic_bin_idx + +-- DROP INDEX IF EXISTS gwolofs.dynamic_bin_idx; + +CREATE INDEX IF NOT EXISTS dynamic_bin_idx + ON gwolofs.congestion_raw_segments USING btree + (segment_id ASC NULLS LAST, time_grp ASC NULLS LAST) + WITH (deduplicate_items=True) + TABLESPACE pg_default; \ No newline at end of file From 48ad3a8f4327c285633322c4acb4f2edafca7285 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 9 Jan 2025 14:57:36 +0000 Subject: [PATCH 02/74] #1132 raw_segments aggregation --- .../sql/select-congestion_raw_segments.sql | 152 ++++++++++++++++++ 1 file changed, 152 insertions(+) create mode 100644 here/traffic/sql/select-congestion_raw_segments.sql diff --git a/here/traffic/sql/select-congestion_raw_segments.sql b/here/traffic/sql/select-congestion_raw_segments.sql new file mode 100644 index 000000000..81241b3d3 --- /dev/null +++ b/here/traffic/sql/select-congestion_raw_segments.sql @@ -0,0 +1,152 @@ +--TRUNCATE gwolofs.congestion_raw_segments; + +--INSERT 0 771478 +--Query returned successfully in 2 min 36 secs. +-- vs 7,756,256 rows in (SELECT COUNT(*) FROM here.ta_path WHERE dt = '2025-01-04') = 1/10 + +WITH segment_5min_bins AS ( + SELECT + segments.segment_id, + date_trunc('hour', ta.tx) AS time_grp, + ta.tx, + RANK() OVER w AS bin_rank, + SUM(links.length) / segments.total_length AS sum_length, + SUM(sample_size) AS num_obs, + ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, + ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, + ARRAY_AGG(links.length ORDER BY link_dir) AS lengths + FROM here.ta_path AS ta + JOIN congestion.network_links_23_4_geom AS links USING (link_dir) + JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) + WHERE ta.dt = '2025-01-04' + --AND tx < '2025-01-04 01:00:00' + --AND segment_id = 1 AND date_trunc('hour', ta.tx) = '2025-01-04 00:00:00' + GROUP BY + segments.segment_id, + ta.tx, + segments.total_length + WINDOW w AS ( + PARTITION BY segments.segment_id, date_trunc('hour', ta.tx) + ORDER BY ta.tx + ) +), + +dynamic_bin_options AS ( + --within each segment/hour, generate all possible forward looking bin combinations + --don't generate options for bins with sufficient length + --also don't generate options past the next bin with 80% length + SELECT + tx, + time_grp, + segment_id, + bin_rank AS start_bin, + --generate all the options for the end bin within the group. + generate_series( + CASE + WHEN sum_length >= 0.8 THEN bin_rank + --if length is insufficient, need at least 1 more bin + ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) + END, + CASE + --dont need to generate options when start segment is already sufficient + WHEN sum_length >= 0.8 THEN bin_rank + --generate options until 1 bin has sufficient length, otherwise until last bin in group + ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) + END, + 1 + ) AS end_bin + FROM segment_5min_bins + WINDOW w AS ( + PARTITION BY time_grp, segment_id + ORDER BY tx + --look only forward for end_bin options + RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) +), + +unnested_db_options AS ( + SELECT + dbo.time_grp, + dbo.segment_id, + dbo.tx AS dt_start, + --exclusive end bin + MAX(s5b.tx) + interval '5 minutes' AS dt_end, + unnested.link_dir, + unnested.len, + AVG(unnested.tt) AS tt, --avg TT for each link_dir + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + FROM dynamic_bin_options AS dbo + LEFT JOIN segment_5min_bins AS s5b + ON s5b.time_grp = dbo.time_grp + AND s5b.segment_id = dbo.segment_id + AND s5b.bin_rank >= dbo.start_bin + AND s5b.bin_rank <= dbo.end_bin, + --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin + UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + GROUP BY + dbo.time_grp, + dbo.segment_id, + dbo.tx, + dbo.end_bin, + unnested.link_dir, + unnested.len +) + +INSERT INTO gwolofs.congestion_raw_segments ( + time_grp, segment_id, dt_start, dt_end, bin_range, tt, + unadjusted_tt, total_length, length_w_data, num_obs +) +--this query contains overlapping values which get eliminated +--via on conflict with the exclusion constraint on congestion_raw_segments table. +SELECT DISTINCT ON (udbo.time_grp, udbo.segment_id, udbo.dt_start) + udbo.time_grp, + udbo.segment_id, + udbo.dt_start, + udbo.dt_end, + tsrange(udbo.dt_start, udbo.dt_end, '[)') AS bin_range, + segments.total_length / SUM(udbo.len) * SUM(udbo.tt) AS tt, + SUM(udbo.tt) AS unadjusted_tt, + segments.total_length, + SUM(udbo.len) AS length_w_data, + SUM(udbo.num_obs) AS num_obs --sum of here.ta_path sample_size for each segment +FROM unnested_db_options AS udbo +LEFT JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) +GROUP BY + udbo.time_grp, + udbo.segment_id, + udbo.dt_start, + udbo.dt_end, + segments.total_length +HAVING SUM(udbo.len) >= 0.8 * segments.total_length +ORDER BY + udbo.time_grp, + udbo.segment_id, + udbo.dt_start, + udbo.dt_end +--exclusion constraint + ordered insert to prevent overlapping bins +ON CONFLICT ON CONSTRAINT congestion_raw_segments_unique +DO NOTHING; + +/* +--bins which were not used. Might consider adding these on to bins that already have sufficient data. +SELECT * +FROM gwolofs.segment_5min_bins AS s5b +LEFT JOIN gwolofs.congestion_raw_segments AS dyb ON + s5b.time_grp = dyb.time_grp + AND s5b.source_node = dyb.source_node + AND s5b.dest_node = dyb.dest_node + AND s5b.tx <@ dyb.bin_range +WHERE dyb.bin_range IS NULL +*/ + +/* +WITH hourly_obs AS ( + SELECT time_grp, segment_id, AVG(tt) AS avg_hour_tt, COUNT(*) + FROM gwolofs.congestion_raw_segments + GROUP BY time_grp, segment_id +) + +SELECT segment_id, date_part('hour', time_grp), AVG(avg_hour_tt) AS avg_tt, SUM(count) +FROM hourly_obs +GROUP BY 1, 2 ORDER BY 1, 2; +*/ \ No newline at end of file From 073a814a891b4bde0e3c338c601732f2c0d8214e Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 9 Jan 2025 20:06:03 +0000 Subject: [PATCH 03/74] #1132 add time periods in addition to hours --- .../create-table-congestion_raw_segments.sql | 2 +- .../sql/select-congestion_raw_segments.sql | 112 +++++++++++++----- 2 files changed, 86 insertions(+), 28 deletions(-) diff --git a/here/traffic/sql/create-table-congestion_raw_segments.sql b/here/traffic/sql/create-table-congestion_raw_segments.sql index 037275267..9b6d39f5d 100644 --- a/here/traffic/sql/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/create-table-congestion_raw_segments.sql @@ -4,7 +4,7 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments ( - time_grp timestamp without time zone NOT NULL, + time_grp tsrange NOT NULL, segment_id integer NOT NULL, bin_range tsrange NOT NULL, dt_start timestamp without time zone, diff --git a/here/traffic/sql/select-congestion_raw_segments.sql b/here/traffic/sql/select-congestion_raw_segments.sql index 81241b3d3..093de5e1c 100644 --- a/here/traffic/sql/select-congestion_raw_segments.sql +++ b/here/traffic/sql/select-congestion_raw_segments.sql @@ -1,21 +1,52 @@ --TRUNCATE gwolofs.congestion_raw_segments; --INSERT 0 771478 ---Query returned successfully in 2 min 36 secs. +--Query returned successfully in 2 min 51 secs. -- vs 7,756,256 rows in (SELECT COUNT(*) FROM here.ta_path WHERE dt = '2025-01-04') = 1/10 +--with addition of am/pm/midday time ranges: +--INSERT 0 1251472 (2024-01-04) +--Query returned successfully in 6 min 29 secs. -WITH segment_5min_bins AS ( +WITH time_bins AS ( + SELECT + start_time, + start_time + '1 hour'::interval AS end_time, + tsrange(start_time, start_time + '1 hour'::interval, '[)') AS time_grp + FROM generate_series( + '2025-01-04'::date, + '2025-01-04'::date + interval '23 hours', + '1 hour'::interval + ) AS hours(start_time) + UNION + SELECT + start_time + '2025-01-04'::date, + end_time + '2025-01-04'::date, + tsrange(start_time + '2025-01-04'::date, end_time + '2025-01-04'::date, '[)') + FROM ( + VALUES + ('07:00'::time, '10:00'::time), + ('10:00', '16:00'), + ('16:00', '19:00') + ) AS time_periods(start_time, end_time) + ORDER BY start_time +), + +segment_5min_bins AS ( SELECT segments.segment_id, - date_trunc('hour', ta.tx) AS time_grp, + tb.time_grp, ta.tx, RANK() OVER w AS bin_rank, + segments.total_length, SUM(links.length) / segments.total_length AS sum_length, + SUM(links.length) AS length_w_data, + SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, SUM(sample_size) AS num_obs, ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, ARRAY_AGG(links.length ORDER BY link_dir) AS lengths FROM here.ta_path AS ta + JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time JOIN congestion.network_links_23_4_geom AS links USING (link_dir) JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) WHERE ta.dt = '2025-01-04' @@ -23,10 +54,11 @@ WITH segment_5min_bins AS ( --AND segment_id = 1 AND date_trunc('hour', ta.tx) = '2025-01-04 00:00:00' GROUP BY segments.segment_id, + tb.time_grp, ta.tx, segments.total_length WINDOW w AS ( - PARTITION BY segments.segment_id, date_trunc('hour', ta.tx) + PARTITION BY segments.segment_id, tb.time_grp ORDER BY ta.tx ) ), @@ -68,6 +100,7 @@ unnested_db_options AS ( SELECT dbo.time_grp, dbo.segment_id, + s5b.total_length, dbo.tx AS dt_start, --exclusive end bin MAX(s5b.tx) + interval '5 minutes' AS dt_end, @@ -83,9 +116,12 @@ unnested_db_options AS ( AND s5b.bin_rank <= dbo.end_bin, --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + --we need to use nested data to determine length for these multi-period bins + WHERE dbo.start_bin != dbo.end_bin GROUP BY dbo.time_grp, dbo.segment_id, + s5b.total_length, dbo.tx, dbo.end_bin, unnested.link_dir, @@ -98,33 +134,55 @@ INSERT INTO gwolofs.congestion_raw_segments ( ) --this query contains overlapping values which get eliminated --via on conflict with the exclusion constraint on congestion_raw_segments table. -SELECT DISTINCT ON (udbo.time_grp, udbo.segment_id, udbo.dt_start) - udbo.time_grp, - udbo.segment_id, - udbo.dt_start, - udbo.dt_end, - tsrange(udbo.dt_start, udbo.dt_end, '[)') AS bin_range, - segments.total_length / SUM(udbo.len) * SUM(udbo.tt) AS tt, - SUM(udbo.tt) AS unadjusted_tt, - segments.total_length, - SUM(udbo.len) AS length_w_data, - SUM(udbo.num_obs) AS num_obs --sum of here.ta_path sample_size for each segment +SELECT DISTINCT ON (time_grp, segment_id, dt_start) + time_grp, + segment_id, + dt_start, + dt_end, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(tt) AS unadjusted_tt, + total_length, + SUM(len) AS length_w_data, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment FROM unnested_db_options AS udbo -LEFT JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) GROUP BY - udbo.time_grp, - udbo.segment_id, - udbo.dt_start, - udbo.dt_end, - segments.total_length -HAVING SUM(udbo.len) >= 0.8 * segments.total_length + time_grp, + segment_id, + dt_start, + dt_end, + total_length +HAVING SUM(len) >= 0.8 * total_length +UNION +--these 5 minute bins already have sufficient length +--don't need to use nested data to validate. +SELECT + dbo.time_grp, + dbo.segment_id, + dbo.tx AS dt_start, + dbo.tx + interval '5 minutes' AS dt_end, + tsrange(dbo.tx, dbo.tx + interval '5 minutes', '[)') AS bin_range, + s5b.total_length / s5b.length_w_data * s5b.unadjusted_tt AS tt, + s5b.unadjusted_tt, + s5b.total_length, + s5b.length_w_data, + s5b.num_obs --sum of here.ta_path sample_size for each segment +FROM dynamic_bin_options AS dbo +JOIN segment_5min_bins AS s5b + ON s5b.time_grp = dbo.time_grp + AND s5b.segment_id = dbo.segment_id + AND s5b.bin_rank = dbo.start_bin +--we do not need to use nested data to determine length here. +WHERE + dbo.start_bin = dbo.end_bin + AND s5b.sum_length >= 0.8 ORDER BY - udbo.time_grp, - udbo.segment_id, - udbo.dt_start, - udbo.dt_end + time_grp, + segment_id, + dt_start, + dt_end --exclusion constraint + ordered insert to prevent overlapping bins -ON CONFLICT ON CONSTRAINT congestion_raw_segments_unique +ON CONFLICT ON CONSTRAINT dynamic_bins_unique DO NOTHING; /* From 29b8326b24c9aa2860ea46228cf8965dc85f4978 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 10 Jan 2025 17:09:40 +0000 Subject: [PATCH 04/74] #1132 dynamic bins should not exceed 1hr in length --- here/traffic/sql/select-congestion_raw_segments.sql | 2 ++ 1 file changed, 2 insertions(+) diff --git a/here/traffic/sql/select-congestion_raw_segments.sql b/here/traffic/sql/select-congestion_raw_segments.sql index 093de5e1c..7ec8f2adf 100644 --- a/here/traffic/sql/select-congestion_raw_segments.sql +++ b/here/traffic/sql/select-congestion_raw_segments.sql @@ -126,6 +126,8 @@ unnested_db_options AS ( dbo.end_bin, unnested.link_dir, unnested.len + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' ) INSERT INTO gwolofs.congestion_raw_segments ( From 6d1847e5127ece4277f5b7391ad9a81611303f45 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 10 Jan 2025 18:47:02 +0000 Subject: [PATCH 05/74] #1132 reamde describing dynamic binning query --- .../sql/select-congestion_raw_segments.md | 282 ++++++++++++++++++ 1 file changed, 282 insertions(+) create mode 100644 here/traffic/sql/select-congestion_raw_segments.md diff --git a/here/traffic/sql/select-congestion_raw_segments.md b/here/traffic/sql/select-congestion_raw_segments.md new file mode 100644 index 000000000..35f5a3e02 --- /dev/null +++ b/here/traffic/sql/select-congestion_raw_segments.md @@ -0,0 +1,282 @@ +This is a readme to describe the complex query [here](./select-congestion_raw_segments.sql). +Samples from each of the CTEs are shown for one segment/time_grp. Not all columns are shown from each CTE result. + +### time_bins +Contains hourly and period definitions, known as `time_grp`s. These define the extents within which to evaluate dynamic bin options. A dynamic bin must be fully within the time_grp. + +```sql +WITH time_bins AS ( + SELECT + start_time, + start_time + '1 hour'::interval AS end_time, + tsrange(start_time, start_time + '1 hour'::interval, '[)') AS time_grp + FROM generate_series( + '2025-01-04'::date, + '2025-01-04'::date + interval '23 hours', + '1 hour'::interval + ) AS hours(start_time) + UNION + SELECT + start_time + '2025-01-04'::date, + end_time + '2025-01-04'::date, + tsrange(start_time + '2025-01-04'::date, end_time + '2025-01-04'::date, '[)') + FROM ( + VALUES + ('07:00'::time, '10:00'::time), + ('10:00', '16:00'), + ('16:00', '19:00') + ) AS time_periods(start_time, end_time) + ORDER BY start_time +), +``` + +| "start_time" | "end_time" | "time_grp" | +|-----------------------|-----------------------|-----------------------------------------------------| +| "2025-01-04 00:00:00" | "2025-01-04 01:00:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | +| "2025-01-04 01:00:00" | "2025-01-04 02:00:00" | "[""2025-01-04 01:00:00"",""2025-01-04 02:00:00"")" | +| "2025-01-04 02:00:00" | "2025-01-04 03:00:00" | "[""2025-01-04 02:00:00"",""2025-01-04 03:00:00"")" | +| "2025-01-04 03:00:00" | "2025-01-04 04:00:00" | "[""2025-01-04 03:00:00"",""2025-01-04 04:00:00"")" | +| "2025-01-04 04:00:00" | "2025-01-04 05:00:00" | "[""2025-01-04 04:00:00"",""2025-01-04 05:00:00"")" | +| "2025-01-04 05:00:00" | "2025-01-04 06:00:00" | "[""2025-01-04 05:00:00"",""2025-01-04 06:00:00"")" | +| "2025-01-04 06:00:00" | "2025-01-04 07:00:00" | "[""2025-01-04 06:00:00"",""2025-01-04 07:00:00"")" | +| "2025-01-04 07:00:00" | "2025-01-04 08:00:00" | "[""2025-01-04 07:00:00"",""2025-01-04 08:00:00"")" | +| "2025-01-04 07:00:00" | "2025-01-04 10:00:00" | "[""2025-01-04 07:00:00"",""2025-01-04 10:00:00"")" | +| "2025-01-04 08:00:00" | "2025-01-04 09:00:00" | "[""2025-01-04 08:00:00"",""2025-01-04 09:00:00"")" | + +### segment_5min_bins +In this step we pull the relevant data from `here.ta_path` for each segment / time_grp. We save the disaggregate travel time data by link in 3 arrays (link_dirs, tts, lengths), so that in future steps we can reaggregate average segment travel time and distinct length over different ranges without referring back to the here.ta_path table. The time bins (`tx`) are also ranked to make it easier to enumerate possible bin extents using generate_series in the next step. + +```sql +segment_5min_bins AS ( + SELECT + segments.segment_id, + tb.time_grp, + ta.tx, + RANK() OVER w AS bin_rank, + segments.total_length, + SUM(links.length) / segments.total_length AS sum_length, + SUM(links.length) AS length_w_data, + SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, + SUM(sample_size) AS num_obs, + ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, + ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, + ARRAY_AGG(links.length ORDER BY link_dir) AS lengths + FROM here.ta_path AS ta + JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time + JOIN congestion.network_links_23_4_geom AS links USING (link_dir) + JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) + WHERE ta.dt = '2025-01-04' + --AND tx < '2025-01-04 01:00:00' + AND segment_id = 29 AND date_trunc('hour', ta.tx) = '2025-01-04 00:00:00' + GROUP BY + segments.segment_id, + tb.time_grp, + ta.tx, + segments.total_length + WINDOW w AS ( + PARTITION BY segments.segment_id, tb.time_grp + ORDER BY ta.tx + ) +), +``` + +`SELECT bin_rank, tx, round(sum_length, 2) AS sum_length, link_dirs, tts FROM segment_5min_bins;` + +| "bin_rank" | "tx" | "sum_length" | "link_dirs" | "tts" | +|------------|-----------------------|--------------|----------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------| +| 1 | "2025-01-04 00:00:00" | 1.01 | "{1000589822T,1000589823T,1280577167T,792343539T, 792343541T, 836248875T,836248876T,845737718T,845737719T}" | {4.59624489795918360,1.274693877551020408164, 4.96575000000000000,6.68329411764705876, 1.101306122448979591836, 1.526693877551020408164,1.196816326530612244884,4.79172413793103452,9.12626086956521724} | +| 2 | "2025-01-04 00:05:00" | 0.12 | "{845737718T}" | {19.85142857142857148} | +| 3 | "2025-01-04 00:15:00" | 0.07 | "{1280577167T}" | {2.787789473684210526300} | +| 4 | "2025-01-04 00:50:00" | 0.39 | "{845737718T,845737719T}" | {34.74000000000000000,28.62327272727272724} | +| 5 | "2025-01-04 00:55:00" | 1.01 | "{1000589822T,1000589823T,1280577167T,792343539T,792343541T, 836248875T,836248876T,845737718T,845737719T}" | {5.17737931034482764,1.435862068965517241376,1.826482758620689655172,3.91779310344827580,1.240551724137931034496,1.719724137931034482752, 1.348137931034482758612,2.459469026548672566372,6.42563265306122460} | + +### dynamic_bin_options +Here we enumerate all the possible dynamic bin options for each starting point. The number of combinations are cut down significantly with the `CASE` statements inside the `generate_series`: +- Don't enumerate options for 5min bins with sufficient length. +- Only look forward until the next 5min bin with sufficient lenght. + +```sql +dynamic_bin_options AS ( + --within each segment/hour, generate all possible forward looking bin combinations + --don't generate options for bins with sufficient length + --also don't generate options past the next bin with 80% length + SELECT + tx, + time_grp, + segment_id, + bin_rank AS start_bin, + --generate all the options for the end bin within the group. + generate_series( + CASE + WHEN sum_length >= 0.8 THEN bin_rank + --if length is insufficient, need at least 1 more bin + ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) + END, + CASE + --dont need to generate options when start segment is already sufficient + WHEN sum_length >= 0.8 THEN bin_rank + --generate options until 1 bin has sufficient length, otherwise until last bin in group + ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) + END, + 1 + ) AS end_bin + FROM segment_5min_bins + WINDOW w AS ( + PARTITION BY time_grp, segment_id + ORDER BY tx + --look only forward for end_bin options + RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) +), +``` + +In this case we find 8 dynamic bin options with the pruning conditions, down from max of 5+4+3+2+1 = 15. + +| "tx" | "time_grp" | "segment_id" | "start_bin" | "end_bin" | +|-----------------------|-----------------------------------------------------|--------------|-------------|-----------| +| "2025-01-04 00:00:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 1 | 1 | +| "2025-01-04 00:05:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 2 | 3 | +| "2025-01-04 00:05:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 2 | 4 | +| "2025-01-04 00:05:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 2 | 5 | +| "2025-01-04 00:15:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 3 | 4 | +| "2025-01-04 00:15:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 3 | 5 | +| "2025-01-04 00:50:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 4 | 5 | +| "2025-01-04 00:55:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 5 | 5 | + +### unnested_db_options +Combining the previous two steps, we have enumerated all the possible bin start/end ranges (`dynamic_bin_options`), now we can unnest the disaggregate data (`segment_5min_bins`) and evaluate them. +Note the multiple arrays unnested at once into rows, see `unnest ( anyarray, anyarray [, ... ] ) ` [here](https://www.postgresql.org/docs/current/functions-array.html#id-1.5.8.25.6.2.2.19.1.1.1). +We then group the results by bin / link_dir so we only have the unique length within each bin. + +```sql +unnested_db_options AS ( + SELECT + dbo.time_grp, + dbo.segment_id, + s5b.total_length, + dbo.tx AS dt_start, + --exclusive end bin + MAX(s5b.tx) + interval '5 minutes' AS dt_end, + unnested.link_dir, + unnested.len, + AVG(unnested.tt) AS tt, --avg TT for each link_dir + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + FROM dynamic_bin_options AS dbo + LEFT JOIN segment_5min_bins AS s5b + ON s5b.time_grp = dbo.time_grp + AND s5b.segment_id = dbo.segment_id + AND s5b.bin_rank >= dbo.start_bin + AND s5b.bin_rank <= dbo.end_bin, + --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin + UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + --we need to use nested data to determine length for these multi-period bins + WHERE dbo.start_bin != dbo.end_bin + GROUP BY + dbo.time_grp, + dbo.segment_id, + s5b.total_length, + dbo.tx, + dbo.end_bin, + unnested.link_dir, + unnested.len +) +``` + +`SELECT dt_start, dt_end, link_dir, len, tt, num_obs FROM unnested_db_options WHERE dt_start = '2025-01-04 00:05:00' AND dt_end = '2025-01-04 01:00:00'` + +| "dt_start" | "dt_end" | "link_dir" | "len" | "tt" | "num_obs" | +|-----------------------|-----------------------|---------------|-------|--------------------------|-----------| +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "1000589822T" | 62.56 | 5.17737931034482764 | 18 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "1000589823T" | 17.35 | 1.435862068965517241376 | 18 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "1280577167T" | 22.07 | 2.307136116152450090736 | 20 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "792343539T" | 47.34 | 3.91779310344827580 | 18 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "792343541T" | 14.99 | 1.240551724137931034496 | 18 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "836248875T" | 20.78 | 1.719724137931034482752 | 18 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "836248876T" | 16.29 | 1.348137931034482758612 | 18 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "845737718T" | 38.60 | 19.016965865992414682124 | 21 | +| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "845737719T" | 87.46 | 17.52445269016697592 | 20 | + +### Insert statement +Here we find bins with sufficient length, for the two cases: +- Multiple 5min bins assembled: need to check sufficient length from last step. +- An original 5min bin, no group by needed to check length. + +```sql +INSERT INTO gwolofs.congestion_raw_segments ( + time_grp, segment_id, dt_start, dt_end, bin_range, tt, + unadjusted_tt, total_length, length_w_data, num_obs +) +--this query contains overlapping values which get eliminated +--via on conflict with the exclusion constraint on congestion_raw_segments table. +SELECT DISTINCT ON (time_grp, segment_id, dt_start) + time_grp, + segment_id, + dt_start, + dt_end, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(tt) AS unadjusted_tt, + total_length, + SUM(len) AS length_w_data, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment +FROM unnested_db_options AS udbo +GROUP BY + time_grp, + segment_id, + dt_start, + dt_end, + total_length +HAVING SUM(len) >= 0.8 * total_length +UNION +--these 5 minute bins already have sufficient length +--don't need to use nested data to validate. +SELECT + time_grp, + segment_id, + tx AS dt_start, + tx + interval '5 minutes' AS dt_end, + tsrange(tx, tx + interval '5 minutes', '[)') AS bin_range, + total_length / length_w_data * unadjusted_tt AS tt, + unadjusted_tt, + total_length, + length_w_data, + num_obs --sum of here.ta_path sample_size for each segment +FROM segment_5min_bins +--we do not need to use nested data to determine length here. +WHERE sum_length >= 0.8 +ORDER BY + time_grp, + segment_id, + dt_start, + dt_end +--exclusion constraint + ordered insert to prevent overlapping bins +ON CONFLICT ON CONSTRAINT dynamic_bins_unique +DO NOTHING; +``` + +`SELECT segment_id, bin_range, round(tt, 2) AS tt, total_length, length_w_data FROM inserted;` + +| "segment_id" | "bin_range" | "tt" | "total_length" | "length_w_data" | +|--------------|-----------------------------------------------------|-------|----------------|-----------------| +| 29 | "[""2025-01-04 00:00:00"",""2025-01-04 00:05:00"")" | 34.93 | 324.33 | 327.44 | +| 29 | "[""2025-01-04 00:05:00"",""2025-01-04 01:00:00"")" | 53.18 | 324.33 | 327.44 | +| 29 | "[""2025-01-04 00:15:00"",""2025-01-04 01:00:00"")" | 52.76 | 324.33 | 327.44 | +| 29 | "[""2025-01-04 00:50:00"",""2025-01-04 01:00:00"")" | 52.29 | 324.33 | 327.44 | +| 29 | "[""2025-01-04 00:55:00"",""2025-01-04 01:00:00"")" | 25.31 | 324.33 | 327.44 | + +After insert against exclusion constraint, only 2 remain, since records 3,4,5 overlap with record 2 above. +`SELECT segment_id, bin_range, round(tt, 2) AS tt, total_length, length_w_data FROM gwolofs.congestion_raw_segments WHERE segment_id = 29 AND time_grp = '["2025-01-04 00:00:00","2025-01-04 01:00:00")'::tsrange` + +Constraint: +```sql + CONSTRAINT dynamic_bins_unique EXCLUDE USING gist ( + segment_id WITH =, + bin_range WITH &&, + time_grp WITH = + ) +``` + +| "segment_id" | "bin_range" | "tt" | "total_length" | "length_w_data" | +|--------------|-----------------------------------------------------|-------|----------------|-----------------| +| 29 | "[""2025-01-04 00:00:00"",""2025-01-04 00:05:00"")" | 34.93 | 324.33 | 327.44 | +| 29 | "[""2025-01-04 00:05:00"",""2025-01-04 01:00:00"")" | 53.18 | 324.33 | 327.44 | \ No newline at end of file From 696de6eee38a02a365a58b05bb1f2ad97c862058 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 10 Jan 2025 18:47:23 +0000 Subject: [PATCH 06/74] #1132 remove unnecessary join from insert subquery --- .../sql/select-congestion_raw_segments.sql | 32 ++++++++----------- 1 file changed, 13 insertions(+), 19 deletions(-) diff --git a/here/traffic/sql/select-congestion_raw_segments.sql b/here/traffic/sql/select-congestion_raw_segments.sql index 7ec8f2adf..ddf922fd1 100644 --- a/here/traffic/sql/select-congestion_raw_segments.sql +++ b/here/traffic/sql/select-congestion_raw_segments.sql @@ -147,7 +147,7 @@ SELECT DISTINCT ON (time_grp, segment_id, dt_start) total_length, SUM(len) AS length_w_data, SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment -FROM unnested_db_options AS udbo +FROM unnested_db_options GROUP BY time_grp, segment_id, @@ -159,25 +159,19 @@ UNION --these 5 minute bins already have sufficient length --don't need to use nested data to validate. SELECT - dbo.time_grp, - dbo.segment_id, - dbo.tx AS dt_start, - dbo.tx + interval '5 minutes' AS dt_end, - tsrange(dbo.tx, dbo.tx + interval '5 minutes', '[)') AS bin_range, - s5b.total_length / s5b.length_w_data * s5b.unadjusted_tt AS tt, - s5b.unadjusted_tt, - s5b.total_length, - s5b.length_w_data, - s5b.num_obs --sum of here.ta_path sample_size for each segment -FROM dynamic_bin_options AS dbo -JOIN segment_5min_bins AS s5b - ON s5b.time_grp = dbo.time_grp - AND s5b.segment_id = dbo.segment_id - AND s5b.bin_rank = dbo.start_bin + time_grp, + segment_id, + tx AS dt_start, + tx + interval '5 minutes' AS dt_end, + tsrange(tx, tx + interval '5 minutes', '[)') AS bin_range, + total_length / length_w_data * unadjusted_tt AS tt, + unadjusted_tt, + total_length, + length_w_data, + num_obs --sum of here.ta_path sample_size for each segment +FROM segment_5min_bins --we do not need to use nested data to determine length here. -WHERE - dbo.start_bin = dbo.end_bin - AND s5b.sum_length >= 0.8 +WHERE sum_length >= 0.8 ORDER BY time_grp, segment_id, From 8edb8c8b604edee000291ee1befeeaf8dd535c6a Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 17 Jan 2025 18:02:29 +0000 Subject: [PATCH 07/74] #1132 here dynamic binning: function --- .../create-function-here_dynamic_bin_avg.sql | 81 ++++++++ .../create-table-dynamic_binning_results.sql | 44 ++++ here/traffic/sql/create-table-tt_segments.sql | 23 +++ .../sql/procedure-cache_tt_results.sql | 195 ++++++++++++++++++ .../sql/procedure-cache_tt_segment.sql | 25 +++ 5 files changed, 368 insertions(+) create mode 100644 here/traffic/sql/create-function-here_dynamic_bin_avg.sql create mode 100644 here/traffic/sql/create-table-dynamic_binning_results.sql create mode 100644 here/traffic/sql/create-table-tt_segments.sql create mode 100644 here/traffic/sql/procedure-cache_tt_results.sql create mode 100644 here/traffic/sql/procedure-cache_tt_segment.sql diff --git a/here/traffic/sql/create-function-here_dynamic_bin_avg.sql b/here/traffic/sql/create-function-here_dynamic_bin_avg.sql new file mode 100644 index 000000000..4c344020c --- /dev/null +++ b/here/traffic/sql/create-function-here_dynamic_bin_avg.sql @@ -0,0 +1,81 @@ +-- FUNCTION: gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], text[], boolean) + +-- DROP FUNCTION IF EXISTS gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], text[], boolean); + +CREATE OR REPLACE FUNCTION gwolofs.here_dynamic_bin_avg( + start_date date, + end_date date, + start_tod time without time zone, + end_tod time without time zone, + dow_list integer[], + link_dirs text[], + holidays boolean) + RETURNS numeric + LANGUAGE 'sql' + COST 100 + VOLATILE PARALLEL UNSAFE +AS $BODY$ + +CALL gwolofs.cache_tt_segment(here_dynamic_bin_avg.link_dirs); + +CALL gwolofs.cache_tt_results( + start_date := here_dynamic_bin_avg.start_date, + end_date := here_dynamic_bin_avg.end_date, + start_tod := here_dynamic_bin_avg.start_tod, + end_tod := here_dynamic_bin_avg.end_tod, + dow_list := here_dynamic_bin_avg.dow_list, + link_dirs := here_dynamic_bin_avg.link_dirs, + holidays := here_dynamic_bin_avg.holidays +); + +WITH time_grps AS ( + SELECT tsrange( + (days.dt + here_dynamic_bin_avg.start_tod)::timestamp, + (days.dt + here_dynamic_bin_avg.end_tod)::timestamp, '[)') AS time_grp + FROM generate_series( + here_dynamic_bin_avg.start_date::date, + here_dynamic_bin_avg.end_date::date - '1 day'::interval, '1 day'::interval) AS days(dt) + WHERE date_part('isodow', dt) = ANY(here_dynamic_bin_avg.dow_list) +) + +SELECT AVG(tt) +FROM gwolofs.dynamic_binning_results AS res +JOIN time_grps USING (time_grp) +JOIN gwolofs.tt_segments AS segs ON res.segment_uid = segs.uid +WHERE segs.link_dirs = here_dynamic_bin_avg.link_dirs + +$BODY$; + +ALTER FUNCTION gwolofs.here_dynamic_bin_avg( + date, date, time without time zone, time without time zone, integer[], text[], boolean +) +OWNER TO gwolofs; + + +/*example of use: + +SELECT + start_date, + end_date, + start_tod, + end_tod, + dow_list, + link_dirs, + gwolofs.here_dynamic_bin_avg( + start_date := l.start_date, + end_date := l.end_date, + start_tod := l.start_tod, + end_tod := l.end_tod, + dow_list := l.dow_list, + link_dirs := l.link_dirs, + holidays := TRUE + ) +FROM +(VALUES +('2025-01-02'::date, '2025-01-10'::date, '07:00'::time, '10:00'::time, '{1,2,3,4,5}'::int[], '{1258924853F,1258924867F,1258924868F,1258924894F}'::text[]), +('2025-01-02'::date, '2025-01-10'::date, '11:00'::time, '15:00'::time, '{1,2,3,4,5}'::int[], '{1258924852F,1258924867F,1258924868F,1258924894F}'::text[]), +('2025-01-02'::date, '2025-01-10'::date, '07:00'::time, '10:00'::time, '{1,3,5}'::int[], '{1258924852F,1258924853F,1258924868F,1258924894F}'::text[]), +('2024-01-02'::date, '2025-01-10'::date, '07:00'::time, '10:00'::time, '{1,2,3,4,5}'::int[], '{1258924852F,1258924853F,1258924867F,1258924894F}'::text[]) +) AS l(start_date, end_date, start_tod, end_tod, dow_list, link_dirs); + +*/ \ No newline at end of file diff --git a/here/traffic/sql/create-table-dynamic_binning_results.sql b/here/traffic/sql/create-table-dynamic_binning_results.sql new file mode 100644 index 000000000..c83618ed3 --- /dev/null +++ b/here/traffic/sql/create-table-dynamic_binning_results.sql @@ -0,0 +1,44 @@ +-- Table: gwolofs.dynamic_binning_results + +-- DROP TABLE IF EXISTS gwolofs.dynamic_binning_results; + +CREATE TABLE IF NOT EXISTS gwolofs.dynamic_binning_results ( + time_grp tsrange NOT NULL, + bin_range tsrange NOT NULL, + dt_start timestamp without time zone, + dt_end timestamp without time zone, + tt numeric, + unadjusted_tt numeric, + total_length numeric, + length_w_data numeric, + num_obs integer, + segment_uid smallint, + CONSTRAINT dynamic_bins_unique_temp EXCLUDE USING gist ( + bin_range WITH &&, + time_grp WITH =, + segment_uid WITH = + ) +) + +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.dynamic_binning_results +OWNER TO gwolofs; + +REVOKE ALL ON TABLE gwolofs.dynamic_binning_results FROM bdit_humans; + +GRANT SELECT ON TABLE gwolofs.dynamic_binning_results TO bdit_humans; + +GRANT ALL ON TABLE gwolofs.dynamic_binning_results TO gwolofs; +-- Index: dynamic_binning_results_time_grp_segment_uid_idx + +-- DROP INDEX IF EXISTS gwolofs.dynamic_binning_results_time_grp_segment_uid_idx; + +CREATE INDEX IF NOT EXISTS dynamic_binning_results_time_grp_segment_uid_idx +ON gwolofs.dynamic_binning_results USING btree +( + time_grp ASC NULLS LAST, + segment_uid ASC NULLS LAST +) +WITH (deduplicate_items=True) +TABLESPACE pg_default; \ No newline at end of file diff --git a/here/traffic/sql/create-table-tt_segments.sql b/here/traffic/sql/create-table-tt_segments.sql new file mode 100644 index 000000000..677c8641e --- /dev/null +++ b/here/traffic/sql/create-table-tt_segments.sql @@ -0,0 +1,23 @@ +-- Table: gwolofs.tt_segments + +-- DROP TABLE IF EXISTS gwolofs.tt_segments; + +CREATE TABLE IF NOT EXISTS gwolofs.tt_segments +( + link_dirs text[] COLLATE pg_catalog."default", + lengths numeric[], + geom geometry, + total_length numeric, + uid smallint NOT NULL DEFAULT nextval('tt_segments_uid_seq'::regclass), + CONSTRAINT unique_link_dirs UNIQUE (link_dirs) +) + +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.tt_segments OWNER TO gwolofs; + +REVOKE ALL ON TABLE gwolofs.tt_segments FROM bdit_humans; + +GRANT SELECT ON TABLE gwolofs.tt_segments TO bdit_humans; + +GRANT ALL ON TABLE gwolofs.tt_segments TO gwolofs; \ No newline at end of file diff --git a/here/traffic/sql/procedure-cache_tt_results.sql b/here/traffic/sql/procedure-cache_tt_results.sql new file mode 100644 index 000000000..d1f5e3d0e --- /dev/null +++ b/here/traffic/sql/procedure-cache_tt_results.sql @@ -0,0 +1,195 @@ +-- PROCEDURE: gwolofs.cache_tt_results(date, date, time without time zone, time without time zone, integer[], text[], boolean) + +-- DROP PROCEDURE IF EXISTS gwolofs.cache_tt_results(date, date, time without time zone, time without time zone, integer[], text[], boolean); + +CREATE OR REPLACE PROCEDURE gwolofs.cache_tt_results( + IN start_date date, + IN end_date date, + IN start_tod time without time zone, + IN end_tod time without time zone, + IN dow_list integer[], + IN link_dirs text[], + IN holidays boolean +) +LANGUAGE 'plpgsql' +AS $BODY$ + +BEGIN +EXECUTE format( + $$ + WITH segment AS ( + SELECT + uid AS segment_uid, + unnested.link_dir, + unnested.length, + tt_segments.total_length + FROM gwolofs.tt_segments, + UNNEST(tt_segments.link_dirs, tt_segments.lengths) AS unnested(link_dir, length) + WHERE link_dirs = %L + ), + + segment_5min_bins AS ( + SELECT + seg.segment_uid, + ta.tx, + seg.total_length, + tsrange( + ta.dt + %L::time, + ta.dt + %L::time, '[)') AS time_grp, + RANK() OVER w AS bin_rank, + SUM(seg.length) / seg.total_length AS sum_length, + SUM(seg.length) AS length_w_data, + SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt, + SUM(sample_size) AS num_obs, + ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, + ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, + ARRAY_AGG(seg.length ORDER BY link_dir) AS lengths + FROM here.ta_path AS ta + JOIN segment AS seg USING (link_dir) + WHERE + ( + tod >= %L + AND --{ToD_and_or} + tod < %L + ) + AND date_part('isodow', dt) = ANY(%L) + AND dt >= %L + AND dt < %L + /*--{holiday_clause} + AND NOT EXISTS ( + SELECT 1 FROM ref.holiday WHERE ta.dt = holiday.dt + )*/ + GROUP BY + ta.tx, + ta.dt, + seg.total_length, + segment_uid + WINDOW w AS ( + PARTITION BY seg.segment_uid, ta.dt + ORDER BY ta.tx + ) + ), + + dynamic_bin_options AS ( + --within each segment/hour, generate all possible forward looking bin combinations + --don't generate options for bins with sufficient length + --also don't generate options past the next bin with 80%% length + SELECT + tx, + time_grp, + bin_rank AS start_bin, + --generate all the options for the end bin within the group. + generate_series( + CASE + WHEN sum_length >= 0.8 THEN bin_rank + --if length is insufficient, need at least 1 more bin + ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) + END, + CASE + --dont need to generate options when start segment is already sufficient + WHEN sum_length >= 0.8 THEN bin_rank + --generate options until 1 bin has sufficient length, otherwise until last bin in group + ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) + END, + 1 + ) AS end_bin + FROM segment_5min_bins + WINDOW w AS ( + PARTITION BY time_grp + ORDER BY tx + --look only forward for end_bin options + RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) + ), + + unnested_db_options AS ( + SELECT + s5b.segment_uid, + dbo.time_grp, + s5b.total_length, + dbo.tx AS dt_start, + --exclusive end bin + MAX(s5b.tx) + interval '5 minutes' AS dt_end, + unnested.link_dir, + unnested.len, + AVG(unnested.tt) AS tt, --avg TT for each link_dir + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + FROM dynamic_bin_options AS dbo + LEFT JOIN segment_5min_bins AS s5b + ON s5b.time_grp = dbo.time_grp + AND s5b.bin_rank >= dbo.start_bin + AND s5b.bin_rank <= dbo.end_bin, + --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin + UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + --we need to use nested data to determine length for these multi-period bins + WHERE dbo.start_bin != dbo.end_bin + GROUP BY + s5b.segment_uid, + dbo.time_grp, + s5b.total_length, + dbo.tx, + dbo.end_bin, + unnested.link_dir, + unnested.len + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' + ) + + INSERT INTO gwolofs.dynamic_binning_results ( + time_grp, segment_uid, dt_start, dt_end, bin_range, tt, + unadjusted_tt, total_length, length_w_data, num_obs + ) + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + SELECT DISTINCT ON (dt_start) + time_grp, + segment_uid, + dt_start, + dt_end, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(tt) AS unadjusted_tt, + total_length, + SUM(len) AS length_w_data, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + time_grp, + segment_uid, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + UNION + --these 5 minute bins already have sufficient length + --don't need to use nested data to validate. + SELECT + time_grp, + segment_uid, + tx AS dt_start, + tx + interval '5 minutes' AS dt_end, + tsrange(tx, tx + interval '5 minutes', '[)') AS bin_range, + total_length / length_w_data * unadjusted_tt AS tt, + unadjusted_tt, + total_length, + length_w_data, + num_obs --sum of here.ta_path sample_size for each segment + FROM segment_5min_bins + --we do not need to use nested data to determine length here. + WHERE sum_length >= 0.8 + ORDER BY + dt_start, + dt_end + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT dynamic_bins_unique_temp + DO NOTHING; + $$, + link_dirs, start_tod, end_tod, start_tod, end_tod, dow_list, start_date, end_date +); + +END; +$BODY$; +ALTER PROCEDURE gwolofs.cache_tt_results( + date, date, time without time zone, time without time zone, integer[], text[], boolean +) +OWNER TO gwolofs; diff --git a/here/traffic/sql/procedure-cache_tt_segment.sql b/here/traffic/sql/procedure-cache_tt_segment.sql new file mode 100644 index 000000000..f88d011e9 --- /dev/null +++ b/here/traffic/sql/procedure-cache_tt_segment.sql @@ -0,0 +1,25 @@ +-- PROCEDURE: gwolofs.cache_tt_segment(text[]) + +-- DROP PROCEDURE IF EXISTS gwolofs.cache_tt_segment(text[]); + +CREATE OR REPLACE PROCEDURE gwolofs.cache_tt_segment( + IN link_dirs text[] +) +LANGUAGE 'sql' +AS $BODY$ + +INSERT INTO gwolofs.tt_segments (link_dirs, lengths, geom, total_length) +SELECT + ARRAY_AGG(link_dir ORDER BY link_dir) AS link_dirs, + ARRAY_AGG(length ORDER BY link_dir) AS lengths, + st_union(st_linemerge(geom)) AS geom, + SUM(length) AS total_length +FROM congestion.network_links_23_4_geom +WHERE link_dir = ANY (cache_tt_segment.link_dirs) +ON CONFLICT (link_dirs) +DO NOTHING; + +$BODY$; + +ALTER PROCEDURE gwolofs.cache_tt_segment(text[]) +OWNER TO gwolofs; From 0128961e6181d05fb070da5c638cc41399d72c03 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:02:01 +0000 Subject: [PATCH 08/74] #1132 update cache_tt_segment to return segment details + Check if exists before routing --- .../sql/procedure-cache_tt_segment.sql | 93 +++++++++++++++---- 1 file changed, 75 insertions(+), 18 deletions(-) diff --git a/here/traffic/sql/procedure-cache_tt_segment.sql b/here/traffic/sql/procedure-cache_tt_segment.sql index f88d011e9..18f39eb4e 100644 --- a/here/traffic/sql/procedure-cache_tt_segment.sql +++ b/here/traffic/sql/procedure-cache_tt_segment.sql @@ -1,25 +1,82 @@ --- PROCEDURE: gwolofs.cache_tt_segment(text[]) +-- FUNCTION: gwolofs.cache_tt_segment(bigint, bigint, text) --- DROP PROCEDURE IF EXISTS gwolofs.cache_tt_segment(text[]); +DROP FUNCTION IF EXISTS gwolofs.cache_tt_segment(bigint, bigint, text); + +CREATE OR REPLACE FUNCTION gwolofs.cache_tt_segment( + IN node_start bigint, + IN node_end bigint, + IN map_version text, + OUT uid smallint, + OUT link_dirs text[], + OUT lengths numeric[], + OUT total_length numeric) + LANGUAGE 'plpgsql' + COST 100 + VOLATILE PARALLEL SAFE -CREATE OR REPLACE PROCEDURE gwolofs.cache_tt_segment( - IN link_dirs text[] -) -LANGUAGE 'sql' AS $BODY$ -INSERT INTO gwolofs.tt_segments (link_dirs, lengths, geom, total_length) -SELECT - ARRAY_AGG(link_dir ORDER BY link_dir) AS link_dirs, - ARRAY_AGG(length ORDER BY link_dir) AS lengths, - st_union(st_linemerge(geom)) AS geom, - SUM(length) AS total_length -FROM congestion.network_links_23_4_geom -WHERE link_dir = ANY (cache_tt_segment.link_dirs) -ON CONFLICT (link_dirs) -DO NOTHING; +DECLARE + routing_function text := 'get_links_btwn_nodes_' || map_version; + street_geoms_table text := 'routing_streets_' || map_version; + +BEGIN + --check if the node pair and map_version have already been routed + --and if so, return values + SELECT + tt.uid, + tt.link_dirs, + tt.lengths, + tt.total_length + INTO uid, link_dirs, lengths, total_length + FROM gwolofs.tt_segments AS tt + WHERE + tt.node_start = cache_tt_segment.node_start + AND tt.node_end = cache_tt_segment.node_end + AND tt.map_version = cache_tt_segment.map_version; + IF FOUND THEN + RETURN; + END IF; + +EXECUTE format ( + $$ + WITH routed_links AS ( + SELECT link_dir, seq + FROM here_gis.%1$I(%2$L, %3$L), + UNNEST (links) WITH ORDINALITY AS unnested (link_dir, seq) + ) + + INSERT INTO gwolofs.tt_segments ( + node_start, node_end, map_version, link_dirs, lengths, geom, total_length + ) + SELECT + %2$L AS node_start, + %3$L AS node_end, + %4$L AS map_version, + ARRAY_AGG(rl.link_dir ORDER BY rl.seq) AS link_dirs, + --lengths in m + ARRAY_AGG(ST_Length(ST_Transform(streets.geom,2952)) ORDER BY rl.seq) AS lengths, + st_union(st_linemerge(streets.geom)) AS geom, + SUM(ST_Length(ST_Transform(streets.geom,2952))) AS total_length + FROM routed_links AS rl + JOIN here.%5$I AS streets USING (link_dir) + --conflict would occur because of null values + ON CONFLICT (node_start, node_end, map_version) + DO UPDATE + SET + link_dirs = excluded.link_dirs, + lengths = excluded.lengths, + total_length = excluded.total_length + RETURNING uid, link_dirs, lengths, total_length + $$, + routing_function, node_start, node_end, -- For routed_links + map_version, -- For INSERT SELECT values + street_geoms_table -- For JOIN table +) INTO uid, link_dirs, lengths, total_length; +RETURN; +END; $BODY$; -ALTER PROCEDURE gwolofs.cache_tt_segment(text[]) -OWNER TO gwolofs; +ALTER FUNCTION gwolofs.cache_tt_segment(bigint, bigint, text) + OWNER TO gwolofs; From 330668c630e4f995a85bd7302f1970f8e464fb73 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:03:04 +0000 Subject: [PATCH 09/74] #1132 cache_tt_segment procedure->function --- ...ocedure-cache_tt_segment.sql => function-cache_tt_segment.sql} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename here/traffic/sql/{procedure-cache_tt_segment.sql => function-cache_tt_segment.sql} (100%) diff --git a/here/traffic/sql/procedure-cache_tt_segment.sql b/here/traffic/sql/function-cache_tt_segment.sql similarity index 100% rename from here/traffic/sql/procedure-cache_tt_segment.sql rename to here/traffic/sql/function-cache_tt_segment.sql From 521eceff2261d4faaa78f0e04f2864063eab6cd6 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:10:50 +0000 Subject: [PATCH 10/74] #1132 cache_tt_results procedure->function --- ...ocedure-cache_tt_results.sql => function-cache_tt_results.sql} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename here/traffic/sql/{procedure-cache_tt_results.sql => function-cache_tt_results.sql} (100%) diff --git a/here/traffic/sql/procedure-cache_tt_results.sql b/here/traffic/sql/function-cache_tt_results.sql similarity index 100% rename from here/traffic/sql/procedure-cache_tt_results.sql rename to here/traffic/sql/function-cache_tt_results.sql From 154ea44982fc4e7cc8cba08aa399c8b748a02628 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:10:59 +0000 Subject: [PATCH 11/74] #1132 select map version func --- .../sql/function-select_map_version.sql | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 here/traffic/sql/function-select_map_version.sql diff --git a/here/traffic/sql/function-select_map_version.sql b/here/traffic/sql/function-select_map_version.sql new file mode 100644 index 000000000..1bbf56064 --- /dev/null +++ b/here/traffic/sql/function-select_map_version.sql @@ -0,0 +1,26 @@ +-- FUNCTION: gwolofs.select_map_version(date, date) + +-- DROP FUNCTION IF EXISTS gwolofs.select_map_version(date, date); + +CREATE OR REPLACE FUNCTION gwolofs.select_map_version( + start_date date, + end_date date) + RETURNS text + LANGUAGE 'sql' + COST 100 + STABLE PARALLEL SAFE +AS $BODY$ + +SELECT street_version +FROM here.street_valid_range AS svr, +LATERAL ( + SELECT svr.valid_range * daterange(select_map_version.start_date, select_map_version.end_date, '[)') AS overlap +) AS lat +WHERE UPPER(lat.overlap) - LOWER(lat.overlap) IS NOT NULL +ORDER BY UPPER(lat.overlap) - LOWER(lat.overlap) DESC NULLS LAST +LIMIT 1; + +$BODY$; + +ALTER FUNCTION gwolofs.select_map_version(date, date) + OWNER TO gwolofs; From ab45c51b41564b125fb22949563e1de2de5e38e9 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:13:03 +0000 Subject: [PATCH 12/74] #1132 cache_tt_results updates; use map version, fix end_bin bug, save uri_string for result lookup --- .../traffic/sql/function-cache_tt_results.sql | 75 ++++++++++++------- 1 file changed, 46 insertions(+), 29 deletions(-) diff --git a/here/traffic/sql/function-cache_tt_results.sql b/here/traffic/sql/function-cache_tt_results.sql index d1f5e3d0e..2cc372e0a 100644 --- a/here/traffic/sql/function-cache_tt_results.sql +++ b/here/traffic/sql/function-cache_tt_results.sql @@ -1,20 +1,29 @@ --- PROCEDURE: gwolofs.cache_tt_results(date, date, time without time zone, time without time zone, integer[], text[], boolean) +-- FUNCTION: gwolofs.cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --- DROP PROCEDURE IF EXISTS gwolofs.cache_tt_results(date, date, time without time zone, time without time zone, integer[], text[], boolean); +-- DROP FUNCTION IF EXISTS gwolofs.cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); -CREATE OR REPLACE PROCEDURE gwolofs.cache_tt_results( - IN start_date date, - IN end_date date, - IN start_tod time without time zone, - IN end_tod time without time zone, - IN dow_list integer[], - IN link_dirs text[], - IN holidays boolean -) -LANGUAGE 'plpgsql' +CREATE OR REPLACE FUNCTION gwolofs.cache_tt_results( + uri_string text, + start_date date, + end_date date, + start_tod time without time zone, + end_tod time without time zone, + dow_list integer[], + node_start bigint, + node_end bigint, + holidays boolean) + RETURNS void + LANGUAGE 'plpgsql' + COST 100 + VOLATILE PARALLEL UNSAFE AS $BODY$ +DECLARE map_version text; + BEGIN + +SELECT gwolofs.select_map_version(cache_tt_results.start_date, cache_tt_results.end_date) INTO map_version; + EXECUTE format( $$ WITH segment AS ( @@ -22,10 +31,9 @@ EXECUTE format( uid AS segment_uid, unnested.link_dir, unnested.length, - tt_segments.total_length - FROM gwolofs.tt_segments, - UNNEST(tt_segments.link_dirs, tt_segments.lengths) AS unnested(link_dir, length) - WHERE link_dirs = %L + total_length + FROM gwolofs.cache_tt_segment(%L, %L, %L), + UNNEST(cache_tt_segment.link_dirs, cache_tt_segment.lengths) AS unnested(link_dir, length) ), segment_5min_bins AS ( @@ -44,7 +52,7 @@ EXECUTE format( ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, ARRAY_AGG(seg.length ORDER BY link_dir) AS lengths - FROM here.ta_path AS ta + FROM here.ta AS ta JOIN segment AS seg USING (link_dir) WHERE ( @@ -52,7 +60,7 @@ EXECUTE format( AND --{ToD_and_or} tod < %L ) - AND date_part('isodow', dt) = ANY(%L) + AND date_part('isodow', dt) = ANY(%L::int[]) AND dt >= %L AND dt < %L /*--{holiday_clause} @@ -109,16 +117,20 @@ EXECUTE format( s5b.total_length, dbo.tx AS dt_start, --exclusive end bin - MAX(s5b.tx) + interval '5 minutes' AS dt_end, + s5b_end.tx + interval '5 minutes' AS dt_end, unnested.link_dir, unnested.len, AVG(unnested.tt) AS tt, --avg TT for each link_dir - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir FROM dynamic_bin_options AS dbo LEFT JOIN segment_5min_bins AS s5b ON s5b.time_grp = dbo.time_grp AND s5b.bin_rank >= dbo.start_bin - AND s5b.bin_rank <= dbo.end_bin, + AND s5b.bin_rank <= dbo.end_bin + --this join is used to get the tx info about the last bin only + LEFT JOIN segment_5min_bins AS s5b_end + ON s5b_end.time_grp = dbo.time_grp + AND s5b_end.bin_rank = dbo.end_bin, --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) --we need to use nested data to determine length for these multi-period bins @@ -127,21 +139,23 @@ EXECUTE format( s5b.segment_uid, dbo.time_grp, s5b.total_length, - dbo.tx, - dbo.end_bin, + dbo.tx, --stard_bin + s5b_end.tx, --end_bin unnested.link_dir, unnested.len --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' + --HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' ) INSERT INTO gwolofs.dynamic_binning_results ( + uri_string, time_grp, segment_uid, dt_start, dt_end, bin_range, tt, unadjusted_tt, total_length, length_w_data, num_obs ) --this query contains overlapping values which get eliminated --via on conflict with the exclusion constraint on congestion_raw_segments table. SELECT DISTINCT ON (dt_start) + %L, time_grp, segment_uid, dt_start, @@ -164,6 +178,7 @@ EXECUTE format( --these 5 minute bins already have sufficient length --don't need to use nested data to validate. SELECT + %L, time_grp, segment_uid, tx AS dt_start, @@ -184,12 +199,14 @@ EXECUTE format( ON CONFLICT ON CONSTRAINT dynamic_bins_unique_temp DO NOTHING; $$, - link_dirs, start_tod, end_tod, start_tod, end_tod, dow_list, start_date, end_date + node_start, node_end, map_version, --segment CTE + start_tod, end_tod, --segment_5min_bins CTE SELECT + start_tod, end_tod, dow_list, start_date, end_date, --segment_5min_bins CTE WHERE + cache_tt_results.uri_string, cache_tt_results.uri_string --INSERT ); END; $BODY$; -ALTER PROCEDURE gwolofs.cache_tt_results( - date, date, time without time zone, time without time zone, integer[], text[], boolean -) -OWNER TO gwolofs; + +ALTER FUNCTION gwolofs.cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) + OWNER TO gwolofs; From e51d6ed8c52c624ad401b442cd1f62efbe6d7856 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:14:02 +0000 Subject: [PATCH 13/74] #1132 tt_segments table; save map_version, nodes, remove link_dir constraint --- here/traffic/sql/create-table-tt_segments.sql | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/here/traffic/sql/create-table-tt_segments.sql b/here/traffic/sql/create-table-tt_segments.sql index 677c8641e..7426b9e66 100644 --- a/here/traffic/sql/create-table-tt_segments.sql +++ b/here/traffic/sql/create-table-tt_segments.sql @@ -9,12 +9,16 @@ CREATE TABLE IF NOT EXISTS gwolofs.tt_segments geom geometry, total_length numeric, uid smallint NOT NULL DEFAULT nextval('tt_segments_uid_seq'::regclass), - CONSTRAINT unique_link_dirs UNIQUE (link_dirs) + node_start bigint NOT NULL, + node_end bigint NOT NULL, + map_version text COLLATE pg_catalog."default" NOT NULL, + CONSTRAINT tt_segments_pkey PRIMARY KEY (node_start, node_end, map_version) ) TABLESPACE pg_default; -ALTER TABLE IF EXISTS gwolofs.tt_segments OWNER TO gwolofs; +ALTER TABLE IF EXISTS gwolofs.tt_segments + OWNER to gwolofs; REVOKE ALL ON TABLE gwolofs.tt_segments FROM bdit_humans; From 71468b60ede060bfa4e73ca5aa9a4fd3aedb8b9f Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:15:49 +0000 Subject: [PATCH 14/74] #1132 update dynamic bin results table; add uri --- .../create-table-dynamic_binning_results.sql | 24 +++++++++++-------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/here/traffic/sql/create-table-dynamic_binning_results.sql b/here/traffic/sql/create-table-dynamic_binning_results.sql index c83618ed3..626a3dcec 100644 --- a/here/traffic/sql/create-table-dynamic_binning_results.sql +++ b/here/traffic/sql/create-table-dynamic_binning_results.sql @@ -2,7 +2,8 @@ -- DROP TABLE IF EXISTS gwolofs.dynamic_binning_results; -CREATE TABLE IF NOT EXISTS gwolofs.dynamic_binning_results ( +CREATE TABLE IF NOT EXISTS gwolofs.dynamic_binning_results +( time_grp tsrange NOT NULL, bin_range tsrange NOT NULL, dt_start timestamp without time zone, @@ -13,17 +14,20 @@ CREATE TABLE IF NOT EXISTS gwolofs.dynamic_binning_results ( length_w_data numeric, num_obs integer, segment_uid smallint, + uri_string text COLLATE pg_catalog."default", CONSTRAINT dynamic_bins_unique_temp EXCLUDE USING gist ( bin_range WITH &&, time_grp WITH =, - segment_uid WITH = + segment_uid WITH =, + uri_string WITH = ) + ) TABLESPACE pg_default; ALTER TABLE IF EXISTS gwolofs.dynamic_binning_results -OWNER TO gwolofs; + OWNER TO gwolofs; REVOKE ALL ON TABLE gwolofs.dynamic_binning_results FROM bdit_humans; @@ -35,10 +39,10 @@ GRANT ALL ON TABLE gwolofs.dynamic_binning_results TO gwolofs; -- DROP INDEX IF EXISTS gwolofs.dynamic_binning_results_time_grp_segment_uid_idx; CREATE INDEX IF NOT EXISTS dynamic_binning_results_time_grp_segment_uid_idx -ON gwolofs.dynamic_binning_results USING btree -( - time_grp ASC NULLS LAST, - segment_uid ASC NULLS LAST -) -WITH (deduplicate_items=True) -TABLESPACE pg_default; \ No newline at end of file + ON gwolofs.dynamic_binning_results USING btree + ( + time_grp ASC NULLS LAST, + segment_uid ASC NULLS LAST + ) + WITH (deduplicate_items=True) + TABLESPACE pg_default; \ No newline at end of file From dcd95840a43d1136d8d3fbffd13c299cb7e7d134 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 30 Jan 2025 23:18:29 +0000 Subject: [PATCH 15/74] #1132 update here_dynamic_bin_avg; use daily avgs -> avg method, use uri_string to locate results --- .../create-function-here_dynamic_bin_avg.sql | 99 ++++++++----------- 1 file changed, 41 insertions(+), 58 deletions(-) diff --git a/here/traffic/sql/create-function-here_dynamic_bin_avg.sql b/here/traffic/sql/create-function-here_dynamic_bin_avg.sql index 4c344020c..6f5bf82d5 100644 --- a/here/traffic/sql/create-function-here_dynamic_bin_avg.sql +++ b/here/traffic/sql/create-function-here_dynamic_bin_avg.sql @@ -1,81 +1,64 @@ --- FUNCTION: gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], text[], boolean) +-- FUNCTION: gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --- DROP FUNCTION IF EXISTS gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], text[], boolean); +-- DROP FUNCTION IF EXISTS gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); CREATE OR REPLACE FUNCTION gwolofs.here_dynamic_bin_avg( - start_date date, - end_date date, - start_tod time without time zone, - end_tod time without time zone, - dow_list integer[], - link_dirs text[], - holidays boolean) + start_date date, + end_date date, + start_tod time without time zone, + end_tod time without time zone, + dow_list integer[], + node_start bigint, + node_end bigint, + holidays boolean) RETURNS numeric - LANGUAGE 'sql' + LANGUAGE 'plpgsql' COST 100 VOLATILE PARALLEL UNSAFE AS $BODY$ -CALL gwolofs.cache_tt_segment(here_dynamic_bin_avg.link_dirs); +DECLARE uri_string_func text := + here_dynamic_bin_avg.node_start::text || '/' || + here_dynamic_bin_avg.node_end::text || '/' || + here_dynamic_bin_avg.start_tod::text || '/' || + here_dynamic_bin_avg.end_tod::text || '/' || + here_dynamic_bin_avg.start_date::text || '/' || + here_dynamic_bin_avg.end_date::text || '/' || + here_dynamic_bin_avg.holidays::text || '/' || + here_dynamic_bin_avg.dow_list::text; + res numeric; -CALL gwolofs.cache_tt_results( +BEGIN + +PERFORM gwolofs.cache_tt_results( + uri_string := uri_string_func, start_date := here_dynamic_bin_avg.start_date, end_date := here_dynamic_bin_avg.end_date, start_tod := here_dynamic_bin_avg.start_tod, end_tod := here_dynamic_bin_avg.end_tod, dow_list := here_dynamic_bin_avg.dow_list, - link_dirs := here_dynamic_bin_avg.link_dirs, + node_start := here_dynamic_bin_avg.node_start, + node_end := here_dynamic_bin_avg.node_end, holidays := here_dynamic_bin_avg.holidays ); -WITH time_grps AS ( - SELECT tsrange( - (days.dt + here_dynamic_bin_avg.start_tod)::timestamp, - (days.dt + here_dynamic_bin_avg.end_tod)::timestamp, '[)') AS time_grp - FROM generate_series( - here_dynamic_bin_avg.start_date::date, - here_dynamic_bin_avg.end_date::date - '1 day'::interval, '1 day'::interval) AS days(dt) - WHERE date_part('isodow', dt) = ANY(here_dynamic_bin_avg.dow_list) +WITH daily_means AS ( + SELECT + dt_start::date, + AVG(tt) AS daily_mean + FROM gwolofs.dynamic_binning_results + WHERE uri_string = uri_string_func + GROUP BY dt_start::date ) -SELECT AVG(tt) -FROM gwolofs.dynamic_binning_results AS res -JOIN time_grps USING (time_grp) -JOIN gwolofs.tt_segments AS segs ON res.segment_uid = segs.uid -WHERE segs.link_dirs = here_dynamic_bin_avg.link_dirs - -$BODY$; - -ALTER FUNCTION gwolofs.here_dynamic_bin_avg( - date, date, time without time zone, time without time zone, integer[], text[], boolean -) -OWNER TO gwolofs; +SELECT AVG(daily_mean) INTO res +FROM daily_means; +RETURN res; -/*example of use: +END; -SELECT - start_date, - end_date, - start_tod, - end_tod, - dow_list, - link_dirs, - gwolofs.here_dynamic_bin_avg( - start_date := l.start_date, - end_date := l.end_date, - start_tod := l.start_tod, - end_tod := l.end_tod, - dow_list := l.dow_list, - link_dirs := l.link_dirs, - holidays := TRUE - ) -FROM -(VALUES -('2025-01-02'::date, '2025-01-10'::date, '07:00'::time, '10:00'::time, '{1,2,3,4,5}'::int[], '{1258924853F,1258924867F,1258924868F,1258924894F}'::text[]), -('2025-01-02'::date, '2025-01-10'::date, '11:00'::time, '15:00'::time, '{1,2,3,4,5}'::int[], '{1258924852F,1258924867F,1258924868F,1258924894F}'::text[]), -('2025-01-02'::date, '2025-01-10'::date, '07:00'::time, '10:00'::time, '{1,3,5}'::int[], '{1258924852F,1258924853F,1258924868F,1258924894F}'::text[]), -('2024-01-02'::date, '2025-01-10'::date, '07:00'::time, '10:00'::time, '{1,2,3,4,5}'::int[], '{1258924852F,1258924853F,1258924867F,1258924894F}'::text[]) -) AS l(start_date, end_date, start_tod, end_tod, dow_list, link_dirs); +$BODY$; -*/ \ No newline at end of file +ALTER FUNCTION gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) + OWNER TO gwolofs; From ad3c31ecb258cd6b4c41fb2898f2e36763c4c7f5 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 4 Feb 2025 15:03:50 +0000 Subject: [PATCH 16/74] #1132 apply end_bin fix to congestion network query --- .../traffic/sql/function-cache_tt_results.sql | 2 +- .../sql/select-congestion_raw_segments.sql | 21 ++++++++++++------- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/here/traffic/sql/function-cache_tt_results.sql b/here/traffic/sql/function-cache_tt_results.sql index 2cc372e0a..000164f49 100644 --- a/here/traffic/sql/function-cache_tt_results.sql +++ b/here/traffic/sql/function-cache_tt_results.sql @@ -144,7 +144,7 @@ EXECUTE format( unnested.link_dir, unnested.len --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - --HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' + --HAVING s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' ) INSERT INTO gwolofs.dynamic_binning_results ( diff --git a/here/traffic/sql/select-congestion_raw_segments.sql b/here/traffic/sql/select-congestion_raw_segments.sql index ddf922fd1..30c60872d 100644 --- a/here/traffic/sql/select-congestion_raw_segments.sql +++ b/here/traffic/sql/select-congestion_raw_segments.sql @@ -103,7 +103,7 @@ unnested_db_options AS ( s5b.total_length, dbo.tx AS dt_start, --exclusive end bin - MAX(s5b.tx) + interval '5 minutes' AS dt_end, + s5b_end.tx + interval '5 minutes' AS dt_end, unnested.link_dir, unnested.len, AVG(unnested.tt) AS tt, --avg TT for each link_dir @@ -113,21 +113,26 @@ unnested_db_options AS ( ON s5b.time_grp = dbo.time_grp AND s5b.segment_id = dbo.segment_id AND s5b.bin_rank >= dbo.start_bin - AND s5b.bin_rank <= dbo.end_bin, + AND s5b.bin_rank <= dbo.end_bin + --this join is used to get the tx info about the last bin only + LEFT JOIN segment_5min_bins AS s5b_end + ON s5b_end.time_grp = dbo.time_grp + AND s5b_end.bin_rank = dbo.end_bin, --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) - --we need to use nested data to determine length for these multi-period bins - WHERE dbo.start_bin != dbo.end_bin + WHERE + --we need to use nested data to determine length for these multi-period bins + dbo.start_bin != dbo.end_bin + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + AND s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' GROUP BY dbo.time_grp, dbo.segment_id, s5b.total_length, - dbo.tx, - dbo.end_bin, + dbo.tx, --stard_bin + s5b_end.tx, --end_bin unnested.link_dir, unnested.len - --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' ) INSERT INTO gwolofs.congestion_raw_segments ( From b1befb71397599e67a5f3e7ef069fd88137dae7c Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 11 Feb 2025 19:34:28 +0000 Subject: [PATCH 17/74] #1132 rename files/functions as per proposed dictionary --- .../create-function-here_dynamic_bin_avg.sql | 14 +- .../create-table-congestion_raw_segments.sql | 22 +- .../create-table-dynamic_binning_results.sql | 34 ++- here/traffic/sql/create-table-tt_segments.sql | 20 +- .../traffic/sql/function-cache_tt_results.sql | 16 +- .../traffic/sql/function-cache_tt_segment.sql | 30 +-- .../sql/function-select_map_version.sql | 8 +- .../sql/select-congestion_raw_segments.sql | 211 ------------------ 8 files changed, 74 insertions(+), 281 deletions(-) delete mode 100644 here/traffic/sql/select-congestion_raw_segments.sql diff --git a/here/traffic/sql/create-function-here_dynamic_bin_avg.sql b/here/traffic/sql/create-function-here_dynamic_bin_avg.sql index 6f5bf82d5..d51b7f0f0 100644 --- a/here/traffic/sql/create-function-here_dynamic_bin_avg.sql +++ b/here/traffic/sql/create-function-here_dynamic_bin_avg.sql @@ -1,8 +1,8 @@ --- FUNCTION: gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) +-- FUNCTION: gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --- DROP FUNCTION IF EXISTS gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); -CREATE OR REPLACE FUNCTION gwolofs.here_dynamic_bin_avg( +CREATE OR REPLACE FUNCTION gwolofs.congestion_dynamic_bin_avg( start_date date, end_date date, start_tod time without time zone, @@ -30,7 +30,7 @@ DECLARE uri_string_func text := BEGIN -PERFORM gwolofs.cache_tt_results( +PERFORM gwolofs.congestion_cache_tt_results( uri_string := uri_string_func, start_date := here_dynamic_bin_avg.start_date, end_date := here_dynamic_bin_avg.end_date, @@ -46,7 +46,7 @@ WITH daily_means AS ( SELECT dt_start::date, AVG(tt) AS daily_mean - FROM gwolofs.dynamic_binning_results + FROM gwolofs.congestion_raw_corridors WHERE uri_string = uri_string_func GROUP BY dt_start::date ) @@ -60,5 +60,7 @@ END; $BODY$; -ALTER FUNCTION gwolofs.here_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) +ALTER FUNCTION gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.congestion_dynamic_bin_avg IS 'Previously gwolofs.here_dynamic_bin_avg.'; diff --git a/here/traffic/sql/create-table-congestion_raw_segments.sql b/here/traffic/sql/create-table-congestion_raw_segments.sql index 9b6d39f5d..7a0ec772d 100644 --- a/here/traffic/sql/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/create-table-congestion_raw_segments.sql @@ -4,21 +4,18 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments ( - time_grp tsrange NOT NULL, segment_id integer NOT NULL, bin_range tsrange NOT NULL, - dt_start timestamp without time zone, - dt_end timestamp without time zone, tt numeric, unadjusted_tt numeric, total_length numeric, length_w_data numeric, num_obs integer, - CONSTRAINT dynamic_bins_unique EXCLUDE USING gist ( - segment_id WITH =, + hr timestamp without time zone, + CONSTRAINT congestion_raw_segments_exclude EXCLUDE USING gist ( + hr WITH =, bin_range WITH &&, - time_grp WITH = - ) + segment_id WITH =) ) TABLESPACE pg_default; @@ -31,12 +28,21 @@ REVOKE ALL ON TABLE gwolofs.congestion_raw_segments FROM bdit_humans; GRANT SELECT ON TABLE gwolofs.congestion_raw_segments TO bdit_humans; GRANT ALL ON TABLE gwolofs.congestion_raw_segments TO gwolofs; +-- Index: dynamic_bin_hr_idx + +-- DROP INDEX IF EXISTS gwolofs.dynamic_bin_hr_idx; + +CREATE INDEX IF NOT EXISTS dynamic_bin_hr_idx + ON gwolofs.congestion_raw_segments USING btree + (hr ASC NULLS LAST) + WITH (deduplicate_items=True) + TABLESPACE pg_default; -- Index: dynamic_bin_idx -- DROP INDEX IF EXISTS gwolofs.dynamic_bin_idx; CREATE INDEX IF NOT EXISTS dynamic_bin_idx ON gwolofs.congestion_raw_segments USING btree - (segment_id ASC NULLS LAST, time_grp ASC NULLS LAST) + (segment_id ASC NULLS LAST, hr ASC NULLS LAST) WITH (deduplicate_items=True) TABLESPACE pg_default; \ No newline at end of file diff --git a/here/traffic/sql/create-table-dynamic_binning_results.sql b/here/traffic/sql/create-table-dynamic_binning_results.sql index 626a3dcec..c0c101d1b 100644 --- a/here/traffic/sql/create-table-dynamic_binning_results.sql +++ b/here/traffic/sql/create-table-dynamic_binning_results.sql @@ -1,8 +1,8 @@ --- Table: gwolofs.dynamic_binning_results +-- Table: gwolofs.congestion_raw_corridors --- DROP TABLE IF EXISTS gwolofs.dynamic_binning_results; +-- DROP TABLE IF EXISTS gwolofs.congestion_raw_corridors; -CREATE TABLE IF NOT EXISTS gwolofs.dynamic_binning_results +CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors ( time_grp tsrange NOT NULL, bin_range tsrange NOT NULL, @@ -15,34 +15,30 @@ CREATE TABLE IF NOT EXISTS gwolofs.dynamic_binning_results num_obs integer, segment_uid smallint, uri_string text COLLATE pg_catalog."default", - CONSTRAINT dynamic_bins_unique_temp EXCLUDE USING gist ( + CONSTRAINT congestion_raw_corridors_exclude EXCLUDE USING gist ( bin_range WITH &&, - time_grp WITH =, segment_uid WITH =, - uri_string WITH = - ) - + time_grp WITH =, + uri_string WITH =) ) TABLESPACE pg_default; -ALTER TABLE IF EXISTS gwolofs.dynamic_binning_results - OWNER TO gwolofs; +ALTER TABLE IF EXISTS gwolofs.congestion_raw_corridors + OWNER to gwolofs; + +REVOKE ALL ON TABLE gwolofs.congestion_raw_corridors FROM bdit_humans; -REVOKE ALL ON TABLE gwolofs.dynamic_binning_results FROM bdit_humans; +GRANT SELECT ON TABLE gwolofs.congestion_raw_corridors TO bdit_humans; -GRANT SELECT ON TABLE gwolofs.dynamic_binning_results TO bdit_humans; +GRANT ALL ON TABLE gwolofs.congestion_raw_corridors TO gwolofs; -GRANT ALL ON TABLE gwolofs.dynamic_binning_results TO gwolofs; -- Index: dynamic_binning_results_time_grp_segment_uid_idx --- DROP INDEX IF EXISTS gwolofs.dynamic_binning_results_time_grp_segment_uid_idx; +-- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_time_grp_segment_uid_idx; CREATE INDEX IF NOT EXISTS dynamic_binning_results_time_grp_segment_uid_idx - ON gwolofs.dynamic_binning_results USING btree - ( - time_grp ASC NULLS LAST, - segment_uid ASC NULLS LAST - ) + ON gwolofs.congestion_raw_corridors USING btree + (time_grp ASC NULLS LAST, segment_uid ASC NULLS LAST) WITH (deduplicate_items=True) TABLESPACE pg_default; \ No newline at end of file diff --git a/here/traffic/sql/create-table-tt_segments.sql b/here/traffic/sql/create-table-tt_segments.sql index 7426b9e66..327c5cb8c 100644 --- a/here/traffic/sql/create-table-tt_segments.sql +++ b/here/traffic/sql/create-table-tt_segments.sql @@ -1,27 +1,27 @@ --- Table: gwolofs.tt_segments +-- Table: gwolofs.congestion_corridors --- DROP TABLE IF EXISTS gwolofs.tt_segments; +-- DROP TABLE IF EXISTS gwolofs.congestion_corridors; -CREATE TABLE IF NOT EXISTS gwolofs.tt_segments +CREATE TABLE IF NOT EXISTS gwolofs.congestion_corridors ( link_dirs text[] COLLATE pg_catalog."default", lengths numeric[], geom geometry, total_length numeric, - uid smallint NOT NULL DEFAULT nextval('tt_segments_uid_seq'::regclass), + corridor_id smallint NOT NULL DEFAULT nextval('congestion_corridors_uid_seq'::regclass), node_start bigint NOT NULL, node_end bigint NOT NULL, map_version text COLLATE pg_catalog."default" NOT NULL, - CONSTRAINT tt_segments_pkey PRIMARY KEY (node_start, node_end, map_version) + CONSTRAINT congestion_corridors_pkey PRIMARY KEY (node_start, node_end, map_version) ) TABLESPACE pg_default; -ALTER TABLE IF EXISTS gwolofs.tt_segments - OWNER to gwolofs; +ALTER TABLE IF EXISTS gwolofs.congestion_corridors +OWNER TO gwolofs; -REVOKE ALL ON TABLE gwolofs.tt_segments FROM bdit_humans; +REVOKE ALL ON TABLE gwolofs.congestion_corridors FROM bdit_humans; -GRANT SELECT ON TABLE gwolofs.tt_segments TO bdit_humans; +GRANT SELECT ON TABLE gwolofs.congestion_corridors TO bdit_humans; -GRANT ALL ON TABLE gwolofs.tt_segments TO gwolofs; \ No newline at end of file +GRANT ALL ON TABLE gwolofs.congestion_corridors TO gwolofs; diff --git a/here/traffic/sql/function-cache_tt_results.sql b/here/traffic/sql/function-cache_tt_results.sql index 000164f49..57d5b7831 100644 --- a/here/traffic/sql/function-cache_tt_results.sql +++ b/here/traffic/sql/function-cache_tt_results.sql @@ -1,8 +1,8 @@ --- FUNCTION: gwolofs.cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) +-- FUNCTION: gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --- DROP FUNCTION IF EXISTS gwolofs.cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); -CREATE OR REPLACE FUNCTION gwolofs.cache_tt_results( +CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results( uri_string text, start_date date, end_date date, @@ -22,7 +22,7 @@ DECLARE map_version text; BEGIN -SELECT gwolofs.select_map_version(cache_tt_results.start_date, cache_tt_results.end_date) INTO map_version; +SELECT gwolofs.congestion_select_map_version(cache_tt_results.start_date, cache_tt_results.end_date) INTO map_version; EXECUTE format( $$ @@ -32,7 +32,7 @@ EXECUTE format( unnested.link_dir, unnested.length, total_length - FROM gwolofs.cache_tt_segment(%L, %L, %L), + FROM gwolofs.congestion_cache_corridor(%L, %L, %L), UNNEST(cache_tt_segment.link_dirs, cache_tt_segment.lengths) AS unnested(link_dir, length) ), @@ -144,10 +144,10 @@ EXECUTE format( unnested.link_dir, unnested.len --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - --HAVING s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' + --HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' ) - INSERT INTO gwolofs.dynamic_binning_results ( + INSERT INTO gwolofs.congestion_raw_corridors ( uri_string, time_grp, segment_uid, dt_start, dt_end, bin_range, tt, unadjusted_tt, total_length, length_w_data, num_obs @@ -208,5 +208,5 @@ EXECUTE format( END; $BODY$; -ALTER FUNCTION gwolofs.cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) +ALTER FUNCTION gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) OWNER TO gwolofs; diff --git a/here/traffic/sql/function-cache_tt_segment.sql b/here/traffic/sql/function-cache_tt_segment.sql index 18f39eb4e..354f63426 100644 --- a/here/traffic/sql/function-cache_tt_segment.sql +++ b/here/traffic/sql/function-cache_tt_segment.sql @@ -1,19 +1,19 @@ --- FUNCTION: gwolofs.cache_tt_segment(bigint, bigint, text) +-- FUNCTION: gwolofs.congestion_cache_corridor(bigint, bigint, text) -DROP FUNCTION IF EXISTS gwolofs.cache_tt_segment(bigint, bigint, text); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_corridor(bigint, bigint, text); -CREATE OR REPLACE FUNCTION gwolofs.cache_tt_segment( - IN node_start bigint, - IN node_end bigint, - IN map_version text, - OUT uid smallint, - OUT link_dirs text[], - OUT lengths numeric[], - OUT total_length numeric) +CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_corridor( + node_start bigint, + node_end bigint, + map_version text, + OUT uid smallint, + OUT link_dirs text[], + OUT lengths numeric[], + OUT total_length numeric) + RETURNS record LANGUAGE 'plpgsql' COST 100 - VOLATILE PARALLEL SAFE - + VOLATILE PARALLEL SAFE AS $BODY$ DECLARE @@ -30,7 +30,7 @@ BEGIN tt.lengths, tt.total_length INTO uid, link_dirs, lengths, total_length - FROM gwolofs.tt_segments AS tt + FROM gwolofs.congestion_corridors AS tt WHERE tt.node_start = cache_tt_segment.node_start AND tt.node_end = cache_tt_segment.node_end @@ -47,7 +47,7 @@ EXECUTE format ( UNNEST (links) WITH ORDINALITY AS unnested (link_dir, seq) ) - INSERT INTO gwolofs.tt_segments ( + INSERT INTO gwolofs.congestion_corridors ( node_start, node_end, map_version, link_dirs, lengths, geom, total_length ) SELECT @@ -78,5 +78,5 @@ RETURN; END; $BODY$; -ALTER FUNCTION gwolofs.cache_tt_segment(bigint, bigint, text) +ALTER FUNCTION gwolofs.congestion_cache_corridor(bigint, bigint, text) OWNER TO gwolofs; diff --git a/here/traffic/sql/function-select_map_version.sql b/here/traffic/sql/function-select_map_version.sql index 1bbf56064..ab4ca1010 100644 --- a/here/traffic/sql/function-select_map_version.sql +++ b/here/traffic/sql/function-select_map_version.sql @@ -1,8 +1,8 @@ --- FUNCTION: gwolofs.select_map_version(date, date) +-- FUNCTION: gwolofs.congestion_select_map_version(date, date) --- DROP FUNCTION IF EXISTS gwolofs.select_map_version(date, date); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_select_map_version(date, date); -CREATE OR REPLACE FUNCTION gwolofs.select_map_version( +CREATE OR REPLACE FUNCTION gwolofs.congestion_select_map_version( start_date date, end_date date) RETURNS text @@ -22,5 +22,5 @@ LIMIT 1; $BODY$; -ALTER FUNCTION gwolofs.select_map_version(date, date) +ALTER FUNCTION gwolofs.congestion_select_map_version(date, date) OWNER TO gwolofs; diff --git a/here/traffic/sql/select-congestion_raw_segments.sql b/here/traffic/sql/select-congestion_raw_segments.sql deleted file mode 100644 index 30c60872d..000000000 --- a/here/traffic/sql/select-congestion_raw_segments.sql +++ /dev/null @@ -1,211 +0,0 @@ ---TRUNCATE gwolofs.congestion_raw_segments; - ---INSERT 0 771478 ---Query returned successfully in 2 min 51 secs. --- vs 7,756,256 rows in (SELECT COUNT(*) FROM here.ta_path WHERE dt = '2025-01-04') = 1/10 ---with addition of am/pm/midday time ranges: ---INSERT 0 1251472 (2024-01-04) ---Query returned successfully in 6 min 29 secs. - -WITH time_bins AS ( - SELECT - start_time, - start_time + '1 hour'::interval AS end_time, - tsrange(start_time, start_time + '1 hour'::interval, '[)') AS time_grp - FROM generate_series( - '2025-01-04'::date, - '2025-01-04'::date + interval '23 hours', - '1 hour'::interval - ) AS hours(start_time) - UNION - SELECT - start_time + '2025-01-04'::date, - end_time + '2025-01-04'::date, - tsrange(start_time + '2025-01-04'::date, end_time + '2025-01-04'::date, '[)') - FROM ( - VALUES - ('07:00'::time, '10:00'::time), - ('10:00', '16:00'), - ('16:00', '19:00') - ) AS time_periods(start_time, end_time) - ORDER BY start_time -), - -segment_5min_bins AS ( - SELECT - segments.segment_id, - tb.time_grp, - ta.tx, - RANK() OVER w AS bin_rank, - segments.total_length, - SUM(links.length) / segments.total_length AS sum_length, - SUM(links.length) AS length_w_data, - SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, - SUM(sample_size) AS num_obs, - ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, - ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, - ARRAY_AGG(links.length ORDER BY link_dir) AS lengths - FROM here.ta_path AS ta - JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time - JOIN congestion.network_links_23_4_geom AS links USING (link_dir) - JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) - WHERE ta.dt = '2025-01-04' - --AND tx < '2025-01-04 01:00:00' - --AND segment_id = 1 AND date_trunc('hour', ta.tx) = '2025-01-04 00:00:00' - GROUP BY - segments.segment_id, - tb.time_grp, - ta.tx, - segments.total_length - WINDOW w AS ( - PARTITION BY segments.segment_id, tb.time_grp - ORDER BY ta.tx - ) -), - -dynamic_bin_options AS ( - --within each segment/hour, generate all possible forward looking bin combinations - --don't generate options for bins with sufficient length - --also don't generate options past the next bin with 80% length - SELECT - tx, - time_grp, - segment_id, - bin_rank AS start_bin, - --generate all the options for the end bin within the group. - generate_series( - CASE - WHEN sum_length >= 0.8 THEN bin_rank - --if length is insufficient, need at least 1 more bin - ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) - END, - CASE - --dont need to generate options when start segment is already sufficient - WHEN sum_length >= 0.8 THEN bin_rank - --generate options until 1 bin has sufficient length, otherwise until last bin in group - ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) - END, - 1 - ) AS end_bin - FROM segment_5min_bins - WINDOW w AS ( - PARTITION BY time_grp, segment_id - ORDER BY tx - --look only forward for end_bin options - RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING - ) -), - -unnested_db_options AS ( - SELECT - dbo.time_grp, - dbo.segment_id, - s5b.total_length, - dbo.tx AS dt_start, - --exclusive end bin - s5b_end.tx + interval '5 minutes' AS dt_end, - unnested.link_dir, - unnested.len, - AVG(unnested.tt) AS tt, --avg TT for each link_dir - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir - FROM dynamic_bin_options AS dbo - LEFT JOIN segment_5min_bins AS s5b - ON s5b.time_grp = dbo.time_grp - AND s5b.segment_id = dbo.segment_id - AND s5b.bin_rank >= dbo.start_bin - AND s5b.bin_rank <= dbo.end_bin - --this join is used to get the tx info about the last bin only - LEFT JOIN segment_5min_bins AS s5b_end - ON s5b_end.time_grp = dbo.time_grp - AND s5b_end.bin_rank = dbo.end_bin, - --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin - UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) - WHERE - --we need to use nested data to determine length for these multi-period bins - dbo.start_bin != dbo.end_bin - --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - AND s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' - GROUP BY - dbo.time_grp, - dbo.segment_id, - s5b.total_length, - dbo.tx, --stard_bin - s5b_end.tx, --end_bin - unnested.link_dir, - unnested.len -) - -INSERT INTO gwolofs.congestion_raw_segments ( - time_grp, segment_id, dt_start, dt_end, bin_range, tt, - unadjusted_tt, total_length, length_w_data, num_obs -) ---this query contains overlapping values which get eliminated ---via on conflict with the exclusion constraint on congestion_raw_segments table. -SELECT DISTINCT ON (time_grp, segment_id, dt_start) - time_grp, - segment_id, - dt_start, - dt_end, - tsrange(dt_start, dt_end, '[)') AS bin_range, - total_length / SUM(len) * SUM(tt) AS tt, - SUM(tt) AS unadjusted_tt, - total_length, - SUM(len) AS length_w_data, - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment -FROM unnested_db_options -GROUP BY - time_grp, - segment_id, - dt_start, - dt_end, - total_length -HAVING SUM(len) >= 0.8 * total_length -UNION ---these 5 minute bins already have sufficient length ---don't need to use nested data to validate. -SELECT - time_grp, - segment_id, - tx AS dt_start, - tx + interval '5 minutes' AS dt_end, - tsrange(tx, tx + interval '5 minutes', '[)') AS bin_range, - total_length / length_w_data * unadjusted_tt AS tt, - unadjusted_tt, - total_length, - length_w_data, - num_obs --sum of here.ta_path sample_size for each segment -FROM segment_5min_bins ---we do not need to use nested data to determine length here. -WHERE sum_length >= 0.8 -ORDER BY - time_grp, - segment_id, - dt_start, - dt_end ---exclusion constraint + ordered insert to prevent overlapping bins -ON CONFLICT ON CONSTRAINT dynamic_bins_unique -DO NOTHING; - -/* ---bins which were not used. Might consider adding these on to bins that already have sufficient data. -SELECT * -FROM gwolofs.segment_5min_bins AS s5b -LEFT JOIN gwolofs.congestion_raw_segments AS dyb ON - s5b.time_grp = dyb.time_grp - AND s5b.source_node = dyb.source_node - AND s5b.dest_node = dyb.dest_node - AND s5b.tx <@ dyb.bin_range -WHERE dyb.bin_range IS NULL -*/ - -/* -WITH hourly_obs AS ( - SELECT time_grp, segment_id, AVG(tt) AS avg_hour_tt, COUNT(*) - FROM gwolofs.congestion_raw_segments - GROUP BY time_grp, segment_id -) - -SELECT segment_id, date_part('hour', time_grp), AVG(avg_hour_tt) AS avg_tt, SUM(count) -FROM hourly_obs -GROUP BY 1, 2 ORDER BY 1, 2; -*/ \ No newline at end of file From c65985ccf9c0144c2b9c8188ab481deab7523484 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 11 Feb 2025 20:55:57 +0000 Subject: [PATCH 18/74] #1132 rename files/functions continued --- .../create-table-congestion_corridors.sql} | 0 ...create-table-congestion_raw_corridors.sql} | 23 +-- .../create-table-congestion_raw_segments.sql | 20 +- .../function-congestion_cache_corridor.sql} | 16 +- .../function-congestion_cache_tt_results.sql} | 55 ++---- ...function-congestion_day_hr_segment_agg.sql | 184 ++++++++++++++++++ .../function-congestion_dynamic_bin_avg.sql} | 34 ++-- ...unction-congestion_select_map_version.sql} | 4 +- 8 files changed, 246 insertions(+), 90 deletions(-) rename here/traffic/sql/{create-table-tt_segments.sql => dynamic_bins/create-table-congestion_corridors.sql} (100%) rename here/traffic/sql/{create-table-dynamic_binning_results.sql => dynamic_bins/create-table-congestion_raw_corridors.sql} (65%) rename here/traffic/sql/{ => dynamic_bins}/create-table-congestion_raw_segments.sql (77%) rename here/traffic/sql/{function-cache_tt_segment.sql => dynamic_bins/function-congestion_cache_corridor.sql} (84%) rename here/traffic/sql/{function-cache_tt_results.sql => dynamic_bins/function-congestion_cache_tt_results.sql} (78%) create mode 100644 here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql rename here/traffic/sql/{create-function-here_dynamic_bin_avg.sql => dynamic_bins/function-congestion_dynamic_bin_avg.sql} (58%) rename here/traffic/sql/{function-select_map_version.sql => dynamic_bins/function-congestion_select_map_version.sql} (80%) diff --git a/here/traffic/sql/create-table-tt_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql similarity index 100% rename from here/traffic/sql/create-table-tt_segments.sql rename to here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql diff --git a/here/traffic/sql/create-table-dynamic_binning_results.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql similarity index 65% rename from here/traffic/sql/create-table-dynamic_binning_results.sql rename to here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql index c0c101d1b..cf250ea1d 100644 --- a/here/traffic/sql/create-table-dynamic_binning_results.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql @@ -4,28 +4,25 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors ( + corridor_id smallint, + dt date, time_grp tsrange NOT NULL, bin_range tsrange NOT NULL, - dt_start timestamp without time zone, - dt_end timestamp without time zone, tt numeric, - unadjusted_tt numeric, - total_length numeric, - length_w_data numeric, num_obs integer, - segment_uid smallint, uri_string text COLLATE pg_catalog."default", CONSTRAINT congestion_raw_corridors_exclude EXCLUDE USING gist ( bin_range WITH &&, - segment_uid WITH =, + corridor_id WITH =, time_grp WITH =, - uri_string WITH =) + uri_string WITH = + ) ) TABLESPACE pg_default; ALTER TABLE IF EXISTS gwolofs.congestion_raw_corridors - OWNER to gwolofs; +OWNER TO gwolofs; REVOKE ALL ON TABLE gwolofs.congestion_raw_corridors FROM bdit_humans; @@ -33,12 +30,12 @@ GRANT SELECT ON TABLE gwolofs.congestion_raw_corridors TO bdit_humans; GRANT ALL ON TABLE gwolofs.congestion_raw_corridors TO gwolofs; --- Index: dynamic_binning_results_time_grp_segment_uid_idx +-- Index: dynamic_binning_results_time_grp_corridor_id_idx --- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_time_grp_segment_uid_idx; +-- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_time_grp_corridor_id_idx; -CREATE INDEX IF NOT EXISTS dynamic_binning_results_time_grp_segment_uid_idx +CREATE INDEX IF NOT EXISTS dynamic_binning_results_time_grp_corridor_id_idx ON gwolofs.congestion_raw_corridors USING btree - (time_grp ASC NULLS LAST, segment_uid ASC NULLS LAST) + (time_grp ASC NULLS LAST, corridor_id ASC NULLS LAST) WITH (deduplicate_items=True) TABLESPACE pg_default; \ No newline at end of file diff --git a/here/traffic/sql/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql similarity index 77% rename from here/traffic/sql/create-table-congestion_raw_segments.sql rename to here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql index 7a0ec772d..4104f9246 100644 --- a/here/traffic/sql/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql @@ -5,17 +5,17 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments ( segment_id integer NOT NULL, + dt date NOT NULL, + time_grp tsrange NOT NULL, bin_range tsrange NOT NULL, tt numeric, - unadjusted_tt numeric, - total_length numeric, - length_w_data numeric, num_obs integer, - hr timestamp without time zone, CONSTRAINT congestion_raw_segments_exclude EXCLUDE USING gist ( - hr WITH =, - bin_range WITH &&, - segment_id WITH =) + segment_id WITH =, + dt WITH =, + time_grp WITH =, + bin_range WITH && + ) ) TABLESPACE pg_default; @@ -32,9 +32,9 @@ GRANT ALL ON TABLE gwolofs.congestion_raw_segments TO gwolofs; -- DROP INDEX IF EXISTS gwolofs.dynamic_bin_hr_idx; -CREATE INDEX IF NOT EXISTS dynamic_bin_hr_idx +CREATE INDEX IF NOT EXISTS dynamic_bin_dt_idx ON gwolofs.congestion_raw_segments USING btree - (hr ASC NULLS LAST) + (dt ASC NULLS LAST) WITH (deduplicate_items=True) TABLESPACE pg_default; -- Index: dynamic_bin_idx @@ -43,6 +43,6 @@ CREATE INDEX IF NOT EXISTS dynamic_bin_hr_idx CREATE INDEX IF NOT EXISTS dynamic_bin_idx ON gwolofs.congestion_raw_segments USING btree - (segment_id ASC NULLS LAST, hr ASC NULLS LAST) + (segment_id ASC NULLS LAST, dt ASC NULLS LAST) WITH (deduplicate_items=True) TABLESPACE pg_default; \ No newline at end of file diff --git a/here/traffic/sql/function-cache_tt_segment.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql similarity index 84% rename from here/traffic/sql/function-cache_tt_segment.sql rename to here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql index 354f63426..7f15f8183 100644 --- a/here/traffic/sql/function-cache_tt_segment.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql @@ -6,7 +6,7 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_corridor( node_start bigint, node_end bigint, map_version text, - OUT uid smallint, + OUT corridor_id smallint, OUT link_dirs text[], OUT lengths numeric[], OUT total_length numeric) @@ -25,16 +25,16 @@ BEGIN --check if the node pair and map_version have already been routed --and if so, return values SELECT - tt.uid, + tt.corridor_id, tt.link_dirs, tt.lengths, tt.total_length - INTO uid, link_dirs, lengths, total_length + INTO corridor_id, link_dirs, lengths, total_length FROM gwolofs.congestion_corridors AS tt WHERE - tt.node_start = cache_tt_segment.node_start - AND tt.node_end = cache_tt_segment.node_end - AND tt.map_version = cache_tt_segment.map_version; + tt.node_start = congestion_cache_corridor.node_start + AND tt.node_end = congestion_cache_corridor.node_end + AND tt.map_version = congestion_cache_corridor.map_version; IF FOUND THEN RETURN; END IF; @@ -68,12 +68,12 @@ EXECUTE format ( link_dirs = excluded.link_dirs, lengths = excluded.lengths, total_length = excluded.total_length - RETURNING uid, link_dirs, lengths, total_length + RETURNING corridor_id, link_dirs, lengths, total_length $$, routing_function, node_start, node_end, -- For routed_links map_version, -- For INSERT SELECT values street_geoms_table -- For JOIN table -) INTO uid, link_dirs, lengths, total_length; +) INTO corridor_id, link_dirs, lengths, total_length; RETURN; END; $BODY$; diff --git a/here/traffic/sql/function-cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql similarity index 78% rename from here/traffic/sql/function-cache_tt_results.sql rename to here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 57d5b7831..fbe8f64f1 100644 --- a/here/traffic/sql/function-cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -22,23 +22,23 @@ DECLARE map_version text; BEGIN -SELECT gwolofs.congestion_select_map_version(cache_tt_results.start_date, cache_tt_results.end_date) INTO map_version; +SELECT gwolofs.congestion_select_map_version(congestion_cache_tt_results.start_date, congestion_cache_tt_results.end_date) INTO map_version; EXECUTE format( $$ WITH segment AS ( SELECT - uid AS segment_uid, + corridor_id, unnested.link_dir, unnested.length, total_length FROM gwolofs.congestion_cache_corridor(%L, %L, %L), - UNNEST(cache_tt_segment.link_dirs, cache_tt_segment.lengths) AS unnested(link_dir, length) + UNNEST(congestion_cache_corridor.link_dirs, congestion_cache_corridor.lengths) AS unnested(link_dir, length) ), segment_5min_bins AS ( SELECT - seg.segment_uid, +seg.corridor_id, ta.tx, seg.total_length, tsrange( @@ -71,9 +71,9 @@ EXECUTE format( ta.tx, ta.dt, seg.total_length, - segment_uid + corridor_id WINDOW w AS ( - PARTITION BY seg.segment_uid, ta.dt + PARTITION BY seg.corridor_id, ta.dt ORDER BY ta.tx ) ), @@ -112,7 +112,7 @@ EXECUTE format( unnested_db_options AS ( SELECT - s5b.segment_uid, + s5b.corridor_id, dbo.time_grp, s5b.total_length, dbo.tx AS dt_start, @@ -133,10 +133,8 @@ EXECUTE format( AND s5b_end.bin_rank = dbo.end_bin, --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) - --we need to use nested data to determine length for these multi-period bins - WHERE dbo.start_bin != dbo.end_bin GROUP BY - s5b.segment_uid, + s5b.corridor_id, dbo.time_grp, s5b.total_length, dbo.tx, --stard_bin @@ -148,61 +146,36 @@ EXECUTE format( ) INSERT INTO gwolofs.congestion_raw_corridors ( - uri_string, - time_grp, segment_uid, dt_start, dt_end, bin_range, tt, - unadjusted_tt, total_length, length_w_data, num_obs + uri_string, time_grp, corridor_id, bin_range, tt, num_obs ) --this query contains overlapping values which get eliminated --via on conflict with the exclusion constraint on congestion_raw_segments table. - SELECT DISTINCT ON (dt_start) + SELECT DISTINCT ON (dt_start) --distinct on ensures only the shortest option gets proposed for insert %L, time_grp, - segment_uid, - dt_start, - dt_end, + corridor_id, tsrange(dt_start, dt_end, '[)') AS bin_range, total_length / SUM(len) * SUM(tt) AS tt, - SUM(tt) AS unadjusted_tt, - total_length, - SUM(len) AS length_w_data, SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment FROM unnested_db_options GROUP BY time_grp, - segment_uid, + corridor_id, dt_start, dt_end, total_length HAVING SUM(len) >= 0.8 * total_length - UNION - --these 5 minute bins already have sufficient length - --don't need to use nested data to validate. - SELECT - %L, - time_grp, - segment_uid, - tx AS dt_start, - tx + interval '5 minutes' AS dt_end, - tsrange(tx, tx + interval '5 minutes', '[)') AS bin_range, - total_length / length_w_data * unadjusted_tt AS tt, - unadjusted_tt, - total_length, - length_w_data, - num_obs --sum of here.ta_path sample_size for each segment - FROM segment_5min_bins - --we do not need to use nested data to determine length here. - WHERE sum_length >= 0.8 ORDER BY dt_start, dt_end --exclusion constraint + ordered insert to prevent overlapping bins - ON CONFLICT ON CONSTRAINT dynamic_bins_unique_temp + ON CONFLICT ON CONSTRAINT congestion_raw_corridors_exclude DO NOTHING; $$, node_start, node_end, map_version, --segment CTE start_tod, end_tod, --segment_5min_bins CTE SELECT start_tod, end_tod, dow_list, start_date, end_date, --segment_5min_bins CTE WHERE - cache_tt_results.uri_string, cache_tt_results.uri_string --INSERT + congestion_cache_tt_results.uri_string, congestion_cache_tt_results.uri_string --INSERT ); END; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql new file mode 100644 index 000000000..6f27989d3 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql @@ -0,0 +1,184 @@ +-- FUNCTION: gwolofs.congestion_day_hr_segment_agg(date) + +-- DROP FUNCTION IF EXISTS gwolofs.congestion_day_hr_segment_agg(date); + +CREATE OR REPLACE FUNCTION gwolofs.congestion_day_hr_segment_agg( + start_date date) + RETURNS void + LANGUAGE 'plpgsql' + COST 100 + VOLATILE PARALLEL UNSAFE +AS $BODY$ + +DECLARE + map_version text := gwolofs.congestion_select_map_version( + dynamic_bin_congestion_ntwrk_hrly.start_date, dynamic_bin_congestion_ntwrk_hrly.end_date); + congestion_network_table text := 'network_links_' || map_version; + +BEGIN + +EXECUTE FORMAT( + $$ + WITH time_bins AS ( + SELECT + start_time, + start_time + '1 hour'::interval AS end_time, + tsrange(start_time, start_time + '1 hour'::interval, '[)') AS time_grp + FROM generate_series( + %1$L::date + '00:00'::time, + %1$L::date + '23 hour'::interval, '1 hour'::interval) AS hours(start_time) + ), + + segments AS ( + SELECT + segment_id, + link_dir, + length, + SUM(length) OVER (PARTITION BY segment_id) AS total_length + FROM congestion.%2$I + ), + + segment_5min_bins AS ( + SELECT + links.segment_id, + tb.time_grp, + ta.tx, + RANK() OVER w AS bin_rank, + links.total_length, + SUM(links.length) / links.total_length AS sum_length, + SUM(links.length) AS length_w_data, + SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, + SUM(sample_size) AS num_obs, + ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, + ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, + ARRAY_AGG(links.length ORDER BY link_dir) AS lengths + FROM here.ta_path AS ta + JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time +-- JOIN congestion.network_links_23_4_geom AS links USING (link_dir) + JOIN segments AS links USING (link_dir) +-- JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) + WHERE + ta.dt >= %1$L + AND ta.dt < %1$L + interval '1 day' + GROUP BY + links.segment_id, + tb.time_grp, + ta.tx, + links.total_length + WINDOW w AS ( + PARTITION BY links.segment_id, tb.time_grp + ORDER BY ta.tx + ) + ), + + dynamic_bin_options AS ( + --within each segment/hour, generate all possible forward looking bin combinations + --don't generate options for bins with sufficient length + --also don't generate options past the next bin with 80%% length + SELECT + tx, + time_grp, + segment_id, + bin_rank AS start_bin, + --generate all the options for the end bin within the group. + generate_series( + CASE + WHEN sum_length >= 0.8 THEN bin_rank + --if length is insufficient, need at least 1 more bin + ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) + END, + CASE + --dont need to generate options when start segment is already sufficient + WHEN sum_length >= 0.8 THEN bin_rank + --generate options until 1 bin has sufficient length, otherwise until last bin in group + ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) + END, + 1 + ) AS end_bin + FROM segment_5min_bins + WINDOW w AS ( + PARTITION BY time_grp, segment_id + ORDER BY tx + --look only forward for end_bin options + RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) + ), + + unnested_db_options AS ( + SELECT + dbo.time_grp, + dbo.segment_id, + s5b.total_length, + dbo.tx AS dt_start, + --exclusive end bin + s5b_end.tx + interval '5 minutes' AS dt_end, + unnested.link_dir, + unnested.len, + AVG(unnested.tt) AS tt, --avg TT for each link_dir + SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + FROM dynamic_bin_options AS dbo + LEFT JOIN segment_5min_bins AS s5b + ON s5b.time_grp = dbo.time_grp + AND s5b.segment_id = dbo.segment_id + AND s5b.bin_rank >= dbo.start_bin + AND s5b.bin_rank <= dbo.end_bin + --this join is used to get the tx info about the last bin only + LEFT JOIN segment_5min_bins AS s5b_end + ON s5b_end.time_grp = dbo.time_grp + AND s5b_end.segment_id = dbo.segment_id + AND s5b_end.bin_rank = dbo.end_bin, + --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin + UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' + GROUP BY + dbo.time_grp, + dbo.segment_id, + s5b.total_length, + dbo.tx, --stard_bin + s5b_end.tx, --end_bin + unnested.link_dir, + unnested.len + ) + + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + INSERT INTO gwolofs.congestion_raw_segments ( + dt, time_grp, segment_id, bin_range, tt, num_obs + ) + --distinct on ensures only the shortest option gets proposed for insert + SELECT DISTINCT ON (time_grp, segment_id, dt_start) + lower(time_grp)::date AS dt, + time_grp, + segment_id, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + time_grp, + segment_id, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + ORDER BY + time_grp, + segment_id, + bin_range --uses the option that ends first + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT dynamic_bins_unique + DO NOTHING; + $$, + dynamic_bin_congestion_ntwrk_hrly.start_date, + congestion_network_table + ); + +END; +$BODY$; + +ALTER FUNCTION gwolofs.congestion_day_hr_segment_agg(date) + OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.congestion_day_hr_segment_agg(date) + IS 'Previously dynamic_bin_congestion_ntwrk_hrly'; diff --git a/here/traffic/sql/create-function-here_dynamic_bin_avg.sql b/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql similarity index 58% rename from here/traffic/sql/create-function-here_dynamic_bin_avg.sql rename to here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql index d51b7f0f0..a87412ec0 100644 --- a/here/traffic/sql/create-function-here_dynamic_bin_avg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql @@ -18,28 +18,28 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_dynamic_bin_avg( AS $BODY$ DECLARE uri_string_func text := - here_dynamic_bin_avg.node_start::text || '/' || - here_dynamic_bin_avg.node_end::text || '/' || - here_dynamic_bin_avg.start_tod::text || '/' || - here_dynamic_bin_avg.end_tod::text || '/' || - here_dynamic_bin_avg.start_date::text || '/' || - here_dynamic_bin_avg.end_date::text || '/' || - here_dynamic_bin_avg.holidays::text || '/' || - here_dynamic_bin_avg.dow_list::text; + congestion_dynamic_bin_avg.node_start::text || '/' || + congestion_dynamic_bin_avg.node_end::text || '/' || + congestion_dynamic_bin_avg.start_tod::text || '/' || + congestion_dynamic_bin_avg.end_tod::text || '/' || + congestion_dynamic_bin_avg.start_date::text || '/' || + congestion_dynamic_bin_avg.end_date::text || '/' || + congestion_dynamic_bin_avg.holidays::text || '/' || + congestion_dynamic_bin_avg.dow_list::text; res numeric; BEGIN PERFORM gwolofs.congestion_cache_tt_results( uri_string := uri_string_func, - start_date := here_dynamic_bin_avg.start_date, - end_date := here_dynamic_bin_avg.end_date, - start_tod := here_dynamic_bin_avg.start_tod, - end_tod := here_dynamic_bin_avg.end_tod, - dow_list := here_dynamic_bin_avg.dow_list, - node_start := here_dynamic_bin_avg.node_start, - node_end := here_dynamic_bin_avg.node_end, - holidays := here_dynamic_bin_avg.holidays + start_date := congestion_dynamic_bin_avg.start_date, + end_date := congestion_dynamic_bin_avg.end_date, + start_tod := congestion_dynamic_bin_avg.start_tod, + end_tod := congestion_dynamic_bin_avg.end_tod, + dow_list := congestion_dynamic_bin_avg.dow_list, + node_start := congestion_dynamic_bin_avg.node_start, + node_end := congestion_dynamic_bin_avg.node_end, + holidays := congestion_dynamic_bin_avg.holidays ); WITH daily_means AS ( @@ -63,4 +63,4 @@ $BODY$; ALTER FUNCTION gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) OWNER TO gwolofs; -COMMENT ON FUNCTION gwolofs.congestion_dynamic_bin_avg IS 'Previously gwolofs.here_dynamic_bin_avg.'; +COMMENT ON FUNCTION gwolofs.congestion_dynamic_bin_avg IS 'Previously gwolofs.congestion_dynamic_bin_avg.'; diff --git a/here/traffic/sql/function-select_map_version.sql b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql similarity index 80% rename from here/traffic/sql/function-select_map_version.sql rename to here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql index ab4ca1010..b1d3c3343 100644 --- a/here/traffic/sql/function-select_map_version.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql @@ -14,7 +14,9 @@ AS $BODY$ SELECT street_version FROM here.street_valid_range AS svr, LATERAL ( - SELECT svr.valid_range * daterange(select_map_version.start_date, select_map_version.end_date, '[)') AS overlap + SELECT svr.valid_range * daterange( + congestion_select_map_version.start_date, + congestion_select_map_version.end_date, '[)') AS overlap ) AS lat WHERE UPPER(lat.overlap) - LOWER(lat.overlap) IS NOT NULL ORDER BY UPPER(lat.overlap) - LOWER(lat.overlap) DESC NULLS LAST From a59f2fd56ba87467e9f0c4b6d5b88c4cccaecba9 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 11 Feb 2025 21:01:07 +0000 Subject: [PATCH 19/74] #1132 fluff --- .../function-congestion_cache_corridor.sql | 14 +++++++------- .../function-congestion_cache_tt_results.sql | 18 +++++++++--------- .../function-congestion_day_hr_segment_agg.sql | 2 +- .../function-congestion_select_map_version.sql | 4 ++-- 4 files changed, 19 insertions(+), 19 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql index 7f15f8183..5433dd398 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql @@ -3,13 +3,13 @@ -- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_corridor(bigint, bigint, text); CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_corridor( - node_start bigint, - node_end bigint, - map_version text, - OUT corridor_id smallint, - OUT link_dirs text[], - OUT lengths numeric[], - OUT total_length numeric) + node_start bigint, + node_end bigint, + map_version text, + OUT corridor_id smallint, + OUT link_dirs text[], + OUT lengths numeric[], + OUT total_length numeric) RETURNS record LANGUAGE 'plpgsql' COST 100 diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index fbe8f64f1..cd66fda48 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -3,15 +3,15 @@ -- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results( - uri_string text, - start_date date, - end_date date, - start_tod time without time zone, - end_tod time without time zone, - dow_list integer[], - node_start bigint, - node_end bigint, - holidays boolean) + uri_string text, + start_date date, + end_date date, + start_tod time without time zone, + end_tod time without time zone, + dow_list integer[], + node_start bigint, + node_end bigint, + holidays boolean) RETURNS void LANGUAGE 'plpgsql' COST 100 diff --git a/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql index 6f27989d3..83009ac12 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql @@ -3,7 +3,7 @@ -- DROP FUNCTION IF EXISTS gwolofs.congestion_day_hr_segment_agg(date); CREATE OR REPLACE FUNCTION gwolofs.congestion_day_hr_segment_agg( - start_date date) + start_date date) RETURNS void LANGUAGE 'plpgsql' COST 100 diff --git a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql index b1d3c3343..1127a5249 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql @@ -3,8 +3,8 @@ -- DROP FUNCTION IF EXISTS gwolofs.congestion_select_map_version(date, date); CREATE OR REPLACE FUNCTION gwolofs.congestion_select_map_version( - start_date date, - end_date date) + start_date date, + end_date date) RETURNS text LANGUAGE 'sql' COST 100 From b23d61115cf2bd205244b86d5d0730aa8968eda8 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 13 Feb 2025 15:40:03 +0000 Subject: [PATCH 20/74] tsrange -> timerange --- .../create-table-congestion_raw_corridors.sql | 2 +- .../create-table-congestion_raw_segments.sql | 2 +- .../function-congestion_cache_tt_results.sql | 26 +++++++++++++------ ...function-congestion_day_hr_segment_agg.sql | 7 ++--- 4 files changed, 24 insertions(+), 13 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql index cf250ea1d..866fcea1f 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql @@ -6,7 +6,7 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors ( corridor_id smallint, dt date, - time_grp tsrange NOT NULL, + time_grp timerange NOT NULL, bin_range tsrange NOT NULL, tt numeric, num_obs integer, diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql index 4104f9246..3081bed57 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql @@ -6,7 +6,7 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments ( segment_id integer NOT NULL, dt date NOT NULL, - time_grp tsrange NOT NULL, + time_grp timerange NOT NULL, bin_range tsrange NOT NULL, tt numeric, num_obs integer, diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index cd66fda48..4e76bea4a 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -33,12 +33,15 @@ EXECUTE format( unnested.length, total_length FROM gwolofs.congestion_cache_corridor(%L, %L, %L), - UNNEST(congestion_cache_corridor.link_dirs, congestion_cache_corridor.lengths) AS unnested(link_dir, length) + UNNEST( + congestion_cache_corridor.link_dirs, + congestion_cache_corridor.lengths + ) AS unnested(link_dir, length) ), segment_5min_bins AS ( SELECT -seg.corridor_id, + seg.corridor_id, ta.tx, seg.total_length, tsrange( @@ -52,7 +55,7 @@ seg.corridor_id, ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, ARRAY_AGG(seg.length ORDER BY link_dir) AS lengths - FROM here.ta AS ta + FROM here.ta_path AS ta JOIN segment AS seg USING (link_dir) WHERE ( @@ -97,7 +100,10 @@ seg.corridor_id, --dont need to generate options when start segment is already sufficient WHEN sum_length >= 0.8 THEN bin_rank --generate options until 1 bin has sufficient length, otherwise until last bin in group - ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) + ELSE COALESCE( + MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, + MAX(bin_rank) OVER w + ) END, 1 ) AS end_bin @@ -146,13 +152,14 @@ seg.corridor_id, ) INSERT INTO gwolofs.congestion_raw_corridors ( - uri_string, time_grp, corridor_id, bin_range, tt, num_obs + uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs ) --this query contains overlapping values which get eliminated --via on conflict with the exclusion constraint on congestion_raw_segments table. SELECT DISTINCT ON (dt_start) --distinct on ensures only the shortest option gets proposed for insert %L, - time_grp, + dt_start::date AS dt, + timerange(lower(time_grp)::time, upper(time_grp)::time, '[)') AS time_grp, corridor_id, tsrange(dt_start, dt_end, '[)') AS bin_range, total_length / SUM(len) * SUM(tt) AS tt, @@ -181,5 +188,8 @@ seg.corridor_id, END; $BODY$; -ALTER FUNCTION gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) - OWNER TO gwolofs; +ALTER FUNCTION gwolofs.congestion_cache_tt_results( + text, date, date, time without time zone, + time without time zone, integer[], bigint, bigint, boolean +) +OWNER TO gwolofs; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql index 83009ac12..bd5612a5c 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql @@ -23,7 +23,10 @@ EXECUTE FORMAT( SELECT start_time, start_time + '1 hour'::interval AS end_time, - tsrange(start_time, start_time + '1 hour'::interval, '[)') AS time_grp + timerange( + start_time::time, + CASE start_time::time WHEN '23:00' THEN '24:00' ELSE start_time::time + '1 hour'::interval END, + '[)') AS time_grp FROM generate_series( %1$L::date + '00:00'::time, %1$L::date + '23 hour'::interval, '1 hour'::interval) AS hours(start_time) @@ -54,9 +57,7 @@ EXECUTE FORMAT( ARRAY_AGG(links.length ORDER BY link_dir) AS lengths FROM here.ta_path AS ta JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time --- JOIN congestion.network_links_23_4_geom AS links USING (link_dir) JOIN segments AS links USING (link_dir) --- JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) WHERE ta.dt >= %1$L AND ta.dt < %1$L + interval '1 day' From b7a6f70536b401a5f02cc4b19ce57ad98822a906 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 13 Feb 2025 19:39:32 +0000 Subject: [PATCH 21/74] #1132 congestion ntwrk hrly and period agg updates --- ...ion-congestion_network_hr_segment_agg.sql} | 20 +- ...-congestion_network_period_segment_agg.sql | 193 ++++++++++++++++++ 2 files changed, 203 insertions(+), 10 deletions(-) rename here/traffic/sql/dynamic_bins/{function-congestion_day_hr_segment_agg.sql => function-congestion_network_hr_segment_agg.sql} (92%) create mode 100644 here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql diff --git a/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql similarity index 92% rename from here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql rename to here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql index bd5612a5c..0eb08624a 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_day_hr_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql @@ -11,8 +11,7 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_day_hr_segment_agg( AS $BODY$ DECLARE - map_version text := gwolofs.congestion_select_map_version( - dynamic_bin_congestion_ntwrk_hrly.start_date, dynamic_bin_congestion_ntwrk_hrly.end_date); + map_version text := gwolofs.congestion_select_map_version(start_date, start_date + 1); congestion_network_table text := 'network_links_' || map_version; BEGIN @@ -59,8 +58,8 @@ EXECUTE FORMAT( JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time JOIN segments AS links USING (link_dir) WHERE - ta.dt >= %1$L - AND ta.dt < %1$L + interval '1 day' + ta.dt >= %1$L::date + AND ta.dt < %1$L::date + interval '1 day' GROUP BY links.segment_id, tb.time_grp, @@ -149,7 +148,7 @@ EXECUTE FORMAT( ) --distinct on ensures only the shortest option gets proposed for insert SELECT DISTINCT ON (time_grp, segment_id, dt_start) - lower(time_grp)::date AS dt, + dt_start::date AS dt, time_grp, segment_id, tsrange(dt_start, dt_end, '[)') AS bin_range, @@ -166,12 +165,13 @@ EXECUTE FORMAT( ORDER BY time_grp, segment_id, - bin_range --uses the option that ends first + dt_start, + dt_end --uses the option that ends first --exclusion constraint + ordered insert to prevent overlapping bins - ON CONFLICT ON CONSTRAINT dynamic_bins_unique + ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude DO NOTHING; $$, - dynamic_bin_congestion_ntwrk_hrly.start_date, + start_date, congestion_network_table ); @@ -179,7 +179,7 @@ END; $BODY$; ALTER FUNCTION gwolofs.congestion_day_hr_segment_agg(date) - OWNER TO gwolofs; +OWNER TO gwolofs; COMMENT ON FUNCTION gwolofs.congestion_day_hr_segment_agg(date) - IS 'Previously dynamic_bin_congestion_ntwrk_hrly'; +IS 'Dynamic bin aggregation of the congestion network by hourly periods.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql new file mode 100644 index 000000000..8091e55fc --- /dev/null +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql @@ -0,0 +1,193 @@ +-- FUNCTION: gwolofs.congestion_network_period_segment_agg(date) + +-- DROP FUNCTION IF EXISTS gwolofs.congestion_network_period_segment_agg(date); + +CREATE OR REPLACE FUNCTION gwolofs.congestion_network_period_segment_agg( + start_date date) + RETURNS void + LANGUAGE 'plpgsql' + COST 100 + VOLATILE PARALLEL UNSAFE +AS $BODY$ + +DECLARE + map_version text := gwolofs.congestion_select_map_version(start_date, start_date + 1); + congestion_network_table text := 'network_links_' || map_version; + +BEGIN + +EXECUTE FORMAT( + $$ + WITH time_bins AS ( + SELECT + %1$L::date + start_tod AS start_time, --start_date + %1$L::date + end_tod AS end_time, --start_date + timerange(start_tod, end_tod, '[)') AS time_grp + FROM + (VALUES + ('00:00:00'::time, '06:00:00'::time), + ('06:00:00'::time, '10:00:00'::time), + ('10:00:00'::time, '15:00:00'::time), + ('15:00:00'::time, '19:00:00'::time), + ('19:00:00'::time, '24:00:00'::time) + ) AS times(start_tod, end_tod) + ), + + segments AS ( + SELECT + segment_id, + link_dir, + length, + SUM(length) OVER (PARTITION BY segment_id) AS total_length + FROM congestion.%2$I + ), + + segment_5min_bins AS ( + SELECT + links.segment_id, + tb.time_grp, + ta.tx, + RANK() OVER w AS bin_rank, + links.total_length, + SUM(links.length) / links.total_length AS sum_length, + SUM(links.length) AS length_w_data, + SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, + SUM(sample_size) AS num_obs, + ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, + ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, + ARRAY_AGG(links.length ORDER BY link_dir) AS lengths + FROM here.ta_path AS ta + JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time + JOIN segments AS links USING (link_dir) + WHERE + ta.dt >= %1$L::date + AND ta.dt < %1$L::date + interval '1 day' + GROUP BY + links.segment_id, + tb.time_grp, + ta.tx, + links.total_length + WINDOW w AS ( + PARTITION BY links.segment_id, tb.time_grp + ORDER BY ta.tx + ) + ), + + dynamic_bin_options AS ( + --within each segment/hour, generate all possible forward looking bin combinations + --don't generate options for bins with sufficient length + --also don't generate options past the next bin with 80%% length + SELECT + tx, + time_grp, + segment_id, + bin_rank AS start_bin, + --generate all the options for the end bin within the group. + generate_series( + CASE + WHEN sum_length >= 0.8 THEN bin_rank + --if length is insufficient, need at least 1 more bin + ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) + END, + CASE + --dont need to generate options when start segment is already sufficient + WHEN sum_length >= 0.8 THEN bin_rank + --generate options until 1 bin has sufficient length, otherwise until last bin in group + ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) + END, + 1 + ) AS end_bin + FROM segment_5min_bins + WINDOW w AS ( + PARTITION BY time_grp, segment_id + ORDER BY tx + --look only forward for end_bin options + RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) + ), + + unnested_db_options AS ( + SELECT + dbo.time_grp, + dbo.segment_id, + s5b.total_length, + dbo.tx AS dt_start, + --exclusive end bin + s5b_end.tx + interval '5 minutes' AS dt_end, + unnested.link_dir, + unnested.len, + AVG(unnested.tt) AS tt, --avg TT for each link_dir + SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + FROM dynamic_bin_options AS dbo + LEFT JOIN segment_5min_bins AS s5b + ON s5b.time_grp = dbo.time_grp + AND s5b.segment_id = dbo.segment_id + AND s5b.bin_rank >= dbo.start_bin + AND s5b.bin_rank <= dbo.end_bin + --this join is used to get the tx info about the last bin only + LEFT JOIN segment_5min_bins AS s5b_end + ON s5b_end.time_grp = dbo.time_grp + AND s5b_end.segment_id = dbo.segment_id + AND s5b_end.bin_rank = dbo.end_bin, + --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin + UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + --makes sense to relax this constraint for periods + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + --WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' + GROUP BY + dbo.time_grp, + dbo.segment_id, + s5b.total_length, + dbo.tx, --stard_bin + s5b_end.tx, --end_bin + unnested.link_dir, + unnested.len + ) + + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + INSERT INTO gwolofs.congestion_raw_segments ( + dt, time_grp, segment_id, bin_range, tt, num_obs + ) + --distinct on ensures only the shortest option gets proposed for insert + SELECT DISTINCT ON (time_grp, segment_id, dt_start) + dt_start::date AS dt, + time_grp, + segment_id, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + time_grp, + segment_id, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + ORDER BY + time_grp, + segment_id, + dt_start, + dt_end --uses the option that ends first + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude + DO NOTHING; + $$, + start_date, + congestion_network_table + ); + +END; +$BODY$; + +ALTER FUNCTION gwolofs.congestion_network_period_segment_agg(date) + OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.congestion_network_period_segment_agg(date) + IS '''Dynamic bin aggregation of the congestion network by periods: + (''00:00:00''::time, ''06:00:00''::time), + (''06:00:00''::time, ''10:00:00''::time), + (''10:00:00''::time, ''15:00:00''::time), + (''15:00:00''::time, ''19:00:00''::time), + (''19:00:00''::time, ''24:00:00''::time)'''; From 674b0c1db503af59a8bf2fea203e494f649b9289 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 14 Feb 2025 17:17:42 +0000 Subject: [PATCH 22/74] #1132 rename function for consistency --- .../function-congestion_network_hr_segment_agg.sql | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql index 0eb08624a..78d69b198 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql @@ -1,8 +1,8 @@ --- FUNCTION: gwolofs.congestion_day_hr_segment_agg(date) +-- FUNCTION: gwolofs.congestion_network_hr_segment_agg(date) --- DROP FUNCTION IF EXISTS gwolofs.congestion_day_hr_segment_agg(date); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_network_hr_segment_agg(date); -CREATE OR REPLACE FUNCTION gwolofs.congestion_day_hr_segment_agg( +CREATE OR REPLACE FUNCTION gwolofs.congestion_network_hr_segment_agg( start_date date) RETURNS void LANGUAGE 'plpgsql' @@ -178,8 +178,8 @@ EXECUTE FORMAT( END; $BODY$; -ALTER FUNCTION gwolofs.congestion_day_hr_segment_agg(date) +ALTER FUNCTION gwolofs.congestion_network_hr_segment_agg(date) OWNER TO gwolofs; -COMMENT ON FUNCTION gwolofs.congestion_day_hr_segment_agg(date) +COMMENT ON FUNCTION gwolofs.congestion_network_hr_segment_agg(date) IS 'Dynamic bin aggregation of the congestion network by hourly periods.'; From 61fdfdc0e2887dfff6c284fdb89b68bebd41e90e Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 18 Feb 2025 21:58:54 +0000 Subject: [PATCH 23/74] #1132 move time_grps to view, combine hourly and period agg --- .../create-view-congestion_time_grps.sql | 32 +++ ...tion-congestion_network_hr_segment_agg.sql | 41 ++-- ...-congestion_network_period_segment_agg.sql | 193 ------------------ 3 files changed, 48 insertions(+), 218 deletions(-) create mode 100644 here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql delete mode 100644 here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql diff --git a/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql b/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql new file mode 100644 index 000000000..1871889d0 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql @@ -0,0 +1,32 @@ +CREATE VIEW gwolofs.congestion_time_grps AS + +SELECT + start_tod, + end_tod, + 1 AS table_order +FROM ( + VALUES + ('00:00:00'::time, '06:00:00'::time), + ('06:00:00'::time, '10:00:00'::time), + ('10:00:00'::time, '15:00:00'::time), + ('15:00:00'::time, '19:00:00'::time), + ('19:00:00'::time, '24:00:00'::time) +) AS times(start_tod, end_tod) +UNION +SELECT + (start_hour || ':00')::time AS start_tod, + (start_hour + 1 || ':00')::time AS end_tod, + 2 AS table_order +FROM generate_series(0, 23, 1) AS start_hour +ORDER BY + table_order, + start_tod, + end_tod; + +COMMENT ON VIEW gwolofs.congestion_time_grps +IS 'Hours and time periods for congestion aggregation.'; + +ALTER VIEW gwolofs.congestion_time_grps OWNER TO gwolofs; + +GRANT SELECT ON TABLE gwolofs.congestion_time_grps TO bdit_humans; +GRANT ALL ON TABLE gwolofs.congestion_time_grps TO gwolofs; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql index 78d69b198..e68ead7eb 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql @@ -1,8 +1,8 @@ --- FUNCTION: gwolofs.congestion_network_hr_segment_agg(date) +-- FUNCTION: gwolofs.congestion_network_segment_agg(date) --- DROP FUNCTION IF EXISTS gwolofs.congestion_network_hr_segment_agg(date); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_network_segment_agg(date); -CREATE OR REPLACE FUNCTION gwolofs.congestion_network_hr_segment_agg( +CREATE OR REPLACE FUNCTION gwolofs.congestion_network_segment_agg( start_date date) RETURNS void LANGUAGE 'plpgsql' @@ -12,26 +12,14 @@ AS $BODY$ DECLARE map_version text := gwolofs.congestion_select_map_version(start_date, start_date + 1); - congestion_network_table text := 'network_links_' || map_version; + congestion_network_table text := 'network_links_' || map_version + || CASE map_version WHEN '23_4' THEN '_geom' ELSE '' END; --temp fix version BEGIN EXECUTE FORMAT( $$ - WITH time_bins AS ( - SELECT - start_time, - start_time + '1 hour'::interval AS end_time, - timerange( - start_time::time, - CASE start_time::time WHEN '23:00' THEN '24:00' ELSE start_time::time + '1 hour'::interval END, - '[)') AS time_grp - FROM generate_series( - %1$L::date + '00:00'::time, - %1$L::date + '23 hour'::interval, '1 hour'::interval) AS hours(start_time) - ), - - segments AS ( + WITH segments AS ( SELECT segment_id, link_dir, @@ -43,7 +31,7 @@ EXECUTE FORMAT( segment_5min_bins AS ( SELECT links.segment_id, - tb.time_grp, + timerange(tg.start_tod, tg.end_tod, '[)') AS time_grp, ta.tx, RANK() OVER w AS bin_rank, links.total_length, @@ -55,18 +43,21 @@ EXECUTE FORMAT( ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, ARRAY_AGG(links.length ORDER BY link_dir) AS lengths FROM here.ta_path AS ta - JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time + JOIN gwolofs.congestion_time_grps AS tg ON + ta.tx >= %1$L::date + tg.start_tod + AND ta.tx < %1$L::date + tg.end_tod JOIN segments AS links USING (link_dir) WHERE ta.dt >= %1$L::date AND ta.dt < %1$L::date + interval '1 day' GROUP BY links.segment_id, - tb.time_grp, + tg.start_tod, + tg.end_tod, ta.tx, links.total_length WINDOW w AS ( - PARTITION BY links.segment_id, tb.time_grp + PARTITION BY links.segment_id, tg.start_tod, tg.end_tod ORDER BY ta.tx ) ), @@ -178,8 +169,8 @@ EXECUTE FORMAT( END; $BODY$; -ALTER FUNCTION gwolofs.congestion_network_hr_segment_agg(date) +ALTER FUNCTION gwolofs.congestion_network_segment_agg(date) OWNER TO gwolofs; -COMMENT ON FUNCTION gwolofs.congestion_network_hr_segment_agg(date) -IS 'Dynamic bin aggregation of the congestion network by hourly periods.'; +COMMENT ON FUNCTION gwolofs.congestion_network_segment_agg(date) +IS 'Dynamic bin aggregation of the congestion network by hour and time periods.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql deleted file mode 100644 index 8091e55fc..000000000 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_period_segment_agg.sql +++ /dev/null @@ -1,193 +0,0 @@ --- FUNCTION: gwolofs.congestion_network_period_segment_agg(date) - --- DROP FUNCTION IF EXISTS gwolofs.congestion_network_period_segment_agg(date); - -CREATE OR REPLACE FUNCTION gwolofs.congestion_network_period_segment_agg( - start_date date) - RETURNS void - LANGUAGE 'plpgsql' - COST 100 - VOLATILE PARALLEL UNSAFE -AS $BODY$ - -DECLARE - map_version text := gwolofs.congestion_select_map_version(start_date, start_date + 1); - congestion_network_table text := 'network_links_' || map_version; - -BEGIN - -EXECUTE FORMAT( - $$ - WITH time_bins AS ( - SELECT - %1$L::date + start_tod AS start_time, --start_date - %1$L::date + end_tod AS end_time, --start_date - timerange(start_tod, end_tod, '[)') AS time_grp - FROM - (VALUES - ('00:00:00'::time, '06:00:00'::time), - ('06:00:00'::time, '10:00:00'::time), - ('10:00:00'::time, '15:00:00'::time), - ('15:00:00'::time, '19:00:00'::time), - ('19:00:00'::time, '24:00:00'::time) - ) AS times(start_tod, end_tod) - ), - - segments AS ( - SELECT - segment_id, - link_dir, - length, - SUM(length) OVER (PARTITION BY segment_id) AS total_length - FROM congestion.%2$I - ), - - segment_5min_bins AS ( - SELECT - links.segment_id, - tb.time_grp, - ta.tx, - RANK() OVER w AS bin_rank, - links.total_length, - SUM(links.length) / links.total_length AS sum_length, - SUM(links.length) AS length_w_data, - SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, - SUM(sample_size) AS num_obs, - ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, - ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, - ARRAY_AGG(links.length ORDER BY link_dir) AS lengths - FROM here.ta_path AS ta - JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time - JOIN segments AS links USING (link_dir) - WHERE - ta.dt >= %1$L::date - AND ta.dt < %1$L::date + interval '1 day' - GROUP BY - links.segment_id, - tb.time_grp, - ta.tx, - links.total_length - WINDOW w AS ( - PARTITION BY links.segment_id, tb.time_grp - ORDER BY ta.tx - ) - ), - - dynamic_bin_options AS ( - --within each segment/hour, generate all possible forward looking bin combinations - --don't generate options for bins with sufficient length - --also don't generate options past the next bin with 80%% length - SELECT - tx, - time_grp, - segment_id, - bin_rank AS start_bin, - --generate all the options for the end bin within the group. - generate_series( - CASE - WHEN sum_length >= 0.8 THEN bin_rank - --if length is insufficient, need at least 1 more bin - ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) - END, - CASE - --dont need to generate options when start segment is already sufficient - WHEN sum_length >= 0.8 THEN bin_rank - --generate options until 1 bin has sufficient length, otherwise until last bin in group - ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) - END, - 1 - ) AS end_bin - FROM segment_5min_bins - WINDOW w AS ( - PARTITION BY time_grp, segment_id - ORDER BY tx - --look only forward for end_bin options - RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING - ) - ), - - unnested_db_options AS ( - SELECT - dbo.time_grp, - dbo.segment_id, - s5b.total_length, - dbo.tx AS dt_start, - --exclusive end bin - s5b_end.tx + interval '5 minutes' AS dt_end, - unnested.link_dir, - unnested.len, - AVG(unnested.tt) AS tt, --avg TT for each link_dir - SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir - FROM dynamic_bin_options AS dbo - LEFT JOIN segment_5min_bins AS s5b - ON s5b.time_grp = dbo.time_grp - AND s5b.segment_id = dbo.segment_id - AND s5b.bin_rank >= dbo.start_bin - AND s5b.bin_rank <= dbo.end_bin - --this join is used to get the tx info about the last bin only - LEFT JOIN segment_5min_bins AS s5b_end - ON s5b_end.time_grp = dbo.time_grp - AND s5b_end.segment_id = dbo.segment_id - AND s5b_end.bin_rank = dbo.end_bin, - --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin - UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) - --makes sense to relax this constraint for periods - --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - --WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' - GROUP BY - dbo.time_grp, - dbo.segment_id, - s5b.total_length, - dbo.tx, --stard_bin - s5b_end.tx, --end_bin - unnested.link_dir, - unnested.len - ) - - --this query contains overlapping values which get eliminated - --via on conflict with the exclusion constraint on congestion_raw_segments table. - INSERT INTO gwolofs.congestion_raw_segments ( - dt, time_grp, segment_id, bin_range, tt, num_obs - ) - --distinct on ensures only the shortest option gets proposed for insert - SELECT DISTINCT ON (time_grp, segment_id, dt_start) - dt_start::date AS dt, - time_grp, - segment_id, - tsrange(dt_start, dt_end, '[)') AS bin_range, - total_length / SUM(len) * SUM(tt) AS tt, - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment - FROM unnested_db_options - GROUP BY - time_grp, - segment_id, - dt_start, - dt_end, - total_length - HAVING SUM(len) >= 0.8 * total_length - ORDER BY - time_grp, - segment_id, - dt_start, - dt_end --uses the option that ends first - --exclusion constraint + ordered insert to prevent overlapping bins - ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude - DO NOTHING; - $$, - start_date, - congestion_network_table - ); - -END; -$BODY$; - -ALTER FUNCTION gwolofs.congestion_network_period_segment_agg(date) - OWNER TO gwolofs; - -COMMENT ON FUNCTION gwolofs.congestion_network_period_segment_agg(date) - IS '''Dynamic bin aggregation of the congestion network by periods: - (''00:00:00''::time, ''06:00:00''::time), - (''06:00:00''::time, ''10:00:00''::time), - (''10:00:00''::time, ''15:00:00''::time), - (''15:00:00''::time, ''19:00:00''::time), - (''19:00:00''::time, ''24:00:00''::time)'''; From e9049a4fb3e0f88685746d19ae20cb060d34401a Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 18 Feb 2025 21:59:27 +0000 Subject: [PATCH 24/74] #1132 rename congestion_network_segment_agg --- ...egment_agg.sql => function-congestion_network_segment_agg.sql} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename here/traffic/sql/dynamic_bins/{function-congestion_network_hr_segment_agg.sql => function-congestion_network_segment_agg.sql} (100%) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql similarity index 100% rename from here/traffic/sql/dynamic_bins/function-congestion_network_hr_segment_agg.sql rename to here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql From 4e93259b34c8bd34c32d9d25585a63670c038878 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 3 Mar 2025 17:30:15 +0000 Subject: [PATCH 25/74] #1132 fluff and add comments --- .../create-table-congestion_corridors.sql | 7 ++- .../create-table-congestion_raw_corridors.sql | 30 ++++++++++--- .../create-table-congestion_raw_segments.sql | 30 +++++++------ .../create-view-congestion_time_grps.sql | 17 ++++--- .../function-congestion_cache_corridor.sql | 29 +++++++----- .../function-congestion_cache_tt_results.sql | 45 +++++++++++-------- .../function-congestion_dynamic_bin_avg.sql | 29 +++++++----- ...unction-congestion_network_segment_agg.sql | 11 ++--- ...function-congestion_select_map_version.sql | 16 ++++--- 9 files changed, 134 insertions(+), 80 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql index 327c5cb8c..529d26905 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql @@ -4,8 +4,8 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_corridors ( - link_dirs text[] COLLATE pg_catalog."default", - lengths numeric[], + link_dirs text [] COLLATE pg_catalog."default", + lengths numeric [], geom geometry, total_length numeric, corridor_id smallint NOT NULL DEFAULT nextval('congestion_corridors_uid_seq'::regclass), @@ -25,3 +25,6 @@ REVOKE ALL ON TABLE gwolofs.congestion_corridors FROM bdit_humans; GRANT SELECT ON TABLE gwolofs.congestion_corridors TO bdit_humans; GRANT ALL ON TABLE gwolofs.congestion_corridors TO gwolofs; + +COMMENT ON TABLE gwolofs.congestion_corridors IS +'Stores cached travel time corridors to reduce routing time.'; diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql index 866fcea1f..9a823249c 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql @@ -30,12 +30,32 @@ GRANT SELECT ON TABLE gwolofs.congestion_raw_corridors TO bdit_humans; GRANT ALL ON TABLE gwolofs.congestion_raw_corridors TO gwolofs; +-- Index: congestion_raw_corridors_dt_idx + +-- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_dt_idx; + +CREATE INDEX IF NOT EXISTS congestion_raw_corridors_dt_idx +ON gwolofs.congestion_raw_corridors USING brin +(dt) +TABLESPACE pg_default; +-- Index: congestion_raw_corridors_uri_string + +-- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_uri_string; + +CREATE INDEX IF NOT EXISTS congestion_raw_corridors_uri_string +ON gwolofs.congestion_raw_corridors USING btree +(uri_string COLLATE pg_catalog."default" ASC NULLS LAST) +WITH (deduplicate_items = TRUE) +TABLESPACE pg_default; -- Index: dynamic_binning_results_time_grp_corridor_id_idx --- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_time_grp_corridor_id_idx; +-- DROP INDEX IF EXISTS gwolofs.dynamic_binning_results_time_grp_corridor_id_idx; CREATE INDEX IF NOT EXISTS dynamic_binning_results_time_grp_corridor_id_idx - ON gwolofs.congestion_raw_corridors USING btree - (time_grp ASC NULLS LAST, corridor_id ASC NULLS LAST) - WITH (deduplicate_items=True) - TABLESPACE pg_default; \ No newline at end of file +ON gwolofs.congestion_raw_corridors USING btree +(time_grp ASC NULLS LAST, corridor_id ASC NULLS LAST, dt ASC NULLS LAST) +WITH (deduplicate_items = TRUE) +TABLESPACE pg_default; + +COMMENT ON TABLE gwolofs.congestion_raw_corridors IS +'Stores dynamic binning results for custom corridor based travel time requests.'; diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql index 3081bed57..f73ecb566 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql @@ -28,21 +28,23 @@ REVOKE ALL ON TABLE gwolofs.congestion_raw_segments FROM bdit_humans; GRANT SELECT ON TABLE gwolofs.congestion_raw_segments TO bdit_humans; GRANT ALL ON TABLE gwolofs.congestion_raw_segments TO gwolofs; --- Index: dynamic_bin_hr_idx --- DROP INDEX IF EXISTS gwolofs.dynamic_bin_hr_idx; +-- Index: congestion_raw_segments_dt_idx -CREATE INDEX IF NOT EXISTS dynamic_bin_dt_idx - ON gwolofs.congestion_raw_segments USING btree - (dt ASC NULLS LAST) - WITH (deduplicate_items=True) - TABLESPACE pg_default; --- Index: dynamic_bin_idx +-- DROP INDEX IF EXISTS gwolofs.congestion_raw_segments_dt_idx; --- DROP INDEX IF EXISTS gwolofs.dynamic_bin_idx; +CREATE INDEX IF NOT EXISTS congestion_raw_segments_dt_idx +ON gwolofs.congestion_raw_segments USING brin +(dt) +TABLESPACE pg_default; +-- Index: congestion_raw_segments_segment_dt_idx + +-- DROP INDEX IF EXISTS gwolofs.congestion_raw_segments_segment_dt_idx; + +CREATE INDEX IF NOT EXISTS congestion_raw_segments_segment_dt_idx +ON gwolofs.congestion_raw_segments USING btree +(segment_id ASC NULLS LAST, dt ASC NULLS LAST) +TABLESPACE pg_default; -CREATE INDEX IF NOT EXISTS dynamic_bin_idx - ON gwolofs.congestion_raw_segments USING btree - (segment_id ASC NULLS LAST, dt ASC NULLS LAST) - WITH (deduplicate_items=True) - TABLESPACE pg_default; \ No newline at end of file +COMMENT ON TABLE gwolofs.congestion_raw_corridors IS +'Stores dynamic binning results from standard HERE congestion network travel time aggregations.'; diff --git a/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql b/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql index 1871889d0..98d828139 100644 --- a/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql +++ b/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql @@ -1,3 +1,6 @@ +--these time periods should be scrutinized more. +--structure may also need changes if we want different weekday and weekend time periods. + CREATE VIEW gwolofs.congestion_time_grps AS SELECT @@ -6,12 +9,12 @@ SELECT 1 AS table_order FROM ( VALUES - ('00:00:00'::time, '06:00:00'::time), - ('06:00:00'::time, '10:00:00'::time), - ('10:00:00'::time, '15:00:00'::time), - ('15:00:00'::time, '19:00:00'::time), - ('19:00:00'::time, '24:00:00'::time) -) AS times(start_tod, end_tod) + ('00:00:00'::time, '06:00:00'::time), + ('06:00:00'::time, '10:00:00'::time), + ('10:00:00'::time, '15:00:00'::time), + ('15:00:00'::time, '19:00:00'::time), + ('19:00:00'::time, '24:00:00'::time) +) AS times (start_tod, end_tod) UNION SELECT (start_hour || ':00')::time AS start_tod, @@ -22,7 +25,7 @@ ORDER BY table_order, start_tod, end_tod; - + COMMENT ON VIEW gwolofs.congestion_time_grps IS 'Hours and time periods for congestion aggregation.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql index 5433dd398..9840dfd7b 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql @@ -7,13 +7,14 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_corridor( node_end bigint, map_version text, OUT corridor_id smallint, - OUT link_dirs text[], - OUT lengths numeric[], - OUT total_length numeric) - RETURNS record - LANGUAGE 'plpgsql' - COST 100 - VOLATILE PARALLEL SAFE + OUT link_dirs text [], + OUT lengths numeric [], + OUT total_length numeric +) +RETURNS record +LANGUAGE plpgsql +COST 100 +VOLATILE PARALLEL SAFE AS $BODY$ DECLARE @@ -23,7 +24,7 @@ DECLARE BEGIN --check if the node pair and map_version have already been routed - --and if so, return values + --and if so, return values, saving routing time SELECT tt.corridor_id, tt.link_dirs, @@ -56,9 +57,9 @@ EXECUTE format ( %4$L AS map_version, ARRAY_AGG(rl.link_dir ORDER BY rl.seq) AS link_dirs, --lengths in m - ARRAY_AGG(ST_Length(ST_Transform(streets.geom,2952)) ORDER BY rl.seq) AS lengths, + ARRAY_AGG(st_length(st_transform(streets.geom, 2952)) ORDER BY rl.seq) AS lengths, st_union(st_linemerge(streets.geom)) AS geom, - SUM(ST_Length(ST_Transform(streets.geom,2952))) AS total_length + SUM(ST_Length(ST_Transform(streets.geom, 2952))) AS total_length FROM routed_links AS rl JOIN here.%5$I AS streets USING (link_dir) --conflict would occur because of null values @@ -79,4 +80,10 @@ END; $BODY$; ALTER FUNCTION gwolofs.congestion_cache_corridor(bigint, bigint, text) - OWNER TO gwolofs; +OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.congestion_cache_corridor IS +'Returns definition of a HERE corridor, given input nodes and map_version. +First checks if corridor has already been cached and if so retrieves the +cached values. If not, a new entry is added to gwolofs.congestion_corridors +table and returned.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 4e76bea4a..4529296df 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -1,6 +1,6 @@ --- FUNCTION: gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) +-- FUNCTION: gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --noqa: LT05 --- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); --noqa: LT05 CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results( uri_string text, @@ -8,21 +8,25 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results( end_date date, start_tod time without time zone, end_tod time without time zone, - dow_list integer[], + dow_list integer [], node_start bigint, node_end bigint, - holidays boolean) - RETURNS void - LANGUAGE 'plpgsql' - COST 100 - VOLATILE PARALLEL UNSAFE + holidays boolean +) +RETURNS void +LANGUAGE plpgsql +COST 100 +VOLATILE PARALLEL UNSAFE AS $BODY$ DECLARE map_version text; BEGIN -SELECT gwolofs.congestion_select_map_version(congestion_cache_tt_results.start_date, congestion_cache_tt_results.end_date) INTO map_version; +SELECT gwolofs.congestion_select_map_version( + congestion_cache_tt_results.start_date, + congestion_cache_tt_results.end_date +) INTO map_version; EXECUTE format( $$ @@ -52,20 +56,20 @@ EXECUTE format( SUM(seg.length) AS length_w_data, SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt, SUM(sample_size) AS num_obs, - ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, - ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, - ARRAY_AGG(seg.length ORDER BY link_dir) AS lengths + ARRAY_AGG(ta.link_dir ORDER BY ta.link_dir) AS link_dirs, + ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY ta.link_dir) AS tts, + ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths FROM here.ta_path AS ta JOIN segment AS seg USING (link_dir) WHERE ( - tod >= %L + ta.tod >= %L AND --{ToD_and_or} - tod < %L + ta.tod < %L ) - AND date_part('isodow', dt) = ANY(%L::int[]) - AND dt >= %L - AND dt < %L + AND date_part('isodow', ta.dt) = ANY(%L::int[]) + AND ta.dt >= %L + AND ta.dt < %L /*--{holiday_clause} AND NOT EXISTS ( SELECT 1 FROM ref.holiday WHERE ta.dt = holiday.dt @@ -74,7 +78,7 @@ EXECUTE format( ta.tx, ta.dt, seg.total_length, - corridor_id + seg.corridor_id WINDOW w AS ( PARTITION BY seg.corridor_id, ta.dt ORDER BY ta.tx @@ -190,6 +194,9 @@ $BODY$; ALTER FUNCTION gwolofs.congestion_cache_tt_results( text, date, date, time without time zone, - time without time zone, integer[], bigint, bigint, boolean + time without time zone, integer [], bigint, bigint, boolean ) OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.congestion_cache_tt_results IS +'Caches the dynamic binning results for a request.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql b/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql index a87412ec0..338076d44 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql @@ -1,20 +1,21 @@ --- FUNCTION: gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) +-- FUNCTION: gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --noqa: LT05 --- DROP FUNCTION IF EXISTS gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); +-- DROP FUNCTION IF EXISTS gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); --noqa: LT05 CREATE OR REPLACE FUNCTION gwolofs.congestion_dynamic_bin_avg( start_date date, end_date date, start_tod time without time zone, end_tod time without time zone, - dow_list integer[], + dow_list integer [], node_start bigint, node_end bigint, - holidays boolean) - RETURNS numeric - LANGUAGE 'plpgsql' - COST 100 - VOLATILE PARALLEL UNSAFE + holidays boolean +) +RETURNS numeric +LANGUAGE plpgsql +COST 100 +VOLATILE PARALLEL UNSAFE AS $BODY$ DECLARE uri_string_func text := @@ -30,6 +31,7 @@ DECLARE uri_string_func text := BEGIN +--caches the dynamic binning results for this query PERFORM gwolofs.congestion_cache_tt_results( uri_string := uri_string_func, start_date := congestion_dynamic_bin_avg.start_date, @@ -42,6 +44,7 @@ PERFORM gwolofs.congestion_cache_tt_results( holidays := congestion_dynamic_bin_avg.holidays ); +--the way we currently do it; find daily averages and then average. WITH daily_means AS ( SELECT dt_start::date, @@ -60,7 +63,11 @@ END; $BODY$; -ALTER FUNCTION gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) - OWNER TO gwolofs; +ALTER FUNCTION gwolofs.congestion_dynamic_bin_avg( + date, date, time without time zone, time without time zone, integer [], bigint, bigint, boolean +) +OWNER TO gwolofs; -COMMENT ON FUNCTION gwolofs.congestion_dynamic_bin_avg IS 'Previously gwolofs.congestion_dynamic_bin_avg.'; +COMMENT ON FUNCTION gwolofs.congestion_dynamic_bin_avg IS +'Meant to mimic the TT app process; caches results for a specific request and +then returns average TT.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index e68ead7eb..0713b6c8f 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -3,11 +3,12 @@ -- DROP FUNCTION IF EXISTS gwolofs.congestion_network_segment_agg(date); CREATE OR REPLACE FUNCTION gwolofs.congestion_network_segment_agg( - start_date date) - RETURNS void - LANGUAGE 'plpgsql' - COST 100 - VOLATILE PARALLEL UNSAFE + start_date date +) +RETURNS void +LANGUAGE plpgsql +COST 100 +VOLATILE PARALLEL UNSAFE AS $BODY$ DECLARE diff --git a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql index 1127a5249..5cdcb6ac7 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql @@ -4,11 +4,12 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_select_map_version( start_date date, - end_date date) - RETURNS text - LANGUAGE 'sql' - COST 100 - STABLE PARALLEL SAFE + end_date date +) +RETURNS text +LANGUAGE sql +COST 100 +STABLE PARALLEL SAFE AS $BODY$ SELECT street_version @@ -25,4 +26,7 @@ LIMIT 1; $BODY$; ALTER FUNCTION gwolofs.congestion_select_map_version(date, date) - OWNER TO gwolofs; +OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.congestion_select_map_version IS +'Implement TT App selectMapVersion.py'; From 82bf16a815d00e0d053f4b0bf3b2c34bc4a4e63e Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 3 Mar 2025 17:31:27 +0000 Subject: [PATCH 26/74] #1132 change path --- .../sql/{ => dynamic_bins}/select-congestion_raw_segments.md | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename here/traffic/sql/{ => dynamic_bins}/select-congestion_raw_segments.md (100%) diff --git a/here/traffic/sql/select-congestion_raw_segments.md b/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md similarity index 100% rename from here/traffic/sql/select-congestion_raw_segments.md rename to here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md From 8bed8c267fb18a0facd72b7483c6da9b49353e1f Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 3 Mar 2025 19:20:29 +0000 Subject: [PATCH 27/74] #1132 update md with new examples --- ...unction-congestion_network_segment_agg.sql | 3 +- .../select-congestion_raw_segments.md | 299 ++++++++---------- 2 files changed, 140 insertions(+), 162 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index 0713b6c8f..1b1724675 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -174,4 +174,5 @@ ALTER FUNCTION gwolofs.congestion_network_segment_agg(date) OWNER TO gwolofs; COMMENT ON FUNCTION gwolofs.congestion_network_segment_agg(date) -IS 'Dynamic bin aggregation of the congestion network by hour and time periods.'; +IS 'Dynamic bin aggregation of the congestion network by hour and time periods. +Takes around 10 minutes to run for one day (hourly and period based aggregation)'; diff --git a/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md b/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md index 35f5a3e02..48370aeee 100644 --- a/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md +++ b/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md @@ -1,60 +1,33 @@ -This is a readme to describe the complex query [here](./select-congestion_raw_segments.sql). +This is a readme to describe the complex query [here](./function-congestion_network_segment_agg.sql). Samples from each of the CTEs are shown for one segment/time_grp. Not all columns are shown from each CTE result. -### time_bins -Contains hourly and period definitions, known as `time_grp`s. These define the extents within which to evaluate dynamic bin options. A dynamic bin must be fully within the time_grp. +### segments + +Identifies the links that make up each segment, along with total segment length from `congestion.network_links_*` table. ```sql -WITH time_bins AS ( - SELECT - start_time, - start_time + '1 hour'::interval AS end_time, - tsrange(start_time, start_time + '1 hour'::interval, '[)') AS time_grp - FROM generate_series( - '2025-01-04'::date, - '2025-01-04'::date + interval '23 hours', - '1 hour'::interval - ) AS hours(start_time) - UNION +WITH segments AS ( SELECT - start_time + '2025-01-04'::date, - end_time + '2025-01-04'::date, - tsrange(start_time + '2025-01-04'::date, end_time + '2025-01-04'::date, '[)') - FROM ( - VALUES - ('07:00'::time, '10:00'::time), - ('10:00', '16:00'), - ('16:00', '19:00') - ) AS time_periods(start_time, end_time) - ORDER BY start_time -), + segment_id, + link_dir, + length, + SUM(length) OVER (PARTITION BY segment_id) AS total_length + FROM congestion.%2$I --eg. congestion.network_links_23_4_geom +) ``` -| "start_time" | "end_time" | "time_grp" | -|-----------------------|-----------------------|-----------------------------------------------------| -| "2025-01-04 00:00:00" | "2025-01-04 01:00:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | -| "2025-01-04 01:00:00" | "2025-01-04 02:00:00" | "[""2025-01-04 01:00:00"",""2025-01-04 02:00:00"")" | -| "2025-01-04 02:00:00" | "2025-01-04 03:00:00" | "[""2025-01-04 02:00:00"",""2025-01-04 03:00:00"")" | -| "2025-01-04 03:00:00" | "2025-01-04 04:00:00" | "[""2025-01-04 03:00:00"",""2025-01-04 04:00:00"")" | -| "2025-01-04 04:00:00" | "2025-01-04 05:00:00" | "[""2025-01-04 04:00:00"",""2025-01-04 05:00:00"")" | -| "2025-01-04 05:00:00" | "2025-01-04 06:00:00" | "[""2025-01-04 05:00:00"",""2025-01-04 06:00:00"")" | -| "2025-01-04 06:00:00" | "2025-01-04 07:00:00" | "[""2025-01-04 06:00:00"",""2025-01-04 07:00:00"")" | -| "2025-01-04 07:00:00" | "2025-01-04 08:00:00" | "[""2025-01-04 07:00:00"",""2025-01-04 08:00:00"")" | -| "2025-01-04 07:00:00" | "2025-01-04 10:00:00" | "[""2025-01-04 07:00:00"",""2025-01-04 10:00:00"")" | -| "2025-01-04 08:00:00" | "2025-01-04 09:00:00" | "[""2025-01-04 08:00:00"",""2025-01-04 09:00:00"")" | - ### segment_5min_bins -In this step we pull the relevant data from `here.ta_path` for each segment / time_grp. We save the disaggregate travel time data by link in 3 arrays (link_dirs, tts, lengths), so that in future steps we can reaggregate average segment travel time and distinct length over different ranges without referring back to the here.ta_path table. The time bins (`tx`) are also ranked to make it easier to enumerate possible bin extents using generate_series in the next step. +In this step we pull the relevant data from `here.ta_path` for each segment / time_grp (gwolofs.congestion_time_grps). We save the disaggregate travel time data by link in 3 arrays (link_dirs, tts, lengths), so that in future steps we can reaggregate average segment travel time and distinct length over different ranges without referring back to the here.ta_path table. The time bins (`tx`) are also ranked to make it easier to enumerate possible bin extents using `generate_series` in the next step. ```sql segment_5min_bins AS ( SELECT - segments.segment_id, - tb.time_grp, + links.segment_id, + timerange(tg.start_tod, tg.end_tod, '[)') AS time_grp, ta.tx, RANK() OVER w AS bin_rank, - segments.total_length, - SUM(links.length) / segments.total_length AS sum_length, + links.total_length, + SUM(links.length) / links.total_length AS sum_length, SUM(links.length) AS length_w_data, SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, SUM(sample_size) AS num_obs, @@ -62,33 +35,37 @@ segment_5min_bins AS ( ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, ARRAY_AGG(links.length ORDER BY link_dir) AS lengths FROM here.ta_path AS ta - JOIN time_bins AS tb ON ta.tx >= tb.start_time AND ta.tx < tb.end_time - JOIN congestion.network_links_23_4_geom AS links USING (link_dir) - JOIN congestion.network_segments_23_4_geom AS segments USING (segment_id) - WHERE ta.dt = '2025-01-04' - --AND tx < '2025-01-04 01:00:00' - AND segment_id = 29 AND date_trunc('hour', ta.tx) = '2025-01-04 00:00:00' + JOIN gwolofs.congestion_time_grps AS tg ON + ta.tx >= %1$L::date + tg.start_tod + AND ta.tx < %1$L::date + tg.end_tod + JOIN segments AS links USING (link_dir) + WHERE + ta.dt >= %1$L::date + AND ta.dt < %1$L::date + interval '1 day' GROUP BY - segments.segment_id, - tb.time_grp, + links.segment_id, + tg.start_tod, + tg.end_tod, ta.tx, - segments.total_length - WINDOW w AS ( - PARTITION BY segments.segment_id, tb.time_grp + links.total_length + WINDOW w AS ( + PARTITION BY links.segment_id, tg.start_tod, tg.end_tod ORDER BY ta.tx - ) + ) ), ``` -`SELECT bin_rank, tx, round(sum_length, 2) AS sum_length, link_dirs, tts FROM segment_5min_bins;` +`SELECT * FROM gwolofs.congestion_raw_segments WHERE segment_id = 1 AND dt = '2025-01-10' AND time_grp = '[00:00:00,01:00:00)';` -| "bin_rank" | "tx" | "sum_length" | "link_dirs" | "tts" | -|------------|-----------------------|--------------|----------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------| -| 1 | "2025-01-04 00:00:00" | 1.01 | "{1000589822T,1000589823T,1280577167T,792343539T, 792343541T, 836248875T,836248876T,845737718T,845737719T}" | {4.59624489795918360,1.274693877551020408164, 4.96575000000000000,6.68329411764705876, 1.101306122448979591836, 1.526693877551020408164,1.196816326530612244884,4.79172413793103452,9.12626086956521724} | -| 2 | "2025-01-04 00:05:00" | 0.12 | "{845737718T}" | {19.85142857142857148} | -| 3 | "2025-01-04 00:15:00" | 0.07 | "{1280577167T}" | {2.787789473684210526300} | -| 4 | "2025-01-04 00:50:00" | 0.39 | "{845737718T,845737719T}" | {34.74000000000000000,28.62327272727272724} | -| 5 | "2025-01-04 00:55:00" | 1.01 | "{1000589822T,1000589823T,1280577167T,792343539T,792343541T, 836248875T,836248876T,845737718T,845737719T}" | {5.17737931034482764,1.435862068965517241376,1.826482758620689655172,3.91779310344827580,1.240551724137931034496,1.719724137931034482752, 1.348137931034482758612,2.459469026548672566372,6.42563265306122460} | +| segment_id | time_grp | tx | bin_rank | total_length | sum_length | length_w_data | unadjusted_tt | num_obs | link_dirs | tts | lengths | +|------------|---------------------|-------------------------|----------|--------------|------------------------|---------------|--------------------------|---------|---------------------------------------------------------------|-----------------------------------------------------------------------------------------------|--------------------------------| +| 1 | [00:00:00,06:00:00) | 2025-01-10 00:20:00.000 | 1 | 374.22 | 1.00000000000000000000 | 374.22 | 29.200422445479049559580 | 5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {3.739245283018868,4.845056603773585,1.8298867924528301,3.109090909090909,15.677142857142858} | {55.05,71.33,26.94,38.0,182.9} | +| 1 | [00:00:00,06:00:00) | 2025-01-10 00:25:00.000 | 2 | 374.22 | 0.48874993319437763882 | 182.90 | 131.68800000000000000 | 1 | {1328374166F} | {131.688} | {182.9} | +| 1 | [00:00:00,06:00:00) | 2025-01-10 00:35:00.000 | 3 | 374.22 | 1.00000000000000000000 | 374.22 | 76.657011086474501198040 | 5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {4.833658536585366,6.263121951219512,2.365463414634146,3.3365853658536584,59.85818181818182} | {55.05,71.33,26.94,38.0,182.9} | +| 1 | [00:00:00,06:00:00) | 2025-01-10 05:00:00.000 | 4 | 374.22 | 0.19060980172091283202 | 71.33 | 6.26312195121951216 | 1 | {1328374159F} | {6.263121951219512} | {71.33} | +| 1 | [00:00:00,06:00:00) | 2025-01-10 05:05:00.000 | 5 | 374.22 | 1.00000000000000000000 | 374.22 | 35.452421052631578833688 | 5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {5.215263157894737,6.757578947368421,2.5522105263157893,3.6,17.327368421052633} | {55.05,71.33,26.94,38.0,182.9} | +| 1 | [00:00:00,06:00:00) | 2025-01-10 05:15:00.000 | 6 | 374.22 | 1.00000000000000000000 | 374.22 | 48.013722580645161104508 | 5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {6.392903225806451,12.8394,3.128516129032258,4.412903225806452,21.24} | {55.05,71.33,26.94,38.0,182.9} | +| 1 | [00:00:00,06:00:00) | 2025-01-10 05:20:00.000 | 7 | 374.22 | 0.48874993319437763882 | 182.90 | 13.16880000000000000 | 1 | {1328374166F} | {13.1688} | {182.9} | ### dynamic_bin_options Here we enumerate all the possible dynamic bin options for each starting point. The number of combinations are cut down significantly with the `CASE` statements inside the `generate_series`: @@ -99,7 +76,7 @@ Here we enumerate all the possible dynamic bin options for each starting point. dynamic_bin_options AS ( --within each segment/hour, generate all possible forward looking bin combinations --don't generate options for bins with sufficient length - --also don't generate options past the next bin with 80% length + --also don't generate options past the next bin with 80%% length SELECT tx, time_grp, @@ -130,18 +107,23 @@ dynamic_bin_options AS ( ), ``` -In this case we find 8 dynamic bin options with the pruning conditions, down from max of 5+4+3+2+1 = 15. +In this case we find 13 dynamic bin options with the pruning conditions, down from max of 10+9+8+7+6+5+4+3+2+1 = 55. -| "tx" | "time_grp" | "segment_id" | "start_bin" | "end_bin" | -|-----------------------|-----------------------------------------------------|--------------|-------------|-----------| -| "2025-01-04 00:00:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 1 | 1 | -| "2025-01-04 00:05:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 2 | 3 | -| "2025-01-04 00:05:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 2 | 4 | -| "2025-01-04 00:05:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 2 | 5 | -| "2025-01-04 00:15:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 3 | 4 | -| "2025-01-04 00:15:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 3 | 5 | -| "2025-01-04 00:50:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 4 | 5 | -| "2025-01-04 00:55:00" | "[""2025-01-04 00:00:00"",""2025-01-04 01:00:00"")" | 29 | 5 | 5 | +| tx | time_grp | segment_id | start_bin | end_bin | +|-------------------------|---------------------|------------|-----------|---------| +| 2025-01-10 00:20:00.000 | [00:00:00,06:00:00) | 1 | 1 | 1 | +| 2025-01-10 00:25:00.000 | [00:00:00,06:00:00) | 1 | 2 | 3 | +| 2025-01-10 00:35:00.000 | [00:00:00,06:00:00) | 1 | 3 | 3 | +| 2025-01-10 05:00:00.000 | [00:00:00,06:00:00) | 1 | 4 | 5 | +| 2025-01-10 05:05:00.000 | [00:00:00,06:00:00) | 1 | 5 | 5 | +| 2025-01-10 05:15:00.000 | [00:00:00,06:00:00) | 1 | 6 | 6 | +| 2025-01-10 05:20:00.000 | [00:00:00,06:00:00) | 1 | 7 | 8 | +| 2025-01-10 05:20:00.000 | [00:00:00,06:00:00) | 1 | 7 | 9 | +| 2025-01-10 05:20:00.000 | [00:00:00,06:00:00) | 1 | 7 | 10 | +| 2025-01-10 05:25:00.000 | [00:00:00,06:00:00) | 1 | 8 | 9 | +| 2025-01-10 05:25:00.000 | [00:00:00,06:00:00) | 1 | 8 | 10 | +| 2025-01-10 05:50:00.000 | [00:00:00,06:00:00) | 1 | 9 | 10 | +| 2025-01-10 05:55:00.000 | [00:00:00,06:00:00) | 1 | 10 | 10 | ### unnested_db_options Combining the previous two steps, we have enumerated all the possible bin start/end ranges (`dynamic_bin_options`), now we can unnest the disaggregate data (`segment_5min_bins`) and evaluate them. @@ -156,45 +138,51 @@ unnested_db_options AS ( s5b.total_length, dbo.tx AS dt_start, --exclusive end bin - MAX(s5b.tx) + interval '5 minutes' AS dt_end, + s5b_end.tx + interval '5 minutes' AS dt_end, unnested.link_dir, unnested.len, AVG(unnested.tt) AS tt, --avg TT for each link_dir - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir FROM dynamic_bin_options AS dbo LEFT JOIN segment_5min_bins AS s5b ON s5b.time_grp = dbo.time_grp AND s5b.segment_id = dbo.segment_id AND s5b.bin_rank >= dbo.start_bin - AND s5b.bin_rank <= dbo.end_bin, + AND s5b.bin_rank <= dbo.end_bin + --this join is used to get the tx info about the last bin only + LEFT JOIN segment_5min_bins AS s5b_end + ON s5b_end.time_grp = dbo.time_grp + AND s5b_end.segment_id = dbo.segment_id + AND s5b_end.bin_rank = dbo.end_bin, --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) - --we need to use nested data to determine length for these multi-period bins - WHERE dbo.start_bin != dbo.end_bin + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' GROUP BY dbo.time_grp, dbo.segment_id, s5b.total_length, - dbo.tx, - dbo.end_bin, + dbo.tx, --stard_bin + s5b_end.tx, --end_bin unnested.link_dir, unnested.len ) ``` -`SELECT dt_start, dt_end, link_dir, len, tt, num_obs FROM unnested_db_options WHERE dt_start = '2025-01-04 00:05:00' AND dt_end = '2025-01-04 01:00:00'` +`SELECT * FROM unnested_db_options WHERE time_grp = '[00:00:00,06:00:00)' LIMIT 10` -| "dt_start" | "dt_end" | "link_dir" | "len" | "tt" | "num_obs" | -|-----------------------|-----------------------|---------------|-------|--------------------------|-----------| -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "1000589822T" | 62.56 | 5.17737931034482764 | 18 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "1000589823T" | 17.35 | 1.435862068965517241376 | 18 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "1280577167T" | 22.07 | 2.307136116152450090736 | 20 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "792343539T" | 47.34 | 3.91779310344827580 | 18 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "792343541T" | 14.99 | 1.240551724137931034496 | 18 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "836248875T" | 20.78 | 1.719724137931034482752 | 18 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "836248876T" | 16.29 | 1.348137931034482758612 | 18 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "845737718T" | 38.60 | 19.016965865992414682124 | 21 | -| "2025-01-04 00:05:00" | "2025-01-04 01:00:00" | "845737719T" | 87.46 | 17.52445269016697592 | 20 | +| time_grp | segment_id | total_length | dt_start | dt_end | link_dir | len | tt | num_obs | +|---------------------|------------|--------------|-------------------------|-------------------------|-------------|--------|-------------------------|---------| +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374158F | 55.05 | 3.739 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374159F | 71.33 | 4.845 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374160F | 26.94 | 1.829 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374165F | 38.00 | 3.109 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374166F | 182.90 | 15.677 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374158F | 55.05 | 4.833 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374159F | 71.33 | 6.263 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374160F | 26.94 | 2.365 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374165F | 38.00 | 3.336 | 5 | +| [00:00:00,06:00:00) | 1 | 374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374166F | 182.90 | 95.773 | 6 | ### Insert statement Here we find bins with sufficient length, for the two cases: @@ -202,81 +190,70 @@ Here we find bins with sufficient length, for the two cases: - An original 5min bin, no group by needed to check length. ```sql -INSERT INTO gwolofs.congestion_raw_segments ( - time_grp, segment_id, dt_start, dt_end, bin_range, tt, - unadjusted_tt, total_length, length_w_data, num_obs -) ---this query contains overlapping values which get eliminated ---via on conflict with the exclusion constraint on congestion_raw_segments table. -SELECT DISTINCT ON (time_grp, segment_id, dt_start) - time_grp, - segment_id, - dt_start, - dt_end, - tsrange(dt_start, dt_end, '[)') AS bin_range, - total_length / SUM(len) * SUM(tt) AS tt, - SUM(tt) AS unadjusted_tt, - total_length, - SUM(len) AS length_w_data, - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment -FROM unnested_db_options AS udbo -GROUP BY - time_grp, - segment_id, - dt_start, - dt_end, - total_length -HAVING SUM(len) >= 0.8 * total_length -UNION ---these 5 minute bins already have sufficient length ---don't need to use nested data to validate. -SELECT - time_grp, - segment_id, - tx AS dt_start, - tx + interval '5 minutes' AS dt_end, - tsrange(tx, tx + interval '5 minutes', '[)') AS bin_range, - total_length / length_w_data * unadjusted_tt AS tt, - unadjusted_tt, - total_length, - length_w_data, - num_obs --sum of here.ta_path sample_size for each segment -FROM segment_5min_bins ---we do not need to use nested data to determine length here. -WHERE sum_length >= 0.8 -ORDER BY - time_grp, - segment_id, - dt_start, - dt_end ---exclusion constraint + ordered insert to prevent overlapping bins -ON CONFLICT ON CONSTRAINT dynamic_bins_unique -DO NOTHING; + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + INSERT INTO gwolofs.congestion_raw_segments ( + dt, time_grp, segment_id, bin_range, tt, num_obs + ) + --distinct on ensures only the shortest option gets proposed for insert + SELECT DISTINCT ON (time_grp, segment_id, dt_start) + dt_start::date AS dt, + time_grp, + segment_id, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + time_grp, + segment_id, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + ORDER BY + time_grp, + segment_id, + dt_start, + dt_end --uses the option that ends first + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude + DO NOTHING; ``` -`SELECT segment_id, bin_range, round(tt, 2) AS tt, total_length, length_w_data FROM inserted;` +`SELECT dt, time_grp, segment_id, bin_range, round(tt, 2), num_obs FROM inserted WHERE time_grp = '[00:00:00,06:00:00)';` -| "segment_id" | "bin_range" | "tt" | "total_length" | "length_w_data" | -|--------------|-----------------------------------------------------|-------|----------------|-----------------| -| 29 | "[""2025-01-04 00:00:00"",""2025-01-04 00:05:00"")" | 34.93 | 324.33 | 327.44 | -| 29 | "[""2025-01-04 00:05:00"",""2025-01-04 01:00:00"")" | 53.18 | 324.33 | 327.44 | -| 29 | "[""2025-01-04 00:15:00"",""2025-01-04 01:00:00"")" | 52.76 | 324.33 | 327.44 | -| 29 | "[""2025-01-04 00:50:00"",""2025-01-04 01:00:00"")" | 52.29 | 324.33 | 327.44 | -| 29 | "[""2025-01-04 00:55:00"",""2025-01-04 01:00:00"")" | 25.31 | 324.33 | 327.44 | +| dt | time_grp | segment_id | bin_range | round | num_obs | +|------------|---------------------|------------|-----------------------------------------------|--------|---------| +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 00:20:00","2025-01-10 00:25:00") | 29.20 | 25 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 00:25:00","2025-01-10 00:40:00") | 112.57 | 26 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 00:35:00","2025-01-10 00:40:00") | 76.66 | 25 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 05:00:00","2025-01-10 05:10:00") | 35.21 | 26 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 05:05:00","2025-01-10 05:10:00") | 35.45 | 25 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 05:15:00","2025-01-10 05:20:00") | 48.01 | 25 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 05:20:00","2025-01-10 05:55:00") | 51.34 | 14 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 05:25:00","2025-01-10 05:55:00") | 69.59 | 13 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 05:50:00","2025-01-10 06:00:00") | 53.28 | 62 | +| 2025-01-10 | [00:00:00,06:00:00) | 1 | ["2025-01-10 05:55:00","2025-01-10 06:00:00") | 39.36 | 50 | -After insert against exclusion constraint, only 2 remain, since records 3,4,5 overlap with record 2 above. -`SELECT segment_id, bin_range, round(tt, 2) AS tt, total_length, length_w_data FROM gwolofs.congestion_raw_segments WHERE segment_id = 29 AND time_grp = '["2025-01-04 00:00:00","2025-01-04 01:00:00")'::tsrange` +After insert against exclusion constraint, only 6 remain (of 10 above), since rows #3,5,8,9 overlap other records. +`SELECT segment_id, bin_range, round(tt, 2) AS tt, total_length, length_w_data FROM gwolofs.congestion_raw_segments WHERE segment_id = 29 AND time_grp = '["2025-01-04 00:00:00","2025-01-04 06:00:00")'::tsrange` Constraint: ```sql - CONSTRAINT dynamic_bins_unique EXCLUDE USING gist ( - segment_id WITH =, + CONSTRAINT congestion_raw_segments_exclude EXCLUDE USING gist ( bin_range WITH &&, - time_grp WITH = + segment_id WITH =, + time_grp WITH =, + dt WITH = ) ``` -| "segment_id" | "bin_range" | "tt" | "total_length" | "length_w_data" | -|--------------|-----------------------------------------------------|-------|----------------|-----------------| -| 29 | "[""2025-01-04 00:00:00"",""2025-01-04 00:05:00"")" | 34.93 | 324.33 | 327.44 | -| 29 | "[""2025-01-04 00:05:00"",""2025-01-04 01:00:00"")" | 53.18 | 324.33 | 327.44 | \ No newline at end of file +| segment_id | bin_range | tt | num_obs | dt | time_grp | +|------------|-----------------------------------------------|-------------------|---------|------------|---------------------| +| 1 | ["2025-01-10 00:20:00","2025-01-10 00:25:00") | 29.2004224454790 | 25 | 2025-01-10 | [00:00:00,06:00:00) | +| 1 | ["2025-01-10 00:25:00","2025-01-10 00:40:00") | 112.5719201773835 | 26 | 2025-01-10 | [00:00:00,06:00:00) | +| 1 | ["2025-01-10 05:00:00","2025-01-10 05:10:00") | 35.2051925545571 | 26 | 2025-01-10 | [00:00:00,06:00:00) | +| 1 | ["2025-01-10 05:15:00","2025-01-10 05:20:00") | 48.0137225806451 | 25 | 2025-01-10 | [00:00:00,06:00:00) | +| 1 | ["2025-01-10 05:20:00","2025-01-10 05:55:00") | 51.34214 | 14 | 2025-01-10 | [00:00:00,06:00:00) | +| 1 | ["2025-01-10 05:55:00","2025-01-10 06:00:00") | 39.3552705888070 | 50 | 2025-01-10 | [00:00:00,06:00:00) | \ No newline at end of file From 401dada9ec05378f5ca8b9a952af93c47ef89428 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 18 Mar 2025 18:44:19 +0000 Subject: [PATCH 28/74] #1132 explore binning extents ipynb --- .../here_dynamic_binning_explore.ipynb | 406 ++++++++++++++++++ 1 file changed, 406 insertions(+) create mode 100644 here/traffic/here_dynamic_binning_explore.ipynb diff --git a/here/traffic/here_dynamic_binning_explore.ipynb b/here/traffic/here_dynamic_binning_explore.ipynb new file mode 100644 index 000000000..b4c1b2a5f --- /dev/null +++ b/here/traffic/here_dynamic_binning_explore.ipynb @@ -0,0 +1,406 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8c6f35d7-fbd6-4336-91e3-4ab18b4009e5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/jupyterhub/.venv/lib/python3.10/site-packages/geopandas/io/sql.py:170: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import configparser\n", + "from psycopg2 import connect\n", + "import struct\n", + "import pandas as pd\n", + "from datetime import datetime\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "import seaborn as sns\n", + "import geopandas as gpd\n", + "\n", + "CONFIG = configparser.ConfigParser()\n", + "CONFIG.read(str(Path.home().joinpath('db.cfg'))) #Creates a path to your db.cfg file\n", + "dbset = CONFIG['SQLALCHEMY']\n", + "\n", + "with connect(**dbset) as con:\n", + " basemap_query = '''select gis.geopandas_transform(ST_union(geom)) as geom from gis.neighbourhood'''\n", + " basemap = gpd.GeoDataFrame.from_postgis(basemap_query, con, geom_col='geom')\n", + " basemap = basemap.to_crs('epsg:26917')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "def42f51-59b0-42bd-b300-5d1f3e3dee15", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_818626/423225491.py:6: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(sql, con)\n" + ] + } + ], + "source": [ + "sql = '''SELECT hr, bin_length, count, legend\n", + "FROM gwolofs.congestion_bin_length_explore'''\n", + "\n", + "try:\n", + " with connect(**dbset) as con:\n", + " df = pd.read_sql(sql, con)\n", + "except Exception as e:\n", + " print(\"Error connecting to the database:\", e)\n", + " exit()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "a1a4f215-4fc4-4b0b-8223-870934a9c7f0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convert bin_length to string for categorical x-axis\n", + "df['bin_length'] = df['bin_length'].astype(str)\n", + "\n", + "# Compute proportions within each bin_size group\n", + "df['proportion'] = df.groupby('hr')['count'].transform(lambda x: x / x.sum())\n", + "\n", + "# Plot multi-bar chart\n", + "plt.figure(figsize=(12, 6))\n", + "sns.barplot(x=df['bin_length'], y=df['proportion'], hue=df['hr'], palette='viridis')\n", + "plt.xlabel('Bin Size')\n", + "plt.ylabel('Proportion')\n", + "plt.title('Congestion Proportions by Bin Size and Hour')\n", + "plt.yticks([i * 0.01 for i in range(0, 100, 5)])\n", + "plt.xticks(rotation=45)\n", + "plt.legend(title='Hour of the Day')\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3e9c7d6d-6e1f-4214-b9cf-dd0b8e16daf5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_842647/1604576776.py:15: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(sql, con)\n" + ] + } + ], + "source": [ + "sql = '''SELECT\n", + " CASE\n", + " WHEN time_grp = '[00:00:00,24:00:00)' THEN '24hr'\n", + " WHEN (upper(time_grp) - lower(time_grp)) = '01:00:00'::interval THEN '1hr'\n", + " ELSE 'Periods'\n", + " END AS legend,\n", + " lower(bin_range)::time AS bin_start,\n", + " upper(bin_range)::time AS bin_end\n", + "FROM gwolofs.congestion_raw_segments\n", + "WHERE dt >= '2024-12-01' AND dt < '2024-12-02' AND segment_id = 2511\n", + "ORDER BY 1, 2'''\n", + "\n", + "try:\n", + " with connect(**dbset) as con:\n", + " df = pd.read_sql(sql, con)\n", + " # Convert time columns to datetime\n", + "except Exception as e:\n", + " print(\"Error connecting to the database:\", e)\n", + " exit()\n", + "\n", + "# Convert time columns to seconds since midnight\n", + "def time_to_seconds(t):\n", + " return t.hour * 3600 + t.minute * 60 + t.second\n", + "\n", + "df['bin_start'] = df['bin_start'].apply(time_to_seconds)\n", + "df['bin_end'] = df['bin_end'].apply(time_to_seconds)\n", + "df['duration'] = df['bin_end'] - df['bin_start']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8d2ba18c-dc79-4a04-8da6-8139f5772b18", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAI7CAYAAABGCSjLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACzeklEQVR4nOzdeXiU1fn/8c8zk4SELZGtgOwgmwKioK2KYrUVd9yrVkWsVsUFFbfaVuxP69LiUmu12gpqtXYBq7UKWit1qxWQxQVQNtlUUCRsgZCZ8/uDZr6EBGHuJDM3zPt1XV4tk8nMm3OehyQnM+eJQghBAAAAAAAAtRDLdgAAAAAAANj1scAAAAAAAABqjQUGAAAAAABQaywwAAAAAACAWmOBAQAAAAAA1BoLDAAAAAAAoNZYYAAAAAAAALXGAgMAAAAAAKg1FhgAAAAAAECtscAAAKhi2LBh6tSpU1aee/To0YqiqMptnTp10rBhw7LSs7M+//xznXrqqWrevLmiKNK9995bJ4+bzbmATRRFGj16dLYzqtjZ46hTp0467rjj6j9oNzd48GANHjw42xkAkBUsMABADoiiaKf+mzx5crZTd0lXXXWVJk2apBtvvFFPPPGEhgwZst37bjvmjRo1Uu/evXXrrbdqw4YN9do5efLkKs8dj8fVqlUrnXrqqZo9e3a9PrdXkydP1sknn6zWrVuroKBArVq10vHHH68JEyZkO223tGjRIkVRpF/+8pfZTgEA1IO8bAcAAOrfE088UeXPjz/+uF5++eVqt/fq1UuPPPKIkslkJvO+1ty5cxWL+V4P/9e//qUTTzxRo0aN2qn7f+c739G5554rSVq3bp1ef/11/eQnP9HMmTP1l7/8JXW/+pqLK664QgMHDtTmzZs1a9YsPfTQQ5o8ebLef/99tW7dus6fz6ubb75ZP/vZz7TXXnvphz/8oTp27Kgvv/xSL7zwgk455RQ9+eSTOuuss7KdCQDALoMFBgDIAd///ver/Pntt9/Wyy+/XO12jxo0aJDthB1asWKFSkpKdvr+3bt3rzL2F198scrLyzVhwgRt3LhRhYWFkqT8/Py6TpUkDRo0SKeeemrqzz169NAll1yixx9/XNddd129PKc3f/3rX/Wzn/1Mp556qp566qkqY33ttddq0qRJ2rx5cxYLpfXr16tRo0ZZbQAAIB2+fyUEAMi4bd+vvfVLmh944AF16dJFDRs21He/+10tWbJEIQT9v//3/9SuXTsVFRXpxBNP1KpVq6o97osvvqhBgwapUaNGatKkiY499lh98MEHO+zZdg+GcePGKYoivfnmm7r66qvVsmVLNWrUSCeddJJWrlxZZ88rSQsWLNBpp52mZs2aqWHDhvrmN7+pf/zjH9VaQgh64IEHUm89sGjdurWiKFJe3v+t/X/dXDz88MPq2rWrGjRooIEDB2rKlCmm55W2LDhI0vz586vc/stf/lIHHXSQmjdvrqKiIu2///7661//Wu3zoyjSZZddpr/97W/aZ5991KBBA+29996aOHFitftOnjxZAwYMUGFhobp27arf/va3Ne69IUl/+MMftP/++6uoqEjNmjXT9773PS1ZsqTKfT7++GOdcsopat26tQoLC9WuXTt973vfU2lp6df+nX/yk5+oWbNmevTRR2tcyDnqqKOq7EewYsUKXXDBBfrGN76hwsJC9evXT4899tjXPkel6dOn6+ijj1bTpk3VuHFjHXHEEXr77ber3KfyWPr3v/+tSy+9VK1atVK7du1SH9/Z47hyDgoLC7XPPvvomWee2anGrb300kvad999VVhYqN69e1d5u8iCBQsURZHuueeeap/31ltvKYoi/fGPf0z7Obe1adMm3XzzzerWrZsaNGig9u3b67rrrtOmTZuq3K+srExXXHGFWrRooSZNmuiEE07QsmXLatwLY9myZRo+fLi+8Y1vpI7RRx99tMp9Kt9G9Oc//1m33Xab2rVrp8LCQh1xxBGaN29etc7K87CoqEgHHHCAXn/99Vr/3QFgV8YrGAAAO+XJJ59UeXm5Lr/8cq1atUp33XWXTj/9dH3729/W5MmTdf3112vevHm6//77NWrUqCrfuD/xxBM677zzdNRRR+nOO+/Uhg0b9OCDD+qQQw7R9OnTTRsZXn755dpjjz108803a9GiRbr33nt12WWX6U9/+lOdPO/nn3+ugw46SBs2bNAVV1yh5s2b67HHHtMJJ5ygv/71rzrppJN06KGH6oknntA555xT5W0PO7Jx40Z98cUXkrb8lvrNN9/UY489prPOOqvKAsP2PPXUU1q7dq1++MMfKooi3XXXXTr55JO1YMEC06seFi1aJEnaY489qtx+33336YQTTtDZZ5+t8vJyPf300zrttNP0/PPP69hjj61y3zfeeEMTJkzQpZdeqiZNmuhXv/qVTjnlFC1evFjNmzeXtOUH7SFDhqhNmza65ZZblEgk9LOf/UwtW7as1nTbbbfpJz/5iU4//XT94Ac/0MqVK3X//ffr0EMP1fTp01VSUqLy8nIdddRR2rRpky6//HK1bt1ay5Yt0/PPP6/Vq1eruLi4xr/vxx9/rDlz5mj48OFq0qTJDsenrKxMgwcP1rx583TZZZepc+fO+stf/qJhw4Zp9erVuvLKK7f7uR988IEGDRqkpk2b6rrrrlN+fr5++9vfavDgwfr3v/+tAw88sMr9L730UrVs2VI//elPtX79ekk7fxy/9NJLOuWUU9S7d2/dfvvt+vLLL3X++edXWajYkY8//lhnnHGGLr74Yp133nkaO3asTjvtNE2cOFHf+c531KVLFx188MF68sknddVVV1X53CeffFJNmjTRiSeeuNPPV5NkMqkTTjhBb7zxhi666CL16tVL7733nu655x599NFH+tvf/pa677Bhw/TnP/9Z55xzjr75zW/q3//+d7VjU9pyPn/zm99MLYa1bNlSL774oi644AKtWbNGI0eOrHL/O+64Q7FYTKNGjVJpaanuuusunX322frvf/+bus/vf/97/fCHP9RBBx2kkSNHasGCBTrhhBPUrFkztW/fvlZjAAC7rAAAyDkjRowI2/sScN5554WOHTum/rxw4cIgKbRs2TKsXr06dfuNN94YJIV+/fqFzZs3p24/88wzQ0FBQdi4cWMIIYS1a9eGkpKScOGFF1Z5ns8++ywUFxdXuf3mm2+u1tWxY8dw3nnnpf48duzYICkceeSRIZlMpm6/6qqrQjweTzWm87w1GTlyZJAUXn/99dRta9euDZ07dw6dOnUKiUQidbukMGLEiK99vK3vW9N/Q4cOTY1Zpe3NRfPmzcOqVatStz/77LNBUvj73//+tc/96quvBknh0UcfDStXrgzLly8PEydODN26dQtRFIV33nmnyv03bNhQ5c/l5eVhn332Cd/+9rer/Z0KCgrCvHnzUrfNnDkzSAr3339/6rbjjz8+NGzYMCxbtix128cffxzy8vKqzPuiRYtCPB4Pt912W5Xnee+990JeXl7q9unTpwdJ4S9/+cvX/r23VTle99xzz07d/9577w2Swh/+8IfUbeXl5eFb3/pWaNy4cVizZk3qdknh5ptvTv156NChoaCgIMyfPz912/Lly0OTJk3CoYcemrqt8rg+5JBDQkVFRer2dI7jfffdN7Rp06bKefrSSy8FSVWOo+3p2LFjkBTGjx+fuq20tDS0adMm9O/fP3Xbb3/72yApzJ49u8p4tGjRosq5WpPKY/gXv/jFdu/zxBNPhFgsVuXcCyGEhx56KEgKb775ZgghhGnTpgVJYeTIkVXuN2zYsGrzcMEFF4Q2bdqEL774osp9v/e974Xi4uLUsV55jvTq1Sts2rQpdb/77rsvSArvvfde6u/bqlWrsO+++1a538MPPxwkhcMOO+xrxwEAdle8RQIAsFNOO+20Kr8RrvzN6/e///0qv3U/8MADVV5ermXLlkmSXn75Za1evVpnnnmmvvjii9R/8XhcBx54oF599VVTz0UXXVTlZfWDBg1SIpHQJ598UifP+8ILL+iAAw7QIYcckrqtcePGuuiii7Ro0SJ9+OGHpm5JOvHEE/Xyyy/r5Zdf1rPPPqsbb7xREydO1FlnnaUQwg4//4wzzqjyaoPKtzgsWLBgp55/+PDhatmypdq2bashQ4aotLRUTzzxhAYOHFjlfkVFRan//9VXX6m0tFSDBg3Su+++W+0xjzzySHXt2jX15759+6pp06appkQioX/+858aOnSo2rZtm7pft27ddPTRR1d5rAkTJiiZTOr000+vMnetW7fWXnvtlZq7yuNx0qRJaV2BY82aNZK0U69ekLYcC61bt9aZZ56Zui0/P19XXHGF1q1bp3//+981fl4ikdBLL72koUOHqkuXLqnb27Rpo7POOktvvPFGqqXShRdeqHg8nvrzzh7Hn376qWbMmKHzzjuvynn6ne98R717996pv6cktW3bVieddFLqz02bNtW5556r6dOn67PPPpMknX766SosLNSTTz6Zut+kSZP0xRdf1Mm+Ln/5y1/Uq1cv9ezZs8rf+dvf/rYkpf7OlW/BufTSS6t8/uWXX17lzyEEjR8/Xscff7xCCFUe86ijjlJpaWm1Y/r8889XQUFB6s/bnmNTp07VihUrdPHFF1e537Bhw7b7yhkAyAW8RQIAsFM6dOhQ5c+V30Rv+1Lgytu/+uorSVteci0p9cPBtpo2bVonPZU/cNfV837yySfVXr4ubbnSRuXH99lnn/Si/6ddu3Y68sgjU38+4YQT1Lx5c40aNUrPP/+8jj/++K/9/B393Xfkpz/9qQYNGqR169bpmWee0dNPP13jlTqef/553XrrrZoxY0aV977XtF/Ctk2VXZVNK1asUFlZmbp161btftve9vHHHyuEoL322qvG/sq3gXTu3FlXX3217r77bj355JMaNGiQTjjhBH3/+9//2h/yKud+7dq1273P1j755BPttdde1cZo62OhJitXrtSGDRvUo0ePah/r1auXksmklixZor333jt1e+fOnavcb2eP48qGmsasR48eNS4K1aRbt27V5rd79+6StryVpnXr1iopKdHxxx+vp556Sv/v//0/SVveHrHnnntutzMdH3/8sWbPnl3jW2ekLceStOXvHIvFqo3ZtsfTypUrtXr1aj388MN6+OGHv/YxK+3oHNveeOfn51dZTAKAXMMCAwBgp2z9W9Wdub3yN/GVl1l84oknarwE4s7sOeDpeevLEUccIUl67bXXdrjAsKO/+4706dMntcAxdOhQbdiwQRdeeKEOOeSQ1ILR66+/rhNOOEGHHnqofvOb36hNmzbKz8/X2LFj9dRTT9V509aSyaSiKNKLL75Y4+M2btw49f/HjBmjYcOG6dlnn9VLL72kK664Qrfffrvefvvt7e490LNnT0nSe++9l3Zbfdv6VSOS3+P43HPP1V/+8he99dZb6tOnj5577jldeumldXJJ2WQyqT59+ujuu++u8ePp7m9QOYbf//73dd5559V4n759+1b5c10ezwCQS3x9dwUA2O1Uvmy+VatWVX5r7/15O3bsqLlz51a7fc6cOamP16WKigpJ0rp16+r0cXfGHXfcoWeeeUa33XabHnroIUnS+PHjVVhYqEmTJlW5VOjYsWNNz9GqVSsVFhbWuBP/trd17dpVIQR17tw59dvzr9OnTx/16dNHP/7xj/XWW2/p4IMP1kMPPaRbb721xvt3795dPXr00LPPPqv77ruvyoJFTTp27KhZs2YpmUxW+QF6R8dCy5Yt1bBhw+0eR7FYbIc/LO/scVzZUPmKh63V9PzbM2/ePIUQqryK4aOPPpKkKpuiDhkyRC1bttSTTz6pAw88UBs2bNA555yz08/zdbp27aqZM2fqiCOO+NqrsnTs2FHJZFILFy6s8kqCbY+nli1bqkmTJkokEnX2b9DW4731qzY2b96shQsXql+/fnXyPACwq2EPBgBAvTrqqKPUtGlT/fznP9fmzZurfbymS0t6eN5jjjlG77zzjv7zn/+kblu/fr0efvhhderUKa33te+Mv//975KUlR9MunbtqlNOOUXjxo1Lvc8+Ho8riiIlEonU/RYtWlRlB/90xONxHXnkkfrb3/6m5cuXp26fN2+eXnzxxSr3PfnkkxWPx3XLLbdU+41xCEFffvmlpC17KVQuzFTq06ePYrFYtcsZbuuWW27Rl19+qR/84AfVHkPackWG559/XtKWY+Gzzz6rcoWSiooK3X///WrcuLEOO+yw7f6dv/vd7+rZZ59NXalD2nJFg6eeekqHHHLIDt+qs7PHcZs2bbTvvvvqscceq3KJzpdffjmt/UKWL19e5dKWa9as0eOPP6599923yiso8vLydOaZZ+rPf/6zxo0bpz59+lR7FYDV6aefrmXLlumRRx6p9rGysrLU1TWOOuooSdJvfvObKve5//77q/w5Ho/rlFNO0fjx4/X+++9Xe0zLv0EDBgxQy5Yt9dBDD6m8vDx1+7hx47R69eq0Hw8Adhe8ggEAUK+aNm2qBx98UOecc472228/fe9731PLli21ePFi/eMf/9DBBx+sX//61+6e94YbbtAf//hHHX300briiivUrFkzPfbYY1q4cKHGjx9fq5eCf/TRR/rDH/4gSdqwYYPefvttPfbYY+rWrVud/RY4Xddee63+/Oc/695779Udd9yhY489VnfffbeGDBmis846SytWrNADDzygbt26adasWabnGD16tF566SUdfPDBuuSSS5RIJPTrX/9a++yzj2bMmJG6X9euXXXrrbfqxhtv1KJFizR06FA1adJECxcu1DPPPKOLLrpIo0aN0r/+9S9ddtllOu2009S9e3dVVFToiSeeSP1A+XXOOOMMvffee7rttts0ffp0nXnmmerYsaO+/PJLTZw4Ua+88krqrSAXXXSRfvvb32rYsGGaNm2aOnXqpL/+9a968803de+9937tZpG33nqrXn75ZR1yyCG69NJLlZeXp9/+9rfatGmT7rrrrh2OWTrH8e23365jjz1WhxxyiIYPH65Vq1bp/vvv1957773Tr4zp3r27LrjgAk2ZMkXf+MY39Oijj+rzzz+v8ZUr5557rn71q1/p1Vdf1Z133rlTj1/plVde0caNG6vdPnToUJ1zzjn685//rIsvvlivvvqqDj74YCUSCc2ZM0d//vOfNWnSJA0YMED777+/TjnlFN1777368ssvU5eprHzFxdavfrjjjjv06quv6sADD9SFF16o3r17a9WqVXr33Xf1z3/+U6tWrUqrPz8/X7feeqt++MMf6tvf/rbOOOMMLVy4UGPHjmUPBgC5LSvXrgAAZJXlMpXbXlau8nJu214isPJye1OmTKl2/6OOOioUFxeHwsLC0LVr1zBs2LAwderU1H3SuUxlTY8vKbz66qtpP+/2zJ8/P5x66qmhpKQkFBYWhgMOOCA8//zz1e6nWlymMh6Ph3bt2oWLLroofP7551Xuu7NzUfm4W1+Wrybbm7NKgwcPDk2bNk1d5vD3v/992GuvvUKDBg1Cz549w9ixY2uco+39/beduxBCeOWVV0L//v1DQUFB6Nq1a/jd734XrrnmmlBYWFjt88ePHx8OOeSQ0KhRo9CoUaPQs2fPMGLEiDB37twQQggLFiwIw4cPD127dg2FhYWhWbNm4fDDDw///Oc/v3Yctu058cQTQ6tWrUJeXl5o2bJlOP7448Ozzz5b5X6ff/55OP/880OLFi1CQUFB6NOnTxg7dmy1x6tpHt59991w1FFHhcaNG4eGDRuGww8/PLz11ltV7rO947rSzh7H48ePD7169QoNGjQIvXv3DhMmTKh2HG1Px44dw7HHHhsmTZoU+vbtm5r3r7sM6N577x1isVhYunTpDh8/hP87hrf33xNPPBFC2HIZyDvvvDPsvffeoUGDBmGPPfYI+++/f7jllltCaWlp6vHWr18fRowYEZo1axYaN24chg4dGubOnRskhTvuuKPKc3/++edhxIgRoX379iE/Pz+0bt06HHHEEeHhhx9O3Wd750hl97Zz/pvf/CZ07tw5NGjQIAwYMCC89tpr4bDDDuMylQByVhQCu9UAAIDsGTp0qD744IMa9w+Ab/3791ezZs30yiuvZDslZcaMGerfv7/+8Ic/6Oyzz852DgDkFPZgAAAAGVNWVlblzx9//LFeeOEFDR48ODtBMJs6dapmzJihc889N2sN2x5PknTvvfcqFovp0EMPzUIRAOQ2XsEAAAAypk2bNho2bJi6dOmiTz75RA8++KA2bdqk6dOnV7kSAPx6//33NW3aNI0ZM0ZffPGFFixYoMLCwqy03HLLLZo2bZoOP/xw5eXl6cUXX9SLL76Y2jcDAJBZbPIIAAAyZsiQIfrjH/+ozz77TA0aNNC3vvUt/fznP2dxYRfy17/+VT/72c/Uo0cP/fGPf8za4oIkHXTQQXr55Zf1//7f/9O6devUoUMHjR49WjfddFPWmgAgl/EKBgAAAAAAUGvswQAAAAAAAGqNBQYAAAAAAFBr7MGQAclkUsuXL1eTJk0URVG2cwAAAAAAu7kQgtauXau2bdsqFsvMawtYYMiA5cuXq3379tnOAAAAAADkmCVLlqhdu3YZeS4WGDKgSZMmkrZMbNOmTTP+/BUVFZo+fbr69++vvDxfU06bjec2yXcfbTa02dBmQ5sNbTa02dBmQ5sNbTarVq1S586dUz+PZoKvEdhNVb4tomnTpllbYGjUqJGaNm3q7qCnzcZzm+S7jzYb2mxos6HNhjYb2mxos6HNhjabiooKScro2/S5TGUGrFmzRsXFxSotLc3KAkMIQWVlZSoqKnK3BwRtNp7bJN99tNnQZkObDW02tNnQZkObDW02tNmUlpaqpKQkoz+HchWJHFFQUJDthO2izcZzm+S7jzYb2mxos6HNhjYb2mxos6HNhrZdAwsMOSCRSGjq1KlKJBLZTqmGNhvPbZLvPtpsaLOhzYY2G9psaLOhzYY2G9psstHEAgMAAAAAAKg1FhgAAAAAAECtscAAAAAAAABqjatIZICHq0gkEgnF43F3O5vSZuO5TfLdR5sNbTa02dBmQ5sNbTa02dBmQ5sNV5FAvSkvL892wnbRZuO5TfLdR5sNbTa02dBmQ5sNbTa02dBmQ9uugQWGHJBIJDRr1iy3O5vSlj7PbZLvPtpsaLOhzYY2G9psaLOhzYY2G9psuIoEAAAAAADYJbHAAAAAAAAAao0FhhwRj8eznbBdtNl4bpN899FmQ5sNbTa02dBmQ5sNbTa02dC2a+AqEhmQ7atIAAAAAABySzZ+DuUVDDkghKDVq1fL41oSbTae2yTffbTZ0GZDmw1tNrTZ0GZDmw1tNrTZZKOJBYYckEgkNGfOHLc7m9KWPs9tku8+2mxos6HNhjYb2mxos6HNhjYb2my4igQAAAAAANglscAAAAAAAABqjQWGHBBFkYqKihRFUbZTqqHNxnOb5LuPNhvabGizoc2GNhvabGizoc2GNptsNHEViQzgKhIAAAAAgEzKxs+heRl5FmRVMpnUF198oRYtWigWq/lFKw/Nf1jLyz5N/bltURtd3PUiF23ZQpud5z7abGiz2V3btv2aUeeC1KSsidYWrZW288uX2nydSqe/b/E+OrX9Kf/3OVu19S3Z5mMZtu0Y7Opzuq1sfi9iPUYk7bA5ncduW9hGJzcdam6r8lg7MZ5pPbZhTndGuvNeY3M9tX2dne2u768LdfXvW33821sbu+vX0/qWTCYz/pwsMOSAZDKpBQsWqFmzZts96JeXfapPNizOcNnOtWULbXae+2izoc1md22r768Z8RDXAV/tr9l7zFEiqvsdsNPpb1PYusrnbN3Wpqjqx7Itl+e0NmoaN+sxsjPSeewoGWnBF/a2dKXz2F7mtKZmL201qe+vC3X171uujVtteG/LNF8jAAAAAAAAdkksMAAAAAAAgFpjgSEHRFGk4uJitzub0pY+z22S7z7abGizoc0mKGh1fqmC/O1D7bmNObXxPG6S3LZ5nlPPbZ6PN8bNxntbprEHQw6Ix+Pq1atXtjNqRJuN5zbJdx9tNrTZ0GaTjJKa3WRutjNq5LmNObXxPG4hFty2eZ5Tz22ejzfGzcZ7W6bxCoYckEwmtXTp0qxs8rEjtNl4bpN899FmQ5sNbTZRiNSubE9FweFvgxy3Mac2nsdNQW7bPM+p5zbPxxvjZuO9LdNYYMgB3g962tLnuU3y3UebDW02tNnEFFP7sj0Vc/htiuc25tTG87hFIXLb5nlOPbd5Pt4YNxvvbZnm7+gBAAAAAAC7HBYYAAAAAABArbHAkANisZhatmypWMzfdNNm47lN8t1Hmw1tNrTZJJXUigYrlZTDl5s6bmNObTyPmyK5bfM8p57bPB9vjJuN97ZM4yoSOSAWi6lr167ZzqgRbTae2yTffbTZ0GZDm02IguY3WpjtjBp5bmNObbyPm+c2r3Pquc378ca4pc97W8afM+PPiIxLJpOaP3++241HaEuf5zbJdx9tNrTZ0GYThUhd13d2uZO55zbm1Mb7uHlu8zqnntu8H2+MW/q8t2UaCww5IJlMauXKlW4PetrS57lN8t1Hmw1tNrTZxBRTq00tXe5k7rmNObXxPG4KctvmeU49t3k+3hg3G+9tmebv6AEAAAAAALscFhgAAAAAAECtscCQA2KxmNq1a+d2Z1Pa0ue5TfLdR5sNbTa02SSV1JKiZS53MvfcxpzaeB63EAW3bZ7n1HOb5+ONcbPx3pZpXEUiB1Qe9B7RZuO5TfLdR5sNbTa02YQoaGnRsmxn1MhzG3Nq43ncFMltm+c59dzm+Xhj3Gy8t2X8OTP+jMi4RCKh2bNnK5FIZDulGtpsPLdJvvtos6HNhjabWIip19oeigV/36Z4bmNObTyPW5SM3LZ5nlPPbZ6PN8bNxntbpvk7elDnQggqLS1VCCHbKdXQZuO5TfLdR5sNbTa02USKVLK5WJH8XSrNcxtzauN53CS5bfM8p57bPB9vjJuN97ZMY4EBAAAAAADUGgsMAAAAAACg1lhgyAGxWExdunRxu7Mpbenz3Cb57qPNhjYb2mySSmp+o4UudzL33Mac2ngetxAFt22e59Rzm+fjjXGz8d6WaVxFIgfEYjG1atUq2xk1os3Gc5vku482G9psaLMJUdCKBiuznVEjz23MqY3ncVMkt22e59Rzm+fjjXGz8d6W8efM+DMi4xKJhGbOnOl2Z1Pa0ue5TfLdR5sNbTa02cRCTPuW9nG5k7nnNubUxvO4RcnIbZvnOfXc5vl4Y9xsvLdlmr+jB3UuhKCysjK3O5vSlj7PbZLvPtpsaLOhzSZSpKJEkcudzD23Mac2nsdNkts2z3Pquc3z8ca42XhvyzQWGAAAAAAAQK2xwAAAAAAAAGqNBYYcEI/H1bNnT8Xj8WynVEObjec2yXcfbTa02dBmk1BCs5vMVUIO38/quI05tfE8biEKbts8z6nnNs/HG+Nm470t07iKRA6IokglJSXZzqgRbTae2yTffbTZ0GZDm1Ekrc4vzXZFzRy3Mac23sfNc5vXOfXc5v14Y9zS570t03gFQw6oqKjQlClTVFFRke2Uamiz8dwm+e6jzYY2G9ps4iGuA77aX/Hg8LdBjtuYUxvP4xYlI7dtnufUc5vn441xs/HelmksMOQIj5dNqUSbjec2yXcfbTa02dBm4/Eb3Eqe25hTG8/j5rnN85x6bmNObTyPm+e2TGOBAQAAAAAA1BoLDAAAAAAAoNZYYMgB8Xhcffv2dbuzKW3p89wm+e6jzYY2G9psEkpoRvF7Lncy99zGnNp4HrcQBbdtnufUc5vn441xs/HelmksMOSIgoKCbCdsF202ntsk33202dBmQ5tNeaw82wnb5bmNObXxPG6e2zzPqec25tTG87h5bss0FhhyQCKR0NSpU11uPkKbjec2yXcfbTa02dBmE9f/djKXw98GOW5jTm08j1sUIrdtnufUc5vn441xs/HelmksMAAAAAAAgFpjgQEAAAAAANQaCwwAAAAAAKDWWGDIAfF4XAMGDHC7sylt6fPcJvnuo82GNhvabBJK6J09prncydxzG3Nq43ncQhTctnmeU89tno83xs3Ge1umscCQI8rL/e4IS5uN5zbJdx9tNrTZ0GZTkPS7I7fnNubUxvO4eW7zPKee25hTG8/j5rkt01hgyAGJREKzZs1yu7Mpbenz3Cb57qPNhjYb2mziimvf0j4udzL33Mac2ngetyhEbts8z6nnNs/HG+Nm470t01hgAAAAAAAAtcYCAwAAAAAAqDUWGHKEx01HKtFm47lN8t1Hmw1tNrTZJCJ/LzWt5LmNObXxPG6e2zzPqec25tTG87h5bsu0vGwHoP7l5eVp4MCB2c6oEW02ntsk33202dBmQ5tNItqyk7lHntuYUxvP4xZiwW2b5zn13Ob5eGPcbLy3ZRqvYMgBIQStXr1aIYRsp1RDm43nNsl3H202tNnQZhSkks3FksM0z23MqY33cfPc5nVOPbd5P94Yt/R5b8s0FhhyQCKR0Jw5c9zubEpb+jy3Sb77aLOhzYY2m7ji6rW2h8udzD23Mac2nsctCpHbNs9z6rnN8/HGuNl4b8s0FhgAAAAAAECtscAAAAAAAABqjQWGHBBFkYqKihRFUbZTqqHNxnOb5LuPNhvabGizCQoqi5cpOHwjsOc25tTG87hJctvmeU49t3k+3hg3G+9tmcZVJHJAPB5Xv379sp1RI9psPLdJvvtos6HNhjabZJTUjOL3sp1RI89tzKmN53ELsaB++/hs8zynnts8H2+Mm433tkzjFQw5IJlMasWKFUomk9lOqYY2G89tku8+2mxos6HNJgqRWm1qqSg4/G2Q4zbm1MbzuCnIbZvnOfXc5vl4Y9xsvLdl2m63wDBs2DANHTq0Vo8xefJkRVGk1atX10lTtiWTSS1YsMDtQU9b+jy3Sb77aLOhzYY2m5hi6rq+s2IOv03x3Mac2ngetyhEbts8z6nnNs/HG+Nm470t07J69AwbNkxRFCmKIhUUFKhbt2762c9+poqKCvNj3nfffRo3blzdRQIAAAAAgB3K+h4MQ4YM0dixY7Vp0ya98MILGjFihPLz83XjjTem9TiJREJRFKm4uLieSgEAAAAAwPZk/fUvDRo0UOvWrdWxY0ddcsklOvLII/Xcc89p06ZNGjVqlPbcc081atRIBx54oCZPnpz6vHHjxqmkpETPPfecevfurQYNGmjx4sXV3iKxadMmXXHFFWrVqpUKCwt1yCGHaMqUKVUaXnjhBXXv3l1FRUU6/PDDtWjRoiof/+STT3T88cdrjz32UKNGjbT33nvrhRdeqMdRqVuVCy9edzalLX2e2yTffbTZ0GZDm01Q0Or8Upc7mXtuY05tPI+bJLdtnufUc5vn441xs/HelmlZfwXDtoqKivTll1/qsssu04cffqinn35abdu21TPPPKMhQ4bovffe01577SVJ2rBhg+6880797ne/U/PmzdWqVatqj3fddddp/Pjxeuyxx9SxY0fdddddOuqoozRv3jw1a9ZMS5Ys0cknn6wRI0booosu0tSpU3XNNddUeYwRI0aovLxcr732mho1aqQPP/xQjRs33u7fYdOmTdq0aVPqz2vWrKmj0bGJx+Pq1atXVhu2hzYbz22S7z7abGizoc0mGSU1u8ncbGfUyHMbc2rjedxCLLht8zynnts8H2+Mm433tkzL+isYKoUQ9M9//lOTJk1S3759NXbsWP3lL3/RoEGD1LVrV40aNUqHHHKIxo4dm/qczZs36ze/+Y0OOugg9ejRQw0bNqzymOvXr9eDDz6oX/ziFzr66KPVu3dvPfLIIyoqKtLvf/97SdKDDz6orl27asyYMerRo4fOPvtsDRs2rMrjLF68WAcffLD69OmjLl266LjjjtOhhx663b/L7bffruLi4tR/7du3r7uBMkgmk1q6dKnbjUdoS5/nNsl3H202tNnQZhOFSO3K9nS5k7nnNubUxvO4Kchtm+c59dzm+Xhj3Gy8t2Va1hcYnn/+eTVu3FiFhYU6+uijdcYZZ+jUU09VIpFQ9+7d1bhx49R///73vzV//vzU5xYUFKhv377bfez58+dr8+bNOvjgg1O35efn64ADDtDs2bMlSbNnz9aBBx5Y5fO+9a1vVfnzFVdcoVtvvVUHH3ywbr75Zs2aNetr/0433nijSktLU/8tWbJkp8ejPng/6GlLn+c2yXcfbTa02dBmE1NM7cv2dLmTuec25tTG87hFIXLb5nlOPbd5Pt4YNxvvbZmW9bdIHH744XrwwQdVUFCgtm3bKi8vT3/6058Uj8c1bdq0ai/r2PqtCUVFRRl5X8kPfvADHXXUUfrHP/6hl156SbfffrvGjBmjyy+/vMb7N2jQQA0aNKj3LgAAAAAAvMj68lSjRo3UrVs3dejQQXl5W9Y7+vfvr0QioRUrVqhbt25V/mvduvVOP3bXrl1VUFCgN998M3Xb5s2bNWXKFPXu3VuS1KtXL73zzjtVPu/tt9+u9ljt27fXxRdfrAkTJuiaa67RI488YvnrAgAAAACwW8r6AkNNunfvrrPPPlvnnnuuJkyYoIULF+qdd97R7bffrn/84x87/TiNGjXSJZdcomuvvVYTJ07Uhx9+qAsvvFAbNmzQBRdcIEm6+OKL9fHHH+vaa6/V3Llz9dRTT2ncuHFVHmfkyJGaNGmSFi5cqHfffVevvvqq2408ahKLxdSyZUvFYv6mmzYbz22S7z7abGizoc0mqaRWNFippBy+3NRxG3Nq43ncFMltm+c59dzm+Xhj3Gy8t2Va1t8isT1jx47VrbfeqmuuuUbLli1TixYt9M1vflPHHXdcWo9zxx13KJlM6pxzztHatWs1YMAATZo0SXvssYckqUOHDho/fryuuuoq3X///TrggAP085//XMOHD089RiKR0IgRI7R06VI1bdpUQ4YM0T333FOnf9/6FIvF1LVr12xn1Ig2G89tku8+2mxos6HNJkRB8xstzHZGjTy3Mac23sfNc5vXOfXc5v14Y9zS570t48+Z8Wfcyrhx4/S3v/2txo/l5+frlltu0cKFC1VeXq7ly5drwoQJ6tOnjyRp2LBhWr169Q4fs7CwUL/61a+0cuVKbdy4UW+88YYGDhxY5XOOO+44ffzxx9q4caNee+01nX/++QohqKSkRJJ0//33a968edq4caNWrFihxx9/XM2bN6+LIciIZDKp+fPnu914hLb0eW6TfPfRZkObDW02UYjUdX1nlzuZe25jTm28j5vnNq9z6rnN+/HGuKXPe1um+XsdB+pcMpnUypUr3R70tKXPc5vku482G9psaLOJKaZWm1q63MnccxtzauN53BTkts3znHpu83y8MW423tsyzd/RAwAAAAAAdjksMAAAAAAAgFpjgSEHxGIxtWvXzu3OprSlz3Ob5LuPNhvabGizSSqpJUXLXO5k7rmNObXxPG4hCm7bPM+p5zbPxxvjZuO9LdPcXkUCdafyoPeINhvPbZLvPtpsaLOhzSZEQUuLlmU7o0ae25hTG8/jpkhu2zzPqec2z8cb42bjvS3jz5nxZ0TGJRIJzZ49W4lEItsp1dBm47lN8t1Hmw1tNrTZxEJMvdb2UCz4+zbFcxtzauN53KJk5LbN85x6bvN8vDFuNt7bMs3f0YM6F0JQaWmpQgjZTqmGNhvPbZLvPtpsaLOhzSZSpJLNxYrk71JpntuYUxvP4ybJbZvnOfXc5vl4Y9xsvLdlGgsMAAAAAACg1lhgAAAAAAAAtcYCQw6IxWLq0qWL251NaUuf5zbJdx9tNrTZ0GaTVFLzGy10uZO55zbm1MbzuIUouG3zPKee2zwfb4ybjfe2TOMqEjkgFoupVatW2c6oEW02ntsk33202dBmQ5tNiIJWNFiZ7YwaeW5jTm08j5siuW3zPKee2zwfb4ybjfe2jD9nxp8RGZdIJDRz5ky3O5vSlj7PbZLvPtpsaLOhzSYWYtq3tI/Lncw9tzGnNp7HLUpGbts8z6nnNs/HG+Nm470t0/wdPahzIQSVlZW53dmUtvR5bpN899FmQ5sNbTaRIhUlilzuZO65jTm18Txukty2eZ5Tz22ejzfGzcZ7W6axwAAAAAAAAGqNBQYAAAAAAFBrLDDkgHg8rp49eyoej2c7pRrabDy3Sb77aLOhzYY2m4QSmt1krhJy+H5Wx23MqY3ncQtRcNvmeU49t3k+3hg3G+9tmcZVJHJAFEUqKSnJdkaNaLPx3Cb57qPNhjYb2owiaXV+abYraua4jTm18T5untu8zqnnNu/HG+OWPu9tmcYrGHJARUWFpkyZooqKimynVEObjec2yXcfbTa02dBmEw9xHfDV/ooHh78NctzGnNp4HrcoGblt8zynnts8H2+Mm433tkxjgSFHeLxsSiXabDy3Sb77aLOhzYY2G4/f4Fby3Mac2ngeN89tnufUcxtzauN53Dy3ZRoLDAAAAAAAoNZYYAAAAAAAALXGAkMOiMfj6tu3r9udTWlLn+c2yXcfbTa02dBmk1BCM4rfc7mTuec25tTG87iFKLht8zynnts8H2+Mm433tkxjgSFHFBQUZDthu2iz8dwm+e6jzYY2G9psymPl2U7YLs9tzKmN53Hz3OZ5Tj23Mac2nsfNc1umscCQAxKJhKZOnepy8xHabDy3Sb77aLOhzYY2m7j+t5O5HP42yHEbc2rjedyiELlt8zynnts8H2+Mm433tkxjgQEAAAAAANQaCwwAAAAAAKDWWGAAAAAAAAC1xgJDDojH4xowYIDbnU1pS5/nNsl3H202tNnQZpNQQu/sMc3lTuae25hTG8/jFqLgts3znHpu83y8MW423tsyjQWGHFFe7ndHWNpsPLdJvvtos6HNhjabgqTfHbk9tzGnNp7HzXOb5zn13Mac2ngeN89tmcYCQw5IJBKaNWuW251NaUuf5zbJdx9tNrTZ0GYTV1z7lvZxuZO55zbm1MbzuEUhctvmeU49t3k+3hg3G+9tmcYCAwAAAAAAqDUWGAAAAAAAQK2xwJAjPG46Uok2G89tku8+2mxos6HNJhH5e6lpJc9tzKmN53Hz3OZ5Tj23Mac2nsfNc1um5WU7APUvLy9PAwcOzHZGjWiz8dwm+e6jzYY2G9psEtGWncw98tzGnNp4HrcQC27bPM+p5zbPxxvjZuO9LdN4BUMOCCFo9erVCiFkO6Ua2mw8t0m++2izoc2GNqMglWwulhymeW5jTm28j5vnNq9z6rnN+/HGuKXPe1umscCQAxKJhObMmeN2Z1Pa0ue5TfLdR5sNbTa02cQVV6+1PVzuZO65jTm18TxuUYjctnmeU89tno83xs3Ge1umscAAAAAAAABqjQUGAAAAAABQayww5IAoilRUVKQoirKdUg1tNp7bJN99tNnQZkObTVBQWbxMweEbgT23Mac2nsdNkts2z3Pquc3z8ca42XhvyzSuIpED4vG4+vXrl+2MGtFm47lN8t1Hmw1tNrTZJKOkZhS/l+2MGnluY05tPI9biAX128dnm+c59dzm+Xhj3Gy8t2Uar2DIAclkUitWrFAymcx2SjW02Xhuk3z30WZDmw1tNlGI1GpTS0XB4W+DHLcxpzaex01Bbts8z6nnNs/HG+Nm470t01hgyAHJZFILFixwe9DTlj7PbZLvPtpsaLOhzSammLqu76yYw29TPLcxpzaexy0Kkds2z3Pquc3z8ca42XhvyzR/Rw8AAAAAANjlsMAAAAAAAABqjQWGHBBFkYqLi93ubEpb+jy3Sb77aLOhzYY2m6Cg1fmlLncy99zGnNp4HjdJbts8z6nnNs/HG+Nm470t07iKRA6Ix+Pq1atXtjNqRJuN5zbJdx9tNrTZ0GaTjJKa3WRutjNq5LmNObXxPG4hFty2eZ5Tz22ejzfGzcZ7W6bxCoYckEwmtXTpUrcbj9CWPs9tku8+2mxos6HNJgqR2pXt6XInc89tzKmN53FTkNs2z3Pquc3z8ca42XhvyzQWGHKA94OetvR5bpN899FmQ5sNbTYxxdS+bE+XO5l7bmNObTyPWxQit22e59Rzm+fjjXGz8d6Waf6OHgAAAAAAsMthgQEAAAAAANQaCww5IBaLqWXLlorF/E03bTae2yTffbTZ0GZDm01SSa1osFJJOXy5qeM25tTG87gpkts2z3Pquc3z8ca42XhvyzSuIpEDYrGYunbtmu2MGtFm47lN8t1Hmw1tNrTZhChofqOF2c6okec25tTG+7h5bvM6p57bvB9vjFv6vLdlGgsMOSCZTGrhwoXq3Lnzdg+ytkVtvvbP9WVn2rKFNjvPfbTZ0Gazu7bV99eIKERqUdpcXxR/qRDVfD322jSk87ktG7So8jlbt237sUzb9nl39TnNdFOlmsatNsfIjqTz2G0btNH8+fPNbek+bzqPbZnTnZHu36+m+9dXW7odNanvrwt19e9bffzbWxu769fT+paNTR6jEEJmzroctmbNGhUXF6u0tFRNmzbN+PNXVFRo6tSpGjBggPLyfK0p0WbjuU3y3UebDW02tNnQZkObDW02tNnQZkObzapVq9S8efOM/hzqa4kFAAAAAADsklhgAAAAAAAAtcYCQw6IxWJq166du/cESbRZeW6TfPfRZkObDW02tNnQZkObDW02tNnQZpONJvZgyIBs78EAAAAAAMgt2fg51N8yC+pcIpHQ7NmzlUgksp1SDW02ntsk33202dBmQ5sNbTa02dBmQ5sNbTa02WSjiQWGHBBCUGlpqTy+WIU2G89tku8+2mxos6HNhjYb2mxos6HNhjYb2myy0cQCAwAAAAAAqDUWGAAAAAAAQK2xwJADYrGYunTp4nZnU9rS57lN8t1Hmw1tNrTZ0GZDmw1tNrTZ0GZDmw1XkdhNcRUJAAAAAEAmcRUJ1ItEIqGZM2e63dmUtvR5bpN899FmQ5sNbTa02dBmQ5sNbTa02dBmw1UkUC9CCCorK3O7sylt6fPcJvnuo82GNhvabGizoc2GNhvabGizoc2Gq0gAAAAAAIBdEgsMAAAAAACg1tjkMQOyvcljCEGlpaUqLi5WFEUZf/6vQ5uN5zbJdx9tNrTZ0GZDmw1tNrTZ0GZDmw1tNqWlpSopKcnoz6EsMGRAthcYAAAAAAC5hatIoF5UVFRoypQpqqioyHZKNbTZeG6TfPfRZkObDW02tNnQZkObDW02tNnQZpONJhYYcoTHy6ZUos3Gc5vku482G9psaLOhzYY2G9psaLOhzYa2XQMLDAAAAAAAoNZYYAAAAAAAALXGJo8ZkO1NHkMIKisrU1FRkbudTWmz8dwm+e6jzYY2G9psaLOhzYY2G9psaLOhzSYbV5HgFQw5oqCgINsJ20Wbjec2yXcfbTa02dBmQ5sNbTa02dBmQ5sNbbsGFhhyQCKR0NSpU11uPkKbjec2yXcfbTa02dBmQ5sNbTa02dBmQ5sNbTbZaGKBAQAAAAAA1BoLDAAAAAAAoNZYYAAAAAAAALXGVSQywMNVJBKJhOLxuLudTWmz8dwm+e6jzYY2G9psaLOhzYY2G9psaLOhzYarSKDelJeXZzthu2iz8dwm+e6jzYY2G9psaLOhzYY2G9psaLOhbdfAAkMOSCQSmjVrltudTWlLn+c2yXcfbTa02dBmQ5sNbTa02dBmQ5sNbTZcRQIAAAAAAOyS8rIdAB+umvQPzVu1KvXnbs2a6Z6jjs1iEQDAq22/ZtS1uKQjGhTpjr98rO397qU2X6fS6R/csZOuOWhQ6nO2bhu0zccyrS6/VnuY021lao4tbVvb+hiRtMPmdNq677GHTitpYf78re3MeGZy3LYn3Xmvqbm+2r6Ol++d6+rft/r4txe5gQWGHBGPx7/24/NWrdIHK1dkqKaqHbVlE212nvtos6HNZndsq++vGflRpP7NW2n2lyu1uR72ok6nv+sezap8ztZtnbb5mAe5OqfbSufvU9u2rY+Rum6LS4o3/4b589OVyXGrKzU1e2nbnvr8ulBX/77l2rjVlue2TGOBIQfk5eVp4MCB2c6oEW02ntsk33202dBmQ5vN5hD02BefZzujRp7bmFMbz20JiTk18NzGeWrjedy8t2UaezDkgBCCVq9eLY9XJKXNxnOb5LuPNhvabGiziSS1K2ggXxf72sJzG3Nq472NOU2f5zbOUxvP4+a9LdNYYMgBiURCc+bMcbuzKW3p89wm+e6jzYY2G9ps8qJIQ4qbKc/Z9cQl323MqY3ntpjEnBp4buM8tfE8bt7bMo0FBgAAAAAAUGssMAAAAAAAgFpjgSEHRFGkoqIiRQ5f7kSbjec2yXcfbTa02dBmE4L0VaJCDt/O6rqNObXx3CaJOTXw3MZ5auN53Ly3ZRpXkcgB8Xhc/fr1y3ZGjWiz8dwm+e6jzYY2G9psKhQ0ftXKbGfUyHMbc2rjuS0hMacGnts4T208j5v3tkzjFQw5IJlMasWKFUomk9lOqYY2G89tku8+2mxos6HNJiapR2GRy29SPLcxpzae2yKJOTXw3MZ5auN53Ly3ZZrH4wd1LJlMasGCBW4PetrS57lN8t1Hmw1tNrTZxKNIg5qUKO7w5aae25hTG89tMYk5NfDcxnlq43ncvLdlGgsMAAAAAACg1lhgAAAAAAAAtcYCQw6IokjFxcVudzalLX2e2yTffbTZ0GZDm00I0tLyTS53MvfcxpzaeG6TxJwaeG7jPLXxPG7e2zKNq0jkgHg8rl69emU7o0a02Xhuk3z30WZDmw1tNhUKmli6KtsZNfLcxpzaeG5LSMypgee23eU8DSGooqJCiUSinqv+T+fOnbV582Zt3rw5Y8+5s7LVFo/HlZeXt92FhGxcRYIFhhyQTCa1fPlytW3bVrGYrxet0GbjuU3y3UebDW02tNnEJO3bsLFmbFgnb1tmbd3mDXNq47ktkrR06VLmNE2e23aH87S8vFyffvqpNmzYkKk0hRCUSCQUj8fdvVIg220NGzZUmzZtVFBQUO1j2djkkQWGHJBMJrV06VK1bt3a3T9ktNl4bpN899FmQ5sNbTbxKNJ+jZrovbL1Sjp7re7Wbd4wpzae22ISc2rguW1XP0/jkhYuXKh4PK62bduqoKAgIz9UhxC0YcMGNWzY0OUCQzbaQggqLy/XypUrtXDhQu21117VjikWGAAAAAAALhXnFyiZTKp9+/Zq2LBhxp638lUChYWFLhcYstVWVFSk/Px8ffLJJyovL1dhYWFGn78mvpbNAAAAAAAuVf7w6O3VF7nM21z4qkG9iMViatmypbuDT6LNynOb5LuPNhvabGizSYaguRs3uHtps+S7jTm18dwWJObUwHMb56ldXp7fF997bcvGceZzJFCnYrGYunbtmu2MGtFm47lN8t1Hmw1tNrTZJCS9vrY02xk18tzGnNp4bktKzKmB5zbOU5soily8/L8mntuyscDgb+kMdS6ZTGr+/PlZ2eRjR2iz8dwm+e6jzYY2G9ps4pIGNSlW5i+utWOe25hTG89tMYk5NfDcxnlqE0LQxo0bFRy+umLbtmHDhmno0KHZjfqfbBxnLDDkgGQyqZUrV7r8h4w2G89tku8+2mxos6HNJhZF6lHYUDFnG3lJvtuYUxvPbZHEnBp4buM83Xnb/qBeUVGRvZgd8NrGAgMAAAAAANglscAAAAAAANhlvP/++zr66KPVuHFjfeMb39A555yjL774IvXxtWvX6uyzz1ajRo3Upk0b3XPPPRo8eLBGjhyZus+mTZs0atQo7bnnnmrUqJEOPPBATZ48OfXxcePGqaSkRJMmTVKvXr3UuHFjDRkyRJ9++mnqPolEQldffbXatWunFi1a6LrrrnP5No5MYoEhB8RiMbVr187lbrW02Xhuk3z30WZDmw1tNokQ9O76tUo4/CbNcxtzauO5LSkxpwae2zhP7QoKCiRJq1ev1re//W31799fU6dO1cSJE/X555/r9NNPT9336quv1ptvvqnnnntOL7/8sl5//XW9++67VR7vsssu03/+8x89/fTTmjVrlk477TQNGTJEH3/8ceo+GzZs0C9/+Us98cQTeu2117R48WKNGjUq9fExY8boscce08MPP6zXX39dq1at0jPPPFPPI7HzuIoE6kXlP2Qe0WbjuU3y3UebDW02tNkkJb27YV22M2rkuY05tfHcFiTm1MBzG+epTRRFqQWGX//61+rfv79+/vOfpz7+6KOPqn379vroo4/Upk0bPfbYY3rqqad0xBFHSJLGjh2rtm3bpu6/ePFijR07VosXL07dPmrUKE2cOFFjx45NPfbmzZv10EMPpa78cdlll+lnP/tZ6nHuvfde3XjjjanFjYceekiTJk2qx5FID1eRQL1IJBKaPXu2EolEtlOqoc3Gc5vku482G9psaLPJU6Qhxc2UJx8bjW3NcxtzauO5LS4xpwae2zhPbUIIKisrUwhBM2fO1KuvvqrGjRun/uvZs6ekLVddWbBggTZv3qwDDjgg9fnFxcXq0aNH6s/vvfeeEomEunfvXuVx/v3vf2v+/Pmp+zVs2LDKZUXbtGmjFStWSJJKS0v16aef6oADDki15eXlacCAAfU9HDstG8cZr2DIASEElZaWunw/EG02ntsk33202dBmQ5tNFEntChooirTlV7iOVGlzhjm18dwmiTk18NzGeWpX+cPyunXrdPzxx+vOO++sdp82bdpo3rx5O3ysdevWKR6Pa9q0aYrHq16Ys3Hjxqn/n5+fX+VjURTVOHceF4wkZeU4Y4EBAAAAALBL2G+//TR+/Hh16tRJeXnVf5zt0qWL8vPzNWXKFHXo0EHSloW6jz76SIceeqgkqX///kokElqxYoUGDRpk6iguLlabNm303//+V/vvv7+kLZernDZtmvbbbz/j327XxwIDAAAAAMCd0tJSzZgxI/UWiaKiIl100UV65JFHdOaZZ+q6665Ts2bNNG/ePD399NP63e9+pyZNmui8887Ttddeq2bNmqlVq1a6+eabFYvFFP3v5Wfdu3fX2WefrXPPPVdjxoxR//79tXLlSr3yyivq27evjj322J3qu/LKK3XnnXeqffv22nfffXXPPfdo9erV9Tgi/rHAkANisZi6dOnicrda2mw8t0m++2izoc2GNptECHp97WqXO5l7bmNObTy3JSXm1MBzG+dpeiZPnqz+/ftXue2CCy7Qm2++qeuvv17f/e53tWnTJnXs2FFDhgxJjevdd9+tiy++WMcdd5yaNm2q6667TkuWLFFhYWHqccaOHatbb71V11xzjZYtW6YWLVrom9/8po477rid7rvmmmu0fPlyXXzxxYrFYho+fLhOOukklZaW1s0A1BJXkUC9iMViatWqVbYzakSbjec2yXcfbTa02dBmk5Q0d2NZtjNq5LmNObXx3BYk5tTAcxvn6c4bN26cxo0bt92PT5gwYbsfa9KkiZ588snUn9evX69bbrlFF110Ueq2/Px83XLLLbrllltqfIxhw4Zp2LBhVW4bOnRolX0N8vLydN999+m+++7bwd8mO7iKBOpFIpHQzJkzXW4+QpuN5zbJdx9tNrTZ0GaTp0inNGvpcidzz23MqY3ntrjEnBp4buM8tQkhaMOGDTu9aeH06dP1xz/+UfPnz9e7776rs88+W5J04oknZr0tk7iKBOrF1pd18YY2G89tku8+2mxos6HNJoqkPeJ5Lncyr9LmDHNq47lNEnNq4LmN89QumUymdf9f/vKXmjt3rgoKCrT//vvr9ddfV4sWLVy0ZQpXkQAAAAAAoBb69++vadOmZTsjJ/EWCQAAAAAAUGssMOSAeDyunj17Kh6PZzulGtpsPLdJvvtos6HNhjabihA0sXSVKhy+hNhzG3Nq47ktKTGnBp7bOE/ttr4ChDde27JxnO30WyROPvnknX7Qr9vRE5kXRZFKSkqynVEj2mw8t0m++2izoc2GNpsgaWn5pmxn1MhzG3Nq472NOU2f5zbOU5soipSX5/Pd/d7bMm2nX8FQXFyc+q9p06Z65ZVXNHXq1NTHp02bpldeeUXFxcX1Egq7iooKTZkyRRUVFdlOqYY2G89tku8+2mxos6HNJj+KdF6Lbyjf4U6KntuYUxvPbXGJOTXw3MZ5ahNC0Pr1611ujum5LRvH2U4vtYwdOzb1/6+//nqdfvrpeuihh1Ivu0gkErr00kvVtGnTuq9ErXm8FE4l2mw8t0m++2izoc2GNpv8yO+7OD23Mac2ntuYUxvPbcypjccf4Ct5bss002s5Hn30Ub3xxhtV3tMRj8d19dVX66CDDtIvfvGLOgsEAAAAAPj22co1Kl1bVi+PXXl5z6KidamX/Rc3KVLrlvxy2xvTAkNFRYXmzJmjHj16VLl9zpw5bq8BCgAAAACoe5+tXKOzLv+9yjdn7tUZBflxPXX/BXW2yNCpUyeNHDlSI0eOrJPHy1Wm18Ccf/75uuCCC3T33XfrjTfe0BtvvKExY8boBz/4gc4///y6bkQtxeNx9e3b1+VutbTZeG6TfPfRZkObDW02FSHor6tWutzJ3HMbc2rjuS0hMacGntt21/O0dG1ZRhcXJKl8cyKtV0y89tprOv7449W2bVtFUaS//e1vddZSVFRUZ49Vl1xfRWJrv/zlL9W6dWuNGTNGn376qSSpTZs2uvbaa3XNNdfUaSDqRkFBQbYTtos2G89tku8+2mxos6EtfUHS+mRC/n408N0mMacWntsk5tTCc5vEnGbL+vXr1a9fPw0fPjytKyR+nc2bNysvL0+xmN+9KzLNNBKxWEzXXXedli1bptWrV2v16tVatmyZrrvuOpercbkukUho6tSpLjeUoc3Gc5vku482G9psaLPZspN5a5c7mXtuY05tPLfFJebUwHMb52n2HH300br11lt10kknbfc+GzZs0PDhw9WkSRN16NBBDz/8cOpjixYtUhRF+tOf/qTDDjtMhYWFevLJJyVtWbzwKBvHWa2XWpo2bcqVIwAAAAAAu7QxY8ZowIABmj59ui699FJdcsklmjt3bpX73HDDDbryyis1e/ZsHXXUUVkq9cu0wPD555/rnHPOUdu2bZWXl6d4PF7lPwAAAAAAdiXHHHOMLr30UnXr1k3XX3+9WrRooVdffbXKfUaOHKmTTz5ZnTt3Vps2bbJU6pdpD4Zhw4Zp8eLF+slPfqI2bdqkLhUCAAAAAMCuqG/fvqn/H0WRWrdurRUrVlS5z4ABAzKdtUsxLTC88cYbev3117XvvvvWcQ7qQzwe14ABA1y+uoQ2G89tku8+2mxos6HNZnMIeuyLz7TZ4Q7wntuYUxvPbQmJOTXw3MZ56lt+fn6VP0dRpGQyWeW2Ro0aVfu8mm7zIBvHmektEu3bt1fI4QNvV1ReXp7thO2izcZzm+S7jzYb2mxoS18kqVEsLo+vj/TcJjGnFp7bJObUwnObxJzujrZdhMhlpgWGe++9VzfccIMWLVpUxzmoD4lEQrNmzXK5Wy1tNp7bJN99tNnQZkObTV4U6dRmLZXn8C2YntuYUxvPbXGJOTXw3MZ5mj3r1q3TjBkzNGPGDEnSwoULNWPGDC1evLjWj11WVlbrx6gP2TjOTG+ROOOMM7RhwwZ17dpVDRs2rPZSklWrVtVJHAAAAADAt+ImRSrIj6t8c+Z+oC3Ij6u4SdFO33/q1Kk6/PDDU3+++uqrJUnnnXeexo0bV9d5Ocu0wHDvvffWcQYAAAAAYFfUumVTPXX/BSpdWz+/yQ8hqKysTEVFRakLDBQ3KVLrlk13+jEGDx78tW/zr+nV+ZWvdpCkTp06sU3ATjAtMJx33nl13ZF1kydP1uGHH66vvvpKJSUl2c6pcx43kqlEm43nNsl3H202tNnQZrM5+H0/q+c25tTGcxtzauO5bXed09Ytm6b1A386QgjasGGDGjZs6PIKhh6bssW0B4MkzZ8/Xz/+8Y915plnpi7d8eKLL+qDDz6os7iddfvtt2vgwIFq0qSJWrVqpaFDh2ru3Lk13jeEoKOPPlpRFOlvf/tbZkOzJC8vTwMHDlRenmk9qV7RZuO5TfLdR5sNbTa02WzZyfxzlzuZe25jTm08tyUk5tTAcxvnqU0URWrUqJHLH+Q9t2XjODMtMPz73/9Wnz599N///lcTJkzQunXrJEkzZ87UzTffXKeBO9szYsQIvf3223r55Ze1efNmffe739X69eur3ffee++ts8n3ugPstkIIWr16tcuX9NBm47lN8t1Hmw1tNrTZRJLaFTRwuZO55zbm1MZ7G3OaPs9tnKc2IQRVVFS4HDfvbZlmWmC44YYbdOutt+rll19WQUFB6vZvf/vbevvtt+ssbmdNnDhRw4YN0957761+/fpp3LhxWrx4saZNm1blfjNmzNCYMWP06KOPbvexpk2bpgEDBqhhw4Y66KCDqrwSYvTo0dp33331u9/9Tp07d1ZhYWG9/Z3qUiKR0Jw5c1zuVkubjec2yXcfbTa02dBmkxdFGlLczOVO5p7bmFMbz20xiTk18NzGeWq3cePGbCdsl9e2bBxnpgWG9957TyeddFK121u1aqUvvvii1lG1VVpaKklq1qxZ6rYNGzborLPO0gMPPKDWrVtv93NvuukmjRkzRlOnTlVeXp6GDx9e5ePz5s3T+PHjNWHChCqbfmxt06ZNWrNmTZX/AAAAAADYnZnelFFSUqJPP/1UnTt3rnL79OnTteeee9ZJmFUymdTIkSN18MEHa5999kndftVVV+mggw7SiSee+LWff9ttt+mwww6TtOWVGscee6w2btyYerVCeXm5Hn/8cbVs2XK7j3H77bfrlltuqYO/DQAAAAAAuwbTKxi+973v6frrr9dnn32mKIqUTCb15ptvatSoUTr33HPrujEtI0aM0Pvvv6+nn346ddtzzz2nf/3rXzt1ec2+ffum/n+bNm0kKbWJpSR17NjxaxcXJOnGG29UaWlp6r8lS5ak+beoW1EUVbmkiye02Xhuk3z30WZDmw1tNiFIXyUq5PDtrK7bmFMbz22SmFMDz22cp3axmPn6BPXOa1s2jjPTKxh+/vOfa8SIEWrfvr0SiYR69+6tRCKhs846Sz/+8Y/runGnXXbZZXr++ef12muvqV27dqnb//Wvf2n+/PnVLj95yimnaNCgQZo8eXLqtvz8/NT/r5yQZPL/LtfSqFGjHXY0aNBADRo0MP4t6l48Hle/fv2ynVEj2mw8t0m++2izoc2GNpsKBY1ftTLbGTXy3Mac2nhuS0jMqYHnNs5TmyiK1LBhw2xn1MhzWzYuiWpaYCgoKNAjjzyin/zkJ3r//fe1bt069e/fX3vttVdd9+2UEIIuv/xyPfPMM5o8eXK1t27ccMMN+sEPflDltj59+uiee+7R8ccfn8nUrEgmk/riiy/UokULd6trtNl4bpN899FmQ5sNbTYxSXsVFunjjWXydiX7rdu8YU5tPLdF2vJKWuY0PZ7bdufzdNnaNfqqrH7+bQwhKJFIKB6Pp34JvEdRkfZs0rReni8dlVeRyMvLc/fKlK1/UZ4ptbowZocOHdShQ4e6ajEbMWKEnnrqKT377LNq0qSJPvvsM0lScXGxioqK1Lp16xo3duzQoUO1xYjdUTKZ1IIFC9SsWTN3/5DRZuO5TfLdR5sNbTa02cSjSIOalGjBpo1KOnut7tZt3jCnNp7bYhJzauC5bXc9T5etXaMjH39UmzJ41YIG8bj+ee7wjC4yTJ48WYcffri++uqrKq+O37Rpk/LyavWjdb3YZRYYrr766hpvj6JIhYWF6tatm0488cQqV3GoTw8++KAkafDgwVVuHzt2rIYNG5aRBgAAAADIRV+VlWV0cUGSNiUS+qqsbKcXGG6//XZNmDBBc+bMUVFRkQ466CDdeeed6tGjR7X7hhB0zDHHaOLEiXrmmWc0dOjQOq7ffZkWGKZPn653331XiUQiNSEfffSR4vG4evbsqd/85je65ppr9MYbb6h37951GlyTYFiZ3PZzBg8eXO22fffdt8pto0eP1ujRo02NAAAAAIDs+Pe//60RI0Zo4MCBqqio0I9+9CN997vf1Ycfflhtn7177723zt7uUF5eroKCgjp5rF2B6XU5J554oo488kgtX75c06ZN07Rp07R06VJ95zvf0Zlnnqlly5bp0EMP1VVXXVXXvTCIokjFxcXu3hMk0WbluU3y3UebDW02tNmEIC0t3+RyJ3PPbcypjec2Scypgec2ztPsmThxooYNG6a9995b/fr107hx47R48WJNmzatyv1mzJihMWPG6NFHH93uY02bNk0DBgxQw4YNdfDBB2v+/Pmpj40ePVr77ruvfve736lz584qLCyst7/TjmTjODMtMPziF7/Q//t//09Nm/7fy1GKi4s1evRo3XXXXWrYsKF++tOfVpssZEc8HlevXr2ysovojtBm47lN8t1Hmw1tNrTZVChoYukqVcjfd7me25hTG89tCYk5NfDcxnnqR2lpqSRVeVv/hg0bdNZZZ+mBBx6ocQ+/SjfddJPGjBmjqVOnKi8vT5deemmVH+bnzZun8ePHa8KECZoxY0a9/R12JBvHmWmBobS0VCtWrKh2+8qVK7VmzRpJUklJicrLy2tXhzqRTCa1dOnSrGzysSO02Xhuk3z30WZDmw1tNjFJ+zVsbPsmpZ55bmNObTy3RRJzauC5jfPUh2QyqZEjR+rggw/WPvvsk7r9qquu0kEHHaQTTzzxaz//tttu02GHHabevXvr+uuv11tvvaWyra6gUV5erscff1z9+/dX37596+3vsSPZOM7Mb5EYPny4nnnmGS1dulRLly7VM888owsuuCC1AcY777yj7t2712UrjDz/Q0abjec2yXcfbTa02dBmE48i7deoieIOX0LsuY05tfHcFpPfBQbP4+a5jfPUhxEjRuj999/X008/nbrtueee07/+9S/de++9O/z8rRcN2rRpI0lVfgHfsWNHtWzZsu6CjXaZq0j89re/1VVXXaXvfe97qqio2PJAeXk677zzdM8990iSevbsqd/97nd1VwoAAAAAQC1cdtllev755/Xaa6+pXbt2qdv/9a9/af78+VUuPylJp5xyigYNGqTJkyenbsvPz0/9/8q3Rmz9w/y2m0bmEtMCQ+PGjfXII4/onnvu0YIFCyRJXbp0UePGjVP32XfffeskEAAAAACA2ggh6PLLL9czzzyjyZMnq3PnzlU+fsMNN+gHP/hBldv69Omje+65R8cff3wmU3dppgWGSp999pk+/fRTHXrooSoqKlIIweWOqLkuFoupZcuWisX8vaOKNhvPbZLvPtpsaLOhzSYZguZu3KCkw63MPbcxpzae24LEnBp4buM8zZ4RI0boqaee0rPPPqsmTZros88+k7TlYgVFRUVq3bp1jRs7dujQodpixK4iG8eZ6Rm//PJLHXHEEerevbuOOeYYffrpp5KkCy64QNdcc02dBqL2YrGYunbt6vIfMtpsPLdJvvtos6HNhjabhKTX15Yqke2QGnhuY05tPLclJebUwHPb7nqe7lFUpAYZvmJBg3hcexQV7fT9H3zwQZWWlmrw4MFq06ZN6r8//elPteqo/AW7x1+0Z+M4M72C4aqrrlJ+fr4WL16sXr16pW4/44wzdPXVV2vMmDF1FojaSyaTWrhwoTp37uzuHzPabDy3Sb77aLOhzYY2m7ikg5oU6y2HPyBs3eYNc2rjuS0maf78+cxpmjy37a7n6Z5Nmuqf5w7XV1tdSaEuhRC0efNm5efnp36Q36OoSHs2aZrWY1ied2uDBw+udlu/fv1UVlamBg0aSJJGjx6t0aNHp/1c9WGX2eTxpZde0qRJk6psiiFJe+21lz755JM6CUPdSSaTWrlypTp27OjuHzLabDy3Sb77aLOhzYY2m1gUqUdhQ729bo0Szl6qu3WbN8ypjee2SGJODTy37c7n6Z5Nmqb1A386Qghav369GjVq5PKVAhUVFakFBk92mctUrl+/Xg0bNqx2+6pVq1wOLAAAAAAAqF+mBYZBgwbp8ccfT/05iiIlk0ndddddGjx4cF21AQAAAACAXYTpLRJ33XWXjjjiCE2dOlXl5eW67rrr9MEHH2jVqlV6880367oRtRSLxdSuXTt3L8OSaLPy3Cb57qPNhjYb2mwSIejd9WvdvbRZ8t3GnNp4bktKzKmB5zbOU7uCgoJsJ2yX17Zd5ioS++yzjz766CMdcsghOvHEE7V+/XqdfPLJeuedd3TnnXfWdSNqyfM/ZLTZeG6TfPfRZkObDW02SUnvblinzL9zdMc8tzGnNp7bgvwuMHgeN89tnKc2URSpoKDA5f4Lntt2mQUGacv1Qm+66Sb9+c9/1gsvvKBbb71VX331lX7/+9/XZR/qQCKR0OzZs5VIeNtHlzYrz22S7z7abGizoc0mT5GGFDdTnvx9s+a5jTm18dwWl5hTA89tnKc2IQSVlZWZrgRR3zy3ZeM487d0hjoXQlBpaanLg542G89tku8+2mxos6HNJoqkdgUN5PCXQa7bmFMbz22SmFMDz22cp3YeF2UqeW3LxnHGAgMAAAAAAKg10yaPAAAAAABU+nLTl1pbsa5eHrvybQhFKkrtddAkr7GaN2heL88Hu7QWGE4++eSv/fjq1atr04J6EovF1KVLF5ebydBm47lN8t1Hmw1tNrTZJELQ62tXu9zJ3HMbc2rjuS0pMacGntt21/P0y01f6vpZN2lz2FwPZTXLj/J1Z9/bsrrIMGzYMK1evVp/+ctfzI8xefJkHX744frqq69UUlJSd3HKziaPaS0wFBcX7/Dj5557bq2CUPdisZhatWqV7Ywa0WbjuU3y3UebDW02tNkkJc3dWJbtjBp5bmNObTy3BYk5NfDctruep2sr1mV0cUGSNofNWluxbqcXGIYNG6bHHntMkpSfn68OHTro3HPP1Y9+9CPl5dle2H/fffcphKD8/HzT59c39wsMY8eOra8O1KNEIqH3339f++yzj+LxeLZzqqDNxnOb5LuPNhvabGizyVOkE5u10LOrvlCFfP0Gcus2b5hTG89tcUkzZ85kTtPkuY3zNLuGDBmisWPHatOmTXrhhRc0YsQI5efn68Ybb0zrcRKJhKIoUnFxsUII2rBhg4qKitxdqpKrSKBeeL50Cm02ntsk33202dBmQ5tNFEl7xPNc7mTuuY05tfHcJok5NfDcxnmaXQ0aNFDr1q3VsWNHXXLJJTryyCP13HPPadOmTRo1apT23HNPNWrUSAceeKAmT56c+rxx48appKREzz33nHr37q0GDRpo8eLFGjZsmE466SQlk0lJ0qZNm3TFFVeoVatWKiws1CGHHKIpU6ZUaXjhhRfUvXt3FRUV6fDDD9eiRYuqfPyTTz7R8ccfrz322EONGjXS3nvvrRdeeMH09+UqEgAAAAAAZEBRUZHKy8t12WWX6T//+Y+efvppzZo1S6eddpqGDBmijz/+OHXfDRs26M4779Tvfvc7ffDBBzW+1eW6667T+PHj9dhjj+ndd99Vt27ddNRRR2nVqlWSpCVLlujkk0/W8ccfrxkzZugHP/iBbrjhhiqPMWLECG3atEmvvfaa3nvvPd15551q3Lhx/Q5EHeIqEgAAAACAnBFC0CuvvKJJkybpzDPP1NixY7V48WK1bdtWkjRq1ChNnDhRY8eO1c9//nNJ0ubNm/Wb3/xG/fr1q/Ex169frwcffFDjxo3T0UcfLUl65JFH9PLLL+v3v/+9rr32Wj344IPq2rWrxowZI0nq0aNHahGh0uLFi3XKKaeoT58+krZs9LorYYEhB8TjcfXs2dPd+7wk2qw8t0m++2izoc2GNpuKEDSxdJUqHL6E2HMbc2rjuS0pMacGnts4T7Pr+eefV+PGjbV582Ylk0mdddZZOvXUUzVu3Dh17969yn03bdqk5s3/bwPJgoIC9e3bt8bHLSws1AcffKDNmzfr4IMPTt2en5+vAw44QLNnz5YkzZ49WwceeGCVz/3Wt75V5c9XXHGFLrnkEr300ks68sgjdcopp2z3eXckG8cZCww5IIqiOr/kSV2hzcZzm+S7jzYb2mxoswmSlpZvynZGjTy3Mac23tuY0/R5buM8za7DDz9cDz74oAoKCtS2bVvl5eXpT3/6k+LxuKZNm1btB/Kt35rwdZs45uXl1dkGjz/4wQ901FFH6R//+Ideeukl3X777RozZowuv/zytB8rG5tOsgdDDqioqNCUKVNUUVGR7ZRqaLPx3Cb57qPNhjYb2mzyo0jntfiG8h3uNOa5jTm18dwWl5hTA89tnKfZ1ahRI3Xr1k0dOnRIXZqyf//+SiQSWrFihbp161blv9atW+/U465fv15dunRRQUGB3nzzzdTtmzdv1pQpU9S7d29JUq9evfTOO+9U+dy333672uO1b99eF198sSZMmKBrrrlGjzzyiOnvm43jjAWGHJGNS5TsLNpsPLdJvvtos6HNhjab/Mjvtyie25hTG89tzKmN5zbm1Jfu3bvr7LPP1rnnnqsJEyZo4cKFeuedd3T77bfrH//4x049RghBjRo10iWXXKJrr71WEydO1IcffqgLL7xQGzZs0AUXXCBJuvjii/Xxxx/r2muv1dy5c/XUU09p3LhxVR5r5MiRmjRpkhYuXKh3331Xr776qnr16lXXf+16k3tHEAAAAACgzjTJa6z8KD+jz5kf5atJXt1cXWHs2LE699xzdc0116hHjx4aOnSopkyZog4dOqT1OHfccYdOOeUUnXPOOdpvv/00b948TZo0SXvssYckqUOHDho/frz+9re/qV+/fnrooYdSm0hWSiQSGjFihHr16qUhQ4aoe/fu+s1vflMnf89MYA8GAAAAAIBZ8wbNdWff27S2Yl29PH4IQWVlZVX2QWiS11jNGzTfwWf+n21fKbC1/Px83XLLLbrllltq/PiwYcM0bNiwGh8zhKD169dL2rLZ469+9Sv96le/2u5zHXfccTruuOOq3Hb++een/v/999//NX8L/1hgyAHxeFx9+/Z1uVstbTae2yTffbTZ0GZDm01FCPrrqpUudzL33Mac2nhuS0jMqYHntt35PG3eoHlaP/CnI4SgZFFSsVgsKxsX7khRUVG2E2qUjeOMt0jkiIKCgmwnbBdtNp7bJN99tNnQZkNb+oKk9cmE/P1o4LtNYk4tPLdJzKmF5zaJObWKxfz+6Oq5LdMYiRyQSCQ0depUlxvK0GbjuU3y3UebDW02tNls2cm8tcudzD23Mac2ntviEnNq4LmN89Su8m0IHnlty8ZxxgIDAAAAAACoNRYYAAAAAAA7VPn2ieBwf4tc5W0uWGAAAAAAAOzQukSFJGnDhg1ZLkGlyrnIz8/sZUK3h6tI5IB4PK4BAwa43K2WNhvPbZLvPtpsaLOhzWZzCHrsi8+02dlvZSTfbcypjee2hMScGnhu29XP003JpEpKSrRixQpJUsOGDTNyVYcQguLxuDZu3OjuKhLZagshaMOGDVqxYoVKSkpqPKaycZyxwJAjysvL3V4+hTYbz22S7z7abGizoS19kaRGsbhKExXudjPfus0j5jR9ntsk5tTCc5u0689p69atJSm1yJApyWTS7dUastlWUlKSmhMPWGDIAYlEQrNmzdKAAQOUl+drymmz8dwm+e6jzYY2G9ps8qJIpzZr6fI3kFu3ecOc2nhui0vMqYHntt3hPI2iSG3atFGrVq20efPmjLRVVFTo/fff1z777ONu3LLZlp+f/7WvUsjGVSR8zQ4AAAAAwL14PJ6xl+BXVGx51VhhYaHLBQbJZ1s2+HyNCQAAAAAA2KWwwJAjPG4kU4k2G89tku8+2mxos6HNZnNIZjthuzy3Mac2ntuYUxvPbcypjedx89yWabyGIwfk5eVp4MCB2c6oEW02ntsk33202dBmQ5vNlp3MP892Ro08tzGnNp7bEhJzauC5jfPUxvO4eW/LNF7BkANCCFq9erWCs01uJNqsPLdJvvtos6HNhjabSFK7ggbydSGyLTy3Mac23tuY0/R5buM8tfE8bt7bMo0FhhyQSCQ0Z86crOwiuiO02Xhuk3z30WZDmw1tNnlRpCHFzZTn7Frnku825tTGc1tMYk4NPLdxntp4HjfvbZnGAgMAAAAAAKg1FhgAAAAAAECtscCQA6IoUlFRkSKHL3eizcZzm+S7jzYb2mxoswlB+ipRIYdvZ3XdxpzaeG6TxJwaeG7jPLXxPG7e2zKNq0jkgHg8rn79+mU7o0a02Xhuk3z30WZDmw1tNhUKGr9qZbYzauS5jTm18dyWkJhTA89tnKc2nsfNe1um8QqGHJBMJrVixQolk/6ua0ubjec2yXcfbTa02dBmE5PUo7DI5TcpntuYUxvPbZHEnBp4buM8tfE8bt7bMs3j8YM6lkwmtWDBArcHPW3p89wm+e6jzYY2G9ps4lGkQU1KFHf4clPPbcypjee2mMScGnhu4zy18Txu3tsyjQUGAAAAAABQa+zBAElSt2bNvvbPAABUqu+vEXFJTRoUqFeLltreFbxr05DO57Zv2rTK52zdtu3HMq0un9fDnG4rU3NsadtausdBOm1d99ijVp+f7udlctzqomF796+vtnQ7sqGu/n2rj397kRuiEDzuE7p7WbNmjYqLi1VaWqqm/zuRMymRSOijjz5S9+7ds7LRx9ehzcZzm+S7jzYb2mxos6HNhjYb2mxos6HNhjabr776Ss2aNcvoz6EsMGRAthcYAAAAAAC5JRs/h7IHQw5IJpNaunSp241HaEuf5zbJdx9tNrTZ0GZDmw1tNrTZ0GZDmw1tNmzyiHrh/aCnLX2e2yTffbTZ0GZDmw1tNrTZ0GZDmw1tNrTZsMAAAAAAAAB2SSwwAAAAAACAWmOBIQfEYjG1bNlSsZi/6abNxnOb5LuPNhvabGizoc2GNhvabGizoc2GNptsNHEViQzgKhIAAAAAgEziKhKoF8lkUvPnz3e78Qht6fPcJvnuo82GNhvabGizoc2GNhvabGizoc2GTR5RL5LJpFauXOn2oKctfZ7bJN99tNnQZkObDW02tNnQZkObDW02tNmwwAAAAAAAAHZJLDAAAAAAAIBaY4EhB8RiMbVr187tzqa0pc9zm+S7jzYb2mxos6HNhjYb2mxos6HNhjYbriKxm+IqEgAAAACATOIqEqgXiURCs2fPViKRyHZKNbTZeG6TfPfRZkObDW02tNnQZkObDW02tNnQZpONJhYYckAIQaWlpfL4YhXabDy3Sb77aLOhzYY2G9psaLOhzYY2G9psaLPJRhMLDAAAAAAAoNZYYAAAAAAAALXGAkMOiMVi6tKli9udTWlLn+c2yXcfbTa02dBmQ5sNbTa02dBmQ5sNbTZcRWI3xVUkAAAAAACZxFUkUC8SiYRmzpzpdmdT2tLnuU3y3UebDW02tNnQZkObDW02tNnQZkObDVeRQL0IIaisrMztzqa0pc9zm+S7jzYb2mxos6HNhjYb2mxos6HNhjYbriIBAAAAAAB2SSwwAAAAAACAWmOTxwzI9iaPIQSVlpaquLhYURRl/Pm/Dm02ntsk33202dBmQ5sNbTa02dBmQ5sNbTa02ZSWlqqkpCSjP4eywJAB2V5gAAAAAADkFq4igXpRUVGhKVOmqKKiItsp1dBm47lN8t1Hmw1tNrTZ0GZDmw1tNrTZ0GZDm002mlhgyBEeL5tSiTYbz22S7z7abGizoc2GNhvabGizoc2GNhvadg0sMAAAAAAAgFpjgQEAAAAAANQamzxmQLY3eQwhqKysTEVFRe52NqXNxnOb5LuPNhvabGizoc2GNhvabGizoc2GNptsXEUiLyPPgqwrKCj42o/fcu8/9MnSL1N/7tiuuW4eeWx9Z0nacVs20WbnuY82G9psaLP5urZtv2bVtQP7d9YPzx5U4/Mc2L+TLjjjIP3svn/ok6WrMvKc21PT12rvc5rOuGXze5F05mHruZO0w+b05riZbrpsiPnzqz5W3Y9nbcZte+qqsz7avk463fV5ntbFvyFfd55m8rzclvd/37AFCww5IJFIaOrUqRowYIDy8mqe8k+WfqmPFq7IcNnOtWULbXae+2izoc2GNpsdtdX316wOezbb7vN0bLeHpk6dqqXLV9Vpw9c9587aFea0rsetLtQ0bunMw9ZztzPSeex4TLVqq0+1Hbf6tKu11aW6+DdkVzlPvfDelmnswQAAAAAAAGqNBQYAAAAAAFBrLDAAAAAAAIBaY4EhB8TjcQ0YMEDxeDzbKdXQZuO5TfLdR5sNbTa02XhuC0EaMGCAEslsl1Tnedwq2xi39CSSctvmedxos+E8tfHelmksMOSI8vLybCdsF202ntsk33202dBmQ5sNbTa02dBmQ5sNbTa07RpYYMgBiURCs2bNysouojtCm43nNsl3H202tNnQZuO5LYqkWbNmKe7wOyjP41bZxrilJx6T2zbP40abDeepjfe2THN4+AAAAAAAgF0NCwwAAAAAAKDWWGDIER43HalEm43nNsl3H202tNnQZkObDW02tNnQZkObDW27BhYYckBeXp4GDhyovLy8bKdUQ5uN5zbJdx9tNrTZ0GbjuS2ESAMHDnS5y7rncatsY9zSk0jKbZvncaPNhvPUxntbprHAkANCCFq9erVCCNlOqYY2G89tku8+2mxos6HNxnObtKXNI8/jVtnmkedxk+S2zfO40WbDeWrjvS3TWGDIAYlEQnPmzHG7sylt6fPcJvnuo82GNhvabDy3RZE0Z84ct7usex23yjbGLT3xmNy2eR432mw4T228t2Waw8MHAAAAAADsalhgAAAAAAAAtcYCQw6IokhFRUWKoijbKdXQZuO5TfLdR5sNbTa02Xhuk6SioiI5fKut63GrbGPc0hOC3LZ5HjfabDhPbby3ZRoLDDkgHo+rX79+Li+fQpuN5zbJdx9tNrTZ0GbjuS2ESP369VPS4Tfgnsetso1xS08yyG2b53GjzYbz1MZ7W6axwJADksmkVqxYoWTS3zVnaLPx3Cb57qPNhjYb2mw8t0lBK1askL/fU/ket8o2xi09keS2zfO40WbDeWrjvS3TWGDIAclkUgsWLHB70NOWPs9tku8+2mxos6HNxnNbFEkLFixQzOF3UJ7HrbKNcUtPLCa3bZ7HjTYbzlMb722Z5vDwAQAAAAAAuxoWGAAAAAAAQK2xwJADoihScXGx251NaUuf5zbJdx9tNrTZ0GbjuU2SiouL3e6y7nXcKtsYt/SEILdtnseNNhvOUxvvbZmWl/FnRMbF43H16tUr2xk1os3Gc5vku482G9psaLPx3BZCpF69eikZpmQ7pRrP41bZxrilJxnkts3zuNFmw3lq470t03gFQw5IJpNaunSp241HaEuf5zbJdx9tNrTZ0GbjuU0KWrp0qRz+osr1uFW2MW7piSK5bfM8brTZcJ7aeG/LNBYYcoD3g5629Hluk3z30WZDmw1tNp7bKn/gi/ENeFoq2xi39MRYYDChzYbz1MZ7W6axwAAAAAAAAGqNBQYAAAAAAFBrLDDkgFgsppYtWyoW8zfdtNl4bpN899FmQ5sNbTae2xSkli1bKulwl3XP41bZxrilJ/m/481jm+dxo82G89TGe1vGnzPjz4iMi8Vi6tq1q9uDnrb0eW6TfPfRZkObDW02ntuCInXt2tXlZdw8j1tlG+OWnhDkts3zuNFmw3lq470t48+Z8WdExiWTSc2fP9/txiO0pc9zm+S7jzYb2mxos/HcFilo/vz5bndZ9zpulW2MW3qiSG7bPI8bbTacpzbe2zKNBYYckEwmtXLlSrcHPW3p89wm+e6jzYY2G9psPLcpklauXOl2l3Wv41bZxrilJ/a/481jm+dxo82G89TGe1umscAAAAAAAABqjQUGAAAAAABQayww5IBYLKZ27dq53XiEtvR5bpN899FmQ5sNbTae20KQ2rVr53aXda/jVtnGuKUn+b/jzWOb53GjzYbz1MZ7W6blZfwZkXGVB71HtNl4bpN899FmQ5sNbTae26RI7dq1c7vLutdxq2xj3NJTuaDlkedxo82G89TGe1vGnzPjz4iMSyQSmj17thKJRLZTqqHNxnOb5LuPNhvabGiz8dwWRUGzZ892uQma53GrbGPc0hOL5LbN87jRZsN5auO9LdNYYMgBIQSVlpYqOFyOpM3Gc5vku482G9psaLPx3CZJpaWlLi/j5nncKtsYt/REkdy2eR432mw4T228t2UaCwwAAAAAAKDWWGAAAAAAAAC1xgJDDojFYurSpYvbnU1pS5/nNsl3H202tNnQZuO5LQSpS5cuSiazXVKd53GrbGPc0pNMym2b53GjzYbz1MZ7W6ZxFYkcEIvF1KpVq2xn1Ig2G89tku8+2mxos6HNxnObFKlVq1by905b3+NW2ca4pSdIbts8jxttNpynNt7bMv6cGX9GZFwikdDMmTPd7mxKW/o8t0m++2izoc2GNhvPbVEUNHPmTLe7rHsdt8o2xi09sUhu2zyPG202nKc23tsyjQWGHBBCUFlZmdudTWlLn+c2yXcfbTa02dBm47lNksrKytzusu513CrbGLf0RJHctnkeN9psOE9tvLdlGgsMAAAAAACg1lhgAAAAAAAAtcYCQw6Ix+Pq2bOn4vF4tlOqoc3Gc5vku482G9psaLPx3BaC1LNnTyUc7rLuedwq2xi39CSSctvmedxos+E8tfHelmlcRSIHRFGkkpKSbGfUiDYbz22S7z7abGizoc3Gc5vkt83zuNFm57XN87jRZkObjfe2TOMVDDmgoqJCU6ZMUUVFRbZTqqHNxnOb5LuPNhvabGiz8dwWRUFTpkxR3OF3UJ7HrbKNcUtPPCa3bZ7HjTYbzlMb722Z5vDwQX3weNmUSrTZeG6TfPfRZkObDW02tNnQZkObDW02tNnQtmtggQEAAAAAANQaCwwAAAAAAKDWWGDIAfF4XH379nW7sylt6fPcJvnuo82GNhvabDy3hSD17dvX7S7rXsetso1xS08iKbdtnseNNhvOUxvvbZnGAkOOKCgoyHbCdtFm47lN8t1Hmw1tNrTZ0GZDmw1tNrTZ0GZD266BBYb/6dSpk+69995sZ9SLRCKhqVOnutx8hDYbz22S7z7abGizoc3Gc1sUSVOnTnW5y7rncatsY9zSE4/JbZvncaPNhvPUxntbpjk8fOrHa6+9puOPP15t27ZVFEX629/+lu0kAAAAAAB2GzmzwLB+/Xr169dPDzzwQJ095ubNm+vssQAAAAAA2JXlzALD0UcfrVtvvVUnnXTSdu+zYcMGDR8+XE2aNFGHDh308MMPpz62aNEiRVGkP/3pTzrssMNUWFioJ598MhPpAAAAAAC4lzMLDDtjzJgxGjBggKZPn65LL71Ul1xyiebOnVvlPjfccIOuvPJKzZ49W0cddVSNj7Np0yatWbOmyn/ZFI/HNWDAALc7m9KWPs9tku8+2mxos6HNxnNbCNKAAQPc7rLuddwq2xi39CSSctvmedxos+E8tfHelmksMGzlmGOO0aWXXqpu3brp+uuvV4sWLfTqq69Wuc/IkSN18sknq3PnzmrTpk2Nj3P77beruLg49V/79u0zkf+1ysvLs52wXbTZeG6TfPfRZkObDW02tNnQZkObDW02tNnQtmtggWErffv2Tf3/KIrUunVrrVixosp9BgwYsMPHufHGG1VaWpr6b8mSJXXemo5EIqFZs2a53dmUtvR5bpN899FmQ5sNbTae26JImjVrlttd1r2OW2Ub45aeeExu2zyPG202nKc23tsyLS/jz+hYfn5+lT9HUaRksuprhBo1arTDx2nQoIEaNGhQp20AAAAAAHjmcH0KAAAAAADsanLmFQzr1q3TvHnzUn9euHChZsyYoWbNmqlDhw5ZLMsMj5uOVKLNxnOb5LuPNhvabGizoc2GNhvabGizoc2Gtl1DzryCYerUqerfv7/69+8vSbr66qvVv39//fSnP81yWf3Ly8vTwIEDlZfnbz2JNhvPbZLvPtpsaLOhzcZzWwiRBg4c6HKXdc/jVtnGuKUnkZTbNs/jRpsN56mN97aMP2fGnzFLBg8erBDCdj++aNGiarfNmDEj9f87der0tZ/vWQhBpaWlKi4uVhRF2c6pgjYbz22S7z7abGizoc3Gc5sUtHr16mxH1MjzuFW2eeR53CRp9erVLts8jxttNpynNt7bMi1nXsGQyxKJhObMmeN2Z1Pa0ue5TfLdR5sNbTa02XhuiyJpzpw5bndZ9zpulW2MW3riMblt8zxutNlwntp4b8s0h4cPAAAAAADY1bDAAAAAAAAAao0FhhwQRZGKiorcvSdIos3Kc5vku482G9psaLPx3CZJRUVF8rgtk+dxq2xj3NITgty2eR432mw4T228t2UaCww5IB6Pq1+/fi4vn0Kbjec2yXcfbTa02dBm47kthEj9+vVT0uE34J7HrbKNcUtPMshtm+dxo82G89TGe1umscCQA5LJpFasWKFk0t81Z2iz8dwm+e6jzYY2G9psPLdJQStWrJC/31P5HrfKNsYtPZHkts3zuNFmw3lq470t01hgyAHJZFILFixwe9DTlj7PbZLvPtpsaLOhzcZzWxRJCxYsUMzhd1Cex62yjXFLTywmt22ex402G85TG+9tmebw8AEAAAAAALsaFhgAAAAAAECtscCQA6IoUnFxsdudTWlLn+c2yXcfbTa02dBm47lNkoqLi93usu513CrbGLf0hCC3bZ7HjTYbzlMb722ZlpfxZ0TGxeNx9erVK9sZNaLNxnOb5LuPNhvabGiz8dwWQqRevXopGaZkO6Uaz+NW2ca4pScZ5LbN87jRZsN5auO9LdN4BUMOSCaTWrp0qduNR2hLn+c2yXcfbTa02dBm47lNClq6dKkc/qLK9bhVtjFu6YkiuW3zPG602XCe2nhvyzQWGHKA94OetvR5bpN899FmQ5sNbTae2yp/4IvxDXhaKtsYt/TEWGAwoc2G89TGe1umscAAAAAAAABqjQUGAAAAAABQayww5IBYLKaWLVsqFvM33bTZeG6TfPfRZkObDW02ntsUpJYtWyrpcJd1z+NW2ca4pSf5v+PNY5vncaPNhvPUxntbxp8z48+IjIvFYuratavbg5629Hluk3z30WZDmw1tNp7bgiJ17drV5WXcPI9bZRvjlp4Q5LbN87jRZsN5auO9LePPmfFnRMYlk0nNnz/f7cYjtKXPc5vku482G9psaLPx3BYpaP78+W53Wfc6bpVtjFt6okhu2zyPG202nKc23tsyjQWGHJBMJrVy5Uq3Bz1t6fPcJvnuo82GNhvabDy3KZJWrlzpdpd1r+NW2ca4pSf2v+PNY5vncaPNhvPUxntbprHAAAAAAAAAao0FBgAAAAAAUGssMOSAWCymdu3aud14hLb0eW6TfPfRZkObDW02nttCkNq1a+d2l3Wv41bZxrilJ/m/481jm+dxo82G89TGe1um5WX8GZFxlQe9R7TZeG6TfPfRZkObDW02ntukSO3atXO7y7rXcatsY9zSU7mg5ZHncaPNhvPUxntbxp8z48+IjEskEpo9e7YSiUS2U6qhzcZzm+S7jzYb2mxos/HcFkVBs2fPdrkJmudxq2xj3NITi+S2zfO40WbDeWrjvS3TWGDIASEElZaWKjhcjqTNxnOb5LuPNhvabGiz8dwmSaWlpS4v4+Z53CrbGLf0RJHctnkeN9psOE9tvLdlGgsMAAAAAACg1lhgAAAAAAAAtcYCQw6IxWLq0qWL251NaUuf5zbJdx9tNrTZ0GbjuS0EqUuXLkoms11Snedxq2xj3NKTTMptm+dxo82G89TGe1umcRWJHBCLxdSqVatsZ9SINhvPbZLvPtpsaLOhzcZzmxSpVatW8vdOW9/jVtnGuKUnSG7bPI8bbTacpzbe2zL+nBl/RmRcIpHQzJkz3e5sSlv6PLdJvvtos6HNhjYbz21RFDRz5ky3u6x7HbfKNsYtPbFIbts8jxttNpynNt7bMo0FhhwQQlBZWZnbnU1pS5/nNsl3H202tNnQZuO5TZLKysrc7rLuddwq2xi39ESR3LZ5HjfabDhPbby3ZRoLDAAAAAAAoNZYYAAAAAAAALXGAkMOiMfj6tmzp+LxeLZTqqHNxnOb5LuPNhvabGiz8dwWgtSzZ08lHO6y7nncKtsYt/QkknLb5nncaLPhPLXx3pZpXEUiB0RRpJKSkmxn1Ig2G89tku8+2mxos6HNxnOb5LfN87jRZue1zfO40WZDm433tkzjFQw5oKKiQlOmTFFFRUW2U6qhzcZzm+S7jzYb2mxos/HcFkVBU6ZMUdzhd1Cex62yjXFLTzwmt22ex402G85TG+9tmebw8EF98HjZlEq02Xhuk3z30WZDmw1tNrTZ0GZDmw1tNrTZ0LZrYIEBAAAAAADUGgsMAAAAAACg1lhgyAHxeFx9+/Z1u7Mpbenz3Cb57qPNhjYb2mw8t4Ug9e3b1+0u617HrbKNcUtPIim3bZ7HjTYbzlMb722ZxgJDjigoKMh2wnbRZuO5TfLdR5sNbTa02dBmQ5sNbTa02dBmQ9uugQWGHJBIJDR16lSXm4/QZuO5TfLdR5sNbTa02XhuiyJp6tSpLndZ9zxulW2MW3riMblt8zxutNlwntp4b8s0h4cPAAAAAADY1bDAAAAAAAAAao0FBgAAAAAAUGssMOSAeDyuAQMGuN3ZlLb0eW6TfPfRZkObDW02nttCkAYMGOB2l3Wv41bZxrilJ5GU2zbP40abDeepjfe2TGOBIUeUl5dnO2G7aLPx3Cb57qPNhjYb2mxos6HNhjYb2mxos6Ft18ACQw5IJBKaNWuW251NaUuf5zbJdx9tNrTZ0GbjuS2KpFmzZrndZd3ruFW2MW7picfkts3zuNFmw3lq470t0xwePgAAAAAAYFfDAgMAAAAAAKg1FhhyhMdNRyrRZuO5TfLdR5sNbTa02dBmQ5sNbTa02dBmQ9uugQWGHJCXl6eBAwcqLy8v2ynV0GbjuU3y3UebDW02tNl4bgsh0sCBA13usu553CrbGLf0JJJy2+Z53Giz4Ty18d6W8efM+DMi40IIKi0tVXFxsaIoqvE+Hds1/9o/15edacsW2uw899FmQ5sNbTY7aqvvr1FtWhVv93natGqq1atXq2O7Zhl7zu3Z9r67wpymM27Z/F4knedOd+7Sm+NmWr16tbnN+rw7o7bjtj118Rj11fZ1dvbx6/s8rYt/Q77uPM3UebmtXeHfN69tmRaFbDxrjlmzZo2Ki4tVWlqqpk2bZvz5KyoqNHXqVA0YMMDdyhptNp7bJN99tNnQZkObDW02tNnQZkObDW02tNmsWrVKzZs3z+jPobxFAgAAAAAA1BoLDAAAAAAAoNZYYMgBURSpqKjI3XuCJNqsPLdJvvtos6HNhjYb2mxos6HNhjYb2mxos8lGE3swZEC292AAAAAAAOSWbPwcyisYckAymdSKFSuUTPq75gxtNp7bJN99tNnQZkObDW02tNnQZkObDW02tNlko4kFhhyQTCa1YMECtwc9benz3Cb57qPNhjYb2mxos6HNhjYb2mxos6HNhgUGAAAAAACwS2KBAQAAAAAA1BoLDDkgiiIVFxe73dmUtvR5bpN899FmQ5sNbTa02dBmQ5sNbTa02dBmw1UkdlNcRQIAAAAAkElcRQL1IplMaunSpW43HqEtfZ7bJN99tNnQZkObDW02tNnQZkObDW02tNmwySPqhfeDnrb0eW6TfPfRZkObDW02tNnQZkObDW02tNnQZsMCAwAAAAAA2CWxwAAAAAAAAGqNBYYcEIvF1LJlS8Vi/qabNhvPbZLvPtpsaLOhzYY2G9psaLOhzYY2G9psstHEVSQygKtIAAAAAAAyiatIoF4kk0nNnz/f7cYjtKXPc5vku482G9psaLOhzYY2G9psaLOhzYY2GzZ5RL1IJpNauXKl24OetvR5bpN899FmQ5sNbTa02dBmQ5sNbTa02dBmwwIDAAAAAADYJeVlOyAXVG5zsWbNmqw8f0VFhdavX681a9YoL8/XlNNm47lN8t1Hmw1tNrTZ0GZDmw1tNrTZ0GZDm03lz5+Z3HbR1wjsptauXStJat++fZZLAAAAAAC55Msvv1RxcXFGnourSGRAMpnU8uXL1aRJE0VRlPHnX7Nmjdq3b68lS5a4u4oFbTae2yTffbTZ0GZDmw1tNrTZ0GZDmw1tNrTZlJaWqkOHDvrqq69UUlKSkefkFQwZEIvF1K5du2xnqGnTpu4O+kq02Xhuk3z30WZDmw1tNrTZ0GZDmw1tNrTZ0GYTi2Vu60U2eQQAAAAAALXGAgMAAAAAAKg1FhhyQIMGDXTzzTerQYMG2U6phjYbz22S7z7abGizoc2GNhvabGizoc2GNhvabLLRxiaPAAAAAACg1ngFAwAAAAAAqDUWGAAAAAAAQK2xwAAAAAAAAGqNBQYAAAAAAFBrLDAAAAAAAIBaY4EBVXi+qAhtNrTZ0GZDm43nNgAAtuX56xZtNnXVxgIDtHHjRlVUVEiSoijKck1V69evV2lpqTZv3uyuzfO40WbjuY1zwcbzuHluq0kufFNUH2izoc2GNhvadg5f7208j1t9tLHAkOPef/99HXfccRo0aJD69++vP/zhD1qyZEm2syRtaTviiCN02GGHqXv37rr11lv14YcfZjtLkv9xoy193ts4F9Lnfdy8tknS8uXL9fbbb2vSpElat26dpC3feCSTySyXSUuWLNE//vEPPfnkk5o/f74kP22ex402G89tnAs2nsfNcxtf7228j1u9tAXkrPnz54eSkpJw4YUXhocffjh8//vfD927dw/nnXdemDVrVlbbFi1aFJo3bx4uvfTS8Pe//z2MGjUqHHDAAWHw4MHhzTffzGqb53Gjbfdr41yw8TxunttCCGHmzJlhzz33DH379g1RFIVvfetb4fbbbw/JZDKEEEIikcha26xZs0KrVq3CgQceGPLz88N+++0XfvjDH6aastnmedxo2/3aOBdsPI+b5za+3tt4Hrf6bGOBIYf94he/CN/5zneq3Pbwww+HQYMGhVNPPTXMnj07S2UhPP7442HQoEFV/jF9/vnnwwknnBAGDBgQ/vvf/2atzfO40WbjuY1zwcbzuHlu+/LLL0OvXr3CqFGjwrJly8LixYvDhRdeGAYOHBguuOCC1A8Ilf+bSaWlpWG//fYLV155ZVizZk1YsWJFuOOOO0K/fv3CkUcemdVvwj2PG227Xxvngo3ncfPcFgJf7608j1t9tvEWiRyWSCS0bNkylZaWpm678MILdeGFF2rZsmUaN26c1q9fn5W28vJyzZkzR5999lnqtmOPPVZXXHGFWrdurbvvvluff/55Vto8jxttu18b54KN53Hz3PbZZ5+pvLxc5557rtq2bav27dvrrrvu0ve+9z1NmzZNI0eOlJSd95CuWbNG69at08knn6wmTZqoZcuWuvzyyzV69Gh9+umnOvnkkxVCUCyW+W9tPI8bbbtfG+eCjedx89wm8fXeyvO41WcbCww5KPxvs5g999xTpaWlmjdvniSlNvg455xzdMIJJ+h3v/udvvjii6y0de3aVc2aNdNbb71V5X1nRxxxhE477TS9/vrrWrx4cVbaPI8bbbtfG+eCrc3zuHlsq9SoUSNVVFRo1qxZqeaSkhJddNFFOu200/TWW2/p73//e1bamjZtKkl68803U7c1bNhQxxxzjG666SYtWrRIDzzwQFbaPI8bbbtfG+eCjedx89rG1/vatXket3ptM7/2AbucZDJZ7aVVgwYNCvvss09YtWpVCCGEzZs3pz7Wpk2bcP/992ekrby8PJSXl1e57aSTTgp77rlnePfdd6vdv2vXruEnP/lJRto8jxttu18b54KN53Hz3Lat1atXh8MPPzwMHTo0rFixosrH1q5dG/bbb79w4YUXZqWtrKwsDB8+PBxxxBFh+vTpVT62cePGcPLJJ4eTTjopK22ex4223a+Nc8HG87h5a+PrvY3ncctkG69gyBGzZ8/WFVdcoeOOO0533HGHJk6cKEl6+umnVVFRoSOPPFLLli1TXl6eJGnt2rVq06aNWrduXe9tH3zwgYYPH67DDjtMl19+uR577DFJ0oQJE9SpUyedeuqpeuutt1Ira5s3b9aee+6pdu3a1Xub53Gjbfdr41yw8TxuntskafXq1Zo3b55WrFihdevWqbi4WHfddZdefPFF3XzzzVq7dm3qvo0bN9axxx6rjz/+ONVbn1auXKl3331Xc+bM0ZdffqnCwkKNGjVKc+bM0ejRo/XRRx+l7tugQQMdfvjhWrhwYUZebup53Gjb/do4F2w8j5vnNr7e23get4y32ddBsKv48MMPQ0lJSTjttNPCWWedFfbbb7+w9957hzvuuCOEEMLcuXNDv379QufOncODDz4YnnnmmXDDDTeE5s2bhwULFtRr29y5c0NJSUkYPnx4GDlyZDjxxBNDy5YtwxVXXBFC2LKiO3jw4NCmTZtw3XXXhYcffjhcddVVoaSkJHz00Uf12uZ53Gjb/do4F2w8j5vnthC27PTep0+f0K1bt9CpU6dw8sknhxkzZoQQQnj22WdDgwYNwrBhw8KcOXNSn/P9738/fO973wsVFRX13rbXXnuFrl27hj333DP0798/TJ48OYQQwowZM0JxcXE44YQTwksvvZT6nB/+8IfhmGOOCRs3bqz3Ns/jRtvu18a5YGvzPG5e2/h6b+N53LLRxgLDbi6RSIQrr7wynHnmmakdez/66KMwevTo0Lx58/Czn/0shLDl5Ubnnntu6N+/f+jcuXM44IADanyZUV275ZZbwjHHHJN6yc7KlSvD73//+1BYWBguvvji1P1uuOGGcPTRR4cePXrU+PKxuuZ53Gjb/dpC4Fyw8jpu3tuWLl0aWrduHa666qrwzjvvhF//+tfh6KOPDk2bNg2vvfZaCCGEf/7zn6FFixbh4IMPDoMHDw5nnnlmaNy4cb1fWuvTTz8NHTp0CNddd134+OOPw7PPPhvOPvvsEI/Hw9ixY0MIWy7ntv/++4f+/fuH3r17h+OPPz40bdo09cNNffE8brTtfm2cCzaex81zG1/vbTyPW7baWGDIAccee2w47bTTqtz2+eefh9tvvz20a9cuPPjgg6nbP/vss/D555+Hr776KiNtw4YNC4cffniV2zZt2hSeeuqp0LBhwyrvmSorKwtfffVVWLduXUbaPI8bbbtfG+eCjedx89z26quvhv333z988cUXqdvmz58fzj777FBYWBj+85//hBC2fCNy3333hWHDhoXrr78+fPDBB/XeNmPGjLD33nuH+fPnp24rKysLN9xwQ8jLywt//etfQwghLF68ODz33HPhqquuCmPGjKnyW9L64nncaNv92jgXbDyPm+e2EPh6b+V53LLRxgJDDrjrrrvCoEGDwty5c6vcvmTJknDhhReGIUOGVPkCkUlPPfVU6Nq1a3jzzTer3L527dpw6623hv32269ad6Z4Hjfadr82zgUbz+Pmue2ZZ54JsVgsLF++vMrty5cvD2eccUbo3LlzmDdvXpWPZeq69a+99lqIoih8/PHHIYSq132/4oorQuPGjcP777+fkZZteR432na/Ns4FG8/j5rktBL7eW3ket2y0scljDhgwYICWLl2qp556SqtWrUrd3q5dO51xxhl6+eWXs3ZJtL333lutW7fWY489prlz56Zub9y4sY4++mjNmTMna22ex4223a+Nc8HG87h5bjvooIM0cOBA3XfffVqzZk3q9jZt2ujqq69WixYt9NZbb0nacq1sKXPXrT/44IN12GGH6Uc/+pG++OILxWKx1GW1rr/+eg0YMEB//vOfFUJItWWK53Gjbfdr41yw8Txuntskvt5beR63bLSxwLCb2vofpcMPP1xXXnmlbr31Vj300ENavnx56mM9evRQ7969s9bWt29f/fCHP9TEiRP161//OnXdZEnaa6+91KNHjyrXtM1km+dxo233a+NcsLV5HjdvbVtr1aqVDjvsML300ksaP368ysrKUh874IADlEwmU9djj8fjGW2LxWI67bTTtHjxYv3qV7/S6tWrUz+YtG3bVo0bN9acOXMURVHG2zyPG227Xxvngo3ncfPYxtf72rd5HrdstOXV+SPChXg8rhCC3njjDQ0aNEhXXnmlEomERo8erSVLluiEE05Qnz59Uv+4tWnTJuNt48eP16mnnqpzzjlHyWRSd9xxhz755BOdeuqp6t+/vx5//HEtX748oyflrjButO2cEELqC7T3Ni/nQmWX5HNOK3kbt12lLZFIKB6PK5lMKhaL6c4779SCBQt09913a8OGDTr//PPVsGFDSVKnTp3Utm3bjLVVNlX+76WXXqoFCxbohRde0IYNG3TTTTdpjz32kCQ1a9ZMTZs2VSKRUCwWq/ffinoeN9p2vzav50IIQclkknHbzdokvt7Xts3zuGWtrU7fcAEXKi/9M3z48NCtW7fwxhtvpD72xBNPhO985zuhcePGYZ999gkdOnTIyM6v27rpppvCnnvuGSZMmJC67YUXXgjDhg0LjRo1CnvvvXfo3r17Rts2b94cQvA5bt7mtHKsQvi/9w96aatpYxovbStWrKj2HlQv58KiRYvCiy++GELYsptwCH7GrSZexm1rleeCx7ZKyWQy3HTTTeGVV15J3TZs2LDQv3//8O1vfzvcfvvtYfjw4aFJkybhww8/zHjbRRddFP70pz+lbrv55pvDN7/5zbDXXnuFq6++Opx++ulZeY+y93Gjbfdr83IubLtJHuO2e7V5+/6yJh6/pvIzw9djgWE3sHz58vDf//43TJw4scp1hWfPnh0uvvjiaj9wrVixIrz33nth2rRp4bPPPqvXtsqerTexCSGETz75JNxyyy1h1apVVW7ftGlTWLp0aViwYEG9b4byxRdfhNmzZ6d2Oq40d+7crI/b0qVLw0svvRTGjRtXZU49tM2ZMydcf/31qQ2KPLVNnz49HHLIIWHmzJnu2t57773Qo0eP8MADD1Q5Hz755JMwevTorJ4L7733XsjLywv77LNPlds9jNv8+fPDPffcE66++urw+uuvhw0bNoQQfPwbsmzZsvDOO++Ev//972Hjxo2pxaOFCxdmfU6356WXXgqtW7cOo0ePDmVlZanbn3jiiXDuueeGb33rW+Hkk0+udg5lwrRp08L+++8fLrvsstQ8h7BlU7SrrroqHHPMMeH8888P7733Xsbb/vnPf7oYt2QyWeVrgqe2L7/8MqxYscJl28cffxzeeecdt20TJkwImzZtSt3m5VyYM2dO+P73vx+WLFmSus3LuK1fvz6sWrWqSsOUKVNcjFtN3nnnHRdt/Mxgw88M6WGBYRc3c+bM0LFjx9C9e/dQXFwcevbsGZ566qnw+eefhxCq/qY50957770wePDgsHjx4hDC//2DUXnwZ2o34ZrMmjUrHHDAAaFHjx6hVatW4aijjqry8W3/ccukWbNmhe7du4f99tsvNGrUKOy3336p3yhnsy2ZTIYNGzaEgQMHhiiKwsUXX1xtbrM5pzNmzAj5+fnh2muvrfHj2ZzT2bNnhz322CNcffXV4ZNPPqn28W1/YMik6dOnh0aNGoVjjz02dO3aNTz++OMhhP/7tyPb50KrVq3C0UcfHbp06RI6depU5Trg2WybOXNm6NSpUxg4cGBo06ZN6NSpU3jooYfCp59+GkLI7pyGsOUbi+uuuy4MGzYs3HvvveGjjz5Kfeyf//xn6hu1bc/ZjRs31vvXja+7BNb06dPD6tWra/xYMpms939jFixYEO6+++5w9dVXh6effrrKx1599dWsjtvcuXPDlVdeGY499thwyy23VPmGOttt8+fPD126dAk/+clPwrJly6p8LNtt06dPD02bNg0PP/xwtY9lu23mzJmhZcuW4cILL6w2btOmTcvquTBjxoxQVFQUoigKY8eOrfKxbI/b+++/H4477rjQq1evMHTo0PD888+nPpbtf0PmzJkTbrjhhvD9738//OIXvwjTp09PfWzKlClZbeNnBht+ZkgfCwy7sBUrVoSePXuGH/3oR2H+/Plh2bJl4Ywzzgi9evUKN998c7XfJPzqV79KXV+3vi1cuDB069YtRFEU9tprr9Tq9/YO9Lvvvjv84he/yEjbnDlzQosWLcINN9wQ/vOf/4RJkyaFLl26hBtvvLHG+2dy3GbPnh1atGgRfvzjH4dPPvkkLFiwILRo0aLKF89stVX60Y9+FM4///xQVFQUzjzzzLBw4cKst73//vuhqKgo/PSnPw0hbPlC9OWXX4YFCxZkvS2RSISLLroonH/++ak/v/baa+HRRx8Nc+fOrfaDVibPhRkzZqSuHV1eXh6++c1vhnPOOWe798/kuC1fvjz06tUrjB49OvUNRu/evcNvfvObGu+fyXFbsmRJ6NatW7jlllvC8uXLQzKZDCeffHIoLCwMI0eOrPaDQibbQgjhgw8+CMXFxWHIkCHhlFNOCcXFxeHII48MDz30UI33X7RoUcbaPvzww1BQUBBOPfXUUFpamrp9e18bMvkS61mzZoV27dqFI444Ihx00EEhFouFu+66a7v3z+S4VS62nXrqqeGHP/xhKCgoCKNHj3bRFkIIDz30UIiiKPTv3z/cdtttqYW2mmSyrfLfuKuvvnqn7p/Jtk8++SR06NBhu4vi28rkuVC5uHDdddeFUaNGhUGDBoVPP/10u+dpJsftgw8+CHvssUcYMWJEeOihh8LBBx8czjrrrO3+AJrJcfvggw9CSUlJOO2008LFF18c2rdvH/bbb7/w61//Outt/Mxgw88MNiww7MI++OCD0KlTpzB16tQqt19//fWhT58+4a677grr168PIWx56WLnzp3DkCFDwtq1a+u1q6ysLPz4xz8OJ510UnjllVfCoYceGjp27LjdfzBKS0vDkUceGQYPHlzt5U91be3ateH0008Pl156aeq2RCIRLr/88nDCCSdUu38mx2316tXhmGOOCSNHjqxy+1FHHRUeeeSRcPfdd4cPP/ww9dK6L774ImNtIfzfvF155ZXhgQceCB988EFo0KBBOPfcc8P69evDL37xi9Q3GZkcty+++CJ069Yt9O/fP3Xb+eefH/bff//Qpk2bcOihh4bp/7+9+46K6srjAP59oGAEKQOKgAUFKUoRLAjiYjBRsR2wl7g27BVXDdKCQuzuWVlLxIJkN4qxrLK79q6oCaBRUQREXXUXG4qIuALDb//gzFuGYpgx82ZMfp9zPEfevGG+3Ffm3fvuve/qVfHiQ8psRJWt735+fpSUlERERP7+/tSpUycyNTUle3t7mjp1qthiX1hYKNmxkJubS4IgUEREhLhsz549ZGhoSKdPn66xvtTlduHCBXJ1dVW68z5ixAhasGABffHFF7R9+3ax3F6+fClZuRERHTlyhLy9venZs2dit+a0tDSytLQkT09P+uqrr8Ruu1Ke34gqu4x+8cUXNHnyZHFZbm4ujRgxgrp160br1q1TWn/NmjX02Wef1fge0YTHjx+Tr68vBQQEkKWlJQ0bNkypkaG6hIQEcnR0pOPHj2s82/3798nBwYEWLVoknuu2bdtGVlZWSvuggpTldvfuXbKzs1O6oI2JiaEZM2Yo3anSRjaFa9eu0bhx4yguLo5sbGwoNja21l4qUmbLyckhQ0ND8RxXWlpKKSkplJCQQAcPHqxxHpO63P7+979Tv379xGwREREUFBREISEh4vcFUWWDuZTHQnp6OpmYmFB4eDgREe3atYtMTU3FcdzVr+GkLLeSkhIKCgqiuXPnissOHjxIwcHB9OTJE6VtKnW5vX79mvr06UOLFi0Slz169IgsLCzIysqK4uLilNaXMhsR1xnUwXUG9fFTJD5ipaWlKCsrQ0lJCQDg7du3+OSTT7BixQq8ffsWmzZtQp8+feDu7g6ZTIbTp09DLpfD2NhYo7kaNWqE9u3bw9XVFQEBAbC3t8fYsWPh5+eHCxcuoEWLFuJMukQEExMTJCUloaKiQpxFV5OMjIzg4eEh/qynpwc/Pz+cOXMGpaWlEAQBDRs2BBFBJpPh1KlTqKio0Hi5mZqaYsCAAUrZ4uLicPLkSZSWluLx48dYuXIl4uPjMXz4cFhYWEi2Tavq27cv9u7dixkzZuD8+fPo0aMHzp07h7KyMgwZMgQAJN3fLCws0Lt3b1y7dg0xMTE4dOgQLCwsMHXqVDRt2hSrVq1CUFAQTpw4AQcHB0mzAZUz+TZt2hSFhYWIjo6GoaEhtm3bhtatW2PDhg34/vvvkZiYiMjISJiamuLbb7+FXC7X+LHQqFEjbNy4EdOmTQNQOUO4j48POnfujJSUFPTs2VPpOJW63F6+fIknT54gLy8PrVq1Qnx8PPbv349p06ahoKAAmzZtwtWrV7Fs2TKYmZlJVm4AcP/+fdy9exeWlpbisuLiYvj4+MDc3BwJCQmYOHEiWrVqBRMTE0mzGRgY4MmTJ2jTpg2Ayu3q4OCAVatW4auvvsLevXvRtm1bDBgwAABgaWmJ0tJSWFlZaTzb1atXYWdnh9DQUFRUVCAwMBAhISHYunUrTExMaqzfokULuLu7w97eXqO5KioqkJycDAcHB4SHh0NPr/IJ3l26dEHDhg1rfeyZVOUml8uxb98+BAYGIiwsTFz+6NEj3Lx5E927d0enTp3Qr18/DBw4UNJsVRERLl68iMTERMjlciQkJKBJkyY4e/YsXFxc8PXXX0uarby8HOvXr4exsTE6duwIAAgKCsKjR49QVFSEBw8eYMiQIVi8eDE8PT0lzaZw5coV8Zn0/fr1Q3l5OTw8PHDr1i2kp6fj9u3bWLZsGQRBQMuWLSU5Ft68eQN/f39MmTJF3GYjR47E1q1bER0djaNHj6JBA+Wqg5TlZmhoiIKCAnGbAcD58+dx9epVeHl5wcnJCV27dsXy5cshCIJk5xCg8lryxYsX4v5WUlICW1tbBAQE4MWLFzh06BC8vLwQGBgIAGjVqpVk2QCgrKwM5eXlOllncHV1hZubm07WGZo0aSJuU0C36gyDBg2Cu7u7uEyn6gwab8Jgvyi5XK40ttfPz49+97vfiT//97//Ff/fuXNnGjlyJBFJMx5YLpfXejeloqKC8vLyxFbJR48eiVkzMjKoqKhIkmyKsWVVu/Ip7mrv3r2b3NzclN5TfeZkTWarOrmTwrlz58je3p5SUlLEVuVBgwZR586dxfdJka36vnPs2DFycnISW0UDAwNJT0+PAgMD39stVhPZqu7v4eHhZGlpSf37968xaU2HDh1o3LhxRCTdsVD1c+bOnUuurq40ZswY2rx5s9K6CxYsIBcXFyotLZVkjGF5eXmNcZZVf46OjiZzc3NxfLcikzb2t759+1LTpk2pV69eZGhoKD7lgohoxYoV1KpVq1rntNB0tvz8fGrdujWNHj2a7ty5QxcuXKDGjRvTihUriIjIycmJYmNjiUjauRjKy8uptLSUJkyYQEOHDhUnnlRsu7y8PPLx8aERI0Yove99vQh+SU+fPlXqHXPp0iWSyWQ0bNgwpXHJVctMce7TtLNnz1JYWJjSMrlcTnZ2drX26CGSrtwePnyoNLFYbGws6evrU0REBMXHx1OXLl0oICCA/vOf/0ierarevXuLQ+ZWrVpFRkZGZGpqSkePHlVaT6psOTk5NGXKFOrWrRu1bNmS+vXrR1lZWVRSUkLp6elka2tLv//977WSjYjo+PHjFBAQQFu3bqXPP/9cvDYqLCykJUuWULdu3ZQm/JPqWKg67FFxLG7ZsoUcHR0pIyODiGq/q6xpcrmcXr16RX369KHg4GDasGEDLV68mD755BNKTEykw4cP05IlS8jLy4sOHDggvk+KcquoqKAnT56QjY2NUtf9hw8fUvv27SkpKYnc3d0pJCRE6X1SbVOFLl260Keffir+rM06Q110oc6gIJfLda7OUDVHVbpQZ6iKGxg+Ijdv3qQxY8ZQr169KCQkhM6cOUMZGRlkb29Pw4YNE9dTVBbmz59PAwcOlDzb1KlTlcb/KA6EO3fuiCeMu3fv0syZM6lz5851TvaliWwzZsxQyqYoqz179lCHDh3E5fPnz6cBAwZo/CT7vnK7d+8e5eXlKeVcvXo1eXt719qQo8ls06ZNo3/84x8kl8vp9evX1LdvXyKqHIrQokUL2rFjBxkbG9OgQYPELwOpsimOBSKizZs3U3JysrjPKbbfkCFDaOjQoRrPVT3blClT6OzZs1RcXEx+fn4kCILY7VTh2LFj5OHhofHjoHo2xTZVUDRyPXv2jFxcXCgsLEzSSZWqb9PU1FQiqux6vXfvXurUqRM9f/5cPBYuXrxIDg4OlJ2dLWm2qVOn0oEDB2j//v3Uvn17kslkJJPJlMZ4+/n51aisalL189SZM2dIX19faTiEYp0zZ86Qnp4eZWZmSnLBUdc5VPHZly9fFhsZXr16RaWlpbRx40Y6cuQIEWl2Yq+6slVtVGvTpg0dO3ZMfO3EiROSNKTWle358+c0b948pca2W7dukSAISsu0ka1nz55i1/5JkyaRiYkJNW/enFatWlVjXhKpst25c4fGjh1L/fv3p9u3byu9lpKSQoIgUHZ2tiQVquqfkZWVRTY2NtS+fXv67LPPlF578OABNW7cmHbu3KnxXNWz1XbMvX79mlq2bEkzZ85UWi5Vo3hVly9fpr59+9Lo0aPJycmJtm3bJr72+PFjatWqFS1fvlzjuWrLtn79ehIEgSZOnEiRkZFkbGwsDlfbs2cP2dnZKX2PaVJxcTEVFRUpNf5cuXKFmjVrRqNGjRKXaaPOUFs2IuVKsLbqDPXJpq06Q13ZiCqH42izzlCdnub7SLBfQnZ2Nnx9fSGXy9GlSxekpaVh4cKF2Lp1K2JjY5GRkYHg4GCUlZWJ3TufPn0KIyMjlJeXg4gky3b58mXExMQgNDQUACAIAogI9vb2SExMRJs2bWBvb48dO3Zg48aNMDMzkyxbamqqUjZFV7/GjRujvLwcABAeHo5NmzYhIiIC+vr6kmVTlNu8efMAAHZ2dmjVqpVSztu3b6NDhw4QBEFjuWrLdunSJcTExGDRokUwNDREw4YN0axZMxw6dAh/+9vfMG7cOBw6dAg//PCD5NnS0tIwb948hIeHY8qUKRgxYoSYQV9fH0QEQRDQvn17AJD0WPjhhx8wd+5cxMTEYNWqVfDx8cFf/vIXHD16FG/evAEAHD16FGZmZjAwMNBYrtqyKbap4lgwMDBARUUFzMzM0K1bN5w9e1Y8JjSttm06Y8YMLFy4EO7u7rC2tkZJSQksLCzEY2H//v0wMzND06ZNJc126dIlrFy5EufPn8fly5eRmpqK48ePY+3atQCAd+/ewdjYGC1btgSg2f0NAHJycvCnP/0J+fn54jJ/f3+sXLkSoaGh2Lp1KwCI57ImTZrAyckJRkZG4neFlNkUFJ/t7e2Nw4cP4+TJk5g8eTKmTp2KuXPnwsHBAQA0dj6pLZtiWwmCgPLycrx9+xb6+vri8I3w8HB8/vnntQ6Z0HQ2BQsLC3z99dfo27cviAgVFRUoLy+Hp6cnbG1tNZqrrmxlZWUAKrelnp4e5syZg8OHD+Onn37CnDlzEBMTg+TkZMjlcsmz2dvbIy4uDrNmzULbtm0B/H87l5aWwsnJCc2aNdPod31d2ZydnZGQkICcnBxcv34dly5dEl+zsrJCt27dIJPJNJqrtmzVjzlFl+qwsDAcOXIEGRkZ4mua/r6vrdy8vb2xd+9efPvtt5DJZErdvWUyGZycnGodciVFtunTpyMxMRE3btxAeno6oqKikJCQAAB4/PgxzM3NIZPJagwz+aXdunULgwcPhr+/P1xcXPDdd98BAFxcXLBu3TocP34cw4YN00qdoa5sRKT0naSNOkN9s2mjzvC+bABga2srnuOkrjPUSvImDaayiooKCg8Pp+HDh4vLioqKaOnSpdS1a1caPXo0HThwgBwdHcnR0ZGCgoJo+PDhZGRkpPHn6daVLS4ujjp27Kg00RhR5V3SkSNHkkwmo5s3b+pMtv3791O3bt0oPDycDAwMxG6A2soWEhKidGegtLSUIiMjydLSkrKysrSWzc3NjSZMmEARERHUv39/8bniilbbqs+jljqbu7s7TZ48WancysrKKDIykqytrSk3N1cr2WJjY8nLy4smTZpE169fJz8/P2rRogV5eHjQwIEDyczMTOnRi1Jmq+s4vXv3LgmCUGM4h9TZPDw8aNasWfTy5Utq164d+fr6UlRUFE2aNIksLCy0Vm6xsbHk5uZG06dPV1q/qKiIwsLCqFmzZuKdBE3Kzc0lmUxGgiDQ4sWL6dmzZ+Jrb968oSVLlpAgCBQZGUlXrlyhgoICCgsLIwcHhxozhkuZrTYXLlwgQRBIJpNp/Pxbn2xyuZzevn1L9vb2lJ6eTkuXLiUjIyPxnKeNbIpzW/W7xuHh4eTt7a31bbp9+3YSBIGsra0pLS1NXL5y5cpaJ8qUMlttd9oXLFhAffr00Xj3/p/LtmvXLtLT06M+ffrQrl27KDc3l8LCwsjGxkacyFZb2apSDCvZsGGDRjPVJ5tcLqfi4mLy9vamqKgoevnyJb1+/ZqioqLI2tq6zidISZGNqPJaqOrwAyKiWbNm0dChQ+nt27ca7flx8+ZNsrCwoNDQUPruu+9o/vz51LBhQ7py5QoRVX43pKSkUIsWLcjZ2VnSOkNd2ao+yrMqKesMqmQ7ePCgpHUGVctNyjpDXbiB4SMxfvx4pbkWiCovZlevXk0+Pj60atUqKioqoi+//JJCQkJo1qxZGj8Yfy7bmjVrqHPnzuK45IqKCoqPjyd9fX3xRKftbIpudLt37yZBEMjc3FyyGaTrW24nTpygIUOGUIsWLbRebqtXr6aePXvSnDlzau3yKkV3yfqW2/Hjx2ngwIHUvHlzrZfbmjVrqEuXLhQfH09EleNZo6OjacWKFZJ08f+5bNWP06KiIpo9e7bGKwXvy/b69Wtas2YNeXl50dq1aykzM5M+/fRT8vHxoWHDhunM+U1xDvnpp59o2rRpZGNjo/GLDaLKrpITJ06k8ePH04YNG0gQBFq4cKFSJVMul1NSUhI1b96cbG1tydnZWZJ8dWWrq/Ly7t07mjZtGjVp0kTj21XVbJ6entSlSxcyMDBQqjTrQrabN29SZGQkmZiY0LVr17SeLTs7myIjI8WLXqnG/NYnW9XvpszMTIqIiCATExO6fv261rMRVX7P+/j4kJWVFTk7O5Ojo6PGv7dU3d+IiMaNG0dOTk4anzOovtkU126Ojo7k7e1NrVu31olyq1o2WVlZNG/ePGrSpInG97eCggLq3bs3zZkzR2l5z549afbs2UrLioqKaNGiRZLVGeqTrWq5yeVy+vOf/yxJnUHVbFLWGVTNpo06Q224gUHHKXaa+Ph46t69e40xhC9evKCQkBDy9vaucWDqQrbJkyeTr6+v+EiUlJQUSSotqmR79+4d3blzh3r06KHxk7+q2QoLCykvL49iYmJqrKeNbAUFBRQSEkI9evSQ5DE3qmSrXm65ubn05ZdfStJ6W99sXbt2lXzyJFXKrerkSdXvvmgzW/fu3cVz2rt372qdFFVb2Xx9fcWeO/v27dP4nTOFkpIS2rBhAyUnJxPR/y94qjcyEFXO53L27Fk6fPiwJHOkvC9bbZWXH3/8kTp06KDx3gGqZCsvL6eCggIyNTUlfX19Sb4bVCm3f/3rXxQcHEwuLi4a78mjSraqk9ZJNYeLKuV279496tu3L7Vt27bOu3/ayvb8+XPKycmhq1ev/myPH6mzKbbl5cuXJTnHqZLtwoULFBcXR998843SBJW6kK2oqIji4+PJ399fkv3t8ePH1LVrVzp37hwR/b8uMGHCBBozZgwRkdLEvwpS1Bnqk606qeoMqmaTss6gSjbFBJlS1RnehxsYPhJ37twhS0tLmjhxolixU5zwHzx4QIIg0D//+U9xfSknZ6tPtkOHDkmWR9Vshw8fFrvb6Vo2xURnUs/+Wt9y0wZVyk3qyryqx4KuHae6vE2rTkjJ2SpVP2clJyeTIAi0YMEC8UK3rKxMsidt1Deb4gklcrlc7AKu6eeZq5qtrKyMnj17RkeOHKHMzEydylZeXk5Pnjyhhw8fis+K13Y2RaOWXC6XrJGtvtmqltvTp0/p3r17kh4T9d3fpKgcq5NNLpdLMuRLlWyK81tpaakkjTGqZKt+nJaVlUl6fqtaIVdM7hcZGUljx45VWq/q0CCprkXqm03KJ0Uo1Deb4jpAyjpDfbMpMkldZ6gNNzB8RE6dOkWGhoY0c+ZMpRNqfn4+eXh40MWLFzmbGtkUs9XrYjZdLjddzsbblLP9VrIRVV7IKi4Qd+3aJd5N+/e//02hoaE0ePBgKi4ulrRBq77ZgoKCxEfe6lq24OBgyR8jV99sQUFBGp/zRt1sgwcP5nJTI5suH6eKbaqL2YKDg3W23LR5fqtayYyIiKA+ffqIPy9btozWrl0rydMsavMxZ1uzZo3WHuOpy+VWHTcwfGRSUlLI0NCQBg8eTMnJyXTr1i0KCwsja2trSe9kcDbOxtk4G2fTjWxEyt1ek5OTqWHDhuTk5EQNGjSQpGuuutm0OUb0fdn09fW53NTMxuWmXjZdLjfOpl42XdjfiCoro4GBgUREFBUVRYIgSDK06n04m3p0OVtV3MDwEcrIyCB/f39q3bo12dvbSzIZUH1xNvVwNvVwNvVwNvXocjaiygsPxcVHQEAAyWQyScaI1gdnUw9nUw9nUw9nU4+uZlM0fHz11Vc0ZcoUWr16NRkaGkoyEfHP4Wzq0eVsVXEDw0fq1atXdO/ePbp+/bpWxp+9D2dTD2dTD2dTD2dTjy5nI6rsshsaGkqCIGj8yQKq4mzq4Wzq4Wzq4Wzq0eVscXFxJAgCmZqaavxpOKribOrR5WxERAIRERhjjDH20ZPL5dixYwc6deqEjh07ajuOEs6mHs6mHs6mHs6mHl3Olp6ejq5duyIzMxPt27fXdhwlnE09upwNALiBgTHGGPsVISIIgqDtGLXibOrhbOrhbOrhbOrR5Wxv3ryBkZGRtmPUirOpR5ezcQMDY4wxxhhjjDHGPpietgMwxhhjjDHGGGPs48cNDIwxxhhjjDHGGPtg3MDAGGOMMcYYY4yxD8YNDIwxxhhjjDHGGPtg3MDAGGOMMcYYY4yxD8YNDIwxxhhjjDHGGPtg3MDAGGOMsTqNHz8eQUFB2o5Rq5KSEgwZMgQmJiYQBAGFhYXajsQYY4z9pnEDA2OMMfYbJQjCe//FxMRg3bp12LFjh7aj1iopKQnnz5/HxYsXkZ+fD1NT0xrr7NixQ/x79PX1YW5uDm9vbyxduhSvXr3SQmrGGGPs16uBtgMwxhhjTDvy8/PF/+/evRvR0dHIzs4WlxkbG8PY2Fgb0eolLy8PLi4ucHV1fe96JiYmyM7OBhGhsLAQFy9exPLly5GYmIjU1FTY2NhIlJgxxhj7deMeDIwxxthvVPPmzcV/pqamEARBaZmxsXGNIRI9e/bE7NmzMW/ePJibm8PKygpbtmzBmzdvMGHCBDRp0gQODg44fPiw0mdlZmYiMDAQxsbGsLKywtixY/H8+fP35tu3bx86dOgAQ0ND2NnZYe3atUo51q5di3PnzkEQBPTs2bPO36P4u6ytreHi4oJJkybh4sWLKC4uxqJFi8T1jhw5Aj8/P5iZmcHCwgIDBgxAXl6e+HpAQABmzZql9LufPXsGAwMDnDx58r1/C2OMMfZbwA0MjDHGGFNJUlISLC0t8eOPP2L27NmYPn06hg0bBl9fX1y5cgW9e/fG2LFjUVJSAgAoLCxEQEAAPD09kZ6ejiNHjuDJkycYPnx4nZ+RkZGB4cOHY+TIkbhx4wZiYmIQFRUlDtfYv38/Jk+eDB8fH+Tn52P//v0q/Q3NmjXDmDFjkJKSArlcDgB48+YN5s+fj/T0dJw8eRJ6enoIDg5GRUUFACAkJAQ7d+7Eu3fvxN/z17/+Fba2tggICFDp8xljjLFfI25gYIwxxphKPDw8EBkZiXbt2mHx4sVo1KgRLC0tMXnyZLRr1w7R0dEoKCjA9evXAQDr16+Hp6cnli1bBmdnZ3h6emL79u04ffo0cnJyav2MP/7xj+jVqxeioqLg6OiI8ePHY9asWVi9ejUAQCaToXHjxjAwMEDz5s0hk8lU/jucnZ3x+vVrFBQUAACGDBmCwYMHw8HBAR07dsT27dtx48YN3Lp1CwAwePBgAMDBgwfF37Fjxw6MHz8egiCo/PmMMcbYrw03MDDGGGNMJe7u7uL/9fX1YWFhATc3N3GZlZUVAODp06cAgGvXruH06dPinA7GxsZwdnYGAKUhCFVlZWWhe/fuSsu6d++O3NxcscfBhyIiABAbB3JzczFq1Ci0bdsWJiYmsLOzAwA8ePAAANCoUSOMHTsW27dvBwBcuXIFmZmZGD9+/C+ShzHGGPvY8SSPjDHGGFNJw4YNlX4WBEFpmaLCrhhaUFxcjIEDB2LlypU1fpe1tbUGk75fVlYWTExMYGFhAQAYOHAgWrdujS1btsDGxgYVFRVwdXVFaWmp+J6QkBB07NgRjx49QmJiIgICAtC6dWtt/QmMMcaYTuEGBsYYY4xplJeXF/bt2wc7Ozs0aFC/Sw8XFxekpqYqLUtNTYWjoyP09fU/ONPTp0+xc+dOBAUFQU9PDwUFBcjOzsaWLVvQo0cPAMCFCxdqvM/NzQ2dO3fGli1bsHPnTqxfv/6DszDGGGO/FjxEgjHGGGMaNXPmTLx48QKjRo1CWloa8vLycPToUUyYMKHO4Q5/+MMfcPLkScTGxiInJwdJSUlYv349FixYoPLnExEeP36M/Px8ZGVlYfv27fD19YWpqSlWrFgBADA3N4eFhQUSEhJw584dnDp1CvPnz6/194WEhGDFihUgIgQHB6uchzHGGPu14gYGxhhjjGmUjY0NUlNTIZfL0bt3b7i5uWHevHkwMzODnl7tlyJeXl74/vvvkZycDFdXV0RHR2Pp0qVqzXdQVFQEa2tr2NrawsfHB5s3b8a4ceNw9epVcYiGnp4ekpOTkZGRAVdXV4SGhooTSlY3atQoNGjQAKNGjUKjRo1UzsMYY4z9WgmkmOGIMcYYY4z9rPv378Pe3h5paWnw8vLSdhzGGGNMZ3ADA2OMMcZYPZSVlaGgoAALFizAvXv3aswRwRhjjP3W8RAJxhhjjLF6SE1NhbW1NdLS0vDNN99oOw5jjDGmc7gHA2OMMcYYY4wxxj4Y92BgjDHGGGOMMcbYB+MGBsYYY4wxxhhjjH0wbmBgjDHGGGOMMcbYB+MGBsYYY4wxxhhjjH0wbmBgjDHGGGOMMcbYB+MGBsYYY4wxxhhjjH0wbmBgjDHGGGOMMcbYB+MGBsYYY4wxxhhjjH2w/wFZZZ0inB29FgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Assign numeric values for y-axis based on legend\n", + "y_labels = df['legend'].unique()\n", + "y_mapping = {label: i for i, label in enumerate(y_labels)}\n", + "df['y_pos'] = df['legend'].map(y_mapping)\n", + "\n", + "# Define color mapping\n", + "palette = sns.color_palette('viridis', n_colors=len(y_labels))\n", + "legend_colors = {label: palette[i] for i, label in enumerate(y_labels)}\n", + "\n", + "# Plot timeline graph using broken_barh\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "for i, row in df.iterrows():\n", + " ax.broken_barh([(row['bin_start'], row['duration'])], (row['y_pos'] - 0.4, 0.8),\n", + " color=legend_colors[row['legend']], edgecolor='white')\n", + "\n", + "ax.set_xlabel('Time of Day')\n", + "ax.set_ylabel('Legend')\n", + "ax.set_title('Timeline of Bin Ranges Colored by Legend')\n", + "ax.set_yticks(range(len(y_labels)))\n", + "ax.set_yticklabels(y_labels)\n", + "ax.grid(axis='x', linestyle='--', alpha=0.7)\n", + "\n", + "# Adjust x-ticks to every 3600 seconds (1 hour)\n", + "ax.set_xticks(range(0, 86400, 3600))\n", + "ax.set_xticklabels([f\"{h:02d}:00\" for h in range(24)])\n", + "plt.xticks(rotation=45)\n", + "\n", + "# Create legend\n", + "handles = [plt.Rectangle((0, 0), 1, 1, color=legend_colors[label]) for label in y_labels]\n", + "ax.legend(handles, y_labels, title='Legend')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "697474c7-e0ba-49d0-9dcb-65e4538e9c06", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1286164/2162353716.py:42: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(sql, con)\n" + ] + } + ], + "source": [ + "#query to identify which segments have a big discrepency.\n", + "sql = '''WITH bins AS (\n", + " SELECT\n", + " CASE\n", + " WHEN time_grp = '[00:00:00,24:00:00)' THEN '24hr'\n", + " WHEN (upper(time_grp) - lower(time_grp)) = '01:00:00'::interval THEN '1hr'\n", + " ELSE 'Periods'\n", + " END AS legend,\n", + " bin_range,\n", + " segment_id,\n", + " dt,\n", + " lower(bin_range) AS bin_start,\n", + " upper(bin_range) AS bin_end\n", + " FROM gwolofs.congestion_raw_segments\n", + " WHERE dt >= '2024-12-01' AND dt < '2024-12-02'\n", + " ORDER BY 1, 2\n", + "),\n", + "\n", + "overlap AS (\n", + " SELECT\n", + " segment_id,\n", + " bin_range,\n", + " dt,\n", + " COUNT(*) FILTER (WHERE legend = '24hr') AS count_24hr,\n", + " COUNT(*) FILTER (WHERE legend = '1hr') AS count_1hr,\n", + " COUNT(*) FILTER (WHERE legend = 'Periods') AS count_period\n", + " FROM bins\n", + " GROUP BY 1, 2, 3\n", + ")\n", + "\n", + "SELECT\n", + " segment_id,\n", + " dt,\n", + " COUNT(*) FILTER (WHERE count_24hr = 1 AND count_1hr = 1) / SUM(count_24hr) AS overlap_24hr_1_hr,\n", + " COUNT(*) FILTER (WHERE count_24hr = 1 AND count_period = 1) / SUM(count_24hr) AS overlap_24hr_period\n", + "FROM overlap\n", + "GROUP BY segment_id, dt\n", + "ORDER BY 3'''\n", + "\n", + "try:\n", + " with connect(**dbset) as con:\n", + " df = pd.read_sql(sql, con)\n", + " df.head\n", + "except Exception as e:\n", + " print(\"Error connecting to the database:\", e)\n", + " exit()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5a4f97c3-b3c3-4474-9925-fc908de6e09a", + "metadata": {}, + "outputs": [], + "source": [ + "def make_map(data, basemap_b, centreline_b, highway_b, color, title):\n", + " f, ax = plt.subplots(figsize=(20,20))\n", + " if basemap_b == True:\n", + " basemap.plot(ax=ax, color = 'grey', alpha=0.2)\n", + " if centreline_b == True:\n", + " centreline.plot(ax=ax, color = 'white', alpha=0.2)\n", + " if highway_b == True:\n", + " highway.plot(ax=ax, color = 'white', alpha=0.2) \n", + " \n", + " data.plot(column = 'id', ax=ax, cmap=color)\n", + " NUM_COLORS = len(data.col.unique())\n", + " cm = plt.get_cmap(color)\n", + " colors = [cm(1.*i/NUM_COLORS) for i in range(NUM_COLORS)]\n", + " handles, labels = [], []\n", + "\n", + " legend_id = data.col.unique()\n", + " for i in range(0, NUM_COLORS):\n", + " label_name = legend_id[i]\n", + " handles.append(mpl.patches.Patch(color=colors[i],label=label_name))\n", + " ax.legend(handles=handles,loc='lower right', ncol=1, title = title) \n", + " ax.set_axis_off()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "cce5f66c-01d9-4be6-9881-70eb8d2c994a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/jupyterhub/.venv/lib/python3.10/site-packages/geopandas/io/sql.py:170: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(\n" + ] + } + ], + "source": [ + "import geopandas as gpd\n", + "new_links = '''\n", + "WITH all_link_dirs_24_4 AS(\n", + "\tSELECT link_id || 'F'::text AS link_dir, func_class\n", + "\tFROM here_gis.traffic_streets_24_4\n", + "\tWHERE dir_travel = ANY (ARRAY['F', 'B'])\n", + "\tUNION ALL\n", + "\tSELECT link_id || 'T'::text AS link_dir, func_class\n", + "\tFROM here_gis.traffic_streets_24_4\n", + "\tWHERE dir_travel = ANY (ARRAY['T', 'B'])\n", + "\t)\n", + "\t,all_link_dirs_23_4 AS(\n", + "\tSELECT link_id || 'F'::text AS link_dir, func_class\n", + "\tFROM here_gis.traffic_streets_23_4\n", + "\tWHERE dir_travel = ANY (ARRAY['F', 'B'])\n", + "\tUNION ALL\n", + "\tSELECT link_id || 'T'::text AS link_dir, func_class\n", + "\tFROM here_gis.traffic_streets_23_4\n", + "\tWHERE dir_travel = ANY (ARRAY['T', 'B'])\n", + "\t)\n", + "SELECT link_dir, a.func_class::integer as id, a.func_class::text as col,gis.geopandas_transform(geom) as geom\n", + "FROM (select nu.* from all_link_dirs_23_4 ole\n", + "FULL OUTER JOIN all_link_dirs_24_4 nu on nu.link_dir = ole.link_dir\n", + "WHERE ole.link_dir IS NULL AND nu.link_dir IS NOT NULL)a\n", + "inner join (SELECT sts.link_id || 'F'::text AS link_dir,\n", + " sts.link_id,\n", + "\t\t\tfunc_class,\n", + " sts.geom\n", + " FROM here_gis.streets_24_4 sts\n", + "\t\t \t\tinner join here_gis.traffic_streets_24_4 using (link_id)\n", + " WHERE dir_travel in ('F', 'B')\n", + " UNION ALL\n", + " SELECT sts.link_id || 'T'::text AS link_dir,\n", + " sts.link_id,\n", + "\t\t\tfunc_class,\n", + " st_reverse(sts.geom) AS geom\n", + " FROM here_gis.streets_24_4 sts\n", + "\t\t inner join here_gis.traffic_streets_24_4 using (link_id)\n", + " WHERE dir_travel in ('T', 'B') )streets\n", + "using (link_dir)\n", + "--where ST_geometrytype(geom) = 'ST_LineString' \n", + "order by a.func_class\n", + " '''\n", + "\n", + "new_links = gpd.GeoDataFrame.from_postgis(new_links, con, geom_col='geom')\n", + "new_links = new_links.to_crs('epsg:26917')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "fd3d8266-58d8-47fe-af42-cd163961e90c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "make_map(new_links, True, False, False, 'magma', 'Functional Class');" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 84b68f29cf7a76b5c9e89ed4eac1198a332b48fd Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 18 Mar 2025 19:08:14 +0000 Subject: [PATCH 29/74] #1132 comments --- here/traffic/here_dynamic_binning_explore.ipynb | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/here/traffic/here_dynamic_binning_explore.ipynb b/here/traffic/here_dynamic_binning_explore.ipynb index b4c1b2a5f..1098f7ef9 100644 --- a/here/traffic/here_dynamic_binning_explore.ipynb +++ b/here/traffic/here_dynamic_binning_explore.ipynb @@ -201,6 +201,17 @@ "plt.show()\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "14483f0e-2cdf-46df-8284-a4662e7c4780", + "metadata": {}, + "outputs": [], + "source": [ + "#show the 95% context..\n", + "#raph's idea: cut off at 15 minutes, use the starting bin hour." + ] + }, { "cell_type": "code", "execution_count": 2, From c5e5f918964cb654c906314f22f19d3e1d8ed6a5 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 24 Mar 2025 17:42:36 +0000 Subject: [PATCH 30/74] #1132 update graph title --- .../here_dynamic_binning_explore.ipynb | 23 ++++++------------- 1 file changed, 7 insertions(+), 16 deletions(-) diff --git a/here/traffic/here_dynamic_binning_explore.ipynb b/here/traffic/here_dynamic_binning_explore.ipynb index 1098f7ef9..3658b4290 100644 --- a/here/traffic/here_dynamic_binning_explore.ipynb +++ b/here/traffic/here_dynamic_binning_explore.ipynb @@ -2,19 +2,10 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "8c6f35d7-fbd6-4336-91e3-4ab18b4009e5", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/data/jupyterhub/.venv/lib/python3.10/site-packages/geopandas/io/sql.py:170: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", - " df = pd.read_sql(\n" - ] - } - ], + "outputs": [], "source": [ "from pathlib import Path\n", "import configparser\n", @@ -104,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "3e9c7d6d-6e1f-4214-b9cf-dd0b8e16daf5", "metadata": { "scrolled": true @@ -114,7 +105,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_842647/1604576776.py:15: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + "/tmp/ipykernel_1286164/1604576776.py:15: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", " df = pd.read_sql(sql, con)\n" ] } @@ -151,13 +142,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "8d2ba18c-dc79-4a04-8da6-8139f5772b18", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -184,7 +175,7 @@ "\n", "ax.set_xlabel('Time of Day')\n", "ax.set_ylabel('Legend')\n", - "ax.set_title('Timeline of Bin Ranges Colored by Legend')\n", + "ax.set_title('Timeline of Bin Ranges by time_grp')\n", "ax.set_yticks(range(len(y_labels)))\n", "ax.set_yticklabels(y_labels)\n", "ax.grid(axis='x', linestyle='--', alpha=0.7)\n", From 53be92520a32a446a2b974355610bb094d7d4af8 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 26 Mar 2025 21:03:21 +0000 Subject: [PATCH 31/74] #1132 add cumulative distribution of tt --- .../here_dynamic_binning_explore.ipynb | 237 +++++++++++++++++- 1 file changed, 235 insertions(+), 2 deletions(-) diff --git a/here/traffic/here_dynamic_binning_explore.ipynb b/here/traffic/here_dynamic_binning_explore.ipynb index 3658b4290..d43b57fa1 100644 --- a/here/traffic/here_dynamic_binning_explore.ipynb +++ b/here/traffic/here_dynamic_binning_explore.ipynb @@ -2,15 +2,25 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 19, "id": "8c6f35d7-fbd6-4336-91e3-4ab18b4009e5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/jupyterhub/.venv/lib/python3.10/site-packages/geopandas/io/sql.py:170: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(\n" + ] + } + ], "source": [ "from pathlib import Path\n", "import configparser\n", "from psycopg2 import connect\n", "import struct\n", + "import numpy as np\n", "import pandas as pd\n", "from datetime import datetime\n", "import matplotlib as mpl\n", @@ -192,6 +202,101 @@ "plt.show()\n" ] }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d31bbf9c-f2f6-42c2-a0c6-9c43c8a5aeb9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1286164/1721737923.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(sql, con)\n" + ] + } + ], + "source": [ + "sql = '''SELECT\n", + " max_bin AS legend,\n", + " lower(bin_range)::time AS bin_start,\n", + " upper(bin_range)::time AS bin_end\n", + "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n", + "WHERE dt >= '2024-12-01' AND dt < '2024-12-02' AND segment_id = 2511\n", + "ORDER BY 1, 2'''\n", + "\n", + "try:\n", + " with connect(**dbset) as con:\n", + " df = pd.read_sql(sql, con)\n", + " # Convert time columns to datetime\n", + "except Exception as e:\n", + " print(\"Error connecting to the database:\", e)\n", + " exit()\n", + "\n", + "# Convert time columns to seconds since midnight\n", + "def time_to_seconds(t):\n", + " return t.hour * 3600 + t.minute * 60 + t.second\n", + "\n", + "df['bin_start'] = df['bin_start'].apply(time_to_seconds)\n", + "df['bin_end'] = df['bin_end'].apply(time_to_seconds)\n", + "df['duration'] = df['bin_end'] - df['bin_start']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3d5d92eb-711d-4b91-b2fd-4a26769b7538", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Assign numeric values for y-axis based on legend\n", + "y_labels = df['legend'].unique()\n", + "y_mapping = {label: i for i, label in enumerate(y_labels)}\n", + "df['y_pos'] = df['legend'].map(y_mapping)\n", + "\n", + "# Define color mapping\n", + "palette = sns.color_palette('viridis', n_colors=len(y_labels))\n", + "legend_colors = {label: palette[i] for i, label in enumerate(y_labels)}\n", + "\n", + "# Plot timeline graph using broken_barh\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "for i, row in df.iterrows():\n", + " ax.broken_barh([(row['bin_start'], row['duration'])], (row['y_pos'] - 0.4, 0.8),\n", + " color=legend_colors[row['legend']], edgecolor='white')\n", + "\n", + "ax.set_xlabel('Time of Day')\n", + "ax.set_ylabel('Legend')\n", + "ax.set_title('Timeline of Bin Ranges by time_grp')\n", + "ax.set_yticks(range(len(y_labels)))\n", + "ax.set_yticklabels(y_labels)\n", + "ax.grid(axis='x', linestyle='--', alpha=0.7)\n", + "\n", + "# Adjust x-ticks to every 3600 seconds (1 hour)\n", + "ax.set_xticks(range(0, 86400, 3600))\n", + "ax.set_xticklabels([f\"{h:02d}:00\" for h in range(24)])\n", + "plt.xticks(rotation=45)\n", + "\n", + "# Create legend\n", + "handles = [plt.Rectangle((0, 0), 1, 1, color=legend_colors[label]) for label in y_labels]\n", + "ax.legend(handles, y_labels, title='Legend')\n", + "\n", + "plt.show()\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -203,6 +308,64 @@ "#raph's idea: cut off at 15 minutes, use the starting bin hour." ] }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6d709c8a-1a4d-4aed-b402-f2eada4b3861", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1286164/271536835.py:14: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(sql, con)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " max_bin count percent_of_original\n", + "0 0 days 00:05:00 5647506 1.000000\n", + "1 0 days 00:10:00 5776554 1.022850\n", + "2 0 days 00:15:00 5793370 1.025828\n", + "3 0 days 00:20:00 5801453 1.027259\n", + "4 0 days 01:00:00 5813682 1.029425\n" + ] + } + ], + "source": [ + "sql = '''WITH count_5min_bins AS (\n", + "SELECT COUNT(*)\n", + "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n", + "WHERE max_bin = '00:05:00'::interval\n", + ")\n", + "\n", + "SELECT max_bin, COUNT(*), COUNT(*) / (SELECT count::numeric FROM count_5min_bins) AS percent_of_original\n", + "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n", + "GROUP BY max_bin\n", + "ORDER BY 1\n", + "'''\n", + "try:\n", + " with connect(**dbset) as con:\n", + " df = pd.read_sql(sql, con)\n", + " print(df)\n", + "except Exception as e:\n", + " print(\"Error connecting to the database:\", e)\n", + " exit()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94d6d78f-f20a-4f95-aede-315e058361ce", + "metadata": {}, + "outputs": [], + "source": [ + "This shows 15 minutes -> 1 hour max bin only results in 0.3% more observations." + ] + }, { "cell_type": "code", "execution_count": 2, @@ -268,6 +431,76 @@ "\n" ] }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4966c18a-7678-4913-8d1d-9df2035afe35", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1286164/1152226507.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + " df = pd.read_sql(sql, con)\n" + ] + } + ], + "source": [ + "sql = '''\n", + "SELECT ROUND(tt, 0) AS tt, COUNT(*)\n", + "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n", + "WHERE max_bin = '00:15:00'::interval\n", + "GROUP BY 1\n", + "ORDER BY 1\n", + "'''\n", + "\n", + "try:\n", + " with connect(**dbset) as con:\n", + " df = pd.read_sql(sql, con)\n", + "except Exception as e:\n", + " print(\"Error connecting to the database:\", e)\n", + " exit()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6781e1d7-012a-4b43-bbe0-7608008ced36", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compute cumulative distribution\n", + "df = df.sort_values(by='tt')\n", + "df['cumulative'] = df['count'].cumsum() / df['count'].sum()\n", + "\n", + "# Plot cumulative distribution\n", + "plt.figure(figsize=(10, 6))\n", + "sns.lineplot(x=df['tt'], y=df['cumulative'], color='royalblue')\n", + "\n", + "plt.xlabel('Travel time (s)')\n", + "plt.ylabel('Cumulative Distribution')\n", + "plt.title('Cumulative Distribution of Congestion network travel times')\n", + "plt.xticks(np.arange(0, 241, 20)) # X-axis limits from 0 to 240\n", + "plt.yticks(np.arange(0, 1.05, 0.05), [f'{int(y*100)}%' for y in np.arange(0, 1.05, 0.05)]) # Y-axis every 5%\n", + "plt.xlim(0, 240)\n", + "plt.ylim(0, 1)\n", + "plt.grid(axis='both', linestyle='--', alpha=0.7)\n", + "\n", + "plt.show()" + ] + }, { "cell_type": "code", "execution_count": 30, From 0422ab098322d3b5eca20e82b0635741480dda28 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 1 Apr 2025 18:15:19 +0000 Subject: [PATCH 32/74] #1132 dynamic binning explore --- .../here_dynamic_binning_explore.ipynb | 120 +++--------------- 1 file changed, 18 insertions(+), 102 deletions(-) diff --git a/here/traffic/here_dynamic_binning_explore.ipynb b/here/traffic/here_dynamic_binning_explore.ipynb index d43b57fa1..5acc7016c 100644 --- a/here/traffic/here_dynamic_binning_explore.ipynb +++ b/here/traffic/here_dynamic_binning_explore.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 19, + "execution_count": 2, "id": "8c6f35d7-fbd6-4336-91e3-4ab18b4009e5", "metadata": {}, "outputs": [ @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "id": "def42f51-59b0-42bd-b300-5d1f3e3dee15", "metadata": {}, "outputs": [ @@ -49,7 +49,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_818626/423225491.py:6: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + "/tmp/ipykernel_2029777/423225491.py:6: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", " df = pd.read_sql(sql, con)\n" ] } @@ -68,13 +68,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 5, "id": "a1a4f215-4fc4-4b0b-8223-870934a9c7f0", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -95,12 +95,13 @@ "sns.barplot(x=df['bin_length'], y=df['proportion'], hue=df['hr'], palette='viridis')\n", "plt.xlabel('Bin Size')\n", "plt.ylabel('Proportion')\n", - "plt.title('Congestion Proportions by Bin Size and Hour')\n", + "plt.title('Proportions of bins by duration and time of day')\n", "plt.yticks([i * 0.01 for i in range(0, 100, 5)])\n", "plt.xticks(rotation=45)\n", "plt.legend(title='Hour of the Day')\n", "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", - "plt.show()\n" + "plt.show()\n", + "#note, higher proportion of longer bins before ~8am" ] }, { @@ -204,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "d31bbf9c-f2f6-42c2-a0c6-9c43c8a5aeb9", "metadata": { "scrolled": true @@ -214,7 +215,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_1286164/1721737923.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + "/tmp/ipykernel_2029777/1721737923.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", " df = pd.read_sql(sql, con)\n" ] } @@ -247,13 +248,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "3d5d92eb-711d-4b91-b2fd-4a26769b7538", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -280,7 +281,7 @@ "\n", "ax.set_xlabel('Time of Day')\n", "ax.set_ylabel('Legend')\n", - "ax.set_title('Timeline of Bin Ranges by time_grp')\n", + "ax.set_title('Timeline of Bin Ranges for Different Max Bin Lengths')\n", "ax.set_yticks(range(len(y_labels)))\n", "ax.set_yticklabels(y_labels)\n", "ax.grid(axis='x', linestyle='--', alpha=0.7)\n", @@ -433,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "id": "4966c18a-7678-4913-8d1d-9df2035afe35", "metadata": {}, "outputs": [ @@ -441,7 +442,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_1286164/1152226507.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", + "/tmp/ipykernel_2029777/1152226507.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", " df = pd.read_sql(sql, con)\n" ] } @@ -465,13 +466,13 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 11, "id": "6781e1d7-012a-4b43-bbe0-7608008ced36", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -491,7 +492,7 @@ "\n", "plt.xlabel('Travel time (s)')\n", "plt.ylabel('Cumulative Distribution')\n", - "plt.title('Cumulative Distribution of Congestion network travel times')\n", + "plt.title('Cumulative Distribution of Congestion network travel times (for max_bin = ''00:15:00'')')\n", "plt.xticks(np.arange(0, 241, 20)) # X-axis limits from 0 to 240\n", "plt.yticks(np.arange(0, 1.05, 0.05), [f'{int(y*100)}%' for y in np.arange(0, 1.05, 0.05)]) # Y-axis every 5%\n", "plt.xlim(0, 240)\n", @@ -530,91 +531,6 @@ " ax.legend(handles=handles,loc='lower right', ncol=1, title = title) \n", " ax.set_axis_off()" ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "cce5f66c-01d9-4be6-9881-70eb8d2c994a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/data/jupyterhub/.venv/lib/python3.10/site-packages/geopandas/io/sql.py:170: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n", - " df = pd.read_sql(\n" - ] - } - ], - "source": [ - "import geopandas as gpd\n", - "new_links = '''\n", - "WITH all_link_dirs_24_4 AS(\n", - "\tSELECT link_id || 'F'::text AS link_dir, func_class\n", - "\tFROM here_gis.traffic_streets_24_4\n", - "\tWHERE dir_travel = ANY (ARRAY['F', 'B'])\n", - "\tUNION ALL\n", - "\tSELECT link_id || 'T'::text AS link_dir, func_class\n", - "\tFROM here_gis.traffic_streets_24_4\n", - "\tWHERE dir_travel = ANY (ARRAY['T', 'B'])\n", - "\t)\n", - "\t,all_link_dirs_23_4 AS(\n", - "\tSELECT link_id || 'F'::text AS link_dir, func_class\n", - "\tFROM here_gis.traffic_streets_23_4\n", - "\tWHERE dir_travel = ANY (ARRAY['F', 'B'])\n", - "\tUNION ALL\n", - "\tSELECT link_id || 'T'::text AS link_dir, func_class\n", - "\tFROM here_gis.traffic_streets_23_4\n", - "\tWHERE dir_travel = ANY (ARRAY['T', 'B'])\n", - "\t)\n", - "SELECT link_dir, a.func_class::integer as id, a.func_class::text as col,gis.geopandas_transform(geom) as geom\n", - "FROM (select nu.* from all_link_dirs_23_4 ole\n", - "FULL OUTER JOIN all_link_dirs_24_4 nu on nu.link_dir = ole.link_dir\n", - "WHERE ole.link_dir IS NULL AND nu.link_dir IS NOT NULL)a\n", - "inner join (SELECT sts.link_id || 'F'::text AS link_dir,\n", - " sts.link_id,\n", - "\t\t\tfunc_class,\n", - " sts.geom\n", - " FROM here_gis.streets_24_4 sts\n", - "\t\t \t\tinner join here_gis.traffic_streets_24_4 using (link_id)\n", - " WHERE dir_travel in ('F', 'B')\n", - " UNION ALL\n", - " SELECT sts.link_id || 'T'::text AS link_dir,\n", - " sts.link_id,\n", - "\t\t\tfunc_class,\n", - " st_reverse(sts.geom) AS geom\n", - " FROM here_gis.streets_24_4 sts\n", - "\t\t inner join here_gis.traffic_streets_24_4 using (link_id)\n", - " WHERE dir_travel in ('T', 'B') )streets\n", - "using (link_dir)\n", - "--where ST_geometrytype(geom) = 'ST_LineString' \n", - "order by a.func_class\n", - " '''\n", - "\n", - "new_links = gpd.GeoDataFrame.from_postgis(new_links, con, geom_col='geom')\n", - "new_links = new_links.to_crs('epsg:26917')" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "fd3d8266-58d8-47fe-af42-cd163961e90c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "make_map(new_links, True, False, False, 'magma', 'Functional Class');" - ] } ], "metadata": { From 40f9c99a89c97afa45ea3faa2d4b4e8dd215241a Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 8 Apr 2025 18:05:37 +0000 Subject: [PATCH 33/74] add trigger_dags_tasks to pull_here_path #1132 --- dags/pull_here_path.py | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/dags/pull_here_path.py b/dags/pull_here_path.py index aeaa4d8de..78f8f6c41 100644 --- a/dags/pull_here_path.py +++ b/dags/pull_here_path.py @@ -3,10 +3,11 @@ import pendulum from datetime import timedelta -from airflow.decorators import task, dag +from airflow.decorators import task, dag, task_group from airflow.hooks.base import BaseHook from airflow.models import Variable from airflow.macros import ds_add, ds_format +from airflow.operators.trigger_dagrun import TriggerDagRunOperator try: repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) @@ -85,6 +86,21 @@ def get_download_link(request_id: str, access_token: str): def load_data()->str: return '''curl $DOWNLOAD_URL | gunzip | psql -h $HOST -U $LOGIN -d bigdata -c "\\COPY here.ta_path_view FROM STDIN WITH (FORMAT csv, HEADER TRUE);" ''' - load_data() + # Create a task group for triggering the DAGs + @task_group + def trigger_dags_tasks(): + # Define TriggerDagRunOperator for each DAG to trigger + trigger_operators = [] + DAGS_TO_TRIGGER = Variable.get('here_path_dag_triggers', deserialize_json=True) + for dag_id in DAGS_TO_TRIGGER: + trigger_operator = TriggerDagRunOperator( + task_id=f'trigger_{dag_id}', + trigger_dag_id=dag_id, + logical_date='{{ ds }}', + reset_dag_run=True # Clear existing dag if already exists (for backfilling), old runs will not be in the logs + ) + trigger_operators.append(trigger_operator) + + load_data() >> trigger_dags_tasks() pull_here_path() \ No newline at end of file From 3ea3d8ad63d91c33cff307c13ed96cde9a243686 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 8 Apr 2025 18:27:17 +0000 Subject: [PATCH 34/74] #1132 add here_dynamic_binning_agg DAG --- dags/here_dynamic_binning_agg.py | 61 ++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 dags/here_dynamic_binning_agg.py diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py new file mode 100644 index 000000000..cea208e63 --- /dev/null +++ b/dags/here_dynamic_binning_agg.py @@ -0,0 +1,61 @@ +import sys +import os +import logging +import pendulum +from datetime import timedelta + +from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator +from airflow.models import Variable +from airflow.decorators import dag, task + +try: + repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) + sys.path.insert(0, repo_path) + from dags.dag_functions import task_fail_slack_alert +except: + raise ImportError("Cannot import slack alert functions") + +LOGGER = logging.getLogger(__name__) +logging.basicConfig(level=logging.DEBUG) + +doc_md = "This DAG is running off the `1132-here-aggregation-proposal` branch to test dynamic binning aggregation." +DAG_NAME = 'here_dynamic_binning_agg' +DAG_OWNERS = Variable.get('dag_owners', deserialize_json=True).get(DAG_NAME, ["Unknown"]) + +# Slack alert +SLACK_CONN_ID = 'slack_data_pipeline' + +default_args = { + 'owner': ','.join(DAG_OWNERS), + 'depends_on_past':False, + 'start_date': pendulum.datetime(2025, 4, 1, tz="America/Toronto"), + 'email_on_failure': False, + 'email_on_success': False, + 'retries': 0, + 'retry_delay': timedelta(minutes=5), + 'on_failure_callback': task_fail_slack_alert +} + +@dag( + DAG_NAME, + default_args=default_args, + schedule=None, # triggered by `pull_here_path` DAG + doc_md = doc_md, + tags=["HERE", "aggregation"], + catchup=False +) + +#to add: catchup, one task at a time, depends on past. + +def here_dynamic_binning_agg(): + + aggregate_daily = SQLExecuteQueryOperator( + #sql="SELECT covid.generate_citywide_tti( '{{macros.ds_add(ds, -1)}}' )", + task_id='aggregate_daily', + conn_id='congestion_bot', + autocommit=True, + retries = 0 + ) + aggregate_daily + +here_dynamic_binning_agg() \ No newline at end of file From 17037fdd69cfb83bf069416c11185e8a92b71026 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 9 Apr 2025 15:22:23 +0000 Subject: [PATCH 35/74] #1132 smol dag changes --- dags/here_dynamic_binning_agg.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index cea208e63..e813e276b 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -22,9 +22,6 @@ DAG_NAME = 'here_dynamic_binning_agg' DAG_OWNERS = Variable.get('dag_owners', deserialize_json=True).get(DAG_NAME, ["Unknown"]) -# Slack alert -SLACK_CONN_ID = 'slack_data_pipeline' - default_args = { 'owner': ','.join(DAG_OWNERS), 'depends_on_past':False, @@ -50,7 +47,7 @@ def here_dynamic_binning_agg(): aggregate_daily = SQLExecuteQueryOperator( - #sql="SELECT covid.generate_citywide_tti( '{{macros.ds_add(ds, -1)}}' )", + sql="SELECT '{{macros.ds_add(ds, -1)}}';", task_id='aggregate_daily', conn_id='congestion_bot', autocommit=True, From b3f8dac84d44591c2639d42c1d17e9ac99336e5c Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 9 Apr 2025 15:27:41 +0000 Subject: [PATCH 36/74] #1132 fix schedule error from rebase --- dags/pull_here_path.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dags/pull_here_path.py b/dags/pull_here_path.py index 78f8f6c41..6b2f0fdc7 100644 --- a/dags/pull_here_path.py +++ b/dags/pull_here_path.py @@ -46,7 +46,7 @@ @dag(dag_id = dag_name, default_args=default_args, - schedule='30 10 * * *' , + schedule='0 17 * * * ', catchup=False, doc_md = doc_md, tags=["HERE", "data_pull"] From ec107527734c1ac748ffb64d44971ae988e0d115 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 9 Apr 2025 16:14:17 +0000 Subject: [PATCH 37/74] #1132 add variable to test_dags --- test/integration/test_dags.py | 1 + 1 file changed, 1 insertion(+) diff --git a/test/integration/test_dags.py b/test/integration/test_dags.py index ce574db40..b41571003 100644 --- a/test/integration/test_dags.py +++ b/test/integration/test_dags.py @@ -27,6 +27,7 @@ 'AIRFLOW_VAR_COLLISIONS_TABLES': "["+",".join([f'["src_schema.table_{i}", "dst_schema.table_{i}"]' for i in range(0, 2)])+"]", 'AIRFLOW_VAR_COUNTS_TABLES': "["+",".join([f'["src_schema.table_{i}", "dst_schema.table_{i}"]' for i in range(0, 3)])+"]", 'AIRFLOW_VAR_HERE_DAG_TRIGGERS': "["+",".join([f'"dag_{i}"' for i in range(0, 3)])+"]", + 'AIRFLOW_VAR_HERE_PATH_DAG_TRIGGERS': "["+",".join([f'"dag_{i}"' for i in range(0, 3)])+"]", 'AIRFLOW_VAR_REPLICATORS': '{"dag": {"dag_name": "value", "tables": "value", "conn": "value"}}', 'AIRFLOW_VAR_TEST_DAG_TRIGGERS': "["+",".join([f'"dag_{i}"' for i in range(0, 3)])+"]", 'AIRFLOW_VAR_GCC_DAGS': '{"dag": {"conn": "value", "deployments": ["value"]}}', From 57496b57d2167c79e52887cce7415863414ee6ac Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 9 Apr 2025 16:46:50 +0000 Subject: [PATCH 38/74] #1132 remove time_grp, add bin_start, add temp table to reduce constraint size --- .../create-table-congestion_raw_segments.sql | 42 +++++--- ...unction-congestion_network_segment_agg.sql | 102 ++++++++++-------- 2 files changed, 82 insertions(+), 62 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql index f73ecb566..940e6bf0f 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql @@ -6,19 +6,12 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments ( segment_id integer NOT NULL, dt date NOT NULL, - time_grp timerange NOT NULL, + bin_start timestamp without time zone NOT NULL, bin_range tsrange NOT NULL, tt numeric, num_obs integer, - CONSTRAINT congestion_raw_segments_exclude EXCLUDE USING gist ( - segment_id WITH =, - dt WITH =, - time_grp WITH =, - bin_range WITH && - ) -) - -TABLESPACE pg_default; + CONSTRAINT congestion_raw_segments_pkey PRIMARY KEY (segment_id, dt, bin_start) +) PARTITION BY RANGE (dt); ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments OWNER TO gwolofs; @@ -28,23 +21,40 @@ REVOKE ALL ON TABLE gwolofs.congestion_raw_segments FROM bdit_humans; GRANT SELECT ON TABLE gwolofs.congestion_raw_segments TO bdit_humans; GRANT ALL ON TABLE gwolofs.congestion_raw_segments TO gwolofs; - -- Index: congestion_raw_segments_dt_idx -- DROP INDEX IF EXISTS gwolofs.congestion_raw_segments_dt_idx; CREATE INDEX IF NOT EXISTS congestion_raw_segments_dt_idx ON gwolofs.congestion_raw_segments USING brin -(dt) -TABLESPACE pg_default; +(dt); -- Index: congestion_raw_segments_segment_dt_idx -- DROP INDEX IF EXISTS gwolofs.congestion_raw_segments_segment_dt_idx; CREATE INDEX IF NOT EXISTS congestion_raw_segments_segment_dt_idx ON gwolofs.congestion_raw_segments USING btree -(segment_id ASC NULLS LAST, dt ASC NULLS LAST) +(segment_id ASC NULLS LAST, bin_start ASC NULLS LAST); + +-- Partitions SQL + +CREATE TABLE gwolofs.congestion_raw_segments_2023 PARTITION OF gwolofs.congestion_raw_segments +FOR VALUES FROM ('2023-01-01') TO ('2024-01-01') TABLESPACE pg_default; -COMMENT ON TABLE gwolofs.congestion_raw_corridors IS -'Stores dynamic binning results from standard HERE congestion network travel time aggregations.'; +ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2023 +OWNER TO gwolofs; + +CREATE TABLE gwolofs.congestion_raw_segments_2024 PARTITION OF gwolofs.congestion_raw_segments +FOR VALUES FROM ('2024-01-01') TO ('2025-01-01') +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2024 +OWNER TO gwolofs; + +CREATE TABLE gwolofs.congestion_raw_segments_2025 PARTITION OF gwolofs.congestion_raw_segments +FOR VALUES FROM ('2025-01-01') TO ('2026-01-01') +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2025 +OWNER TO gwolofs; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index 1b1724675..e8c137cdf 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -18,6 +18,20 @@ DECLARE BEGIN +--using a temp table to aply the exclusion constraint should prevent the +--insert from getting bogged down by large constraint on main table over time +CREATE TEMPORARY TABLE congestion_raw_segments_temp ( + segment_id integer NOT NULL, + bin_start timestamp without time zone NOT NULL, + bin_range tsrange NOT NULL, + tt numeric, + num_obs integer, + CONSTRAINT congestion_raw_segments_exclude_temp EXCLUDE USING gist ( + bin_range WITH &&, + segment_id WITH = + ) +); + EXECUTE FORMAT( $$ WITH segments AS ( @@ -32,7 +46,6 @@ EXECUTE FORMAT( segment_5min_bins AS ( SELECT links.segment_id, - timerange(tg.start_tod, tg.end_tod, '[)') AS time_grp, ta.tx, RANK() OVER w AS bin_rank, links.total_length, @@ -44,21 +57,16 @@ EXECUTE FORMAT( ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, ARRAY_AGG(links.length ORDER BY link_dir) AS lengths FROM here.ta_path AS ta - JOIN gwolofs.congestion_time_grps AS tg ON - ta.tx >= %1$L::date + tg.start_tod - AND ta.tx < %1$L::date + tg.end_tod JOIN segments AS links USING (link_dir) WHERE ta.dt >= %1$L::date AND ta.dt < %1$L::date + interval '1 day' GROUP BY links.segment_id, - tg.start_tod, - tg.end_tod, ta.tx, links.total_length WINDOW w AS ( - PARTITION BY links.segment_id, tg.start_tod, tg.end_tod + PARTITION BY links.segment_id ORDER BY ta.tx ) ), @@ -69,7 +77,6 @@ EXECUTE FORMAT( --also don't generate options past the next bin with 80%% length SELECT tx, - time_grp, segment_id, bin_rank AS start_bin, --generate all the options for the end bin within the group. @@ -89,7 +96,7 @@ EXECUTE FORMAT( ) AS end_bin FROM segment_5min_bins WINDOW w AS ( - PARTITION BY time_grp, segment_id + PARTITION BY segment_id ORDER BY tx --look only forward for end_bin options RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING @@ -98,7 +105,6 @@ EXECUTE FORMAT( unnested_db_options AS ( SELECT - dbo.time_grp, dbo.segment_id, s5b.total_length, dbo.tx AS dt_start, @@ -110,63 +116,67 @@ EXECUTE FORMAT( SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir FROM dynamic_bin_options AS dbo LEFT JOIN segment_5min_bins AS s5b - ON s5b.time_grp = dbo.time_grp - AND s5b.segment_id = dbo.segment_id + ON s5b.segment_id = dbo.segment_id AND s5b.bin_rank >= dbo.start_bin AND s5b.bin_rank <= dbo.end_bin --this join is used to get the tx info about the last bin only LEFT JOIN segment_5min_bins AS s5b_end - ON s5b_end.time_grp = dbo.time_grp - AND s5b_end.segment_id = dbo.segment_id + ON s5b_end.segment_id = dbo.segment_id AND s5b_end.bin_rank = dbo.end_bin, --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) - --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' + --dynamic bins should not exceed 15 minutes (dt_end <= dt_start + 15 min) + WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '15 minutes' GROUP BY - dbo.time_grp, dbo.segment_id, s5b.total_length, dbo.tx, --stard_bin s5b_end.tx, --end_bin unnested.link_dir, unnested.len + ), + + inserted AS ( + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + INSERT INTO congestion_raw_segments_temp AS inserted ( + bin_start, segment_id, bin_range, tt, num_obs + ) + --distinct on ensures only the shortest option gets proposed for insert + SELECT DISTINCT ON (segment_id, dt_start) + dt_start AS bin_start, + segment_id, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + segment_id, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + ORDER BY + segment_id, + dt_start, + dt_end --uses the option that ends first + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude_temp + DO NOTHING + RETURNING inserted.bin_start, inserted.segment_id, inserted.bin_range, inserted.tt, inserted.num_obs ) + + INSERT INTO gwolofs.congestion_raw_segments (dt, bin_start, segment_id, bin_range, tt, num_obs) + SELECT bin_start::date AS dt, bin_start, segment_id, bin_range, tt, num_obs + FROM inserted; - --this query contains overlapping values which get eliminated - --via on conflict with the exclusion constraint on congestion_raw_segments table. - INSERT INTO gwolofs.congestion_raw_segments ( - dt, time_grp, segment_id, bin_range, tt, num_obs - ) - --distinct on ensures only the shortest option gets proposed for insert - SELECT DISTINCT ON (time_grp, segment_id, dt_start) - dt_start::date AS dt, - time_grp, - segment_id, - tsrange(dt_start, dt_end, '[)') AS bin_range, - total_length / SUM(len) * SUM(tt) AS tt, - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment - FROM unnested_db_options - GROUP BY - time_grp, - segment_id, - dt_start, - dt_end, - total_length - HAVING SUM(len) >= 0.8 * total_length - ORDER BY - time_grp, - segment_id, - dt_start, - dt_end --uses the option that ends first - --exclusion constraint + ordered insert to prevent overlapping bins - ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude - DO NOTHING; $$, start_date, congestion_network_table ); + DROP TABLE congestion_raw_segments_temp; + END; $BODY$; From d1ccac35afab4869549fef15e2fa7856e5feee0d Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 9 Apr 2025 21:03:47 +0000 Subject: [PATCH 39/74] #1132 add trigger command for here_dynamic_binning_agg --- dags/here_dynamic_binning_agg.py | 18 +++++++++++++++--- dags/pull_here_path.py | 2 +- ...function-congestion_network_segment_agg.sql | 2 ++ .../function-congestion_select_map_version.sql | 2 ++ 4 files changed, 20 insertions(+), 4 deletions(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index e813e276b..ec2af86c9 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -1,3 +1,14 @@ +''' +To trigger for past date (range) use CLI: +for i in {0..5}; do + end_date=$(date -I -d "2023-11-02 +$i days") + airflow dags trigger -e "${end_date}" here_dynamic_binning_agg +done + +or trigger just one day: airflow dags trigger -e 2023-11-02 here_dynamic_binning_agg +`airflow dags backfill ...` doesn't work because there are no scheduled run dates in that range. +''' + import sys import os import logging @@ -25,7 +36,7 @@ default_args = { 'owner': ','.join(DAG_OWNERS), 'depends_on_past':False, - 'start_date': pendulum.datetime(2025, 4, 1, tz="America/Toronto"), + 'start_date': pendulum.datetime(2023, 1, 1, tz="America/Toronto"), 'email_on_failure': False, 'email_on_success': False, 'retries': 0, @@ -39,15 +50,16 @@ schedule=None, # triggered by `pull_here_path` DAG doc_md = doc_md, tags=["HERE", "aggregation"], + max_active_runs=1, catchup=False ) #to add: catchup, one task at a time, depends on past. def here_dynamic_binning_agg(): - aggregate_daily = SQLExecuteQueryOperator( - sql="SELECT '{{macros.ds_add(ds, -1)}}';", + sql=["DELETE FROM gwolofs.congestion_raw_segments WHERE dt = '{{ ds }}'", + "SELECT gwolofs.congestion_network_segment_agg('{{ ds }}'::date);"], task_id='aggregate_daily', conn_id='congestion_bot', autocommit=True, diff --git a/dags/pull_here_path.py b/dags/pull_here_path.py index 6b2f0fdc7..ee6888009 100644 --- a/dags/pull_here_path.py +++ b/dags/pull_here_path.py @@ -96,7 +96,7 @@ def trigger_dags_tasks(): trigger_operator = TriggerDagRunOperator( task_id=f'trigger_{dag_id}', trigger_dag_id=dag_id, - logical_date='{{ ds }}', + logical_date='{{macros.ds_add(ds, 1)}}', reset_dag_run=True # Clear existing dag if already exists (for backfilling), old runs will not be in the logs ) trigger_operators.append(trigger_operator) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index e8c137cdf..4d89920fc 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -183,6 +183,8 @@ $BODY$; ALTER FUNCTION gwolofs.congestion_network_segment_agg(date) OWNER TO gwolofs; +GRANT EXECUTE ON FUNCTION gwolofs.congestion_network_segment_agg(date) TO congestion_bot; + COMMENT ON FUNCTION gwolofs.congestion_network_segment_agg(date) IS 'Dynamic bin aggregation of the congestion network by hour and time periods. Takes around 10 minutes to run for one day (hourly and period based aggregation)'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql index 5cdcb6ac7..5999cb713 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql @@ -28,5 +28,7 @@ $BODY$; ALTER FUNCTION gwolofs.congestion_select_map_version(date, date) OWNER TO gwolofs; +GRANT EXECUTE ON FUNCTION gwolofs.congestion_select_map_version(date, date) TO congestion_bot; + COMMENT ON FUNCTION gwolofs.congestion_select_map_version IS 'Implement TT App selectMapVersion.py'; From 98d7b95276d9a579e02c13d79f72d4644843c5c6 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 11 Apr 2025 16:14:24 +0000 Subject: [PATCH 40/74] #1132 add temp aggregation end date --- dags/here_dynamic_binning_agg.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index ec2af86c9..4c8301df3 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -37,6 +37,8 @@ 'owner': ','.join(DAG_OWNERS), 'depends_on_past':False, 'start_date': pendulum.datetime(2023, 1, 1, tz="America/Toronto"), + #aggregation doesn't work on 24_4 yet (no congestion.network_links_24_4) + 'end_date': pendulum.datetime(2025, 3, 17, tz="America/Toronto"), 'email_on_failure': False, 'email_on_success': False, 'retries': 0, From 9e37d4a1e4513b378bde87791c4652025cc4cfa0 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 3 Jun 2025 19:49:06 +0000 Subject: [PATCH 41/74] #1132 an overloaded/simplified version of congestion_cache_tt_results_daily --- .../traffic/sql/dynamic_bins/corridor_agg.sql | 14 ++++++++++ .../function-congestion_cache_tt_results.sql | 27 +++++++++++++++++++ 2 files changed, 41 insertions(+) create mode 100644 here/traffic/sql/dynamic_bins/corridor_agg.sql diff --git a/here/traffic/sql/dynamic_bins/corridor_agg.sql b/here/traffic/sql/dynamic_bins/corridor_agg.sql new file mode 100644 index 000000000..5e81033f1 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/corridor_agg.sql @@ -0,0 +1,14 @@ +--test: 35 projects, 1 day = 47s +SELECT gwolofs.congestion_cache_tt_results_daily( + node_start := congestion_corridors.node_start, + node_end := congestion_corridors.node_end, + start_date := dates.dt::date +) +FROM gwolofs.congestion_corridors +JOIN gwolofs.congestion_projects USING (project_id), +generate_series('2025-02-01', '2025-02-28', '1 day'::interval) AS dates(dt) +WHERE + congestion_projects.description IN ( + 'bluetooth_corridors', 'scrutinized-cycleway-corridors' + ) + AND map_version = '23_4'; \ No newline at end of file diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 4529296df..105f2766d 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -200,3 +200,30 @@ OWNER TO gwolofs; COMMENT ON FUNCTION gwolofs.congestion_cache_tt_results IS 'Caches the dynamic binning results for a request.'; + +-- overload the function for more straightforward situation of daily corridor agg +CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results_daily( + start_date date, + node_start bigint, + node_end bigint +) +RETURNS void +LANGUAGE sql +COST 100 +VOLATILE PARALLEL UNSAFE +AS +$BODY$ +SELECT gwolofs.congestion_cache_tt_results( + uri_string := NULL::text, + start_date := congestion_cache_tt_results_daily.start_date, + end_date := congestion_cache_tt_results_daily.start_date + 1, + start_tod := '00:00'::time without time zone, + end_tod := '24:00'::time without time zone, + dow_list := ARRAY[extract('isodow' from congestion_cache_tt_results_daily.start_date)]::int[], + node_start := congestion_cache_tt_results_daily.node_start, + node_end := congestion_cache_tt_results_daily.node_end, + holidays := True) +$BODY$; + +COMMENT ON FUNCITON gwolofs.congestion_cache_tt_results_daily +IS 'A simplified version of `congestion_cache_tt_results` for aggregating entire days of data.' \ No newline at end of file From 79b7cf75d490ab991e282a7e95893add63ea1b46 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 3 Jun 2025 19:49:44 +0000 Subject: [PATCH 42/74] #1132 add project table, fkey, and corridor descriptions --- .../create-table-congestion_corridors.sql | 11 +++++++++- .../create-table-congestion_projects.sql | 22 +++++++++++++++++++ .../function-congestion_cache_corridor.sql | 12 ++++++---- 3 files changed, 40 insertions(+), 5 deletions(-) create mode 100644 here/traffic/sql/dynamic_bins/create-table-congestion_projects.sql diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql index 529d26905..827bb6710 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql @@ -12,7 +12,16 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_corridors node_start bigint NOT NULL, node_end bigint NOT NULL, map_version text COLLATE pg_catalog."default" NOT NULL, - CONSTRAINT congestion_corridors_pkey PRIMARY KEY (node_start, node_end, map_version) + corridor_streets text COLLATE pg_catalog."default", + corridor_start text COLLATE pg_catalog."default", + corridor_end text COLLATE pg_catalog."default", + project_id integer, + CONSTRAINT congestion_corridors_pkey PRIMARY KEY (node_start, node_end, map_version), + CONSTRAINT project_id_fk FOREIGN KEY (project_id) + REFERENCES gwolofs.congestion_projects (project_id) MATCH SIMPLE + ON UPDATE NO ACTION + ON DELETE NO ACTION + NOT VALID ) TABLESPACE pg_default; diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_projects.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_projects.sql new file mode 100644 index 000000000..67ae3a2bc --- /dev/null +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_projects.sql @@ -0,0 +1,22 @@ +-- Table: gwolofs.congestion_projects + +-- DROP TABLE IF EXISTS gwolofs.congestion_projects; + +CREATE TABLE IF NOT EXISTS gwolofs.congestion_projects +( + project_id integer NOT NULL DEFAULT nextval('congestion_projects_project_id_seq'::regclass), + description text COLLATE pg_catalog."default" NOT NULL, + CONSTRAINT congestion_projects_pkey PRIMARY KEY (project_id), + CONSTRAINT unique_prj_description UNIQUE NULLS NOT DISTINCT (description) +) + +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.congestion_projects +OWNER TO gwolofs; + +REVOKE ALL ON TABLE gwolofs.congestion_projects FROM bdit_humans; + +GRANT SELECT ON TABLE gwolofs.congestion_projects TO bdit_humans; + +GRANT ALL ON TABLE gwolofs.congestion_projects TO gwolofs; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql index 9840dfd7b..9d4878198 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql @@ -20,6 +20,7 @@ AS $BODY$ DECLARE routing_function text := 'get_links_btwn_nodes_' || map_version; street_geoms_table text := 'routing_streets_' || map_version; + traffic_streets_table text := 'traffic_streets_' || map_version; BEGIN @@ -49,7 +50,7 @@ EXECUTE format ( ) INSERT INTO gwolofs.congestion_corridors ( - node_start, node_end, map_version, link_dirs, lengths, geom, total_length + node_start, node_end, map_version, link_dirs, lengths, geom, total_length, corridor_streets ) SELECT %2$L AS node_start, @@ -59,9 +60,11 @@ EXECUTE format ( --lengths in m ARRAY_AGG(st_length(st_transform(streets.geom, 2952)) ORDER BY rl.seq) AS lengths, st_union(st_linemerge(streets.geom)) AS geom, - SUM(ST_Length(ST_Transform(streets.geom, 2952))) AS total_length + SUM(ST_Length(ST_Transform(streets.geom, 2952))) AS total_length, + string_agg(DISTINCT initcap(traffic_streets.st_name), ' / ') AS corridor_streets FROM routed_links AS rl JOIN here.%5$I AS streets USING (link_dir) + LEFT JOIN here_gis.%6$I AS traffic_streets USING (link_id) --conflict would occur because of null values ON CONFLICT (node_start, node_end, map_version) DO UPDATE @@ -72,8 +75,9 @@ EXECUTE format ( RETURNING corridor_id, link_dirs, lengths, total_length $$, routing_function, node_start, node_end, -- For routed_links - map_version, -- For INSERT SELECT values - street_geoms_table -- For JOIN table + map_version, -- For INSERT / SELECT values + street_geoms_table, -- For JOIN here.%5$I AS streets + traffic_streets_table -- For LEFT JOIN here_gis.%6$I AS traffic_streets ) INTO corridor_id, link_dirs, lengths, total_length; RETURN; END; From b3a49f84207e4a89e029dd3d5a790d0e4c2d4918 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 3 Jun 2025 19:50:01 +0000 Subject: [PATCH 43/74] #1132 project / corridor demo --- .../insert_projects_and_corridors.sql | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql diff --git a/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql b/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql new file mode 100644 index 000000000..62c107fc0 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql @@ -0,0 +1,46 @@ +--for naming corridor_streets. +--need help with corridor_start and corridor_end locations - not sure how to turn here nodes into names. Intersection conflation? +WITH named_corridors AS ( + SELECT corridor_id, string_agg(DISTINCT initcap(st_name), ' / ') AS corridor_streets + FROM gwolofs.congestion_corridors, + UNNEST (congestion_corridors.link_dirs) AS unnested(link_dir) + LEFT JOIN here_gis.traffic_streets_24_4 ON link_id = trim(trailing 'T|F' from link_dir)::int + WHERE map_version = '24_4' + GROUP BY corridor_id + ORDER BY corridor_id DESC +) + +UPDATE gwolofs.congestion_corridors AS cc +SET corridor_streets = nc.corridor_streets +FROM named_corridors AS nc +WHERE nc.corridor_id = cc.corridor_id; + +--look at bluetooth corridors +REFRESH MATERIALIZED VIEW bluetooth.here_cn_23_4_lookup; + +--cache project +WITH project AS ( + INSERT INTO gwolofs.congestion_projects (description) + VALUES ('bluetooth_corridors') + RETURNING project_id +), + +--cache corridors, repeat with multiple map versions +corridors AS ( + SELECT corridor_id + FROM bluetooth.here_cn_23_4_lookup AS bt, + gwolofs.congestion_cache_corridor(bt.here_fnode, bt.here_tnode, '24_4') +) + +--add project_id to corridors +UPDATE gwolofs.congestion_corridors +SET project_id = (SELECT project_id FROM project) +WHERE corridor_id IN (SELECT corridor_id FROM corridors) +RETURNING corridor_id; + +--examine the projects +SELECT congestion_corridors.* +FROM gwolofs.congestion_corridors +JOIN gwolofs.congestion_projects USING (project_id) +WHERE congestion_projects.description IN ('bluetooth_corridors', 'scrutinized-cycleway-corridors') + From c3501a7e91e837b00c5191e3580b786d1f6dfbcc Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 4 Jun 2025 20:24:59 +0000 Subject: [PATCH 44/74] #1132 add node start/end names to corridors --- .../function-congestion_cache_corridor.sql | 32 ++++++++++++++++--- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql index 9d4878198..da926770f 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql @@ -21,6 +21,7 @@ DECLARE routing_function text := 'get_links_btwn_nodes_' || map_version; street_geoms_table text := 'routing_streets_' || map_version; traffic_streets_table text := 'traffic_streets_' || map_version; + routing_nodes_table text := 'routing_nodes_' || map_version; BEGIN @@ -50,7 +51,8 @@ EXECUTE format ( ) INSERT INTO gwolofs.congestion_corridors ( - node_start, node_end, map_version, link_dirs, lengths, geom, total_length, corridor_streets + node_start, node_end, map_version, link_dirs, lengths, geom, + total_length, corridor_streets, corridor_start, corridor_end ) SELECT %2$L AS node_start, @@ -61,23 +63,43 @@ EXECUTE format ( ARRAY_AGG(st_length(st_transform(streets.geom, 2952)) ORDER BY rl.seq) AS lengths, st_union(st_linemerge(streets.geom)) AS geom, SUM(ST_Length(ST_Transform(streets.geom, 2952))) AS total_length, - string_agg(DISTINCT initcap(traffic_streets.st_name), ' / ') AS corridor_streets + string_agg(DISTINCT initcap(traffic_streets.st_name), + ' / ' ORDER BY initcap(traffic_streets.st_name)) AS corridor_streets, + string_agg(DISTINCT initcap(from_streets.st_name), + ' / ' ORDER BY initcap(from_streets.st_name)) AS corridor_start, + string_agg(DISTINCT initcap(to_streets.st_name), + ' / ' ORDER BY initcap(to_streets.st_name)) AS corridor_end FROM routed_links AS rl JOIN here.%5$I AS streets USING (link_dir) LEFT JOIN here_gis.%6$I AS traffic_streets USING (link_id) + LEFT JOIN here.%7$I AS from_node ON from_node.node_id = %2$L + LEFT JOIN here_gis.%6$I AS from_streets + ON from_node.link_id = from_streets.link_id + AND from_streets.st_name <> traffic_streets.st_name + AND from_streets.st_name IS NOT NULL + LEFT JOIN here.%7$I AS to_node ON to_node.node_id = %3$L + LEFT JOIN here_gis.%6$I AS to_streets + ON to_node.link_id = to_streets.link_id + AND to_streets.st_name <> traffic_streets.st_name + AND to_streets.st_name IS NOT NULL --conflict would occur because of null values ON CONFLICT (node_start, node_end, map_version) DO UPDATE SET link_dirs = excluded.link_dirs, lengths = excluded.lengths, - total_length = excluded.total_length + total_length = excluded.total_length, + corridor_streets = excluded.corridor_streets, + corridor_start = excluded.corridor_start, + corridor_end = excluded.corridor_end + --returned values are used by fn congestion_cache_tt_results RETURNING corridor_id, link_dirs, lengths, total_length $$, routing_function, node_start, node_end, -- For routed_links map_version, -- For INSERT / SELECT values street_geoms_table, -- For JOIN here.%5$I AS streets - traffic_streets_table -- For LEFT JOIN here_gis.%6$I AS traffic_streets + traffic_streets_table, -- For LEFT JOIN here_gis.%6$I AS traffic_streets + routing_nodes_table -- For LEFT JOIN here.%7$I AS from_node / to_node ) INTO corridor_id, link_dirs, lengths, total_length; RETURN; END; @@ -90,4 +112,4 @@ COMMENT ON FUNCTION gwolofs.congestion_cache_corridor IS 'Returns definition of a HERE corridor, given input nodes and map_version. First checks if corridor has already been cached and if so retrieves the cached values. If not, a new entry is added to gwolofs.congestion_corridors -table and returned.'; +table and returned.'; \ No newline at end of file From 0254db5c916f4993c30bbdcf4033a72ca834db4a Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 5 Jun 2025 18:34:53 +0000 Subject: [PATCH 45/74] #1132 reconcile some differences between segment and corridor functions --- .../function-congestion_cache_tt_results.sql | 128 +++++++++++------- ...unction-congestion_network_segment_agg.sql | 38 +++--- 2 files changed, 103 insertions(+), 63 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 105f2766d..9cfbf8c4d 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -23,23 +23,41 @@ DECLARE map_version text; BEGIN +--using a temp table to aply the exclusion constraint should prevent the +--insert from getting bogged down by large constraint on main table over time +CREATE TEMPORARY TABLE congestion_raw_corridors_temp ( + corridor_id smallint, + time_grp timerange NOT NULL, + bin_range tsrange NOT NULL, + tt numeric, + num_obs integer, + uri_string text, + dt date, + CONSTRAINT congestion_raw_corridors_exclude_temp EXCLUDE USING gist ( + bin_range WITH &&, + corridor_id WITH =, + time_grp WITH =, + uri_string WITH = + ) +); + SELECT gwolofs.congestion_select_map_version( congestion_cache_tt_results.start_date, congestion_cache_tt_results.end_date ) INTO map_version; -EXECUTE format( +EXECUTE FORMAT( $$ - WITH segment AS ( + WITH corridor AS ( SELECT - corridor_id, + ccc.corridor_id, unnested.link_dir, unnested.length, - total_length - FROM gwolofs.congestion_cache_corridor(%L, %L, %L), + ccc.total_length + FROM gwolofs.congestion_cache_corridor(%1$L, %2$L, %3$L) AS ccc, UNNEST( - congestion_cache_corridor.link_dirs, - congestion_cache_corridor.lengths + ccc.link_dirs, + ccc.lengths ) AS unnested(link_dir, length) ), @@ -49,8 +67,8 @@ EXECUTE format( ta.tx, seg.total_length, tsrange( - ta.dt + %L::time, - ta.dt + %L::time, '[)') AS time_grp, + ta.dt + %4$L::time, + ta.dt + %5$L::time, '[)') AS time_grp, RANK() OVER w AS bin_rank, SUM(seg.length) / seg.total_length AS sum_length, SUM(seg.length) AS length_w_data, @@ -60,25 +78,25 @@ EXECUTE format( ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY ta.link_dir) AS tts, ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths FROM here.ta_path AS ta - JOIN segment AS seg USING (link_dir) + JOIN corridor AS seg USING (link_dir) WHERE ( - ta.tod >= %L + ta.tod >= %4$L AND --{ToD_and_or} - ta.tod < %L + ta.tod < %5$L ) - AND date_part('isodow', ta.dt) = ANY(%L::int[]) - AND ta.dt >= %L - AND ta.dt < %L + AND date_part('isodow', ta.dt) = ANY(%6$L::int[]) + AND ta.dt >= %7$L + AND ta.dt < %8$L /*--{holiday_clause} AND NOT EXISTS ( SELECT 1 FROM ref.holiday WHERE ta.dt = holiday.dt )*/ GROUP BY + seg.corridor_id, ta.tx, ta.dt, - seg.total_length, - seg.corridor_id + seg.total_length WINDOW w AS ( PARTITION BY seg.corridor_id, ta.dt ORDER BY ta.tx @@ -86,11 +104,12 @@ EXECUTE format( ), dynamic_bin_options AS ( - --within each segment/hour, generate all possible forward looking bin combinations + --within each corridor/hour, generate all possible forward looking bin combinations --don't generate options for bins with sufficient length --also don't generate options past the next bin with 80%% length SELECT tx, + corridor_id, time_grp, bin_rank AS start_bin, --generate all the options for the end bin within the group. @@ -113,7 +132,7 @@ EXECUTE format( ) AS end_bin FROM segment_5min_bins WINDOW w AS ( - PARTITION BY time_grp + PARTITION BY corridor_id, time_grp ORDER BY tx --look only forward for end_bin options RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING @@ -143,6 +162,8 @@ EXECUTE format( AND s5b_end.bin_rank = dbo.end_bin, --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + --WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' GROUP BY s5b.corridor_id, dbo.time_grp, @@ -151,44 +172,57 @@ EXECUTE format( s5b_end.tx, --end_bin unnested.link_dir, unnested.len - --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - --HAVING MAX(s5b.tx) + interval '5 minutes' <= dbo.tx + interval '1 hour' + ), + + inserted AS ( + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + INSERT INTO congestion_raw_corridors_temp AS inserted ( + uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs + ) + --distinct on ensures only the shortest option gets proposed for insert + SELECT DISTINCT ON (dt_start) + %9$L, --uristring + dt_start::date AS dt, + timerange(lower(time_grp)::time, upper(time_grp)::time, '[)') AS time_grp, + corridor_id, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + time_grp, + corridor_id, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + ORDER BY + dt_start, + dt_end + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT congestion_raw_corridors_exclude_temp + DO NOTHING + RETURNING inserted.uri_string, inserted.dt, inserted.time_grp, inserted.corridor_id, inserted.bin_range, inserted.tt, inserted.num_obs ) + --insert into the final table INSERT INTO gwolofs.congestion_raw_corridors ( uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs ) - --this query contains overlapping values which get eliminated - --via on conflict with the exclusion constraint on congestion_raw_segments table. - SELECT DISTINCT ON (dt_start) --distinct on ensures only the shortest option gets proposed for insert - %L, - dt_start::date AS dt, - timerange(lower(time_grp)::time, upper(time_grp)::time, '[)') AS time_grp, - corridor_id, - tsrange(dt_start, dt_end, '[)') AS bin_range, - total_length / SUM(len) * SUM(tt) AS tt, - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment - FROM unnested_db_options - GROUP BY - time_grp, - corridor_id, - dt_start, - dt_end, - total_length - HAVING SUM(len) >= 0.8 * total_length - ORDER BY - dt_start, - dt_end - --exclusion constraint + ordered insert to prevent overlapping bins - ON CONFLICT ON CONSTRAINT congestion_raw_corridors_exclude - DO NOTHING; + SELECT uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs + FROM inserted + ON CONFLICT DO NOTHING; + $$, node_start, node_end, map_version, --segment CTE start_tod, end_tod, --segment_5min_bins CTE SELECT - start_tod, end_tod, dow_list, start_date, end_date, --segment_5min_bins CTE WHERE - congestion_cache_tt_results.uri_string, congestion_cache_tt_results.uri_string --INSERT + dow_list, start_date, end_date, --segment_5min_bins CTE WHERE + congestion_cache_tt_results.uri_string --INSERT ); + DROP TABLE congestion_raw_corridors_temp; + END; $BODY$; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index 4d89920fc..813c37203 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -45,28 +45,28 @@ EXECUTE FORMAT( segment_5min_bins AS ( SELECT - links.segment_id, + seg.segment_id, ta.tx, + seg.total_length, RANK() OVER w AS bin_rank, - links.total_length, - SUM(links.length) / links.total_length AS sum_length, - SUM(links.length) AS length_w_data, - SUM(links.length / ta.mean * 3.6) AS unadjusted_tt, + SUM(seg.length) / seg.total_length AS sum_length, + SUM(seg.length) AS length_w_data, + SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt, SUM(sample_size) AS num_obs, - ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs, - ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts, - ARRAY_AGG(links.length ORDER BY link_dir) AS lengths + ARRAY_AGG(ta.link_dir ORDER BY ta.link_dir) AS link_dirs, + ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY ta.link_dir) AS tts, + ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths FROM here.ta_path AS ta - JOIN segments AS links USING (link_dir) + JOIN segments AS seg USING (link_dir) WHERE ta.dt >= %1$L::date AND ta.dt < %1$L::date + interval '1 day' GROUP BY - links.segment_id, + seg.segment_id, ta.tx, - links.total_length + seg.total_length WINDOW w AS ( - PARTITION BY links.segment_id + PARTITION BY seg.segment_id ORDER BY ta.tx ) ), @@ -90,7 +90,10 @@ EXECUTE FORMAT( --dont need to generate options when start segment is already sufficient WHEN sum_length >= 0.8 THEN bin_rank --generate options until 1 bin has sufficient length, otherwise until last bin in group - ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w) + ELSE COALESCE( + MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, + MAX(bin_rank) OVER w + ) END, 1 ) AS end_bin @@ -166,11 +169,14 @@ EXECUTE FORMAT( RETURNING inserted.bin_start, inserted.segment_id, inserted.bin_range, inserted.tt, inserted.num_obs ) - INSERT INTO gwolofs.congestion_raw_segments (dt, bin_start, segment_id, bin_range, tt, num_obs) + INSERT INTO gwolofs.congestion_raw_segments ( + dt, bin_start, segment_id, bin_range, tt, num_obs + ) SELECT bin_start::date AS dt, bin_start, segment_id, bin_range, tt, num_obs - FROM inserted; + FROM inserted + ON CONFLICT DO NOTHING; - $$, + $$, start_date, congestion_network_table ); From bbf677954cad2d1f92e4a1e0e7d77ae3742ac5d8 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 6 Jun 2025 19:34:29 +0000 Subject: [PATCH 46/74] #1132 account for streets_valid_range_path --- .../function-congestion_cache_tt_results.sql | 3 +- ...unction-congestion_network_segment_agg.sql | 2 +- ...function-congestion_select_map_version.sql | 40 ++++++++++++------- 3 files changed, 29 insertions(+), 16 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 9cfbf8c4d..39932d0df 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -43,7 +43,8 @@ CREATE TEMPORARY TABLE congestion_raw_corridors_temp ( SELECT gwolofs.congestion_select_map_version( congestion_cache_tt_results.start_date, - congestion_cache_tt_results.end_date + congestion_cache_tt_results.end_date, + 'path' ) INTO map_version; EXECUTE FORMAT( diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index 813c37203..e9d587931 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -12,7 +12,7 @@ VOLATILE PARALLEL UNSAFE AS $BODY$ DECLARE - map_version text := gwolofs.congestion_select_map_version(start_date, start_date + 1); + map_version text := gwolofs.congestion_select_map_version(start_date, start_date + 1, 'path'); congestion_network_table text := 'network_links_' || map_version || CASE map_version WHEN '23_4' THEN '_geom' ELSE '' END; --temp fix version diff --git a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql index 5999cb713..71c635e7b 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql @@ -4,31 +4,43 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_select_map_version( start_date date, - end_date date + end_date date, + agg_type text default null, --null or 'path' + OUT selected_version text ) RETURNS text -LANGUAGE sql +LANGUAGE plpgsql COST 100 STABLE PARALLEL SAFE AS $BODY$ -SELECT street_version -FROM here.street_valid_range AS svr, -LATERAL ( - SELECT svr.valid_range * daterange( - congestion_select_map_version.start_date, - congestion_select_map_version.end_date, '[)') AS overlap -) AS lat -WHERE UPPER(lat.overlap) - LOWER(lat.overlap) IS NOT NULL -ORDER BY UPPER(lat.overlap) - LOWER(lat.overlap) DESC NULLS LAST -LIMIT 1; +DECLARE + svr text := 'street_valid_range' || CASE agg_type WHEN 'path' THEN '_path' ELSE '' END; +BEGIN +EXECUTE FORMAT( + $$ + SELECT street_version + FROM here.%I AS svr, + LATERAL ( + SELECT svr.valid_range * daterange(%L, %L, '[)') AS overlap + ) AS lat + WHERE UPPER(lat.overlap) - LOWER(lat.overlap) IS NOT NULL + ORDER BY UPPER(lat.overlap) - LOWER(lat.overlap) DESC NULLS LAST + LIMIT 1; + $$, svr, congestion_select_map_version.start_date, congestion_select_map_version.end_date +) INTO selected_version; +END; $BODY$; -ALTER FUNCTION gwolofs.congestion_select_map_version(date, date) +ALTER FUNCTION gwolofs.congestion_select_map_version(date, date, text) OWNER TO gwolofs; -GRANT EXECUTE ON FUNCTION gwolofs.congestion_select_map_version(date, date) TO congestion_bot; +GRANT EXECUTE ON FUNCTION gwolofs.congestion_select_map_version(date, date, text) TO congestion_bot; COMMENT ON FUNCTION gwolofs.congestion_select_map_version IS 'Implement TT App selectMapVersion.py'; + +--test cases +SELECT * FROM gwolofs.congestion_select_map_version('2022-01-01', '2023-01-01'); +SELECT * FROM gwolofs.congestion_select_map_version('2022-01-01', '2023-01-01', 'path'); \ No newline at end of file From e1e9e38eb4be568dc203fe38161f44cfa8a25d15 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 6 Jun 2025 20:17:42 +0000 Subject: [PATCH 47/74] #1132 fn to calculate hourly overlap --- .../dynamic_bins/function-assign_bin_hr.sql | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql diff --git a/here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql b/here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql new file mode 100644 index 000000000..59bc7c7ec --- /dev/null +++ b/here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql @@ -0,0 +1,30 @@ +CREATE OR REPLACE FUNCTION gwolofs.assign_bin_hour(bin_range tsrange) +RETURNS timestamp +LANGUAGE plpgsql +IMMUTABLE +AS $$ + DECLARE + lower_hour timestamp; + upper_hour timestamp; + + BEGIN + --calculate hour boundaries + lower_hour := date_trunc('hour', lower(bin_range)); + upper_hour := date_trunc('hour', upper(bin_range)); + + --early return if same hour + IF lower_hour = upper_hour THEN + RETURN lower_hour; + --if the intersection between the hours is equal or in favour of lower. + ELSIF + (least(upper(bin_range), upper_hour) - lower(bin_range)) >= + upper(bin_range) - least(upper_hour, upper(bin_range)) THEN + RETURN lower_hour; + ELSE + RETURN upper_hour; + END IF; + END; +$$; + +COMMENT ON FUNCTION gwolofs.assign_bin_hour +IS 'Assign hour to a tsrange based on how much overlap there is with start/end hour.'; From afd63a861f02c9d15ee2299e70ed1192560ec013 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 9 Jun 2025 17:55:10 +0000 Subject: [PATCH 48/74] #1132 new method to calcualte hr; midpoint --- .../create-table-congestion_raw_corridors.sql | 21 ++++++++++++- .../create-table-congestion_raw_segments.sql | 19 ++++++++++++ .../dynamic_bins/function-assign_bin_hr.sql | 30 ------------------- .../function-congestion_cache_tt_results.sql | 20 +++++++++---- ...unction-congestion_network_segment_agg.sql | 15 ++++++++-- 5 files changed, 65 insertions(+), 40 deletions(-) delete mode 100644 here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql index 9a823249c..cd6d73ee1 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql @@ -5,12 +5,13 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors ( corridor_id smallint, - dt date, time_grp timerange NOT NULL, bin_range tsrange NOT NULL, tt numeric, num_obs integer, uri_string text COLLATE pg_catalog."default", + dt date, + hr timestamp without time zone, CONSTRAINT congestion_raw_corridors_exclude EXCLUDE USING gist ( bin_range WITH &&, corridor_id WITH =, @@ -59,3 +60,21 @@ TABLESPACE pg_default; COMMENT ON TABLE gwolofs.congestion_raw_corridors IS 'Stores dynamic binning results for custom corridor based travel time requests.'; + +COMMENT ON TABLE gwolofs.congestion_raw_corridors + IS 'Stores dynamic binning results from standard HERE congestion network travel time aggregations.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_corridors.bin_range + IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_corridors.tt + IS 'Travel time in seconds.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_corridors.num_obs + IS 'The sum of the sample size from here.ta_path.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_corridors.dt + IS 'The date of aggregation for the record. Records may not overlap dates.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_corridors.hr + IS 'The hour the majority of the record occured in. Ties are rounded up.'; diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql index 940e6bf0f..dc2c090c6 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql @@ -10,6 +10,7 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments bin_range tsrange NOT NULL, tt numeric, num_obs integer, + hr timestamp without time zone, CONSTRAINT congestion_raw_segments_pkey PRIMARY KEY (segment_id, dt, bin_start) ) PARTITION BY RANGE (dt); @@ -58,3 +59,21 @@ TABLESPACE pg_default; ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2025 OWNER TO gwolofs; + +COMMENT ON COLUMN gwolofs.congestion_raw_segments.dt + IS 'The date of aggregation for the record. Records may not overlap dates.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_segments.bin_start + IS 'The start of the observation. It is recommended to use `hr` to group the bin instead. This column is used in the primary key, although the main constraint occurs during insert (non overlapping ranges).'; + +COMMENT ON COLUMN gwolofs.congestion_raw_segments.bin_range + IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_segments.tt + IS 'Travel time in seconds.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_segments.num_obs + IS 'The sum of the sample size from here.ta_path.'; + +COMMENT ON COLUMN gwolofs.congestion_raw_segments.hr + IS 'The hour the majority of the record occured in. Ties are rounded up.'; diff --git a/here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql b/here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql deleted file mode 100644 index 59bc7c7ec..000000000 --- a/here/traffic/sql/dynamic_bins/function-assign_bin_hr.sql +++ /dev/null @@ -1,30 +0,0 @@ -CREATE OR REPLACE FUNCTION gwolofs.assign_bin_hour(bin_range tsrange) -RETURNS timestamp -LANGUAGE plpgsql -IMMUTABLE -AS $$ - DECLARE - lower_hour timestamp; - upper_hour timestamp; - - BEGIN - --calculate hour boundaries - lower_hour := date_trunc('hour', lower(bin_range)); - upper_hour := date_trunc('hour', upper(bin_range)); - - --early return if same hour - IF lower_hour = upper_hour THEN - RETURN lower_hour; - --if the intersection between the hours is equal or in favour of lower. - ELSIF - (least(upper(bin_range), upper_hour) - lower(bin_range)) >= - upper(bin_range) - least(upper_hour, upper(bin_range)) THEN - RETURN lower_hour; - ELSE - RETURN upper_hour; - END IF; - END; -$$; - -COMMENT ON FUNCTION gwolofs.assign_bin_hour -IS 'Assign hour to a tsrange based on how much overlap there is with start/end hour.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 39932d0df..968a2e11a 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -32,7 +32,6 @@ CREATE TEMPORARY TABLE congestion_raw_corridors_temp ( tt numeric, num_obs integer, uri_string text, - dt date, CONSTRAINT congestion_raw_corridors_exclude_temp EXCLUDE USING gist ( bin_range WITH &&, corridor_id WITH =, @@ -179,12 +178,11 @@ EXECUTE FORMAT( --this query contains overlapping values which get eliminated --via on conflict with the exclusion constraint on congestion_raw_segments table. INSERT INTO congestion_raw_corridors_temp AS inserted ( - uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs + uri_string, time_grp, corridor_id, bin_range, tt, num_obs ) --distinct on ensures only the shortest option gets proposed for insert SELECT DISTINCT ON (dt_start) %9$L, --uristring - dt_start::date AS dt, timerange(lower(time_grp)::time, upper(time_grp)::time, '[)') AS time_grp, corridor_id, tsrange(dt_start, dt_end, '[)') AS bin_range, @@ -204,14 +202,24 @@ EXECUTE FORMAT( --exclusion constraint + ordered insert to prevent overlapping bins ON CONFLICT ON CONSTRAINT congestion_raw_corridors_exclude_temp DO NOTHING - RETURNING inserted.uri_string, inserted.dt, inserted.time_grp, inserted.corridor_id, inserted.bin_range, inserted.tt, inserted.num_obs + RETURNING + inserted.uri_string, inserted.time_grp, inserted.corridor_id, + inserted.bin_range, inserted.tt, inserted.num_obs ) --insert into the final table INSERT INTO gwolofs.congestion_raw_corridors ( - uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs + uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs, hr ) - SELECT uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs + SELECT + uri_string, + lower(bin_range)::date AS dt, + time_grp, + corridor_id, + bin_range, + tt, + num_obs, + date_trunc('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr FROM inserted ON CONFLICT DO NOTHING; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index e9d587931..e838ca00c 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -166,13 +166,22 @@ EXECUTE FORMAT( --exclusion constraint + ordered insert to prevent overlapping bins ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude_temp DO NOTHING - RETURNING inserted.bin_start, inserted.segment_id, inserted.bin_range, inserted.tt, inserted.num_obs + RETURNING + inserted.bin_start, inserted.segment_id, inserted.bin_range, + inserted.tt, inserted.num_obs ) INSERT INTO gwolofs.congestion_raw_segments ( - dt, bin_start, segment_id, bin_range, tt, num_obs + dt, bin_start, segment_id, bin_range, tt, num_obs, hr ) - SELECT bin_start::date AS dt, bin_start, segment_id, bin_range, tt, num_obs + SELECT + bin_start::date AS dt, + bin_start, + segment_id, + bin_range, + tt, + num_obs, + date_trunc('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr FROM inserted ON CONFLICT DO NOTHING; From b69fcd77e79595faaee20bc469bbc5172c1e0cf8 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 9 Jun 2025 17:55:54 +0000 Subject: [PATCH 49/74] #1132 new fn to calculate node streets --- .../function-congestion_cache_corridor.sql | 22 +++------- .../function-identify_node_streets.sql | 43 +++++++++++++++++++ 2 files changed, 48 insertions(+), 17 deletions(-) create mode 100644 here/traffic/sql/dynamic_bins/function-identify_node_streets.sql diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql index da926770f..ef95b0de5 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql @@ -21,7 +21,6 @@ DECLARE routing_function text := 'get_links_btwn_nodes_' || map_version; street_geoms_table text := 'routing_streets_' || map_version; traffic_streets_table text := 'traffic_streets_' || map_version; - routing_nodes_table text := 'routing_nodes_' || map_version; BEGIN @@ -65,23 +64,13 @@ EXECUTE format ( SUM(ST_Length(ST_Transform(streets.geom, 2952))) AS total_length, string_agg(DISTINCT initcap(traffic_streets.st_name), ' / ' ORDER BY initcap(traffic_streets.st_name)) AS corridor_streets, - string_agg(DISTINCT initcap(from_streets.st_name), - ' / ' ORDER BY initcap(from_streets.st_name)) AS corridor_start, - string_agg(DISTINCT initcap(to_streets.st_name), - ' / ' ORDER BY initcap(to_streets.st_name)) AS corridor_end + gwolofs.identify_node_streets(%2$L, %4$L, + array_agg(DISTINCT initcap(traffic_streets.st_name))) AS corridor_start, + gwolofs.identify_node_streets(%3$L, %4$L, + array_agg(DISTINCT initcap(traffic_streets.st_name))) AS corridor_end FROM routed_links AS rl JOIN here.%5$I AS streets USING (link_dir) LEFT JOIN here_gis.%6$I AS traffic_streets USING (link_id) - LEFT JOIN here.%7$I AS from_node ON from_node.node_id = %2$L - LEFT JOIN here_gis.%6$I AS from_streets - ON from_node.link_id = from_streets.link_id - AND from_streets.st_name <> traffic_streets.st_name - AND from_streets.st_name IS NOT NULL - LEFT JOIN here.%7$I AS to_node ON to_node.node_id = %3$L - LEFT JOIN here_gis.%6$I AS to_streets - ON to_node.link_id = to_streets.link_id - AND to_streets.st_name <> traffic_streets.st_name - AND to_streets.st_name IS NOT NULL --conflict would occur because of null values ON CONFLICT (node_start, node_end, map_version) DO UPDATE @@ -98,8 +87,7 @@ EXECUTE format ( routing_function, node_start, node_end, -- For routed_links map_version, -- For INSERT / SELECT values street_geoms_table, -- For JOIN here.%5$I AS streets - traffic_streets_table, -- For LEFT JOIN here_gis.%6$I AS traffic_streets - routing_nodes_table -- For LEFT JOIN here.%7$I AS from_node / to_node + traffic_streets_table -- For LEFT JOIN here_gis.%6$I AS traffic_streets ) INTO corridor_id, link_dirs, lengths, total_length; RETURN; END; diff --git a/here/traffic/sql/dynamic_bins/function-identify_node_streets.sql b/here/traffic/sql/dynamic_bins/function-identify_node_streets.sql new file mode 100644 index 000000000..2793e3f9f --- /dev/null +++ b/here/traffic/sql/dynamic_bins/function-identify_node_streets.sql @@ -0,0 +1,43 @@ +CREATE OR REPLACE FUNCTION gwolofs.identify_node_streets( + node bigint, + map_version text, + exclude_streets text [], + OUT streets text +) +RETURNS text +LANGUAGE plpgsql +COST 100 +VOLATILE PARALLEL SAFE +AS $BODY$ + +DECLARE + routing_nodes_table text := 'routing_nodes_' || map_version; + traffic_streets_table text := 'traffic_streets_' || map_version; + +BEGIN +EXECUTE format ( + $$ + SELECT string_agg(DISTINCT initcap(streets.st_name), ' / ' ORDER BY initcap(streets.st_name)) + FROM here.%1$I AS node + LEFT JOIN here_gis.%2$I AS streets + ON node.link_id = streets.link_id + AND NOT(initcap(streets.st_name) = ANY(%3$L)) + AND streets.st_name IS NOT NULL + WHERE node.node_id = %4$L + $$, + routing_nodes_table, + traffic_streets_table, + identify_node_streets.exclude_streets, + identify_node_streets.node +) INTO streets; + +RETURN; +END; +$BODY$; + +ALTER FUNCTION gwolofs.identify_node_streets(bigint, text, text []) +OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.identify_node_streets IS +'Identifies the streets intersecting with a HERE node_id, given a node, map_version, +and a list of streets to exclude (generally those which form the corridor).'; From aa724cece12ae128d877c14e5253543729eb1cd7 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 30 Jun 2025 21:29:59 +0000 Subject: [PATCH 50/74] #1132 add task timeout --- dags/here_dynamic_binning_agg.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index 4c8301df3..05c57daaa 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -12,8 +12,7 @@ import sys import os import logging -import pendulum -from datetime import timedelta +from pendulum import duration, datetime from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator from airflow.models import Variable @@ -36,13 +35,13 @@ default_args = { 'owner': ','.join(DAG_OWNERS), 'depends_on_past':False, - 'start_date': pendulum.datetime(2023, 1, 1, tz="America/Toronto"), + 'start_date': datetime(2019, 1, 1, tz="America/Toronto"), #aggregation doesn't work on 24_4 yet (no congestion.network_links_24_4) - 'end_date': pendulum.datetime(2025, 3, 17, tz="America/Toronto"), + #'end_date': datetime(2025, 3, 17, tz="America/Toronto"), 'email_on_failure': False, 'email_on_success': False, - 'retries': 0, - 'retry_delay': timedelta(minutes=5), + 'retries': 1, + 'retry_delay': duration(minutes=5), 'on_failure_callback': task_fail_slack_alert } @@ -65,7 +64,8 @@ def here_dynamic_binning_agg(): task_id='aggregate_daily', conn_id='congestion_bot', autocommit=True, - retries = 0 + retries = 0, + execution_timeout=duration(minutes=30) ) aggregate_daily From 5c71af76a899e63b8654f33ba9477a42f31c2309 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 30 Jun 2025 21:30:15 +0000 Subject: [PATCH 51/74] #1132 adjust constraints --- here/traffic/sql/dynamic_bins/corridor_agg.sql | 11 ++++++++--- .../create-table-congestion_corridors.sql | 1 + .../create-table-congestion_raw_corridors.sql | 12 ++++++------ .../function-congestion_cache_tt_results.sql | 4 ++-- 4 files changed, 17 insertions(+), 11 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/corridor_agg.sql b/here/traffic/sql/dynamic_bins/corridor_agg.sql index 5e81033f1..a16c0dbd2 100644 --- a/here/traffic/sql/dynamic_bins/corridor_agg.sql +++ b/here/traffic/sql/dynamic_bins/corridor_agg.sql @@ -6,9 +6,14 @@ SELECT gwolofs.congestion_cache_tt_results_daily( ) FROM gwolofs.congestion_corridors JOIN gwolofs.congestion_projects USING (project_id), -generate_series('2025-02-01', '2025-02-28', '1 day'::interval) AS dates(dt) -WHERE +generate_series('2025-01-01', '2025-02-28', '1 day'::interval) AS dates(dt) +WHERE congestion_projects.description IN ( - 'bluetooth_corridors', 'scrutinized-cycleway-corridors' + 'Avenue Road cycleway installation', + 'bluetooth_corridors', + 'scrutinized-cycleway-corridors' + ) + AND corridor_id NOT IN ( + SELECT DISTINCT corridor_id FROM gwolofs.congestion_raw_corridors WHERE dt >= '2025-01-01' AND dt < '2025-02-28' ) AND map_version = '23_4'; \ No newline at end of file diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql index 827bb6710..2d905a19e 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql @@ -17,6 +17,7 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_corridors corridor_end text COLLATE pg_catalog."default", project_id integer, CONSTRAINT congestion_corridors_pkey PRIMARY KEY (node_start, node_end, map_version), + CONSTRAINT corridor_pkey UNIQUE NULLS NOT DISTINCT (corridor_id), CONSTRAINT project_id_fk FOREIGN KEY (project_id) REFERENCES gwolofs.congestion_projects (project_id) MATCH SIMPLE ON UPDATE NO ACTION diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql index cd6d73ee1..9088b1a6a 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql @@ -12,12 +12,12 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors uri_string text COLLATE pg_catalog."default", dt date, hr timestamp without time zone, - CONSTRAINT congestion_raw_corridors_exclude EXCLUDE USING gist ( - bin_range WITH &&, - corridor_id WITH =, - time_grp WITH =, - uri_string WITH = - ) + CONSTRAINT congestion_raw_corridors_pkey PRIMARY KEY (corridor_id, bin_range, time_grp), + CONSTRAINT corridor_fkey FOREIGN KEY (corridor_id) + REFERENCES gwolofs.congestion_corridors (corridor_id) MATCH SIMPLE + ON UPDATE NO ACTION + ON DELETE CASCADE + NOT VALID ) TABLESPACE pg_default; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 968a2e11a..ff29ab8b5 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -36,7 +36,7 @@ CREATE TEMPORARY TABLE congestion_raw_corridors_temp ( bin_range WITH &&, corridor_id WITH =, time_grp WITH =, - uri_string WITH = + coalesce(uri_string, '') WITH = --this is the only column in constraint which is nullable ) ); @@ -268,5 +268,5 @@ SELECT gwolofs.congestion_cache_tt_results( holidays := True) $BODY$; -COMMENT ON FUNCITON gwolofs.congestion_cache_tt_results_daily +COMMENT ON FUNCTION gwolofs.congestion_cache_tt_results_daily IS 'A simplified version of `congestion_cache_tt_results` for aggregating entire days of data.' \ No newline at end of file From ecb658591b64ef6695199821a53b8a2ac93b6e5c Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 15 Jul 2025 17:53:25 +0000 Subject: [PATCH 52/74] #1132 add max bin length constraint --- .../sql/dynamic_bins/function-congestion_cache_tt_results.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index ff29ab8b5..4398838e9 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -163,7 +163,7 @@ EXECUTE FORMAT( --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - --WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour' + WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '30 minutes' GROUP BY s5b.corridor_id, dbo.time_grp, From d2dafe6c2d2d7a1b5bd113c4ee31911854499991 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Tue, 15 Jul 2025 17:53:55 +0000 Subject: [PATCH 53/74] #1132 add DROP (temp) TABLE IF EXISTS --- .../sql/dynamic_bins/function-congestion_cache_tt_results.sql | 1 + .../sql/dynamic_bins/function-congestion_network_segment_agg.sql | 1 + 2 files changed, 2 insertions(+) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 4398838e9..f55190539 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -25,6 +25,7 @@ BEGIN --using a temp table to aply the exclusion constraint should prevent the --insert from getting bogged down by large constraint on main table over time +DROP TABLE IF EXISTS congestion_raw_corridors_temp; CREATE TEMPORARY TABLE congestion_raw_corridors_temp ( corridor_id smallint, time_grp timerange NOT NULL, diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index e838ca00c..557c81756 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -20,6 +20,7 @@ BEGIN --using a temp table to aply the exclusion constraint should prevent the --insert from getting bogged down by large constraint on main table over time +DROP TABLE IF EXISTS congestion_raw_segments_temp; CREATE TEMPORARY TABLE congestion_raw_segments_temp ( segment_id integer NOT NULL, bin_start timestamp without time zone NOT NULL, From 3ff60e4c6ce58c6b4b30f98ab0bad161c978de99 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 16 Jul 2025 18:38:23 +0000 Subject: [PATCH 54/74] #1132 add task timeout --- dags/here_dynamic_binning_agg.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index 05c57daaa..2e89c0e2d 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -42,7 +42,7 @@ 'email_on_success': False, 'retries': 1, 'retry_delay': duration(minutes=5), - 'on_failure_callback': task_fail_slack_alert + #'on_failure_callback': task_fail_slack_alert } @dag( @@ -64,8 +64,8 @@ def here_dynamic_binning_agg(): task_id='aggregate_daily', conn_id='congestion_bot', autocommit=True, - retries = 0, - execution_timeout=duration(minutes=30) + retries = 1, + execution_timeout=duration(hours=1) ) aggregate_daily From bb3880038648ac09a3ef6559f084bef72a29858f Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 30 Jul 2025 20:10:04 +0000 Subject: [PATCH 55/74] #1132 monthly agg dag --- dags/here_dynamic_binning_monthly_agg.py | 73 +++++++++++++++++++ ...ble-congestion_segments_monthy_summary.sql | 30 ++++++++ ...unction-congestion_segment_monthly_agg.sql | 51 +++++++++++++ .../select-check_missing_days.sql | 19 +++++ 4 files changed, 173 insertions(+) create mode 100644 dags/here_dynamic_binning_monthly_agg.py create mode 100644 here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql create mode 100644 here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql create mode 100644 here/traffic/sql/dynamic_bins/select-check_missing_days.sql diff --git a/dags/here_dynamic_binning_monthly_agg.py b/dags/here_dynamic_binning_monthly_agg.py new file mode 100644 index 000000000..cd42d9b38 --- /dev/null +++ b/dags/here_dynamic_binning_monthly_agg.py @@ -0,0 +1,73 @@ +import os +import sys +import logging +from datetime import timedelta +from pendulum import duration, datetime + +from airflow.models import Variable +from airflow.decorators import dag +from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator + +try: + repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) + sys.path.insert(0, repo_path) + from dags.dag_functions import task_fail_slack_alert + from dags.custom_operators import SQLCheckOperatorWithReturnValue +except: + raise ImportError("Cannot import slack alert functions") + +LOGGER = logging.getLogger(__name__) +logging.basicConfig(level=logging.DEBUG) + +doc_md = "This DAG is running off the `1132-here-aggregation-proposal` branch to test dynamic binning aggregation." +DAG_NAME = 'here_dynamic_binning_monthly_agg' +DAG_OWNERS = Variable.get('dag_owners', deserialize_json=True).get(DAG_NAME, ["Unknown"]) + +default_args = { + 'owner': ','.join(DAG_OWNERS), + 'depends_on_past':False, + 'start_date': datetime(2019, 1, 1, tz="America/Toronto"), + 'email_on_failure': False, + 'email_on_success': False, + 'retries': 1, + 'retry_delay': duration(hours=1), + 'on_failure_callback': task_fail_slack_alert +} + +@dag( + DAG_NAME, + default_args=default_args, + schedule='* 10 1 * *', # 10am, first day of month + template_searchpath=os.path.join(repo_path,'here/traffic/sql/dynamic_bins'), + doc_md = doc_md, + tags=["HERE", "aggregation"], + max_active_runs=1, + catchup=True +) + +#to add: catchup, one task at a time, depends on past. + +def here_dynamic_binning_monthly_agg(): + + check_missing_dates = SQLCheckOperatorWithReturnValue( + sql="select-check_missing_days.sql", + task_id="check_missing_dates", + conn_id='congestion_bot', + retries = 1, + execution_timeout=timedelta(minutes=10) + ) + + aggregate_monthly = SQLExecuteQueryOperator( + sql=[ + "DELETE FROM gwolofs.congestion_segments_monthy_summary WHERE mnth = '{{ ds }}'", + "SELECT gwolofs.congestion_segment_monthly_agg('{{ ds }}')" + ], + task_id='aggregate_monthly', + conn_id='congestion_bot', + autocommit=True, + retries = 1, + execution_timeout=timedelta(hours=1) + ) + check_missing_dates >> aggregate_monthly + +here_dynamic_binning_monthly_agg() \ No newline at end of file diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql new file mode 100644 index 000000000..462ae6b59 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql @@ -0,0 +1,30 @@ +-- Table: gwolofs.congestion_segments_monthy_summary + +-- DROP TABLE IF EXISTS gwolofs.congestion_segments_monthy_summary; + +CREATE TABLE IF NOT EXISTS gwolofs.congestion_segments_monthy_summary +( + segment_id integer, + mnth date, + is_wkdy boolean, + hr double precision, + avg_tt numeric, + stdev numeric, + percentile_05 numeric, + percentile_15 numeric, + percentile_50 numeric, + percentile_85 numeric, + percentile_95 numeric, + num_quasi_obs bigint +) + +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.congestion_segments_monthy_summary +OWNER TO gwolofs; + +REVOKE ALL ON TABLE gwolofs.congestion_segments_monthy_summary FROM bdit_humans; + +GRANT SELECT ON TABLE gwolofs.congestion_segments_monthy_summary TO bdit_humans; + +GRANT ALL ON TABLE gwolofs.congestion_segments_monthy_summary TO gwolofs; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql new file mode 100644 index 000000000..b80610c33 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql @@ -0,0 +1,51 @@ +-- FUNCTION: gwolofs.congestion_segment_monthly_agg(date) + +-- DROP FUNCTION IF EXISTS gwolofs.congestion_segment_monthly_agg(date); + +CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_monthly_agg( + mon date) + RETURNS void + LANGUAGE 'sql' + COST 100 + VOLATILE PARALLEL UNSAFE +AS $BODY$ + +INSERT INTO gwolofs.congestion_segments_monthy_summary ( + segment_id, mnth, is_wkdy, hr, avg_tt, stdev, percentile_05, percentile_15, + percentile_50, percentile_85, percentile_95, num_quasi_obs +) +SELECT + segment_id, + congestion_segment_monthly_agg.mon AS mnth, + date_part('isodow', dt) <= 5 AS is_wkdy, + date_part('hour', hr) AS hr, + ROUND(AVG(tt), 2) AS avg_tt, + ROUND(stddev(tt), 2) AS stdev, + ROUND(PERCENTILE_CONT(0.05) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_05, + ROUND(PERCENTILE_CONT(0.15) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_15, + ROUND(PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_50, + ROUND(PERCENTILE_CONT(0.85) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_85, + ROUND(PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_95, + COUNT(*) AS num_quasi_obs +FROM gwolofs.congestion_raw_segments +LEFT JOIN ref.holiday USING (dt) +WHERE + dt >= congestion_segment_monthly_agg.mon + AND dt < congestion_segment_monthly_agg.mon + interval '1 month' + AND holiday.holiday IS NULL +GROUP BY + segment_id, + date_part('hour', hr), + is_wkdy; + +$BODY$; + +ALTER FUNCTION gwolofs.congestion_segment_monthly_agg(date) + OWNER TO gwolofs; + +GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO PUBLIC; + +GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO congestion_bot; + +GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO gwolofs; + diff --git a/here/traffic/sql/dynamic_bins/select-check_missing_days.sql b/here/traffic/sql/dynamic_bins/select-check_missing_days.sql new file mode 100644 index 000000000..a993ba57c --- /dev/null +++ b/here/traffic/sql/dynamic_bins/select-check_missing_days.sql @@ -0,0 +1,19 @@ +WITH distinct_days AS ( + SELECT DISTINCT dt + FROM gwolofs.congestion_raw_segments + WHERE + dt >= '{{ ds }}'::date + AND dt < '{{ ds }}'::date + interval '1 month' +) + +SELECT + COUNT(*) = 0, + 'The following days are missing from `congestion_raw_segments`: ' + || string_agg(dates.dt::date::text, ', ') AS summary +FROM generate_series( + '{{ ds }}'::date, + --one day before start of next month + ('{{ ds }}'::date + interval '1 month')::date - 1, + '1 day') AS dates(dt) +LEFT JOIN distinct_days USING (dt) +WHERE distinct_days.dt IS NULL; \ No newline at end of file From d742eb9bec4ff93db5388e63ea56fe7b2b32b7c8 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 30 Jul 2025 20:10:22 +0000 Subject: [PATCH 56/74] #1132 try execution_timeout with timedelta rather than duration --- dags/here_dynamic_binning_agg.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index 2e89c0e2d..0dc6d349b 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -12,6 +12,7 @@ import sys import os import logging +from datetime import timedelta from pendulum import duration, datetime from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator @@ -65,7 +66,7 @@ def here_dynamic_binning_agg(): conn_id='congestion_bot', autocommit=True, retries = 1, - execution_timeout=duration(hours=1) + execution_timeout=timedelta(hours=1) ) aggregate_daily From 70e0fc9ede3fddb4c79287b09d099ab447059035 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 30 Jul 2025 20:14:44 +0000 Subject: [PATCH 57/74] #1132 fix monthly cron schedule --- dags/here_dynamic_binning_monthly_agg.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dags/here_dynamic_binning_monthly_agg.py b/dags/here_dynamic_binning_monthly_agg.py index cd42d9b38..57b9eb201 100644 --- a/dags/here_dynamic_binning_monthly_agg.py +++ b/dags/here_dynamic_binning_monthly_agg.py @@ -37,7 +37,7 @@ @dag( DAG_NAME, default_args=default_args, - schedule='* 10 1 * *', # 10am, first day of month + schedule='0 16 1 * *', # 4pm, first day of month template_searchpath=os.path.join(repo_path,'here/traffic/sql/dynamic_bins'), doc_md = doc_md, tags=["HERE", "aggregation"], From f1679d18019a186be7447d2975b1791b197acaf2 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 28 Aug 2025 19:51:17 +0000 Subject: [PATCH 58/74] #1132 fix sql operator timeout --- dags/here_dynamic_binning_agg.py | 4 ++-- dags/here_dynamic_binning_monthly_agg.py | 5 ++--- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index 0dc6d349b..a516fcaa8 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -65,8 +65,8 @@ def here_dynamic_binning_agg(): task_id='aggregate_daily', conn_id='congestion_bot', autocommit=True, - retries = 1, - execution_timeout=timedelta(hours=1) + retries = 2, + hook_params={"options": "-c statement_timeout=10800000ms"} #3 hours ) aggregate_daily diff --git a/dags/here_dynamic_binning_monthly_agg.py b/dags/here_dynamic_binning_monthly_agg.py index 57b9eb201..fd8f1e0d9 100644 --- a/dags/here_dynamic_binning_monthly_agg.py +++ b/dags/here_dynamic_binning_monthly_agg.py @@ -31,7 +31,7 @@ 'email_on_success': False, 'retries': 1, 'retry_delay': duration(hours=1), - 'on_failure_callback': task_fail_slack_alert + #'on_failure_callback': task_fail_slack_alert } @dag( @@ -53,8 +53,7 @@ def here_dynamic_binning_monthly_agg(): sql="select-check_missing_days.sql", task_id="check_missing_dates", conn_id='congestion_bot', - retries = 1, - execution_timeout=timedelta(minutes=10) + retries = 0 ) aggregate_monthly = SQLExecuteQueryOperator( From cdb888674f9e3f57743a81d7d8d2afb332648cfa Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 28 Aug 2025 19:51:30 +0000 Subject: [PATCH 59/74] #1132 implementation of bootstrapping method --- ...-function-congestion_segment_bootstrap.sql | 108 ++++++++++++++++++ .../sql/dynamic_bins/segment_grouping.sql | 22 ++++ 2 files changed, 130 insertions(+) create mode 100644 here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql create mode 100644 here/traffic/sql/dynamic_bins/segment_grouping.sql diff --git a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql new file mode 100644 index 000000000..5d2dd9418 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql @@ -0,0 +1,108 @@ +/* +--test +SELECT tt_array[ceiling(random() * 3)] +FROM (VALUES(ARRAY[1,2,3])) AS val(tt_array) +CROSS JOIN generate_series(1,100,1) +*/ + + +CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_bootstrap( + mnth date, + segment_ids bigint[], + n_resamples int) + RETURNS TABLE( + segment_id integer, mnth date, is_wkdy boolean, hr numeric, avg_tt real, n bigint, ci_lower real, ci_upper real + ) + LANGUAGE SQL + COST 100 + VOLATILE PARALLEL SAFE +AS $BODY$ + +WITH raw_obs AS ( + SELECT + segment_id, + date_trunc('month', dt)::date AS mnth, + EXTRACT('isodow' FROM dt) IN (1, 2, 3, 4, 5) AS is_wkdy, + EXTRACT('hour' FROM hr) AS hr, + ARRAY_AGG(tt::real) AS tt_array, + AVG(tt::real) AS avg_tt, + COUNT(*) AS n + FROM gwolofs.congestion_raw_segments + WHERE -- same params as the above aggregation + dt >= congestion_segment_bootstrap.mnth + AND dt < congestion_segment_bootstrap.mnth + interval '1 month' + AND segment_id = ANY(congestion_segment_bootstrap.segment_ids) + GROUP BY + segment_id, + mnth, + is_wkdy, + EXTRACT('hour' FROM hr) +), + +random_selections AS ( + SELECT + raw_obs.segment_id, + raw_obs.mnth, + raw_obs.is_wkdy, + raw_obs.hr, + sample_group.group_id, + raw_obs.avg_tt, + raw_obs.n, + --get a random observation from the array of tts + raw_obs.tt_array[ceiling(random() * raw_obs.n)] AS rnd_tt + FROM raw_obs + CROSS JOIN generate_series(1, n) + -- 200 resamples (could be any number) + CROSS JOIN generate_series(1, congestion_segment_bootstrap.n_resamples) AS sample_group(group_id) +), + +resampled_averages AS ( + SELECT + segment_id, + mnth, + is_wkdy, + hr, + group_id, + AVG(rnd_tt) AS rnd_avg_tt + FROM random_selections + GROUP BY + segment_id, + mnth, + is_wkdy, + hr, + group_id +) + +SELECT + ra.segment_id, + ra.mnth, + ra.is_wkdy, + ra.hr, + raw_obs.avg_tt::real, + raw_obs.n, + percentile_disc(0.025) WITHIN GROUP (ORDER BY ra.rnd_avg_tt)::real AS ci_lower, + percentile_disc(0.975) WITHIN GROUP (ORDER BY ra.rnd_avg_tt)::real AS ci_upper +FROM resampled_averages AS ra +JOIN raw_obs USING (segment_id, mnth, is_wkdy, hr) +GROUP BY + ra.segment_id, + ra.mnth, + ra.is_wkdy, + ra.hr, + raw_obs.avg_tt, + raw_obs.n; + + $BODY$; + +--6:52 for 100 +/*example +SELECT congestion_segment_bootstrap.* +FROM gwolofs.congestion_segment_bootstrap( + mnth := '2025-05-01'::date, + segment_ids := (SELECT ARRAY(SELECT segment_id FROM generate_series(1,100) AS a(segment_id))), + n_resamples := 300 +) +*/ + +--6.5 hours estimate for all +--SELECT COUNT(DISTINCT segment_id) / 100.0 * 352 / 60 / 60 FROM congestion.network_segments_24_4 ORDER BY 1 diff --git a/here/traffic/sql/dynamic_bins/segment_grouping.sql b/here/traffic/sql/dynamic_bins/segment_grouping.sql new file mode 100644 index 000000000..6343181f8 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/segment_grouping.sql @@ -0,0 +1,22 @@ +WITH summary AS ( + --find the number of groups required to have no more than 100 per group + SELECT + FLOOR(COUNT(DISTINCT segment_id) + / CEIL((COUNT(DISTINCT segment_id)) / 100.0)) AS num_per_group + FROM congestion.network_segments_24_4 +), + +groups AS ( + SELECT + CEIL(ROW_NUMBER() OVER (ORDER BY segment_id) / summary.num_per_group) AS group_id, + segment_id + FROM congestion.network_segments_24_4, summary +) + +SELECT + group_id, + array_agg(segment_id), + COUNT(*) +FROM groups +GROUP BY group_id +ORDER BY group_id \ No newline at end of file From 065747123930d0b463cd4b3943a96199bbe40adf Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Fri, 29 Aug 2025 14:14:30 +0000 Subject: [PATCH 60/74] #1132 bootstrapping method - eliminate another cte --- ...-function-congestion_segment_bootstrap.sql | 67 ++++++++----------- 1 file changed, 29 insertions(+), 38 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql index 5d2dd9418..5c1a0c832 100644 --- a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql +++ b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql @@ -6,12 +6,14 @@ CROSS JOIN generate_series(1,100,1) */ + CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_bootstrap( mnth date, segment_ids bigint[], n_resamples int) RETURNS TABLE( - segment_id integer, mnth date, is_wkdy boolean, hr numeric, avg_tt real, n bigint, ci_lower real, ci_upper real + segment_id integer, mnth date, is_wkdy boolean, hr numeric, + avg_tt real, n bigint, ci_lower real, ci_upper real ) LANGUAGE SQL COST 100 @@ -21,7 +23,7 @@ AS $BODY$ WITH raw_obs AS ( SELECT segment_id, - date_trunc('month', dt)::date AS mnth, + congestion_segment_bootstrap.mnth AS mnth, EXTRACT('isodow' FROM dt) IN (1, 2, 3, 4, 5) AS is_wkdy, EXTRACT('hour' FROM hr) AS hr, ARRAY_AGG(tt::real) AS tt_array, @@ -34,7 +36,6 @@ WITH raw_obs AS ( AND segment_id = ANY(congestion_segment_bootstrap.segment_ids) GROUP BY segment_id, - mnth, is_wkdy, EXTRACT('hour' FROM hr) ), @@ -42,55 +43,45 @@ WITH raw_obs AS ( random_selections AS ( SELECT raw_obs.segment_id, - raw_obs.mnth, raw_obs.is_wkdy, raw_obs.hr, - sample_group.group_id, raw_obs.avg_tt, raw_obs.n, + raw_obs.mnth, + sample_group.group_id, --get a random observation from the array of tts - raw_obs.tt_array[ceiling(random() * raw_obs.n)] AS rnd_tt + AVG(raw_obs.tt_array[ceiling(random() * raw_obs.n)]) AS rnd_avg_tt FROM raw_obs CROSS JOIN generate_series(1, n) -- 200 resamples (could be any number) CROSS JOIN generate_series(1, congestion_segment_bootstrap.n_resamples) AS sample_group(group_id) -), - -resampled_averages AS ( - SELECT - segment_id, - mnth, - is_wkdy, - hr, - group_id, - AVG(rnd_tt) AS rnd_avg_tt - FROM random_selections GROUP BY - segment_id, - mnth, - is_wkdy, - hr, - group_id + raw_obs.segment_id, + raw_obs.is_wkdy, + raw_obs.hr, + raw_obs.avg_tt, + raw_obs.n, + raw_obs.mnth, + sample_group.group_id ) SELECT - ra.segment_id, - ra.mnth, - ra.is_wkdy, - ra.hr, - raw_obs.avg_tt::real, - raw_obs.n, - percentile_disc(0.025) WITHIN GROUP (ORDER BY ra.rnd_avg_tt)::real AS ci_lower, - percentile_disc(0.975) WITHIN GROUP (ORDER BY ra.rnd_avg_tt)::real AS ci_upper -FROM resampled_averages AS ra -JOIN raw_obs USING (segment_id, mnth, is_wkdy, hr) + segment_id, + mnth, + is_wkdy, + hr, + avg_tt::real, + n, + percentile_disc(0.025) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_lower, + percentile_disc(0.975) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_upper +FROM random_selections GROUP BY - ra.segment_id, - ra.mnth, - ra.is_wkdy, - ra.hr, - raw_obs.avg_tt, - raw_obs.n; + segment_id, + mnth, + is_wkdy, + hr, + avg_tt, + n; $BODY$; From e77503ac80e48f4070580a422ba817167160a849 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 3 Sep 2025 17:24:59 +0000 Subject: [PATCH 61/74] #1132 update segment_grouping to work for all map versions --- .../sql/dynamic_bins/segment_grouping.sql | 44 +++++++++++++------ 1 file changed, 30 insertions(+), 14 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/segment_grouping.sql b/here/traffic/sql/dynamic_bins/segment_grouping.sql index 6343181f8..e18f762b2 100644 --- a/here/traffic/sql/dynamic_bins/segment_grouping.sql +++ b/here/traffic/sql/dynamic_bins/segment_grouping.sql @@ -1,22 +1,38 @@ -WITH summary AS ( - --find the number of groups required to have no more than 100 per group +WITH segments AS ( + --segments active in relevant month + SELECT DISTINCT segment_id + FROM gwolofs.congestion_raw_segments + WHERE + dt >= {{ ds }}::date + AND dt < {{ ds }}::date + '1 month'::interval +), + +group_size AS ( + --find the number of groups required to have no more than `max_group_size` per group SELECT - FLOOR(COUNT(DISTINCT segment_id) - / CEIL((COUNT(DISTINCT segment_id)) / 100.0)) AS num_per_group - FROM congestion.network_segments_24_4 + FLOOR(COUNT(*) + / CEIL((COUNT(*)) / {{ params.max_group_size }}::numeric)) AS num_per_group + FROM segments ), groups AS ( SELECT - CEIL(ROW_NUMBER() OVER (ORDER BY segment_id) / summary.num_per_group) AS group_id, + --assign group_ids using row number + CEIL(ROW_NUMBER() OVER (ORDER BY segment_id) / group_size.num_per_group) AS group_id, segment_id - FROM congestion.network_segments_24_4, summary + FROM segments, group_size +), + +groups_summarized AS ( + SELECT + group_id, + array_agg(segment_id) AS segment_ids, + COUNT(*) + FROM groups + GROUP BY group_id + ORDER BY group_id ) -SELECT - group_id, - array_agg(segment_id), - COUNT(*) -FROM groups -GROUP BY group_id -ORDER BY group_id \ No newline at end of file +--return list of lists for xcom +SELECT array_agg(segment_ids::text) +FROM groups_summarized \ No newline at end of file From f50d023fb3873e89678f8866d0fc7fa2caa3ce3d Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 3 Sep 2025 17:25:34 +0000 Subject: [PATCH 62/74] #1132 check day is not empty before aggregating --- dags/here_dynamic_binning_agg.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index a516fcaa8..3d46af93b 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -12,7 +12,6 @@ import sys import os import logging -from datetime import timedelta from pendulum import duration, datetime from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator @@ -23,6 +22,7 @@ repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) sys.path.insert(0, repo_path) from dags.dag_functions import task_fail_slack_alert + from dags.custom_operators import SQLCheckOperatorWithReturnValue except: raise ImportError("Cannot import slack alert functions") @@ -37,8 +37,6 @@ 'owner': ','.join(DAG_OWNERS), 'depends_on_past':False, 'start_date': datetime(2019, 1, 1, tz="America/Toronto"), - #aggregation doesn't work on 24_4 yet (no congestion.network_links_24_4) - #'end_date': datetime(2025, 3, 17, tz="America/Toronto"), 'email_on_failure': False, 'email_on_success': False, 'retries': 1, @@ -59,6 +57,14 @@ #to add: catchup, one task at a time, depends on past. def here_dynamic_binning_agg(): + check_not_empty = SQLCheckOperatorWithReturnValue( + task_id="check_not_empty", + sql="SELECT COUNT(*), COUNT(*) FROM here.ta_path WHERE dt = '{{ ds }}'", + conn_id="congestion_bot", + retries=1, + retry_delay=duration(days=1) + ) + aggregate_daily = SQLExecuteQueryOperator( sql=["DELETE FROM gwolofs.congestion_raw_segments WHERE dt = '{{ ds }}'", "SELECT gwolofs.congestion_network_segment_agg('{{ ds }}'::date);"], @@ -68,6 +74,7 @@ def here_dynamic_binning_agg(): retries = 2, hook_params={"options": "-c statement_timeout=10800000ms"} #3 hours ) - aggregate_daily + + check_not_empty >> aggregate_daily here_dynamic_binning_agg() \ No newline at end of file From 57cc194b4091ca18e5d4bf2b44e5e8cc6f0f9386 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 3 Sep 2025 17:26:04 +0000 Subject: [PATCH 63/74] #1132 perform bootstrapping by group of segment_ids --- dags/here_dynamic_binning_monthly_agg.py | 56 ++++++++++++++++++++---- 1 file changed, 48 insertions(+), 8 deletions(-) diff --git a/dags/here_dynamic_binning_monthly_agg.py b/dags/here_dynamic_binning_monthly_agg.py index fd8f1e0d9..d46989cf9 100644 --- a/dags/here_dynamic_binning_monthly_agg.py +++ b/dags/here_dynamic_binning_monthly_agg.py @@ -1,12 +1,12 @@ import os import sys import logging -from datetime import timedelta from pendulum import duration, datetime from airflow.models import Variable -from airflow.decorators import dag +from airflow.decorators import dag, task from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator +from airflow.providers.postgres.hooks.postgres import PostgresHook try: repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) @@ -27,10 +27,8 @@ 'owner': ','.join(DAG_OWNERS), 'depends_on_past':False, 'start_date': datetime(2019, 1, 1, tz="America/Toronto"), - 'email_on_failure': False, - 'email_on_success': False, 'retries': 1, - 'retry_delay': duration(hours=1), + 'retry_delay': duration(hours=1) #'on_failure_callback': task_fail_slack_alert } @@ -64,9 +62,51 @@ def here_dynamic_binning_monthly_agg(): task_id='aggregate_monthly', conn_id='congestion_bot', autocommit=True, - retries = 1, - execution_timeout=timedelta(hours=1) + retries = 1 ) - check_missing_dates >> aggregate_monthly + + create_groups = SQLExecuteQueryOperator( + sql="segment_grouping.sql", + task_id="create_segment_groups", + #TODO: update sql to work for different map versions + start_date=datetime(2025, 4, 1, tz="America/Toronto"), + conn_id='congestion_bot', + retries = 0, + params={"max_group_size": 100} + ) + + delete_data = SQLExecuteQueryOperator( + sql="DELETE FROM gwolofs.congestion_segments_monthly_bootstrap WHERE mnth = '{{ ds }}' AND n_resamples = 300", + task_id="delete_bootstrap_results", + conn_id='congestion_bot', + retries=0 + ) + + @task + def expand_groups(**context): + return context["ti"].xcom_pull(task_ids="create_segment_groups")[0][0] + + @task(retries=0, max_active_tis_per_dag=1) + def bootstrap_agg(segments, ds): + print(f"segments: {segments}") + postgres_cred = PostgresHook("congestion_bot") + query="""SELECT * + FROM UNNEST(%s::bigint[]) AS unnested(segment_id), + LATERAL ( + SELECT gwolofs.congestion_segment_bootstrap( + mnth := %s::date, + segment_id := segment_id, + n_resamples := 300) + ) AS lat""" + with postgres_cred.get_conn() as conn: + with conn.cursor() as cur: + cur.execute(query, (segments, ds)) + conn.commit() + + expand = expand_groups() + + check_missing_dates >> aggregate_monthly >> create_groups >> delete_data + delete_data >> expand + bootstrap_agg.expand(segments=expand) here_dynamic_binning_monthly_agg() \ No newline at end of file From 2c3763140ecf9adeaaa3c850c2cc58a128e25733 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 3 Sep 2025 17:26:33 +0000 Subject: [PATCH 64/74] #1132 much faster over a single segment_id rather than array --- ...-function-congestion_segment_bootstrap.sql | 160 ++++++++---------- 1 file changed, 75 insertions(+), 85 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql index 5c1a0c832..d23110761 100644 --- a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql +++ b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql @@ -1,99 +1,89 @@ -/* ---test -SELECT tt_array[ceiling(random() * 3)] -FROM (VALUES(ARRAY[1,2,3])) AS val(tt_array) -CROSS JOIN generate_series(1,100,1) -*/ - - +--DROP FUNCTION gwolofs.congestion_segment_bootstrap(date,bigint,integer); CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_bootstrap( - mnth date, - segment_ids bigint[], - n_resamples int) - RETURNS TABLE( - segment_id integer, mnth date, is_wkdy boolean, hr numeric, - avg_tt real, n bigint, ci_lower real, ci_upper real - ) + mnth date, + segment_id bigint, + n_resamples int + ) + RETURNS VOID LANGUAGE SQL COST 100 VOLATILE PARALLEL SAFE AS $BODY$ -WITH raw_obs AS ( + SELECT setseed(('0.'||replace(mnth::text, '-', ''))::numeric); + + WITH raw_obs AS ( + SELECT + --segment_id and mnth don't need to be in group by until end + EXTRACT('isodow' FROM dt) IN (1, 2, 3, 4, 5) AS is_wkdy, + EXTRACT('hour' FROM hr) AS hr, + ARRAY_AGG(tt::real) AS tt_array, + AVG(tt::real) AS avg_tt, + COUNT(*) AS n + FROM gwolofs.congestion_raw_segments + WHERE -- same params as the above aggregation + dt >= congestion_segment_bootstrap.mnth + AND dt < congestion_segment_bootstrap.mnth + interval '1 month' + AND segment_id = congestion_segment_bootstrap.segment_id + GROUP BY + segment_id, + is_wkdy, + EXTRACT('hour' FROM hr) + ), + + random_selections AS ( + SELECT + raw_obs.is_wkdy, + raw_obs.hr, + raw_obs.avg_tt, + raw_obs.n, + sample_group.group_id, + --get a random observation from the array of tts + AVG(raw_obs.tt_array[ceiling(random() * raw_obs.n)]) AS rnd_avg_tt + FROM raw_obs + CROSS JOIN generate_series(1, n) + -- 200 resamples (could be any number) + CROSS JOIN generate_series(1, congestion_segment_bootstrap.n_resamples) AS sample_group(group_id) + GROUP BY + raw_obs.is_wkdy, + raw_obs.hr, + raw_obs.avg_tt, + raw_obs.n, + sample_group.group_id + ) + + INSERT INTO gwolofs.congestion_segments_monthly_bootstrap ( + segment_id, mnth, is_wkdy, hr, avg_tt, n, n_resamples, ci_lower, ci_upper + ) SELECT - segment_id, - congestion_segment_bootstrap.mnth AS mnth, - EXTRACT('isodow' FROM dt) IN (1, 2, 3, 4, 5) AS is_wkdy, - EXTRACT('hour' FROM hr) AS hr, - ARRAY_AGG(tt::real) AS tt_array, - AVG(tt::real) AS avg_tt, - COUNT(*) AS n - FROM gwolofs.congestion_raw_segments - WHERE -- same params as the above aggregation - dt >= congestion_segment_bootstrap.mnth - AND dt < congestion_segment_bootstrap.mnth + interval '1 month' - AND segment_id = ANY(congestion_segment_bootstrap.segment_ids) - GROUP BY - segment_id, + congestion_segment_bootstrap.segment_id, + congestion_segment_bootstrap.mnth, is_wkdy, - EXTRACT('hour' FROM hr) -), - -random_selections AS ( - SELECT - raw_obs.segment_id, - raw_obs.is_wkdy, - raw_obs.hr, - raw_obs.avg_tt, - raw_obs.n, - raw_obs.mnth, - sample_group.group_id, - --get a random observation from the array of tts - AVG(raw_obs.tt_array[ceiling(random() * raw_obs.n)]) AS rnd_avg_tt - FROM raw_obs - CROSS JOIN generate_series(1, n) - -- 200 resamples (could be any number) - CROSS JOIN generate_series(1, congestion_segment_bootstrap.n_resamples) AS sample_group(group_id) + hr, + avg_tt::real, + n, + n_resamples, + percentile_disc(0.025) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_lower, + percentile_disc(0.975) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_upper + FROM random_selections GROUP BY - raw_obs.segment_id, - raw_obs.is_wkdy, - raw_obs.hr, - raw_obs.avg_tt, - raw_obs.n, - raw_obs.mnth, - sample_group.group_id -) - -SELECT - segment_id, - mnth, - is_wkdy, - hr, - avg_tt::real, - n, - percentile_disc(0.025) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_lower, - percentile_disc(0.975) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_upper -FROM random_selections -GROUP BY - segment_id, - mnth, - is_wkdy, - hr, - avg_tt, - n; + is_wkdy, + hr, + avg_tt, + n; $BODY$; ---6:52 for 100 -/*example -SELECT congestion_segment_bootstrap.* -FROM gwolofs.congestion_segment_bootstrap( - mnth := '2025-05-01'::date, - segment_ids := (SELECT ARRAY(SELECT segment_id FROM generate_series(1,100) AS a(segment_id))), - n_resamples := 300 -) -*/ +GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_bootstrap(date,bigint,integer) TO congestion_bot; ---6.5 hours estimate for all ---SELECT COUNT(DISTINCT segment_id) / 100.0 * 352 / 60 / 60 FROM congestion.network_segments_24_4 ORDER BY 1 +/*Usage example: (works best one segment at a time with Lateral) +SELECT * +FROM UNNEST('{1,2,3,4,5,6,7,8,9}'::bigint[]) AS unnested(segment_id) +LATERAL ( + SELECT gwolofs.congestion_segment_bootstrap( + mnth := '2025-06-01'::date, + segment_ids := segment_id, + n_resamples := 300) +) +*/ \ No newline at end of file From 0effb5ff1f7e258e3bc93ecffe3d0f31fee5b02a Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 3 Sep 2025 17:27:00 +0000 Subject: [PATCH 65/74] #1132 bootstrap table structure --- ...-congestion_segments_monthly_bootstrap.sql | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql new file mode 100644 index 000000000..4b9ea844a --- /dev/null +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql @@ -0,0 +1,33 @@ +-- Table: gwolofs.congestion_segments_monthly_bootstrap + +-- DROP TABLE IF EXISTS gwolofs.congestion_segments_monthly_bootstrap; + +CREATE TABLE IF NOT EXISTS gwolofs.congestion_segments_monthly_bootstrap +( + segment_id integer NOT NULL, + mnth date NOT NULL, + is_wkdy boolean NOT NULL, + hr numeric NOT NULL, + avg_tt real, + n bigint, + ci_lower real, + ci_upper real, + n_resamples integer NOT NULL, + CONSTRAINT congestion_segments_monthly_bootstrap_pkey PRIMARY KEY (segment_id, mnth, is_wkdy, hr, n_resamples) +) + +TABLESPACE pg_default; + +ALTER TABLE IF EXISTS gwolofs.congestion_segments_monthly_bootstrap +OWNER TO gwolofs; + +REVOKE ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap FROM bdit_humans; +REVOKE ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap FROM congestion_bot; + +GRANT SELECT, TRIGGER, REFERENCES ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO bdit_humans WITH GRANT OPTION; + +GRANT INSERT, SELECT, DELETE ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO congestion_bot; + +GRANT ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO dbadmin; + +GRANT ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO rds_superuser WITH GRANT OPTION; From a058f7cc833d75329d074874fe8fa1c652e529b4 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 10 Sep 2025 21:20:02 +0000 Subject: [PATCH 66/74] #1132 tt->real, hr->smallint --- .../create-table-congestion_raw_corridors.sql | 4 ++-- .../create-table-congestion_raw_segments.sql | 4 ++-- ...-congestion_segments_monthly_bootstrap.sql | 6 ++--- ...ble-congestion_segments_monthy_summary.sql | 18 +++++++-------- .../function-congestion_cache_tt_results.sql | 4 ++-- ...unction-congestion_network_segment_agg.sql | 6 ++--- ...unction-congestion_segment_monthly_agg.sql | 23 ++++++++++--------- 7 files changed, 33 insertions(+), 32 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql index 9088b1a6a..b4471f323 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql @@ -7,11 +7,11 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors corridor_id smallint, time_grp timerange NOT NULL, bin_range tsrange NOT NULL, - tt numeric, + tt real, num_obs integer, uri_string text COLLATE pg_catalog."default", dt date, - hr timestamp without time zone, + hr smallint, CONSTRAINT congestion_raw_corridors_pkey PRIMARY KEY (corridor_id, bin_range, time_grp), CONSTRAINT corridor_fkey FOREIGN KEY (corridor_id) REFERENCES gwolofs.congestion_corridors (corridor_id) MATCH SIMPLE diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql index dc2c090c6..ce988d66b 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql @@ -8,9 +8,9 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments dt date NOT NULL, bin_start timestamp without time zone NOT NULL, bin_range tsrange NOT NULL, - tt numeric, + tt real, num_obs integer, - hr timestamp without time zone, + hr smallint, CONSTRAINT congestion_raw_segments_pkey PRIMARY KEY (segment_id, dt, bin_start) ) PARTITION BY RANGE (dt); diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql index 4b9ea844a..52d71097d 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql @@ -7,12 +7,12 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_segments_monthly_bootstrap segment_id integer NOT NULL, mnth date NOT NULL, is_wkdy boolean NOT NULL, - hr numeric NOT NULL, + hr smallint NOT NULL, avg_tt real, - n bigint, + n smallint, ci_lower real, ci_upper real, - n_resamples integer NOT NULL, + n_resamples smallint NOT NULL, CONSTRAINT congestion_segments_monthly_bootstrap_pkey PRIMARY KEY (segment_id, mnth, is_wkdy, hr, n_resamples) ) diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql index 462ae6b59..09e2c0733 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql @@ -7,15 +7,15 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_segments_monthy_summary segment_id integer, mnth date, is_wkdy boolean, - hr double precision, - avg_tt numeric, - stdev numeric, - percentile_05 numeric, - percentile_15 numeric, - percentile_50 numeric, - percentile_85 numeric, - percentile_95 numeric, - num_quasi_obs bigint + hr smallint, + avg_tt real, + stdev real, + percentile_05 real, + percentile_15 real, + percentile_50 real, + percentile_85 real, + percentile_95 real, + num_quasi_obs smallint ) TABLESPACE pg_default; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index f55190539..221c36bf7 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -218,9 +218,9 @@ EXECUTE FORMAT( time_grp, corridor_id, bin_range, - tt, + tt::real, num_obs, - date_trunc('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr + date_part('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr FROM inserted ON CONFLICT DO NOTHING; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index 557c81756..a99a94549 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -140,7 +140,7 @@ EXECUTE FORMAT( unnested.len ), - inserted AS ( + inserted AS ( --this query contains overlapping values which get eliminated --via on conflict with the exclusion constraint on congestion_raw_segments table. INSERT INTO congestion_raw_segments_temp AS inserted ( @@ -180,9 +180,9 @@ EXECUTE FORMAT( bin_start, segment_id, bin_range, - tt, + tt::real, num_obs, - date_trunc('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr + date_part('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr FROM inserted ON CONFLICT DO NOTHING; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql index b80610c33..93e8741d6 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql @@ -3,9 +3,10 @@ -- DROP FUNCTION IF EXISTS gwolofs.congestion_segment_monthly_agg(date); CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_monthly_agg( - mon date) - RETURNS void - LANGUAGE 'sql' + mon date +) + RETURNS VOID + LANGUAGE SQL COST 100 VOLATILE PARALLEL UNSAFE AS $BODY$ @@ -19,13 +20,13 @@ SELECT congestion_segment_monthly_agg.mon AS mnth, date_part('isodow', dt) <= 5 AS is_wkdy, date_part('hour', hr) AS hr, - ROUND(AVG(tt), 2) AS avg_tt, - ROUND(stddev(tt), 2) AS stdev, - ROUND(PERCENTILE_CONT(0.05) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_05, - ROUND(PERCENTILE_CONT(0.15) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_15, - ROUND(PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_50, - ROUND(PERCENTILE_CONT(0.85) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_85, - ROUND(PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY tt)::numeric, 2) AS percentile_95, + AVG(tt) AS avg_tt, + stddev(tt) AS stdev, + PERCENTILE_CONT(0.05) WITHIN GROUP (ORDER BY tt) AS percentile_05, + PERCENTILE_CONT(0.15) WITHIN GROUP (ORDER BY tt) AS percentile_15, + PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY tt) AS percentile_50, + PERCENTILE_CONT(0.85) WITHIN GROUP (ORDER BY tt) AS percentile_85, + PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY tt) AS percentile_95, COUNT(*) AS num_quasi_obs FROM gwolofs.congestion_raw_segments LEFT JOIN ref.holiday USING (dt) @@ -41,7 +42,7 @@ GROUP BY $BODY$; ALTER FUNCTION gwolofs.congestion_segment_monthly_agg(date) - OWNER TO gwolofs; +OWNER TO gwolofs; GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO PUBLIC; From c6ef2082cd65cf5cc014beb56098f61e6eb676de Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 15 Sep 2025 14:42:30 +0000 Subject: [PATCH 67/74] #1132 fluff --- .../traffic/sql/dynamic_bins/corridor_agg.sql | 19 ++++++++++-------- ...-function-congestion_segment_bootstrap.sql | 14 +++++++------ .../create-table-congestion_corridors.sql | 8 ++++---- .../create-table-congestion_raw_corridors.sql | 20 +++++++++---------- .../create-table-congestion_raw_segments.sql | 12 +++++------ ...unction-congestion_segment_monthly_agg.sql | 12 +++++------ ...function-congestion_select_map_version.sql | 2 +- .../insert_projects_and_corridors.sql | 12 ++++++----- .../sql/dynamic_bins/segment_grouping.sql | 10 ++++++---- .../select-check_missing_days.sql | 20 ++++++++++--------- 10 files changed, 70 insertions(+), 59 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/corridor_agg.sql b/here/traffic/sql/dynamic_bins/corridor_agg.sql index a16c0dbd2..b1cb9e9b8 100644 --- a/here/traffic/sql/dynamic_bins/corridor_agg.sql +++ b/here/traffic/sql/dynamic_bins/corridor_agg.sql @@ -1,19 +1,22 @@ --test: 35 projects, 1 day = 47s -SELECT gwolofs.congestion_cache_tt_results_daily( - node_start := congestion_corridors.node_start, - node_end := congestion_corridors.node_end, - start_date := dates.dt::date -) +SELECT + gwolofs.congestion_cache_tt_results_daily( + node_start := congestion_corridors.node_start, + node_end := congestion_corridors.node_end, + start_date := dates.dt::date + ) FROM gwolofs.congestion_corridors JOIN gwolofs.congestion_projects USING (project_id), -generate_series('2025-01-01', '2025-02-28', '1 day'::interval) AS dates(dt) -WHERE + generate_series('2025-01-01', '2025-02-28', '1 day'::interval) AS dates (dt) +WHERE congestion_projects.description IN ( 'Avenue Road cycleway installation', 'bluetooth_corridors', 'scrutinized-cycleway-corridors' ) AND corridor_id NOT IN ( - SELECT DISTINCT corridor_id FROM gwolofs.congestion_raw_corridors WHERE dt >= '2025-01-01' AND dt < '2025-02-28' + SELECT DISTINCT corridor_id + FROM gwolofs.congestion_raw_corridors + WHERE dt >= '2025-01-01' AND dt < '2025-02-28' ) AND map_version = '23_4'; \ No newline at end of file diff --git a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql index d23110761..7a9e7ad8f 100644 --- a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql +++ b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql @@ -4,11 +4,11 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_bootstrap( mnth date, segment_id bigint, n_resamples int - ) - RETURNS VOID - LANGUAGE SQL - COST 100 - VOLATILE PARALLEL SAFE +) +RETURNS void +LANGUAGE SQL +COST 100 +VOLATILE PARALLEL SAFE AS $BODY$ SELECT setseed(('0.'||replace(mnth::text, '-', ''))::numeric); @@ -75,7 +75,9 @@ AS $BODY$ $BODY$; -GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_bootstrap(date,bigint,integer) TO congestion_bot; +GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_bootstrap( + date, bigint, integer +) TO CONGESTION_BOT; /*Usage example: (works best one segment at a time with Lateral) SELECT * diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql index 2d905a19e..7c09a0628 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql @@ -19,10 +19,10 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_corridors CONSTRAINT congestion_corridors_pkey PRIMARY KEY (node_start, node_end, map_version), CONSTRAINT corridor_pkey UNIQUE NULLS NOT DISTINCT (corridor_id), CONSTRAINT project_id_fk FOREIGN KEY (project_id) - REFERENCES gwolofs.congestion_projects (project_id) MATCH SIMPLE - ON UPDATE NO ACTION - ON DELETE NO ACTION - NOT VALID + REFERENCES gwolofs.congestion_projects (project_id) MATCH SIMPLE + ON UPDATE NO ACTION + ON DELETE NO ACTION + NOT VALID ) TABLESPACE pg_default; diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql index b4471f323..2d6f294ca 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql @@ -14,10 +14,10 @@ CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors hr smallint, CONSTRAINT congestion_raw_corridors_pkey PRIMARY KEY (corridor_id, bin_range, time_grp), CONSTRAINT corridor_fkey FOREIGN KEY (corridor_id) - REFERENCES gwolofs.congestion_corridors (corridor_id) MATCH SIMPLE - ON UPDATE NO ACTION - ON DELETE CASCADE - NOT VALID + REFERENCES gwolofs.congestion_corridors (corridor_id) MATCH SIMPLE + ON UPDATE NO ACTION + ON DELETE CASCADE + NOT VALID ) TABLESPACE pg_default; @@ -62,19 +62,19 @@ COMMENT ON TABLE gwolofs.congestion_raw_corridors IS 'Stores dynamic binning results for custom corridor based travel time requests.'; COMMENT ON TABLE gwolofs.congestion_raw_corridors - IS 'Stores dynamic binning results from standard HERE congestion network travel time aggregations.'; +IS 'Stores dynamic binning results from standard HERE congestion network travel time aggregations.'; COMMENT ON COLUMN gwolofs.congestion_raw_corridors.bin_range - IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.'; +IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.'; COMMENT ON COLUMN gwolofs.congestion_raw_corridors.tt - IS 'Travel time in seconds.'; +IS 'Travel time in seconds.'; COMMENT ON COLUMN gwolofs.congestion_raw_corridors.num_obs - IS 'The sum of the sample size from here.ta_path.'; +IS 'The sum of the sample size from here.ta_path.'; COMMENT ON COLUMN gwolofs.congestion_raw_corridors.dt - IS 'The date of aggregation for the record. Records may not overlap dates.'; +IS 'The date of aggregation for the record. Records may not overlap dates.'; COMMENT ON COLUMN gwolofs.congestion_raw_corridors.hr - IS 'The hour the majority of the record occured in. Ties are rounded up.'; +IS 'The hour the majority of the record occured in. Ties are rounded up.'; diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql index ce988d66b..cfcc515bb 100644 --- a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql +++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql @@ -61,19 +61,19 @@ ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2025 OWNER TO gwolofs; COMMENT ON COLUMN gwolofs.congestion_raw_segments.dt - IS 'The date of aggregation for the record. Records may not overlap dates.'; +IS 'The date of aggregation for the record. Records may not overlap dates.'; COMMENT ON COLUMN gwolofs.congestion_raw_segments.bin_start - IS 'The start of the observation. It is recommended to use `hr` to group the bin instead. This column is used in the primary key, although the main constraint occurs during insert (non overlapping ranges).'; +IS 'The start of the observation. It is recommended to use `hr` to group the bin instead. This column is used in the primary key, although the main constraint occurs during insert (non overlapping ranges).'; COMMENT ON COLUMN gwolofs.congestion_raw_segments.bin_range - IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.'; +IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.'; COMMENT ON COLUMN gwolofs.congestion_raw_segments.tt - IS 'Travel time in seconds.'; +IS 'Travel time in seconds.'; COMMENT ON COLUMN gwolofs.congestion_raw_segments.num_obs - IS 'The sum of the sample size from here.ta_path.'; +IS 'The sum of the sample size from here.ta_path.'; COMMENT ON COLUMN gwolofs.congestion_raw_segments.hr - IS 'The hour the majority of the record occured in. Ties are rounded up.'; +IS 'The hour the majority of the record occured in. Ties are rounded up.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql index 93e8741d6..4c13186a8 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql @@ -5,10 +5,10 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_monthly_agg( mon date ) - RETURNS VOID - LANGUAGE SQL - COST 100 - VOLATILE PARALLEL UNSAFE +RETURNS void +LANGUAGE SQL +COST 100 +VOLATILE PARALLEL UNSAFE AS $BODY$ INSERT INTO gwolofs.congestion_segments_monthy_summary ( @@ -46,7 +46,7 @@ OWNER TO gwolofs; GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO PUBLIC; -GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO congestion_bot; +GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO CONGESTION_BOT; -GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO gwolofs; +GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO GWOLOFS; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql index 71c635e7b..cd5371ef0 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql @@ -5,7 +5,7 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_select_map_version( start_date date, end_date date, - agg_type text default null, --null or 'path' + agg_type text DEFAULT NULL, --null or 'path' OUT selected_version text ) RETURNS text diff --git a/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql b/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql index 62c107fc0..cbde86da4 100644 --- a/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql +++ b/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql @@ -1,10 +1,12 @@ --for naming corridor_streets. --need help with corridor_start and corridor_end locations - not sure how to turn here nodes into names. Intersection conflation? WITH named_corridors AS ( - SELECT corridor_id, string_agg(DISTINCT initcap(st_name), ' / ') AS corridor_streets + SELECT + corridor_id, + string_agg(DISTINCT initcap(st_name), ' / ') AS corridor_streets FROM gwolofs.congestion_corridors, - UNNEST (congestion_corridors.link_dirs) AS unnested(link_dir) - LEFT JOIN here_gis.traffic_streets_24_4 ON link_id = trim(trailing 'T|F' from link_dir)::int + UNNEST(congestion_corridors.link_dirs) AS unnested (link_dir) + LEFT JOIN here_gis.traffic_streets_24_4 ON link_id = trim(TRAILING 'T|F' FROM link_dir)::int WHERE map_version = '24_4' GROUP BY corridor_id ORDER BY corridor_id DESC @@ -29,12 +31,12 @@ WITH project AS ( corridors AS ( SELECT corridor_id FROM bluetooth.here_cn_23_4_lookup AS bt, - gwolofs.congestion_cache_corridor(bt.here_fnode, bt.here_tnode, '24_4') + gwolofs.congestion_cache_corridor(bt.here_fnode, bt.here_tnode, '24_4') ) --add project_id to corridors UPDATE gwolofs.congestion_corridors -SET project_id = (SELECT project_id FROM project) +SET project_id = (SELECT project_id FROM project) WHERE corridor_id IN (SELECT corridor_id FROM corridors) RETURNING corridor_id; diff --git a/here/traffic/sql/dynamic_bins/segment_grouping.sql b/here/traffic/sql/dynamic_bins/segment_grouping.sql index e18f762b2..93303ca43 100644 --- a/here/traffic/sql/dynamic_bins/segment_grouping.sql +++ b/here/traffic/sql/dynamic_bins/segment_grouping.sql @@ -3,15 +3,17 @@ WITH segments AS ( SELECT DISTINCT segment_id FROM gwolofs.congestion_raw_segments WHERE - dt >= {{ ds }}::date - AND dt < {{ ds }}::date + '1 month'::interval + dt >= '{{ ds }}'::date --noqa: TMP + AND dt < '{{ ds }}'::date + '1 month'::interval --noqa: TMP ), group_size AS ( --find the number of groups required to have no more than `max_group_size` per group SELECT - FLOOR(COUNT(*) - / CEIL((COUNT(*)) / {{ params.max_group_size }}::numeric)) AS num_per_group + FLOOR( + COUNT(*) + / CEIL((COUNT(*)) / {{ params.max_group_size }}::numeric) --noqa: TMP + ) AS num_per_group FROM segments ), diff --git a/here/traffic/sql/dynamic_bins/select-check_missing_days.sql b/here/traffic/sql/dynamic_bins/select-check_missing_days.sql index a993ba57c..0b09c3673 100644 --- a/here/traffic/sql/dynamic_bins/select-check_missing_days.sql +++ b/here/traffic/sql/dynamic_bins/select-check_missing_days.sql @@ -2,18 +2,20 @@ WITH distinct_days AS ( SELECT DISTINCT dt FROM gwolofs.congestion_raw_segments WHERE - dt >= '{{ ds }}'::date - AND dt < '{{ ds }}'::date + interval '1 month' + dt >= '{{ ds }}'::date --noqa: TMP + AND dt < '{{ ds }}'::date + interval '1 month' --noqa: TMP ) SELECT - COUNT(*) = 0, + COUNT(*) = 0 AS _check, 'The following days are missing from `congestion_raw_segments`: ' - || string_agg(dates.dt::date::text, ', ') AS summary -FROM generate_series( - '{{ ds }}'::date, - --one day before start of next month - ('{{ ds }}'::date + interval '1 month')::date - 1, - '1 day') AS dates(dt) + || string_agg(dates.dt::date::text, ', ') AS _summary +FROM + generate_series( + '{{ ds }}'::date, + --one day before start of next month + ('{{ ds }}'::date + interval '1 month')::date - 1, + '1 day' + ) AS dates (dt) LEFT JOIN distinct_days USING (dt) WHERE distinct_days.dt IS NULL; \ No newline at end of file From 6dc942fa671ea2173ee3bd4a079c9af3f2ae30f7 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 29 Sep 2025 20:50:55 +0000 Subject: [PATCH 68/74] #1132 separate out insert and select funcionality --- .../function-congestion_cache_tt_results.sql | 224 +-------------- ...unction-congestion_return_dynamic_bins.sql | 256 ++++++++++++++++++ 2 files changed, 270 insertions(+), 210 deletions(-) create mode 100644 here/traffic/sql/dynamic_bins/function-congestion_return_dynamic_bins.sql diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql index 221c36bf7..1c486eada 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql @@ -14,226 +14,30 @@ CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results( holidays boolean ) RETURNS void -LANGUAGE plpgsql +LANGUAGE SQL COST 100 VOLATILE PARALLEL UNSAFE AS $BODY$ -DECLARE map_version text; - -BEGIN - ---using a temp table to aply the exclusion constraint should prevent the ---insert from getting bogged down by large constraint on main table over time -DROP TABLE IF EXISTS congestion_raw_corridors_temp; -CREATE TEMPORARY TABLE congestion_raw_corridors_temp ( - corridor_id smallint, - time_grp timerange NOT NULL, - bin_range tsrange NOT NULL, - tt numeric, - num_obs integer, - uri_string text, - CONSTRAINT congestion_raw_corridors_exclude_temp EXCLUDE USING gist ( - bin_range WITH &&, - corridor_id WITH =, - time_grp WITH =, - coalesce(uri_string, '') WITH = --this is the only column in constraint which is nullable - ) -); - -SELECT gwolofs.congestion_select_map_version( - congestion_cache_tt_results.start_date, - congestion_cache_tt_results.end_date, - 'path' -) INTO map_version; - -EXECUTE FORMAT( - $$ - WITH corridor AS ( - SELECT - ccc.corridor_id, - unnested.link_dir, - unnested.length, - ccc.total_length - FROM gwolofs.congestion_cache_corridor(%1$L, %2$L, %3$L) AS ccc, - UNNEST( - ccc.link_dirs, - ccc.lengths - ) AS unnested(link_dir, length) - ), - - segment_5min_bins AS ( - SELECT - seg.corridor_id, - ta.tx, - seg.total_length, - tsrange( - ta.dt + %4$L::time, - ta.dt + %5$L::time, '[)') AS time_grp, - RANK() OVER w AS bin_rank, - SUM(seg.length) / seg.total_length AS sum_length, - SUM(seg.length) AS length_w_data, - SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt, - SUM(sample_size) AS num_obs, - ARRAY_AGG(ta.link_dir ORDER BY ta.link_dir) AS link_dirs, - ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY ta.link_dir) AS tts, - ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths - FROM here.ta_path AS ta - JOIN corridor AS seg USING (link_dir) - WHERE - ( - ta.tod >= %4$L - AND --{ToD_and_or} - ta.tod < %5$L - ) - AND date_part('isodow', ta.dt) = ANY(%6$L::int[]) - AND ta.dt >= %7$L - AND ta.dt < %8$L - /*--{holiday_clause} - AND NOT EXISTS ( - SELECT 1 FROM ref.holiday WHERE ta.dt = holiday.dt - )*/ - GROUP BY - seg.corridor_id, - ta.tx, - ta.dt, - seg.total_length - WINDOW w AS ( - PARTITION BY seg.corridor_id, ta.dt - ORDER BY ta.tx - ) - ), - - dynamic_bin_options AS ( - --within each corridor/hour, generate all possible forward looking bin combinations - --don't generate options for bins with sufficient length - --also don't generate options past the next bin with 80%% length - SELECT - tx, - corridor_id, - time_grp, - bin_rank AS start_bin, - --generate all the options for the end bin within the group. - generate_series( - CASE - WHEN sum_length >= 0.8 THEN bin_rank - --if length is insufficient, need at least 1 more bin - ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) - END, - CASE - --dont need to generate options when start segment is already sufficient - WHEN sum_length >= 0.8 THEN bin_rank - --generate options until 1 bin has sufficient length, otherwise until last bin in group - ELSE COALESCE( - MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, - MAX(bin_rank) OVER w - ) - END, - 1 - ) AS end_bin - FROM segment_5min_bins - WINDOW w AS ( - PARTITION BY corridor_id, time_grp - ORDER BY tx - --look only forward for end_bin options - RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING - ) - ), - - unnested_db_options AS ( - SELECT - s5b.corridor_id, - dbo.time_grp, - s5b.total_length, - dbo.tx AS dt_start, - --exclusive end bin - s5b_end.tx + interval '5 minutes' AS dt_end, - unnested.link_dir, - unnested.len, - AVG(unnested.tt) AS tt, --avg TT for each link_dir - SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir - FROM dynamic_bin_options AS dbo - LEFT JOIN segment_5min_bins AS s5b - ON s5b.time_grp = dbo.time_grp - AND s5b.bin_rank >= dbo.start_bin - AND s5b.bin_rank <= dbo.end_bin - --this join is used to get the tx info about the last bin only - LEFT JOIN segment_5min_bins AS s5b_end - ON s5b_end.time_grp = dbo.time_grp - AND s5b_end.bin_rank = dbo.end_bin, - --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin - UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) - --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) - WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '30 minutes' - GROUP BY - s5b.corridor_id, - dbo.time_grp, - s5b.total_length, - dbo.tx, --stard_bin - s5b_end.tx, --end_bin - unnested.link_dir, - unnested.len - ), - - inserted AS ( - --this query contains overlapping values which get eliminated - --via on conflict with the exclusion constraint on congestion_raw_segments table. - INSERT INTO congestion_raw_corridors_temp AS inserted ( - uri_string, time_grp, corridor_id, bin_range, tt, num_obs - ) - --distinct on ensures only the shortest option gets proposed for insert - SELECT DISTINCT ON (dt_start) - %9$L, --uristring - timerange(lower(time_grp)::time, upper(time_grp)::time, '[)') AS time_grp, - corridor_id, - tsrange(dt_start, dt_end, '[)') AS bin_range, - total_length / SUM(len) * SUM(tt) AS tt, - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment - FROM unnested_db_options - GROUP BY - time_grp, - corridor_id, - dt_start, - dt_end, - total_length - HAVING SUM(len) >= 0.8 * total_length - ORDER BY - dt_start, - dt_end - --exclusion constraint + ordered insert to prevent overlapping bins - ON CONFLICT ON CONSTRAINT congestion_raw_corridors_exclude_temp - DO NOTHING - RETURNING - inserted.uri_string, inserted.time_grp, inserted.corridor_id, - inserted.bin_range, inserted.tt, inserted.num_obs - ) - --insert into the final table INSERT INTO gwolofs.congestion_raw_corridors ( uri_string, dt, time_grp, corridor_id, bin_range, tt, num_obs, hr ) SELECT - uri_string, - lower(bin_range)::date AS dt, - time_grp, - corridor_id, - bin_range, - tt::real, - num_obs, - date_part('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr - FROM inserted + congestion_cache_tt_results.uri_string, + dt, time_grp, corridor_id, bin_range, tt, num_obs, hr + FROM gwolofs.congestion_return_dynamic_bins( + congestion_cache_tt_results.start_date, + congestion_cache_tt_results.end_date, + congestion_cache_tt_results.start_tod, + congestion_cache_tt_results.end_tod, + congestion_cache_tt_results.dow_list, + congestion_cache_tt_results.node_start, + congestion_cache_tt_results.node_end, + congestion_cache_tt_results.holidays + ) ON CONFLICT DO NOTHING; - $$, - node_start, node_end, map_version, --segment CTE - start_tod, end_tod, --segment_5min_bins CTE SELECT - dow_list, start_date, end_date, --segment_5min_bins CTE WHERE - congestion_cache_tt_results.uri_string --INSERT -); - - DROP TABLE congestion_raw_corridors_temp; - -END; $BODY$; ALTER FUNCTION gwolofs.congestion_cache_tt_results( @@ -270,4 +74,4 @@ SELECT gwolofs.congestion_cache_tt_results( $BODY$; COMMENT ON FUNCTION gwolofs.congestion_cache_tt_results_daily -IS 'A simplified version of `congestion_cache_tt_results` for aggregating entire days of data.' \ No newline at end of file +IS 'A simplified version of `congestion_cache_tt_results` for aggregating entire days of data.'; diff --git a/here/traffic/sql/dynamic_bins/function-congestion_return_dynamic_bins.sql b/here/traffic/sql/dynamic_bins/function-congestion_return_dynamic_bins.sql new file mode 100644 index 000000000..38ccbc8a8 --- /dev/null +++ b/here/traffic/sql/dynamic_bins/function-congestion_return_dynamic_bins.sql @@ -0,0 +1,256 @@ +-- FUNCTION: gwolofs.congestion_return_dynamic_bins(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --noqa: LT05 + +-- DROP FUNCTION IF EXISTS gwolofs.congestion_return_dynamic_bins(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); --noqa: LT05 + +CREATE OR REPLACE FUNCTION gwolofs.congestion_return_dynamic_bins( + start_date date, + end_date date, + start_tod time without time zone, + end_tod time without time zone, + dow_list integer [], + node_start bigint, + node_end bigint, + holidays boolean +) +RETURNS TABLE ( + dt date, + time_grp timerange, + corridor_id smallint, + bin_range tsrange, + tt real, + num_obs integer, + hr smallint +) +LANGUAGE plpgsql +COST 100 +VOLATILE PARALLEL RESTRICTED +AS $BODY$ + +DECLARE +map_version text; + +BEGIN + +--using a temp table to aply the exclusion constraint should prevent the +--insert from getting bogged down by large constraint on main table over time +DROP TABLE IF EXISTS congestion_raw_corridors_temp; +CREATE TEMPORARY TABLE congestion_raw_corridors_temp ( + dt date GENERATED ALWAYS AS (lower(bin_range)) STORED, + corridor_id smallint, + time_grp timerange NOT NULL, + bin_range tsrange NOT NULL, + tt real, + num_obs integer, + hr smallint GENERATED ALWAYS AS (date_part('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2)) STORED, + CONSTRAINT congestion_raw_corridors_exclude_temp EXCLUDE USING gist ( + bin_range WITH &&, + corridor_id WITH =, + time_grp WITH = + ) +); + +SELECT gwolofs.congestion_select_map_version( + congestion_return_dynamic_bins.start_date, + congestion_return_dynamic_bins.end_date, + 'path' +) INTO map_version; + +RETURN QUERY EXECUTE FORMAT( + $$ + WITH corridor AS ( + SELECT + ccc.corridor_id, + unnested.link_dir, + unnested.length, + ccc.total_length + FROM gwolofs.congestion_cache_corridor(%1$L, %2$L, %3$L) AS ccc, + UNNEST( + ccc.link_dirs, + ccc.lengths + ) AS unnested(link_dir, length) + ), + + segment_5min_bins AS ( + SELECT + seg.corridor_id, + ta.tx, + seg.total_length, + tsrange( + ta.dt + %4$L::time, + ta.dt + %5$L::time, '[)') AS time_grp, + RANK() OVER w AS bin_rank, + SUM(seg.length) / seg.total_length AS sum_length, + SUM(seg.length) AS length_w_data, + SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt, + SUM(sample_size) AS num_obs, + ARRAY_AGG(ta.link_dir ORDER BY ta.link_dir) AS link_dirs, + ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY ta.link_dir) AS tts, + ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths + FROM here.ta_path AS ta + JOIN corridor AS seg USING (link_dir) + LEFT JOIN ref.holiday USING (dt) + WHERE + ( + ta.tod >= %4$L + AND --{ToD_and_or} + ta.tod < %5$L + ) + AND date_part('isodow', ta.dt) = ANY(%6$L::int[]) + AND ta.dt >= %7$L + AND ta.dt < %8$L + AND (%9$L OR holiday.dt IS NULL) --holiday clause + GROUP BY + seg.corridor_id, + ta.tx, + ta.dt, + seg.total_length + WINDOW w AS ( + PARTITION BY seg.corridor_id, ta.dt + ORDER BY ta.tx + ) + ), + + dynamic_bin_options AS ( + --within each corridor/hour, generate all possible forward looking bin combinations + --don't generate options for bins with sufficient length + --also don't generate options past the next bin with 80%% length + SELECT + tx, + corridor_id, + time_grp, + bin_rank AS start_bin, + --generate all the options for the end bin within the group. + generate_series( + CASE + WHEN sum_length >= 0.8 THEN bin_rank + --if length is insufficient, need at least 1 more bin + ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w) + END, + CASE + --dont need to generate options when start segment is already sufficient + WHEN sum_length >= 0.8 THEN bin_rank + --generate options until 1 bin has sufficient length, otherwise until last bin in group + ELSE COALESCE( + MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, + MAX(bin_rank) OVER w + ) + END, + 1 + ) AS end_bin + FROM segment_5min_bins + WINDOW w AS ( + PARTITION BY corridor_id, time_grp + ORDER BY tx + --look only forward for end_bin options + RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) + ), + + unnested_db_options AS ( + SELECT + s5b.corridor_id, + dbo.time_grp, + s5b.total_length, + dbo.tx AS dt_start, + --exclusive end bin + s5b_end.tx + interval '5 minutes' AS dt_end, + unnested.link_dir, + unnested.len, + AVG(unnested.tt) AS tt, --avg TT for each link_dir + SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir + FROM dynamic_bin_options AS dbo + LEFT JOIN segment_5min_bins AS s5b + ON s5b.time_grp = dbo.time_grp + AND s5b.bin_rank >= dbo.start_bin + AND s5b.bin_rank <= dbo.end_bin + --this join is used to get the tx info about the last bin only + LEFT JOIN segment_5min_bins AS s5b_end + ON s5b_end.time_grp = dbo.time_grp + AND s5b_end.bin_rank = dbo.end_bin, + --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin + UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt) + --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr) + WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '30 minutes' + GROUP BY + s5b.corridor_id, + dbo.time_grp, + s5b.total_length, + dbo.tx, --stard_bin + s5b_end.tx, --end_bin + unnested.link_dir, + unnested.len + ) + + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + INSERT INTO congestion_raw_corridors_temp AS inserted ( + time_grp, corridor_id, bin_range, tt, num_obs + ) + --distinct on ensures only the shortest option gets proposed for insert + SELECT DISTINCT ON (dt_start) + timerange(lower(time_grp)::time, upper(time_grp)::time, '[)') AS time_grp, + corridor_id, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + time_grp, + corridor_id, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + ORDER BY + dt_start, + dt_end + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT congestion_raw_corridors_exclude_temp + DO NOTHING + RETURNING + inserted.dt, inserted.time_grp, inserted.corridor_id, + inserted.bin_range, inserted.tt, inserted.num_obs, inserted.hr; + + $$, + node_start, node_end, map_version, --segment CTE + start_tod, end_tod, --segment_5min_bins CTE SELECT + dow_list, start_date, end_date, holidays --segment_5min_bins CTE WHERE +); + +END; +$BODY$; + +ALTER FUNCTION gwolofs.congestion_return_dynamic_bins( + date, date, time without time zone, + time without time zone, integer [], bigint, bigint, boolean +) +OWNER TO gwolofs; + +COMMENT ON FUNCTION gwolofs.congestion_return_dynamic_bins IS +'Returns the dynamic binning results for a request.'; + +-- overload the function for more straightforward situation of daily corridor agg +CREATE OR REPLACE FUNCTION gwolofs.congestion_return_dynamic_bins_daily( + start_date date, + node_start bigint, + node_end bigint +) +RETURNS void +LANGUAGE sql +COST 100 +VOLATILE PARALLEL UNSAFE +AS +$BODY$ +SELECT gwolofs.congestion_return_dynamic_bins( + start_date := congestion_return_dynamic_bins_daily.start_date, + end_date := congestion_return_dynamic_bins_daily.start_date + 1, + start_tod := '00:00'::time without time zone, + end_tod := '24:00'::time without time zone, + dow_list := ARRAY[extract('isodow' from congestion_return_dynamic_bins_daily.start_date)]::int[], + node_start := congestion_return_dynamic_bins_daily.node_start, + node_end := congestion_return_dynamic_bins_daily.node_end, + holidays := True) +$BODY$; + +COMMENT ON FUNCTION gwolofs.congestion_return_dynamic_bins_daily +IS 'A simplified version of `congestion_return_dynamic_bins` for aggregating entire days of data.' From dd3170b0f4fb49ea4bb615df4e4951c86a838b29 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Mon, 29 Sep 2025 20:51:17 +0000 Subject: [PATCH 69/74] #1132 fix logical date of TriggerDagRunOperator --- dags/here_dynamic_binning_monthly_agg.py | 2 -- dags/pull_here_path.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/dags/here_dynamic_binning_monthly_agg.py b/dags/here_dynamic_binning_monthly_agg.py index d46989cf9..75d7e9a29 100644 --- a/dags/here_dynamic_binning_monthly_agg.py +++ b/dags/here_dynamic_binning_monthly_agg.py @@ -68,8 +68,6 @@ def here_dynamic_binning_monthly_agg(): create_groups = SQLExecuteQueryOperator( sql="segment_grouping.sql", task_id="create_segment_groups", - #TODO: update sql to work for different map versions - start_date=datetime(2025, 4, 1, tz="America/Toronto"), conn_id='congestion_bot', retries = 0, params={"max_group_size": 100} diff --git a/dags/pull_here_path.py b/dags/pull_here_path.py index ee6888009..421c82987 100644 --- a/dags/pull_here_path.py +++ b/dags/pull_here_path.py @@ -96,7 +96,7 @@ def trigger_dags_tasks(): trigger_operator = TriggerDagRunOperator( task_id=f'trigger_{dag_id}', trigger_dag_id=dag_id, - logical_date='{{macros.ds_add(ds, 1)}}', + logical_date='{{macros.ds_add(ds, -1)}}', reset_dag_run=True # Clear existing dag if already exists (for backfilling), old runs will not be in the logs ) trigger_operators.append(trigger_operator) From 7863ef953c5bb95d658d3b6724b7e55b0c0369a3 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 9 Oct 2025 20:58:04 +0000 Subject: [PATCH 70/74] #1132 changes to reflect change in hr datatype --- .../create-function-congestion_segment_bootstrap.sql | 6 +++--- .../function-congestion_segment_monthly_agg.sql | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql index 7a9e7ad8f..d95e82638 100644 --- a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql +++ b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql @@ -17,7 +17,7 @@ AS $BODY$ SELECT --segment_id and mnth don't need to be in group by until end EXTRACT('isodow' FROM dt) IN (1, 2, 3, 4, 5) AS is_wkdy, - EXTRACT('hour' FROM hr) AS hr, + hr, ARRAY_AGG(tt::real) AS tt_array, AVG(tt::real) AS avg_tt, COUNT(*) AS n @@ -29,7 +29,7 @@ AS $BODY$ GROUP BY segment_id, is_wkdy, - EXTRACT('hour' FROM hr) + hr ), random_selections AS ( @@ -77,7 +77,7 @@ AS $BODY$ GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_bootstrap( date, bigint, integer -) TO CONGESTION_BOT; +) TO congestion_bot; /*Usage example: (works best one segment at a time with Lateral) SELECT * diff --git a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql index 4c13186a8..ab2e7602a 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql @@ -19,7 +19,7 @@ SELECT segment_id, congestion_segment_monthly_agg.mon AS mnth, date_part('isodow', dt) <= 5 AS is_wkdy, - date_part('hour', hr) AS hr, + hr, AVG(tt) AS avg_tt, stddev(tt) AS stdev, PERCENTILE_CONT(0.05) WITHIN GROUP (ORDER BY tt) AS percentile_05, @@ -36,7 +36,7 @@ WHERE AND holiday.holiday IS NULL GROUP BY segment_id, - date_part('hour', hr), + hr, is_wkdy; $BODY$; From 9c63a32c1daa31e21e2568c9dda497fe2e22f79f Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 9 Oct 2025 20:58:14 +0000 Subject: [PATCH 71/74] #1132 try adding an analyze on temp table --- ...unction-congestion_network_segment_agg.sql | 71 +++++++++---------- 1 file changed, 34 insertions(+), 37 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index a99a94549..e8d51f6b2 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -138,40 +138,42 @@ EXECUTE FORMAT( s5b_end.tx, --end_bin unnested.link_dir, unnested.len - ), + ) - inserted AS ( - --this query contains overlapping values which get eliminated - --via on conflict with the exclusion constraint on congestion_raw_segments table. - INSERT INTO congestion_raw_segments_temp AS inserted ( - bin_start, segment_id, bin_range, tt, num_obs - ) - --distinct on ensures only the shortest option gets proposed for insert - SELECT DISTINCT ON (segment_id, dt_start) - dt_start AS bin_start, - segment_id, - tsrange(dt_start, dt_end, '[)') AS bin_range, - total_length / SUM(len) * SUM(tt) AS tt, - SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment - FROM unnested_db_options - GROUP BY - segment_id, - dt_start, - dt_end, - total_length - HAVING SUM(len) >= 0.8 * total_length - ORDER BY - segment_id, - dt_start, - dt_end --uses the option that ends first - --exclusion constraint + ordered insert to prevent overlapping bins - ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude_temp - DO NOTHING - RETURNING - inserted.bin_start, inserted.segment_id, inserted.bin_range, - inserted.tt, inserted.num_obs + --this query contains overlapping values which get eliminated + --via on conflict with the exclusion constraint on congestion_raw_segments table. + INSERT INTO congestion_raw_segments_temp AS inserted ( + bin_start, segment_id, bin_range, tt, num_obs ) + --distinct on ensures only the shortest option gets proposed for insert + SELECT DISTINCT ON (segment_id, dt_start) + dt_start AS bin_start, + segment_id, + tsrange(dt_start, dt_end, '[)') AS bin_range, + total_length / SUM(len) * SUM(tt) AS tt, + SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment + FROM unnested_db_options + GROUP BY + segment_id, + dt_start, + dt_end, + total_length + HAVING SUM(len) >= 0.8 * total_length + ORDER BY + segment_id, + dt_start, + dt_end --uses the option that ends first + --exclusion constraint + ordered insert to prevent overlapping bins + ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude_temp + DO NOTHING; + + $$, + start_date, + congestion_network_table + ); + ANALYZE congestion_raw_segments_temp; + INSERT INTO gwolofs.congestion_raw_segments ( dt, bin_start, segment_id, bin_range, tt, num_obs, hr ) @@ -183,13 +185,8 @@ EXECUTE FORMAT( tt::real, num_obs, date_part('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr - FROM inserted + FROM congestion_raw_segments_temp ON CONFLICT DO NOTHING; - - $$, - start_date, - congestion_network_table - ); DROP TABLE congestion_raw_segments_temp; From 191a2c22e6207a899d8597a102da1d70bcce0387 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Thu, 9 Oct 2025 21:06:08 +0000 Subject: [PATCH 72/74] #1132 materialize? --- .../dynamic_bins/function-congestion_network_segment_agg.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index e8d51f6b2..a314837cb 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -44,7 +44,7 @@ EXECUTE FORMAT( FROM congestion.%2$I ), - segment_5min_bins AS ( + segment_5min_bins AS MATERIALIZED ( SELECT seg.segment_id, ta.tx, From 4e14aee95cd5dd5a100dc19da5d9090cd9c08c1a Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 15 Oct 2025 14:18:36 +0000 Subject: [PATCH 73/74] #1132 separate out delete query --- dags/here_dynamic_binning_agg.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py index 3d46af93b..166031952 100644 --- a/dags/here_dynamic_binning_agg.py +++ b/dags/here_dynamic_binning_agg.py @@ -65,9 +65,16 @@ def here_dynamic_binning_agg(): retry_delay=duration(days=1) ) + delete_daily = SQLExecuteQueryOperator( + sql="DELETE FROM gwolofs.congestion_raw_segments WHERE dt = '{{ ds }}'", + task_id='delete_daily', + conn_id='congestion_bot', + autocommit=True, + retries = 2 + ) + aggregate_daily = SQLExecuteQueryOperator( - sql=["DELETE FROM gwolofs.congestion_raw_segments WHERE dt = '{{ ds }}'", - "SELECT gwolofs.congestion_network_segment_agg('{{ ds }}'::date);"], + sql="SELECT gwolofs.congestion_network_segment_agg('{{ ds }}'::date);", task_id='aggregate_daily', conn_id='congestion_bot', autocommit=True, @@ -75,6 +82,6 @@ def here_dynamic_binning_agg(): hook_params={"options": "-c statement_timeout=10800000ms"} #3 hours ) - check_not_empty >> aggregate_daily + check_not_empty >> delete_daily >> aggregate_daily here_dynamic_binning_agg() \ No newline at end of file From b3c62df9b26a2770e25bf5b8c033a91e156c2232 Mon Sep 17 00:00:00 2001 From: gabrielwol <80077912+gabrielwol@users.noreply.github.com> Date: Wed, 15 Oct 2025 14:19:07 +0000 Subject: [PATCH 74/74] #1132 change cte's to temp tables with indices to speed up congestion_network_segment_agg --- ...unction-congestion_network_segment_agg.sql | 70 +++++++++---------- 1 file changed, 34 insertions(+), 36 deletions(-) diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql index a314837cb..f5905d600 100644 --- a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql +++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql @@ -31,52 +31,52 @@ CREATE TEMPORARY TABLE congestion_raw_segments_temp ( bin_range WITH &&, segment_id WITH = ) -); +) ON COMMIT DROP; EXECUTE FORMAT( $$ - WITH segments AS ( - SELECT - segment_id, - link_dir, - length, - SUM(length) OVER (PARTITION BY segment_id) AS total_length - FROM congestion.%2$I - ), - - segment_5min_bins AS MATERIALIZED ( + DROP TABLE IF EXISTS segment_5min_bins; + CREATE TEMP TABLE segment_5min_bins ON COMMIT DROP AS SELECT seg.segment_id, ta.tx, - seg.total_length, - RANK() OVER w AS bin_rank, - SUM(seg.length) / seg.total_length AS sum_length, + seg.segment_length AS total_length, + ROW_NUMBER() OVER w AS bin_rank, + SUM(seg.length) / seg.segment_length AS sum_length, SUM(seg.length) AS length_w_data, SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt, SUM(sample_size) AS num_obs, ARRAY_AGG(ta.link_dir ORDER BY ta.link_dir) AS link_dirs, - ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY ta.link_dir) AS tts, + ARRAY_AGG(lat.tt ORDER BY ta.link_dir) AS tts, ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths FROM here.ta_path AS ta - JOIN segments AS seg USING (link_dir) + JOIN congestion.%1$I AS seg USING (link_dir), + LATERAL ( + SELECT seg.length / ta.mean * 3.6 AS tt + ) AS lat WHERE - ta.dt >= %1$L::date - AND ta.dt < %1$L::date + interval '1 day' + ta.dt >= %2$L::date + AND ta.dt < %2$L::date + interval '1 day' GROUP BY seg.segment_id, ta.tx, - seg.total_length - WINDOW w AS ( + seg.segment_length + WINDOW w AS ( PARTITION BY seg.segment_id ORDER BY ta.tx - ) - ), + ); + $$, congestion_network_table, start_date); + + CREATE INDEX idx_s5b_segment_rank ON segment_5min_bins(segment_id, bin_rank); + CREATE INDEX idx_s5b_segment_tx ON segment_5min_bins(segment_id, tx); + ANALYZE segment_5min_bins; - dynamic_bin_options AS ( - --within each segment/hour, generate all possible forward looking bin combinations - --don't generate options for bins with sufficient length - --also don't generate options past the next bin with 80%% length - SELECT + --within each segment/hour, generate all possible forward looking bin combinations + --don't generate options for bins with sufficient length + --also don't generate options past the next bin with 80% length + DROP TABLE IF EXISTS dynamic_bin_options; + CREATE TEMP TABLE dynamic_bin_options ON COMMIT DROP AS + SELECT tx, segment_id, bin_rank AS start_bin, @@ -103,11 +103,14 @@ EXECUTE FORMAT( PARTITION BY segment_id ORDER BY tx --look only forward for end_bin options - RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING - ) - ), + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ); - unnested_db_options AS ( + CREATE INDEX idx_dbo_composite ON dynamic_bin_options(segment_id, start_bin, end_bin); + CREATE INDEX idx_dbo_segment_tx ON dynamic_bin_options(segment_id, tx); + ANALYZE dynamic_bin_options; + + WITH unnested_db_options AS ( SELECT dbo.segment_id, s5b.total_length, @@ -167,11 +170,6 @@ EXECUTE FORMAT( ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude_temp DO NOTHING; - $$, - start_date, - congestion_network_table - ); - ANALYZE congestion_raw_segments_temp; INSERT INTO gwolofs.congestion_raw_segments (