lsa-planer

LSA-Planer Professional – Planungssoftware für Lichtsignalanlagen nach RiLSA 2015 und § 45 StVO. EUPL-1.2.

/ tests domain geometriefaktoren.test.ts

13,0 KB Rohdatei
tests/domain/geometriefaktoren.test.ts — 300 Zeilen
1 import { describe, expect, it } from 'vitest';
2 import { geometriefaktor, saturationFlow } from '@/domain/rilsa/capacity';
3 import { HBS_STANDARDBEDINGUNGEN, RILSA_DEFAULTS } from '@/domain/rilsa/constants';
4 import { buildSignalPlan } from '@/domain/plan/signalPlan';
5 import { validateProject } from '@/domain/validation';
6 import { createStandardIntersectionProject } from '@/domain/model/factory';
7 import { loadProject } from '@/domain/model/migrate';
8 import type { Project, SignalGroup } from '@/domain/model/project';
9
10 /**
11 * Fassung 5.30.0 - die geometrischen Anpassungsfaktoren des Zeitbedarfswerts
12 * (BASt V 400).
13 *
14 * WARUM SIE GEBAUT WURDEN: Ohne sie rechnete das Programm jede Zufahrt unter
15 * Standardbedingungen, und die eigene Unterlage nannte das die unsichere
16 * Richtung. An einer 2,50 m breiten Zufahrt fiel die
17 * Saettigungsverkehrsstaerke um 18,8 % zu gross aus.
18 *
19 * Alle Zahlen hier sind aus den drei Geraden von Hand nachgerechnet:
20 * fb = -0,375 b + 2,125 (nur unter 3,00 m)
21 * fR = -0,015 R + 1,3 (nur unter 20 m)
22 * fs = 0,03 s + 1
23 * angesetzt wird max(1; max(fb, fR, fs) * min(1; fs))
24 */
25
26 const DATUM = new Date('2026-01-01T00:00:00Z');
27
28 describe('Geometriefaktoren - die drei Geraden', () => {
29 it('geht an den Grenzpunkten stetig in den Regelfall über', () => {
30 // fb(3,00) = -1,125 + 2,125 = 1,000; fR(20) = -0,30 + 1,30 = 1,000;
31 // fs(0) = 1,000. Ein Sprung an der Schwelle waere ein Rechenfehler.
32 const b = geometriefaktor(
33 { breite: HBS_STANDARDBEDINGUNGEN.fahrstreifenbreiteAb },
34 'geradeaus',
35 );
36 const r = geometriefaktor({ radius: HBS_STANDARDBEDINGUNGEN.kurvenradiusAb }, 'geradeaus');
37 const s = geometriefaktor({ neigung: 0 }, 'geradeaus');
38 expect(b.fb).toBe(1);
39 expect(r.fR).toBe(1);
40 expect(s.fs).toBe(1);
41 for (const ergebnis of [b, r, s]) expect(ergebnis.gesamt).toBe(1);
42 });
43
44 it('mindert eine schmale Zufahrt', () => {
45 // fb(2,50) = -0,9375 + 2,125 = 1,1875
46 const ergebnis = geometriefaktor({ breite: 2.5 }, 'geradeaus');
47 expect(ergebnis.fb).toBeCloseTo(1.1875, 6);
48 expect(ergebnis.gesamt).toBeCloseTo(1.1875, 6);
49 // 2000 / 1,1875 = 1684,2 Kfz/h - die Zahl aus der Schemachronik.
50 expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, { breite: 2.5 })).toBeCloseTo(1684.2, 1);
51 });
52
53 it('mindert einen engen Bogen im durchgehenden Fahrstreifen', () => {
54 // fR(10) = -0,15 + 1,30 = 1,15
55 const ergebnis = geometriefaktor({ radius: 10 }, 'geradeaus');
56 expect(ergebnis.fR).toBeCloseTo(1.15, 6);
57 expect(ergebnis.gesamt).toBeCloseTo(1.15, 6);
58 });
59
60 it('mindert eine Steigung', () => {
61 // fs(4) = 0,12 + 1 = 1,12; 2000 / 1,12 = 1785,7 Kfz/h
62 const ergebnis = geometriefaktor({ neigung: 4 }, 'geradeaus');
63 expect(ergebnis.fs).toBeCloseTo(1.12, 6);
64 expect(ergebnis.gesamt).toBeCloseTo(1.12, 6);
65 expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, { neigung: 4 })).toBeCloseTo(1785.7, 1);
66 });
67
68 it('nimmt den größten der drei Faktoren, nicht ihr Produkt', () => {
69 // f1 = max(1,1875; 1,15; 1,06) = 1,1875 - und NICHT 1,1875 * 1,15 * 1,06.
70 // Ein Produkt waere eine dreifache Abminderung derselben Engstelle.
71 const ergebnis = geometriefaktor({ breite: 2.5, radius: 10, neigung: 2 }, 'geradeaus');
72 expect(ergebnis.f1).toBeCloseTo(1.1875, 6);
73 expect(ergebnis.gesamt).toBeCloseTo(1.1875, 6);
74 });
75
76 it('lässt eine fehlende oder unbrauchbare Angabe als Standardbedingung gelten', () => {
77 for (const geometrie of [
78 {},
79 { breite: undefined, radius: undefined, neigung: undefined },
80 { breite: Number.NaN, radius: Number.POSITIVE_INFINITY, neigung: Number.NaN },
81 ]) {
82 const ergebnis = geometriefaktor(geometrie, 'geradeaus');
83 expect(ergebnis.gesamt, JSON.stringify(geometrie)).toBe(1);
84 expect(ergebnis.gedeckelt).toBe(false);
85 }
86 // Und die Saettigungsverkehrsstaerke bleibt der Grundwert - der Stand bis
87 // Schema 13. Ohne diese Zusage waere jede Bestandsdatei betroffen.
88 expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS)).toBe(
89 RILSA_DEFAULTS.capacity.saturationFlow,
90 );
91 expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, {})).toBe(
92 RILSA_DEFAULTS.capacity.saturationFlow,
93 );
94 });
95 });
96
97 describe('Geometriefaktoren - der Deckel bei 1', () => {
98 it('lässt ein Gefälle die Sättigungsverkehrsstärke nicht anheben', () => {
99 /*
100 * DIE SICHERHEITSENTSCHEIDUNG DIESES PUNKTES. fs(-4) = -0,12 + 1 = 0,88;
101 * f1 = max(1; 1; 0,88) = 1, f2 = min(1; 0,88) = 0,88, also 0,88 nach der
102 * geschlossenen Formel - und 2000 / 0,88 = 2273 Kfz/h, 13,6 % ueber dem
103 * Grundwert. Dieses Programm setzt 1,000 an.
104 */
105 const ergebnis = geometriefaktor({ neigung: -4 }, 'geradeaus');
106 expect(ergebnis.fs).toBeCloseTo(0.88, 6);
107 expect(ergebnis.f1).toBe(1);
108 expect(ergebnis.f2).toBeCloseTo(0.88, 6);
109 expect(ergebnis.gesamt, 'gedeckelt bei 1').toBe(1);
110 expect(ergebnis.gedeckelt).toBe(true);
111 expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, { neigung: -4 })).toBe(
112 RILSA_DEFAULTS.capacity.saturationFlow,
113 );
114 });
115
116 it('lässt ein Gefälle eine andere Abminderung trotzdem mildern', () => {
117 /*
118 * Der Deckel greift am PRODUKT, nicht an f2. Schmale Zufahrt mit Gefaelle:
119 * f1 = 1,1875, f2 = 0,88, Produkt 1,045 - das liegt ueber 1 und bleibt
120 * stehen. Die Zufahrt ist immer noch schmal, nur weniger schlimm.
121 */
122 const ergebnis = geometriefaktor({ breite: 2.5, neigung: -4 }, 'geradeaus');
123 expect(ergebnis.gesamt).toBeCloseTo(1.045, 3);
124 expect(ergebnis.gedeckelt).toBe(false);
125 });
126
127 it('meldet den greifenden Deckel im Prüfbericht', () => {
128 const bericht = validateProject(mitGeometrie({ laengsneigung: -4 }));
129 const meldung = bericht.findings.find(
130 (f) => f.rule === 'leistungsfaehigkeit.geometrie-gefaelle-gedeckelt',
131 );
132 expect(meldung, 'die Abweichung wird nicht verschwiegen').toBeDefined();
133 expect(meldung?.severity).toBe('hinweis');
134 expect(meldung?.message).toContain('13,6');
135 });
136
137 it('schweigt, wo keine Geometrie erfasst ist', () => {
138 // Eine Meldung an jeder Signalgruppe jedes Plans saehe niemand mehr an.
139 const bericht = validateProject(createStandardIntersectionProject('Ohne Geometrie', DATUM));
140 expect(bericht.findings.some((f) => f.rule.startsWith('leistungsfaehigkeit.geometrie-'))).toBe(
141 false,
142 );
143 });
144 });
145
146 describe('Geometriefaktoren - kein fR am Abbieger', () => {
147 it('lässt den Radius an abbiegenden Strömen ohne Wirkung', () => {
148 /*
149 * Sonst mindert der Radius zweimal ab: Der pauschale Abbiegerfaktor 0,90
150 * ist in quellen.ts ausdruecklich als Ersatz fuer die differenzierten
151 * HBS-Faktoren nach Abbiegeradius, Gegenverkehr und Fussgaengerquerung
152 * gefuehrt. 0,90 / 1,15 waeren 0,783 des Grundwerts.
153 */
154 for (const movement of ['links', 'rechts'] as const) {
155 const ergebnis = geometriefaktor({ radius: 10 }, movement);
156 expect(ergebnis.fR, movement).toBe(1);
157 expect(ergebnis.gesamt, movement).toBe(1);
158 expect(ergebnis.radiusVomAbbiegerfaktorGedeckt, movement).toBe(true);
159 }
160 // Der Abbiegerfaktor selbst bleibt: 2000 * 0,9 = 1800 Kfz/h.
161 expect(saturationFlow('rechts', 1, RILSA_DEFAULTS, { radius: 10 })).toBeCloseTo(
162 RILSA_DEFAULTS.capacity.saturationFlow * RILSA_DEFAULTS.capacity.turningFactor,
163 6,
164 );
165 });
166
167 it('lässt Breite und Neigung am Abbieger sehr wohl wirken', () => {
168 // Nur der Radius ist vom pauschalen Faktor gedeckt, die beiden anderen
169 // nicht - sie pauschal mit auszunehmen waere die unsichere Richtung.
170 const ergebnis = geometriefaktor({ breite: 2.5, neigung: 4 }, 'links');
171 expect(ergebnis.gesamt).toBeCloseTo(1.1875, 6);
172 expect(ergebnis.radiusVomAbbiegerfaktorGedeckt).toBe(false);
173 });
174
175 it('meldet den wirkungslosen Eintrag im Prüfbericht', () => {
176 const bericht = validateProject(mitGeometrie({ kurvenradius: 10 }, 'links'));
177 const meldung = bericht.findings.find(
178 (f) => f.rule === 'leistungsfaehigkeit.geometrie-radius-ohne-wirkung',
179 );
180 expect(meldung, 'ein Eintrag ohne Wirkung wird benannt').toBeDefined();
181 expect(meldung?.message).toContain('Abbiegerfaktor');
182 });
183 });
184
185 describe('Geometriefaktoren - im Plan und in der Datei', () => {
186 it('senkt die Kapazität der betroffenen Signalgruppe', () => {
187 /*
188 * BEIDE PLAENE AUS DEMSELBEN PROJEKT. `createStandardIntersectionProject`
189 * vergibt bei jedem Aufruf neue Kennungen; wer zweimal aufruft und die
190 * Gruppen ueber `groupId` gegeneinanderhaelt, findet keine - und ein
191 * `?? 0` daneben macht aus dem leeren Vergleich einen bestandenen Fall.
192 * Genau so stand dieser Fall zuerst da, und er hat nichts geprueft.
193 */
194 const basis = ohneGeometrie();
195 const gruppenId = basis.signalGroups.find((g) => g.mode === 'kfz')?.id;
196 expect(gruppenId, 'die Vorlage führt eine Kfz-Signalgruppe').toBeDefined();
197
198 const ohne = buildSignalPlan(basis);
199 const mit = buildSignalPlan({
200 ...basis,
201 signalGroups: basis.signalGroups.map((g) =>
202 g.id === gruppenId ? { ...g, fahrstreifenbreite: 2.5 } : g,
203 ),
204 });
205
206 const vorher = ohne.groups.find((g) => g.groupId === gruppenId);
207 const nachher = mit.groups.find((g) => g.groupId === gruppenId);
208 expect(vorher?.capacity, 'die Gruppe steht im Plan').not.toBeNull();
209 expect(nachher?.capacity, 'und auch im zweiten Plan').not.toBeNull();
210 // fb(2,50) = 1,1875 - dieselbe Minderung wie an der reinen Funktion.
211 expect(nachher?.capacity?.saturationFlow).toBeCloseTo(
212 (vorher?.capacity?.saturationFlow ?? 0) / 1.1875,
213 6,
214 );
215
216 // Die uebrigen Gruppen bleiben unberuehrt: Die Geometrie haengt an der
217 // Signalgruppe und nicht an der Anlage.
218 for (const gruppe of mit.groups) {
219 if (gruppe.groupId === gruppenId || gruppe.capacity === null) continue;
220 const gegenstueck = ohne.groups.find((g) => g.groupId === gruppe.groupId);
221 expect(gruppe.capacity.saturationFlow, gruppe.name).toBe(
222 gegenstueck?.capacity?.saturationFlow,
223 );
224 }
225 });
226
227 it('trägt die drei Felder unverändert durch Datei und Einlesen', () => {
228 const projekt = mitGeometrie({ fahrstreifenbreite: 2.75, kurvenradius: 12, laengsneigung: 3 });
229 const geladen = loadProject(JSON.parse(JSON.stringify(projekt)));
230 const gruppe = geladen.project.signalGroups[0];
231 expect(geladen.project.schemaVersion).toBe(19);
232 expect(gruppe?.fahrstreifenbreite).toBe(2.75);
233 expect(gruppe?.kurvenradius).toBe(12);
234 expect(gruppe?.laengsneigung).toBe(3);
235 });
236
237 it('erfindet für eine Altdatei keine Vermessung', () => {
238 /*
239 * Ein fehlendes Feld bleibt fehlend - es wird nicht mit einem Regelwert
240 * gefuellt. Sonst stuende in jeder alten Datei nach dem naechsten Speichern
241 * eine Angabe, die niemand gemacht hat (dasselbe Muster wie beim
242 * Blindenzusatz in Schema 11).
243 */
244 const roh = JSON.parse(JSON.stringify(mitGeometrie({}))) as Record<string, unknown>;
245 const gruppen = roh['signalGroups'] as Record<string, unknown>[];
246 expect(gruppen[0], 'die Vorlage traegt kein Geometriefeld').not.toHaveProperty(
247 'fahrstreifenbreite',
248 );
249 const geladen = loadProject(roh);
250 expect(geladen.project.signalGroups[0]?.fahrstreifenbreite).toBeUndefined();
251 });
252
253 it('meldet einen unlesbaren Eintrag, statt still mit Standardbedingung zu rechnen', () => {
254 const roh = JSON.parse(JSON.stringify(mitGeometrie({}))) as Record<string, unknown>;
255 const gruppen = roh['signalGroups'] as Record<string, unknown>[];
256 (gruppen[0] as Record<string, unknown>)['fahrstreifenbreite'] = 'schmal';
257 const geladen = loadProject(roh);
258 expect(geladen.project.signalGroups[0]?.fahrstreifenbreite).toBeUndefined();
259 const meldung = geladen.issues.find((i) => i.path.endsWith('.fahrstreifenbreite'));
260 expect(meldung, 'die Meldung fehlt').toBeDefined();
261 // Die Fehlerrichtung gehoert in die Meldung: Ohne den Wert faellt die
262 // Saettigungsverkehrsstaerke GROESSER aus.
263 expect(meldung?.message).toContain('größer');
264 });
265 });
266
267 /** Standardknotenpunkt mit Verkehrsstaerken, ohne jede Geometrie. */
268 function ohneGeometrie(): Project {
269 const roh = createStandardIntersectionProject('Geometrie', DATUM);
270 return {
271 ...roh,
272 demands: roh.signalGroups
273 .filter((g) => g.mode === 'kfz')
274 .map((g) => ({ signalGroupId: g.id, volume: 500, heavyVehicleShare: 0.05 })),
275 };
276 }
277
278 /** Standardknotenpunkt, dessen erste Kfz-Gruppe die Geometrie traegt. */
279 function mitGeometrie(
280 geometrie: Partial<Pick<SignalGroup, 'fahrstreifenbreite' | 'kurvenradius' | 'laengsneigung'>>,
281 movement?: SignalGroup['movement'],
282 ): Project {
283 const roh = createStandardIntersectionProject('Geometrie', DATUM);
284 let gesetzt = false;
285 return {
286 ...roh,
287 signalGroups: roh.signalGroups.map((gruppe) => {
288 if (gesetzt || gruppe.mode !== 'kfz') return gruppe;
289 gesetzt = true;
290 return {
291 ...gruppe,
292 ...(movement === undefined ? {} : { movement }),
293 ...geometrie,
294 };
295 }),
296 demands: roh.signalGroups
297 .filter((g) => g.mode === 'kfz')
298 .map((g) => ({ signalGroupId: g.id, volume: 500, heavyVehicleShare: 0.05 })),
299 };
300 }