Terminplan als Gantt: Verknüpfungen mit mehreren Vorgängern, Neuplanung der Nachfolger, Vorgangsnummern
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
149
src/domain/terminplan.ts
Normal file
149
src/domain/terminplan.ts
Normal file
@@ -0,0 +1,149 @@
|
||||
// Terminplanung mit Verknüpfungen (T3, T5): ein Vorgang darf mehrere Vorgänger haben.
|
||||
// Regeln wie in V70 (reqOf/reschedAll): EA, AA, EE, AE mit Verzögerung in Arbeitstagen.
|
||||
// Nachfolger werden nach hinten geschoben, wenn ein Vorgänger sich verlängert oder später
|
||||
// liegt. Nach vorn rücken nur Nachfolger, die vorher direkt am Vorgänger hingen („eng“).
|
||||
|
||||
import { type Datum } from "./datum.js";
|
||||
import { type Arbeitswoche, endeNachDauer, naechsterArbeitstag, verschiebeArbeitstage } from "./kalender.js";
|
||||
|
||||
export type Art = "EA" | "AA" | "EE" | "AE";
|
||||
|
||||
export interface PlanVorgang {
|
||||
id: string;
|
||||
start: Datum;
|
||||
/** Arbeitstage; angefangene Tage zählen voll; 0 = Meilenstein */
|
||||
dauer: number;
|
||||
}
|
||||
|
||||
export interface Verknuepfung {
|
||||
vorgang_id: string;
|
||||
vorgaenger_id: string;
|
||||
art: Art;
|
||||
/** Arbeitstage, darf negativ sein */
|
||||
verzoegerung: number;
|
||||
}
|
||||
|
||||
const tage = (v: PlanVorgang) => Math.ceil(v.dauer);
|
||||
|
||||
export function anfang(v: PlanVorgang, woche: Arbeitswoche): Datum {
|
||||
return naechsterArbeitstag(v.start, woche);
|
||||
}
|
||||
|
||||
export function ende(v: PlanVorgang, woche: Arbeitswoche): Datum {
|
||||
return endeNachDauer(v.start, tage(v), woche);
|
||||
}
|
||||
|
||||
/** V70 offW: n Arbeitstage nach (n > 0) oder vor (n < 0) dem Tag; 0 = der Tag oder der nächste Arbeitstag. */
|
||||
function versatz(d: Datum, n: number, woche: Arbeitswoche): Datum {
|
||||
return n === 0 ? naechsterArbeitstag(d, woche) : verschiebeArbeitstage(d, n, woche);
|
||||
}
|
||||
|
||||
/** Start, der sich ergibt, wenn der Vorgang an `endeAm` endet. */
|
||||
function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche): Datum {
|
||||
const e = naechsterArbeitstag(endeAm, woche);
|
||||
return tage(v) <= 1 ? e : verschiebeArbeitstage(e, -(tage(v) - 1), woche);
|
||||
}
|
||||
|
||||
/** Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt. */
|
||||
export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum {
|
||||
const lg = k.verzoegerung;
|
||||
const meilenstein = tage(v) === 0;
|
||||
switch (k.art) {
|
||||
case "EA": return versatz(ende(vorgaenger, woche), meilenstein ? lg : 1 + lg, woche);
|
||||
case "AA": return versatz(anfang(vorgaenger, woche), lg, woche);
|
||||
case "EE": return startFuerEnde(v, versatz(ende(vorgaenger, woche), lg, woche), woche);
|
||||
case "AE": return startFuerEnde(v, versatz(anfang(vorgaenger, woche), lg, woche), woche);
|
||||
}
|
||||
}
|
||||
|
||||
/** Frühester Start aus allen Vorgängern; undefined ohne Vorgänger. */
|
||||
export function fruehesterStart(v: PlanVorgang, alle: Map<string, PlanVorgang>, links: Verknuepfung[], woche: Arbeitswoche): Datum | undefined {
|
||||
let s: Datum | undefined;
|
||||
for (const k of links) {
|
||||
if (k.vorgang_id !== v.id) continue;
|
||||
const p = alle.get(k.vorgaenger_id);
|
||||
if (!p) continue;
|
||||
const x = startNachVerknuepfung(v, p, k, woche);
|
||||
if (!s || x > s) s = x;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
/** Vorgänge, die genau an ihrem frühesten Start liegen; sie rücken mit, wenn der Vorgänger früher fertig wird. */
|
||||
export function engeVorgaenge(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche): Set<string> {
|
||||
const alle = new Map(vorgaenge.map((v) => [v.id, v]));
|
||||
const eng = new Set<string>();
|
||||
for (const v of vorgaenge) {
|
||||
const f = fruehesterStart(v, alle, links, woche);
|
||||
if (f && f === anfang(v, woche)) eng.add(v.id);
|
||||
}
|
||||
return eng;
|
||||
}
|
||||
|
||||
/** true, wenn die neue Verknüpfung einen Kreis bilden würde (Vorgänger hängt schon am Vorgang). */
|
||||
export function bildetKreis(neu: Pick<Verknuepfung, "vorgang_id" | "vorgaenger_id">, links: Verknuepfung[]): boolean {
|
||||
if (neu.vorgang_id === neu.vorgaenger_id) return true;
|
||||
const nachfolger = new Map<string, string[]>();
|
||||
for (const k of links) nachfolger.set(k.vorgaenger_id, [...(nachfolger.get(k.vorgaenger_id) ?? []), k.vorgang_id]);
|
||||
const offen = [neu.vorgang_id];
|
||||
const gesehen = new Set<string>();
|
||||
while (offen.length) {
|
||||
const x = offen.pop()!;
|
||||
if (x === neu.vorgaenger_id) return true;
|
||||
if (gesehen.has(x)) continue;
|
||||
gesehen.add(x);
|
||||
offen.push(...(nachfolger.get(x) ?? []));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Reihenfolge, in der Vorgänger vor ihren Nachfolgern kommen. Wirft bei einem Kreis. */
|
||||
function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorgang[] {
|
||||
const ids = new Set(vorgaenge.map((v) => v.id));
|
||||
const rest = new Map(vorgaenge.map((v) => [v.id, 0]));
|
||||
const nach = new Map<string, string[]>();
|
||||
for (const k of links) {
|
||||
if (!ids.has(k.vorgang_id) || !ids.has(k.vorgaenger_id)) continue;
|
||||
rest.set(k.vorgang_id, rest.get(k.vorgang_id)! + 1);
|
||||
nach.set(k.vorgaenger_id, [...(nach.get(k.vorgaenger_id) ?? []), k.vorgang_id]);
|
||||
}
|
||||
const byId = new Map(vorgaenge.map((v) => [v.id, v]));
|
||||
const bereit = vorgaenge.filter((v) => rest.get(v.id) === 0).map((v) => v.id);
|
||||
const aus: PlanVorgang[] = [];
|
||||
while (bereit.length) {
|
||||
const id = bereit.shift()!;
|
||||
aus.push(byId.get(id)!);
|
||||
for (const n of nach.get(id) ?? []) {
|
||||
rest.set(n, rest.get(n)! - 1);
|
||||
if (rest.get(n) === 0) bereit.push(n);
|
||||
}
|
||||
}
|
||||
if (aus.length !== vorgaenge.length) throw new Error("Die Verknüpfungen bilden einen Kreis.");
|
||||
return aus;
|
||||
}
|
||||
|
||||
export interface Ergebnis {
|
||||
/** neuer Start je verschobenem Vorgang */
|
||||
starts: Map<string, Datum>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Plant alle Nachfolger neu. `eng` sind die Vorgänge, die vor der Änderung direkt am Vorgänger hingen
|
||||
* (engeVorgaenge auf dem alten Stand); nur sie dürfen nach vorn rücken. `fest` werden nicht bewegt
|
||||
* (der Vorgang, den der Benutzer gerade gezogen hat, wird vorher auf seinen frühesten Start begrenzt).
|
||||
*/
|
||||
export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set<string> = new Set()): Ergebnis {
|
||||
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
|
||||
const starts = new Map<string, Datum>();
|
||||
for (const v of topologisch(vorgaenge, links)) {
|
||||
const x = stand.get(v.id)!;
|
||||
const f = fruehesterStart(x, stand, links, woche);
|
||||
if (!f) continue;
|
||||
const a = anfang(x, woche);
|
||||
if (f > a || (f < a && eng.has(v.id))) {
|
||||
x.start = f;
|
||||
starts.set(v.id, f);
|
||||
}
|
||||
}
|
||||
return { starts };
|
||||
}
|
||||
Reference in New Issue
Block a user