0.30.0: Terminplan in Vierteltagen, Überschneidung erst über einen Tag
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:
@@ -1,12 +1,18 @@
|
||||
// Besetzung der Vorgänge (T14) und Warnung bei Terminüberschneidung (T9): dieselbe Person,
|
||||
// derselbe Subunternehmer oder dieselbe Kolonne zur gleichen Zeit an zwei Stellen.
|
||||
// derselbe Subunternehmer oder dieselbe Kolonne zur gleichen Zeit an zwei Stellen. Mit Vierteltagen (Henning,
|
||||
// 22.10.2026) erst, wenn die Dauern an einem Tag zusammen mehr als einen Tag ergeben.
|
||||
|
||||
import { type Datum } from "./datum.js";
|
||||
import { type Arbeitswoche, tagesAnteile, wocheVon } from "./kalender.js";
|
||||
|
||||
export interface EinsatzVorgang {
|
||||
id: string;
|
||||
anfang: Datum;
|
||||
ende: Datum;
|
||||
start?: Datum;
|
||||
start_teil?: number | null;
|
||||
dauer?: number;
|
||||
freitage?: Datum[] | null;
|
||||
}
|
||||
|
||||
export interface Besetzung {
|
||||
@@ -36,7 +42,13 @@ export function wer(b: Pick<Besetzung, "kontakt_id" | "platzhalter"> & { kolonne
|
||||
return p && !/^n\.?\s*n\.?$/.test(p) ? `platzhalter:${p}` : undefined;
|
||||
}
|
||||
|
||||
export function ueberschneidungen(vorgaenge: EinsatzVorgang[], besetzungen: Besetzung[]): Ueberschneidung[] {
|
||||
/** Anteil je Tag; ohne Dauer und Kalender zählt jeder Tag von Anfang bis Ende ganz */
|
||||
function anteile(v: EinsatzVorgang, woche?: Arbeitswoche): Map<Datum, number> | null {
|
||||
if (!woche || v.dauer === undefined) return null;
|
||||
return tagesAnteile(v.anfang, Number(v.dauer), wocheVon(v, woche), v.start === v.anfang ? Number(v.start_teil ?? 0) : 0);
|
||||
}
|
||||
|
||||
export function ueberschneidungen(vorgaenge: EinsatzVorgang[], besetzungen: Besetzung[], woche?: Arbeitswoche): Ueberschneidung[] {
|
||||
const v = new Map(vorgaenge.map((x) => [x.id, x]));
|
||||
const jeWer = new Map<string, EinsatzVorgang[]>();
|
||||
for (const b of besetzungen) {
|
||||
@@ -48,13 +60,19 @@ export function ueberschneidungen(vorgaenge: EinsatzVorgang[], besetzungen: Bese
|
||||
jeWer.set(w, liste);
|
||||
}
|
||||
const aus: Ueberschneidung[] = [];
|
||||
const anteilVon = new Map(vorgaenge.map((x) => [x.id, anteile(x, woche)]));
|
||||
for (const [w, liste] of jeWer) {
|
||||
liste.sort((a, b) => (a.anfang < b.anfang ? -1 : a.anfang > b.anfang ? 1 : 0));
|
||||
for (let i = 0; i < liste.length; i++) {
|
||||
for (let j = i + 1; j < liste.length; j++) {
|
||||
const a = liste[i]!, b = liste[j]!;
|
||||
if (b.anfang > a.ende) break;
|
||||
aus.push({ wer: w, vorgang_a: a.id, vorgang_b: b.id, ab: b.anfang });
|
||||
const ta = anteilVon.get(a.id), tb = anteilVon.get(b.id);
|
||||
if (!ta || !tb) { aus.push({ wer: w, vorgang_a: a.id, vorgang_b: b.id, ab: b.anfang }); continue; }
|
||||
// erster gemeinsamer Tag, an dem alle Vorgänge dieser Person zusammen mehr als einen Tag ergeben
|
||||
const tag = [...ta.keys()].filter((d) => tb.has(d)).sort().find((d) =>
|
||||
liste.reduce((s, x) => { const m = anteilVon.get(x.id); return s + (m ? (m.get(d) ?? 0) : x.anfang <= d && x.ende >= d ? 1 : 0); }, 0) > 1 + 1e-9);
|
||||
if (tag) aus.push({ wer: w, vorgang_a: a.id, vorgang_b: b.id, ab: tag });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -114,15 +114,38 @@ export function verschiebeArbeitstage(d: Datum, n: number, woche: Arbeitswoche =
|
||||
return x;
|
||||
}
|
||||
|
||||
const EPS = 1e-9;
|
||||
|
||||
/** Dauern in Vierteltagen (Henning, 22.10.2026: mehrere kleine Vorgänge an einem Tag) */
|
||||
export const viertelTage = (x: number) => Math.round(x * 4) / 4;
|
||||
export const istViertel = (x: number) => Math.abs(x * 4 - Math.round(x * 4)) < 1e-6;
|
||||
|
||||
/**
|
||||
* Letzter Arbeitstag eines Vorgangs, der am Start (bzw. dem nächsten Arbeitstag) beginnt
|
||||
* und `dauer` Arbeitstage dauert. Dauer 0 ist ein Meilenstein: Ende = Start.
|
||||
* und `dauer` Arbeitstage dauert. Dauer 0 ist ein Meilenstein: Ende = Start. `teil` ist der Teil des
|
||||
* ersten Tages, der schon vorher belegt ist (0, 0,25, 0,5 oder 0,75).
|
||||
*/
|
||||
export function endeNachDauer(start: Datum, dauer: number, woche: Arbeitswoche = STANDARDWOCHE): Datum {
|
||||
if (!Number.isInteger(dauer) || dauer < 0) throw new Error(`Ungültige Dauer: ${dauer}`);
|
||||
export function endeNachDauer(start: Datum, dauer: number, woche: Arbeitswoche = STANDARDWOCHE, teil = 0): Datum {
|
||||
if (!(dauer >= 0) || !istViertel(dauer)) throw new Error(`Ungültige Dauer: ${dauer}`);
|
||||
const beginn = naechsterArbeitstag(start, woche);
|
||||
if (dauer === 0) return beginn;
|
||||
return verschiebeArbeitstage(beginn, dauer - 1, woche);
|
||||
return verschiebeArbeitstage(beginn, Math.ceil(teil + dauer - EPS) - 1, woche);
|
||||
}
|
||||
|
||||
/** Wie viel von jedem Arbeitstag ein Vorgang belegt (1 = ganzer Tag); ein Meilenstein belegt nichts */
|
||||
export function tagesAnteile(start: Datum, dauer: number, woche: Arbeitswoche = STANDARDWOCHE, teil = 0): Map<Datum, number> {
|
||||
const aus = new Map<Datum, number>();
|
||||
let rest = dauer;
|
||||
let d = naechsterArbeitstag(start, woche);
|
||||
let frei = 1 - teil;
|
||||
while (rest > EPS) {
|
||||
const a = Math.min(frei, rest);
|
||||
aus.set(d, a);
|
||||
rest -= a;
|
||||
frei = 1;
|
||||
d = verschiebeArbeitstage(d, 1, woche);
|
||||
}
|
||||
return aus;
|
||||
}
|
||||
|
||||
/** Anzahl Arbeitstage von `von` bis `bis`, beide eingeschlossen. 0, wenn bis vor von liegt. */
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
// Geplant wird im Firmenkalender (Mo–Do); der Freitag bleibt Reserve und zählt nicht mit.
|
||||
|
||||
import { type Datum, montagDerWoche, plusTage } from "./datum.js";
|
||||
import { type Arbeitswoche, feiertag, istArbeitstag, naechsterArbeitstag, wocheVon } from "./kalender.js";
|
||||
import { type Arbeitswoche, feiertag, istArbeitstag, naechsterArbeitstag, tagesAnteile, wocheVon } from "./kalender.js";
|
||||
import { type Abwesenheit, type Modell, abwesendStunden, sollStunden, wirksam } from "./personal.js";
|
||||
|
||||
export interface KapBesetzung {
|
||||
@@ -45,28 +45,33 @@ const MAX_TAGE = 260;
|
||||
|
||||
/**
|
||||
* Arbeitstage, bis die Stunden geleistet sind. Tage ohne Kapazität (Urlaub aller Eingeteilten) liegen im Balken
|
||||
* und zählen mit. Der letzte Tag zählt halb, wenn höchstens die Hälfte gebraucht wird. undefined ohne Kapazität.
|
||||
* und zählen mit. Angefangene Tage zählen in Vierteln (Henning, 22.10.2026), aufgerundet. `teil`: so viel vom
|
||||
* ersten Tag ist schon belegt. undefined ohne Kapazität.
|
||||
*/
|
||||
export function dauerAusKapazitaet(start: Datum, stunden: number, kapazitaet: (d: Datum) => number, woche: Arbeitswoche): number | undefined {
|
||||
export function dauerAusKapazitaet(start: Datum, stunden: number, kapazitaet: (d: Datum) => number, woche: Arbeitswoche, teil = 0): number | undefined {
|
||||
if (!(stunden > 0)) return undefined;
|
||||
let rest = stunden;
|
||||
let d = naechsterArbeitstag(start, woche);
|
||||
for (let n = 0; n < MAX_TAGE; n++) {
|
||||
const k = kapazitaet(d);
|
||||
if (k > EPS) {
|
||||
if (rest <= k + EPS) return n + (rest / k <= 0.5 + EPS ? 0.5 : 1);
|
||||
rest -= k;
|
||||
}
|
||||
let frei = 1 - teil;
|
||||
let n = 0;
|
||||
for (let i = 0; i < MAX_TAGE; i++) {
|
||||
const k = kapazitaet(d) * frei;
|
||||
if (k > EPS && rest <= k + EPS) return n + Math.max(0.25, Math.ceil((rest / kapazitaet(d)) * 4 - EPS) / 4);
|
||||
if (k > EPS) rest -= k;
|
||||
n += frei;
|
||||
frei = 1;
|
||||
d = naechsterArbeitstag(plusTage(d, 1), woche);
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/** Dauer eines Vorgangs nach seiner Besetzung; undefined ohne Stunden oder ohne Besetzung */
|
||||
export function dauerNachBesetzung(v: { id: string; start: Datum; stunden?: number | null; freitage?: Datum[] | null }, besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): number | undefined {
|
||||
export function dauerNachBesetzung(v: { id: string; start: Datum; start_teil?: number | null; stunden?: number | null; freitage?: Datum[] | null }, besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): number | undefined {
|
||||
const bs = besetzungen.filter((b) => b.vorgang_id === v.id);
|
||||
if (!bs.length || !(Number(v.stunden) > 0)) return undefined;
|
||||
return dauerAusKapazitaet(v.start, Number(v.stunden), (d) => bs.reduce((s, b) => s + leistung(p, b, d).frei, 0), wocheVon(v, woche));
|
||||
const w = wocheVon(v, woche);
|
||||
const teil = naechsterArbeitstag(v.start, w) === v.start ? Number(v.start_teil ?? 0) : 0;
|
||||
return dauerAusKapazitaet(v.start, Number(v.stunden), (d) => bs.reduce((s, b) => s + leistung(p, b, d).frei, 0), w, teil);
|
||||
}
|
||||
|
||||
/** Tage im Vorgang, an denen die Besetzung nicht voll da ist (Balken heller) */
|
||||
@@ -97,11 +102,13 @@ export interface Woche {
|
||||
* abgezogen, damit Einplanung im Urlaub als Überplanung auffällt), gegen die verfügbaren Stunden (Urlaub abgezogen).
|
||||
* Ein freigegebener Freitag zählt nur für die Leute, die an diesem Vorgang eingeteilt sind, geplant und verfügbar.
|
||||
*/
|
||||
export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: { id: string; anfang: Datum; ende: Datum; dauer: number; freitage?: Datum[] | null }[],
|
||||
export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: { id: string; start?: Datum; start_teil?: number | null; anfang: Datum; ende: Datum; dauer: number; freitage?: Datum[] | null }[],
|
||||
besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): Woche[] {
|
||||
const imTeam = new Set(team);
|
||||
const eigene = besetzungen.filter((b) => b.kontakt_id && imTeam.has(b.kontakt_id));
|
||||
const vById = new Map(vorgaenge.filter((v) => Number(v.dauer) > 0).map((v) => [v.id, v]));
|
||||
// Vierteltage: an jedem Tag zählt nur der Teil, den der Vorgang belegt
|
||||
const anteile = new Map([...vById.values()].map((v) => [v.id, tagesAnteile(v.anfang, Number(v.dauer), wocheVon(v, woche), v.start === v.anfang ? Number(v.start_teil ?? 0) : 0)]));
|
||||
const wochen = new Map<Datum, Woche>();
|
||||
const extra = new Set(vorgaenge.flatMap((v) => v.freitage ?? []));
|
||||
for (let d = von; d <= bis; d = plusTage(d, 1)) {
|
||||
@@ -123,7 +130,7 @@ export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: {
|
||||
const v = vById.get(b.vorgang_id);
|
||||
if (!v || v.anfang > d || v.ende < d) continue;
|
||||
if (!firmentag && !v.freitage?.includes(d)) continue;
|
||||
const h = sollStunden(p.modelle, b.kontakt_id!, d, p.stundenProTag) * (Number(b.personen) > 0 ? Number(b.personen) : 1);
|
||||
const h = sollStunden(p.modelle, b.kontakt_id!, d, p.stundenProTag) * (Number(b.personen) > 0 ? Number(b.personen) : 1) * (anteile.get(v.id)!.get(d) ?? 0);
|
||||
w.personen.find((x) => x.kontakt_id === b.kontakt_id)!.geplant += h;
|
||||
w.geplant += h;
|
||||
}
|
||||
|
||||
@@ -3,7 +3,8 @@
|
||||
|
||||
import { type Datum } from "./datum.js";
|
||||
import { type Cent } from "./geld.js";
|
||||
import { type Arbeitswoche, endeNachDauer, wocheVon } from "./kalender.js";
|
||||
import { type Arbeitswoche } from "./kalender.js";
|
||||
import { ende } from "./terminplan.js";
|
||||
import { type BezugArt, bezugsTermin } from "./bezug.js";
|
||||
import { type Daten, type Einnahme, type Ausgabe, type Kostenart, type LaufendeKosten, projektBewegungen } from "./liquiditaet.js";
|
||||
|
||||
@@ -21,8 +22,9 @@ export interface BestandVorgang {
|
||||
id: string;
|
||||
projekt_id: string;
|
||||
start: Datum;
|
||||
/** Arbeitstage, angefangene Tage zählen voll; 0 = Meilenstein */
|
||||
/** Arbeitstage in Vierteln; 0 = Meilenstein */
|
||||
dauer: number;
|
||||
start_teil?: number | null;
|
||||
}
|
||||
|
||||
export interface BestandZahlung {
|
||||
@@ -66,8 +68,8 @@ export interface Bestand {
|
||||
/** P5: Anfragen und Angebote fließen nicht in die Liquidität (V70 hat sie mitgerechnet). */
|
||||
export const OHNE_LIQUIDITAET = new Set(["anfrage", "angebot"]);
|
||||
|
||||
export function vorgangsEnde(v: Pick<BestandVorgang, "start" | "dauer"> & { freitage?: Datum[] | null }, woche: Arbeitswoche): Datum {
|
||||
return endeNachDauer(v.start, Math.ceil(v.dauer), wocheVon(v, woche));
|
||||
export function vorgangsEnde(v: Pick<BestandVorgang, "start" | "dauer" | "start_teil"> & { freitage?: Datum[] | null }, woche: Arbeitswoche): Datum {
|
||||
return ende({ id: "", ...v, dauer: Number(v.dauer) }, woche);
|
||||
}
|
||||
|
||||
/** Ein noch nicht gestellter Abschlag wandert mit dem Ende seines Vorgangs. */
|
||||
@@ -81,7 +83,7 @@ export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten
|
||||
// am Anfang oder Ende des Vorgangs, mit Versatz (Terminplan)
|
||||
const bezogen = (x: { vorgang_id?: string | null; bezug_art?: BezugArt; bezug_tage?: number; freitag?: boolean | null }) => {
|
||||
const v = x.vorgang_id ? vorgang.get(x.vorgang_id) : undefined;
|
||||
return v ? bezugsTermin({ ...v, dauer: Math.ceil(v.dauer) }, x.bezug_art ?? "EE", Number(x.bezug_tage ?? 0), woche, x.freitag) : undefined;
|
||||
return v ? bezugsTermin({ ...v, dauer: Number(v.dauer) }, x.bezug_art ?? "EE", Number(x.bezug_tage ?? 0), woche, x.freitag) : undefined;
|
||||
};
|
||||
const einnahmen: Einnahme[] = [];
|
||||
const ausgaben: Ausgabe[] = [];
|
||||
|
||||
@@ -11,8 +11,10 @@ export type Art = "EA" | "AA" | "EE" | "AE";
|
||||
export interface PlanVorgang {
|
||||
id: string;
|
||||
start: Datum;
|
||||
/** Arbeitstage; angefangene Tage zählen voll; 0 = Meilenstein */
|
||||
/** Arbeitstage in Vierteln (0,25 = Vierteltag); 0 = Meilenstein */
|
||||
dauer: number;
|
||||
/** Teil des ersten Tages, der vorher schon belegt ist (z. B. 0,5: beginnt mittags) */
|
||||
start_teil?: number | null;
|
||||
/** Freitage, an denen dieser Vorgang ausnahmsweise ausgeführt wird */
|
||||
freitage?: Datum[] | null;
|
||||
}
|
||||
@@ -25,14 +27,33 @@ export interface Verknuepfung {
|
||||
verzoegerung: number;
|
||||
}
|
||||
|
||||
const tage = (v: PlanVorgang) => Math.ceil(v.dauer);
|
||||
const tage = (v: PlanVorgang) => Number(v.dauer);
|
||||
export const teilVon = (v: PlanVorgang) => (tage(v) > 0 ? Number(v.start_teil ?? 0) : 0);
|
||||
|
||||
/** Zeitpunkt im Plan: Tag und wie viel davon schon vorbei ist (0 = Tagesbeginn) */
|
||||
export interface Lage { tag: Datum; teil: number }
|
||||
const vorLage = (a: Lage, b: Lage) => a.tag < b.tag || (a.tag === b.tag && a.teil < b.teil - 1e-9);
|
||||
const gleich = (a: Lage, b: Lage) => a.tag === b.tag && Math.abs(a.teil - b.teil) < 1e-9;
|
||||
|
||||
export function anfang(v: PlanVorgang, woche: Arbeitswoche): Datum {
|
||||
return naechsterArbeitstag(v.start, wocheVon(v, woche));
|
||||
}
|
||||
|
||||
export function ende(v: PlanVorgang, woche: Arbeitswoche): Datum {
|
||||
return endeNachDauer(v.start, tage(v), wocheVon(v, woche));
|
||||
return endeNachDauer(v.start, tage(v), wocheVon(v, woche), teilVon(v));
|
||||
}
|
||||
|
||||
/** Wie viel vom letzten Tag belegt ist (0 < x ≤ 1); Meilensteine zählen als ganzer Tag */
|
||||
export function endeTeil(v: PlanVorgang): number {
|
||||
if (tage(v) === 0) return 1;
|
||||
const x = teilVon(v) + tage(v);
|
||||
return x - (Math.ceil(x - 1e-9) - 1);
|
||||
}
|
||||
|
||||
/** Anfang als Lage; der Teil gilt nur, wenn der Starttag ein Arbeitstag ist */
|
||||
function anfangsLage(v: PlanVorgang, woche: Arbeitswoche): Lage {
|
||||
const a = anfang(v, woche);
|
||||
return { tag: a, teil: a === v.start ? teilVon(v) : 0 };
|
||||
}
|
||||
|
||||
/** V70 offW: n Arbeitstage nach (n > 0) oder vor (n < 0) dem Tag; 0 = der Tag oder der nächste Arbeitstag. */
|
||||
@@ -40,47 +61,75 @@ 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 {
|
||||
/** Start, der sich ergibt, wenn der Vorgang an `endeAm` endet, und zwar nach `teil` dieses Tages (1 = Tagesende). */
|
||||
function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche, teil = 1): Lage {
|
||||
const w = wocheVon(v, woche);
|
||||
const e = naechsterArbeitstag(endeAm, w);
|
||||
return tage(v) <= 1 ? e : verschiebeArbeitstage(e, -(tage(v) - 1), w);
|
||||
if (e !== endeAm) teil = 1;
|
||||
if (tage(v) === 0) return { tag: e, teil: 0 };
|
||||
// vom Ende zurückrechnen: Tag e zählt als 0, davor negativ
|
||||
const x = teil - tage(v);
|
||||
const ganz = Math.floor(x + 1e-9);
|
||||
return { tag: ganz === 0 ? e : verschiebeArbeitstage(e, ganz, w), teil: Math.max(0, x - ganz) };
|
||||
}
|
||||
|
||||
/** Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt. */
|
||||
export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum {
|
||||
/** Start an einem Tag nach `teil`; liegt der Tag im Kalender des Nachfolgers nicht, ab dem nächsten Arbeitstag */
|
||||
function lageAm(d: Datum, teil: number, w: Arbeitswoche): Lage {
|
||||
const t = naechsterArbeitstag(d, w);
|
||||
return t === d ? { tag: d, teil } : { tag: t, teil: 0 };
|
||||
}
|
||||
|
||||
/**
|
||||
* Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt, mit dem Teil des Tages: endet der Vorgänger
|
||||
* nach einem Vierteltag, beginnt der Nachfolger am selben Tag danach (Henning, 22.10.2026).
|
||||
*/
|
||||
export function lageNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Lage {
|
||||
const lg = k.verzoegerung;
|
||||
const meilenstein = tage(v) === 0;
|
||||
// gezählt wird im Kalender des Nachfolgers: ein freigegebener Freitag des Nachfolgers kann sein Start sein
|
||||
const w = wocheVon(v, woche);
|
||||
const e = ende(vorgaenger, woche), et = endeTeil(vorgaenger);
|
||||
const a = anfangsLage(vorgaenger, woche);
|
||||
switch (k.art) {
|
||||
case "EA": return versatz(ende(vorgaenger, woche), meilenstein ? lg : 1 + lg, w);
|
||||
case "AA": return versatz(anfang(vorgaenger, woche), lg, w);
|
||||
case "EE": return startFuerEnde(v, versatz(ende(vorgaenger, woche), lg, w), woche);
|
||||
case "AE": return startFuerEnde(v, versatz(anfang(vorgaenger, woche), lg, w), woche);
|
||||
case "EA":
|
||||
if (meilenstein) return { tag: versatz(e, lg, w), teil: 0 };
|
||||
if (et < 1 - 1e-9) return lg === 0 ? lageAm(e, et, w) : { tag: versatz(e, lg, w), teil: et };
|
||||
return { tag: versatz(e, 1 + lg, w), teil: 0 };
|
||||
case "AA": return lg === 0 ? lageAm(a.tag, a.teil, w) : { tag: versatz(a.tag, lg, w), teil: a.teil };
|
||||
case "EE": return startFuerEnde(v, versatz(e, lg, w), woche, et);
|
||||
case "AE": return startFuerEnde(v, versatz(a.tag, lg, w), woche, a.teil > 0 ? a.teil : 1);
|
||||
}
|
||||
}
|
||||
|
||||
/** 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;
|
||||
/** Frühester Starttag, den eine Verknüpfung dem Nachfolger erlaubt. */
|
||||
export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum {
|
||||
return lageNachVerknuepfung(v, vorgaenger, k, woche).tag;
|
||||
}
|
||||
|
||||
function fruehesteLage(v: PlanVorgang, alle: Map<string, PlanVorgang>, links: Verknuepfung[], woche: Arbeitswoche): Lage | undefined {
|
||||
let s: Lage | 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;
|
||||
const x = lageNachVerknuepfung(v, p, k, woche);
|
||||
if (!s || vorLage(s, x)) s = x;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
/** 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 {
|
||||
return fruehesteLage(v, alle, links, woche)?.tag;
|
||||
}
|
||||
|
||||
/** 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);
|
||||
const f = fruehesteLage(v, alle, links, woche);
|
||||
if (f && gleich(f, anfangsLage(v, woche))) eng.add(v.id);
|
||||
}
|
||||
return eng;
|
||||
}
|
||||
@@ -130,6 +179,8 @@ function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorga
|
||||
export interface Ergebnis {
|
||||
/** neuer Start je verschobenem Vorgang */
|
||||
starts: Map<string, Datum>;
|
||||
/** Teil des Starttags je verschobenem Vorgang */
|
||||
teile: Map<string, number>;
|
||||
/** neue Dauer je Vorgang, dessen Dauer sich aus Stunden und Besetzung ergibt (T15) */
|
||||
dauern: Map<string, number>;
|
||||
}
|
||||
@@ -145,6 +196,7 @@ export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche:
|
||||
dauerFuer?: (v: PlanVorgang) => number | undefined): Ergebnis {
|
||||
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
|
||||
const starts = new Map<string, Datum>();
|
||||
const teile = new Map<string, number>();
|
||||
const dauern = new Map<string, number>();
|
||||
for (const v of topologisch(vorgaenge, links)) {
|
||||
const x = stand.get(v.id)!;
|
||||
@@ -154,12 +206,14 @@ export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche:
|
||||
x.dauer = d;
|
||||
dauern.set(v.id, d);
|
||||
}
|
||||
const f = fruehesterStart(x, stand, links, woche);
|
||||
const a = anfang(x, woche);
|
||||
if (!f || !(f > a || (f < a && eng.has(v.id)))) break;
|
||||
x.start = f;
|
||||
starts.set(v.id, f);
|
||||
const f = fruehesteLage(x, stand, links, woche);
|
||||
const a = anfangsLage(x, woche);
|
||||
if (!f || !(vorLage(a, f) || (vorLage(f, a) && eng.has(v.id)))) break;
|
||||
x.start = f.tag;
|
||||
x.start_teil = f.teil;
|
||||
starts.set(v.id, f.tag);
|
||||
teile.set(v.id, f.teil);
|
||||
}
|
||||
}
|
||||
return { starts, dauern };
|
||||
return { starts, teile, dauern };
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user