@jetta/axle-load-calculator 0.1.3

package/build/core/physics/transports/containerweight/container_max_weight_calculator.d.ts

@@ -0,0 +1,27 @@
+import type { GroupedContainers } from '../grouped_containers.js';
+type MaxWeightInput = {
+    sequence_index: number;
+    percentage_of_weight: number;
+    total_max_supported_weight: number;
+    tare: number;
+};
+/**
+ * Applies neck weight cap and redistributes excess to second container.
+ */
+export declare class ContainerMaxWeightCalculator {
+    private readonly grouped_containers;
+    private neck_weight_reduction;
+    /**
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(grouped_containers: GroupedContainers);
+    /**
+     * @param input - Sequence, share, capacity, and tare.
+     * @returns Max supported weight for container.
+     */
+    calculate(input: MaxWeightInput): number;
+    private is_neck;
+    private is_second_container;
+}
+export {};
+//# sourceMappingURL=container_max_weight_calculator.d.ts.map

package/build/core/physics/transports/containerweight/container_max_weight_calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container_max_weight_calculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/container_max_weight_calculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAEjE,KAAK,cAAc,GAAG;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,0BAA0B,EAAE,MAAM,CAAA;IAClC,IAAI,EAAE,MAAM,CAAA;CACf,CAAA;AAID;;GAEG;AACH,qBAAa,4BAA4B;IAOzB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAL/C,OAAO,CAAC,qBAAqB,CAAI;IAEjC;;OAEG;gBAC0B,kBAAkB,EAAE,iBAAiB;IAGlE;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAmBxC,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,mBAAmB;CAK9B"}

package/build/core/physics/transports/containerweight/container_max_weight_calculator.js

@@ -0,0 +1,40 @@
+const MAX_NECK_SUPPORTED = 6000;
+/**
+ * Applies neck weight cap and redistributes excess to second container.
+ */
+export class ContainerMaxWeightCalculator {
+    grouped_containers;
+    neck_weight_reduction = 0;
+    /**
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(grouped_containers) {
+        this.grouped_containers = grouped_containers;
+    }
+    /**
+     * @param input - Sequence, share, capacity, and tare.
+     * @returns Max supported weight for container.
+     */
+    calculate(input) {
+        const max_supported = input.total_max_supported_weight * input.percentage_of_weight;
+        if (this.is_neck(input.sequence_index)) {
+            const supported = max_supported - input.tare;
+            if (supported > MAX_NECK_SUPPORTED) {
+                this.neck_weight_reduction = supported - MAX_NECK_SUPPORTED;
+                return input.tare + MAX_NECK_SUPPORTED;
+            }
+        }
+        else if (this.is_second_container(input.sequence_index)) {
+            return max_supported + this.neck_weight_reduction;
+        }
+        return max_supported;
+    }
+    is_neck(sequence_index) {
+        const list = this.grouped_containers.list_containers_sequence_indexes();
+        return list.length >= 2 && list[0] === sequence_index;
+    }
+    is_second_container(sequence_index) {
+        const list = this.grouped_containers.list_containers_sequence_indexes();
+        return list.length >= 2 && list[1] === sequence_index;
+    }
+}

package/build/core/physics/transports/containerweight/container_tare_calculator.d.ts

@@ -0,0 +1,28 @@
+import type { Transport } from '../transport.js';
+import type { GroupedContainers } from '../grouped_containers.js';
+/**
+ * Distributes grouper tare across containers (neck gets axle-1 share).
+ */
+export declare class ContainerTareCalculator {
+    private readonly transport;
+    private readonly grouped_containers;
+    private revised_tare_percentage;
+    private first_neck_tare;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport: Transport, grouped_containers: GroupedContainers);
+    /**
+     * @param sequence_index - Container sequence.
+     * @param percentage_of_weight - Lateral area share.
+     * @param total_tare - Grouper total tare.
+     * @returns Container tare.
+     */
+    calculate(sequence_index: number, percentage_of_weight: number, total_tare: number): number;
+    private is_first_neck;
+    private calculate_tare_of_first_neck;
+    private tare_percentage_review;
+    private axle1_on_neck_tare_contribution;
+}
+//# sourceMappingURL=container_tare_calculator.d.ts.map

package/build/core/physics/transports/containerweight/container_tare_calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container_tare_calculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/container_tare_calculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAIjE;;GAEG;AACH,qBAAa,uBAAuB;IAU5B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IATvC,OAAO,CAAC,uBAAuB,CAAI;IACnC,OAAO,CAAC,eAAe,CAAI;IAE3B;;;OAGG;gBAEkB,SAAS,EAAE,SAAS,EACpB,kBAAkB,EAAE,iBAAiB;IAI1D;;;;;OAKG;IACH,SAAS,CACL,cAAc,EAAE,MAAM,EACtB,oBAAoB,EAAE,MAAM,EAC5B,UAAU,EAAE,MAAM,GACnB,MAAM;IAWT,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,sBAAsB;IAQ9B,OAAO,CAAC,+BAA+B;CAO1C"}

package/build/core/physics/transports/containerweight/container_tare_calculator.js

@@ -0,0 +1,55 @@
+const NECK_SEQUENCE = 1;
+/**
+ * Distributes grouper tare across containers (neck gets axle-1 share).
+ */
+export class ContainerTareCalculator {
+    transport;
+    grouped_containers;
+    revised_tare_percentage = 0;
+    first_neck_tare = 0;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport, grouped_containers) {
+        this.transport = transport;
+        this.grouped_containers = grouped_containers;
+    }
+    /**
+     * @param sequence_index - Container sequence.
+     * @param percentage_of_weight - Lateral area share.
+     * @param total_tare - Grouper total tare.
+     * @returns Container tare.
+     */
+    calculate(sequence_index, percentage_of_weight, total_tare) {
+        if (this.is_first_neck(sequence_index)) {
+            this.calculate_tare_of_first_neck(percentage_of_weight);
+            this.tare_percentage_review(percentage_of_weight, total_tare);
+            return this.first_neck_tare;
+        }
+        return (percentage_of_weight + this.revised_tare_percentage) * total_tare;
+    }
+    is_first_neck(sequence_index) {
+        return this.grouped_containers.list_containers_sequence_indexes().length >= 2
+            && sequence_index === NECK_SEQUENCE;
+    }
+    calculate_tare_of_first_neck(percentage_of_weight) {
+        const neck = this.grouped_containers.get_container_by_sequence_index(NECK_SEQUENCE);
+        const axle1 = this.axle1_on_neck_tare_contribution(neck.length);
+        const remaining = percentage_of_weight * (this.transport.axle_manager.get_axle(1).tare
+            + this.transport.axle_manager.get_axle(2).tare);
+        this.first_neck_tare = axle1 + remaining;
+    }
+    tare_percentage_review(percentage_of_weight, total_tare) {
+        const tare = percentage_of_weight * total_tare;
+        const change = (this.first_neck_tare - tare) / total_tare;
+        const count = this.grouped_containers.list_containers_sequence_indexes().length;
+        this.revised_tare_percentage = -change / (count - 1);
+    }
+    axle1_on_neck_tare_contribution(neck_length) {
+        const end_container = this.transport.first_axle_distance + neck_length;
+        const end_grouper = this.transport.first_axle_distance + this.grouped_containers.length;
+        const share = end_container / end_grouper;
+        return share * this.transport.axle_manager.get_axle(0).tare;
+    }
+}

package/build/core/physics/transports/containerweight/container_weight_model.d.ts

@@ -0,0 +1,15 @@
+import type { Transport } from '../transport.js';
+/**
+ * Computes per-container supported cargo capacity.
+ */
+export declare class ContainerWeightModel {
+    private readonly transport;
+    private readonly merged_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /** Updates container supported_weight on transport. */
+    calculate(): void;
+}
+//# sourceMappingURL=container_weight_model.d.ts.map

package/build/core/physics/transports/containerweight/container_weight_model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container_weight_model.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/container_weight_model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAKhD;;GAEG;AACH,qBAAa,oBAAoB;IAOjB,OAAO,CAAC,QAAQ,CAAC,SAAS;IALtC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkB;IAEpD;;OAEG;gBAC0B,SAAS,EAAE,SAAS;IAKjD,uDAAuD;IACvD,SAAS,IAAI,IAAI;CAgBpB"}

package/build/core/physics/transports/containerweight/container_weight_model.js

@@ -0,0 +1,31 @@
+import { MergedContainers } from '../merged_containers.js';
+import { MergedContainersWeightCalculator } from './merged_containers_weight_calculator.js';
+import { SingleContainerWeightCalculator } from './single_container_weight_calculator.js';
+/**
+ * Computes per-container supported cargo capacity.
+ */
+export class ContainerWeightModel {
+    transport;
+    merged_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.merged_containers = new MergedContainers(transport);
+    }
+    /** Updates container supported_weight on transport. */
+    calculate() {
+        const axles = this.transport.axle_manager.list_axles_indexes()
+            .map((index) => this.transport.axle_manager.get_axle(index));
+        new MergedContainersWeightCalculator(this.merged_containers, axles).calculate();
+        for (const grouper of this.merged_containers.list_grouper_indexes()) {
+            const grouped = this.merged_containers.get_container_by_grouper_index(grouper);
+            new SingleContainerWeightCalculator(this.transport, grouped).calculate();
+        }
+        for (const sequence of this.transport.list_containers_sequence_indexes()) {
+            const container = this.transport.get_container_by_sequence_index(sequence);
+            container.supported_weight = container.max_supported_weight - container.tare;
+        }
+    }
+}

package/build/core/physics/transports/containerweight/merged_containers_weight_calculator.d.ts

@@ -0,0 +1,17 @@
+import type { MergedContainers } from '../merged_containers.js';
+import type { AxleRecord } from '../axle_record.js';
+/**
+ * Sums axle capacity and tare onto merged grouper containers.
+ */
+export declare class MergedContainersWeightCalculator {
+    private readonly merged_containers;
+    private readonly transport_axles_list;
+    /**
+     * @param merged_containers - Grouper layout.
+     * @param transport_axles_list - All axles.
+     */
+    constructor(merged_containers: MergedContainers, transport_axles_list: AxleRecord[]);
+    /** Applies summed max weight and tare to each merged grouper container. */
+    calculate(): void;
+}
+//# sourceMappingURL=merged_containers_weight_calculator.d.ts.map

package/build/core/physics/transports/containerweight/merged_containers_weight_calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merged_containers_weight_calculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/merged_containers_weight_calculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAEnD;;GAEG;AACH,qBAAa,gCAAgC;IAOrC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IANzC;;;OAGG;gBAEkB,iBAAiB,EAAE,gBAAgB,EACnC,oBAAoB,EAAE,UAAU,EAAE;IAIvD,2EAA2E;IAC3E,SAAS,IAAI,IAAI;CAmBpB"}

package/build/core/physics/transports/containerweight/merged_containers_weight_calculator.js

@@ -0,0 +1,31 @@
+/**
+ * Sums axle capacity and tare onto merged grouper containers.
+ */
+export class MergedContainersWeightCalculator {
+    merged_containers;
+    transport_axles_list;
+    /**
+     * @param merged_containers - Grouper layout.
+     * @param transport_axles_list - All axles.
+     */
+    constructor(merged_containers, transport_axles_list) {
+        this.merged_containers = merged_containers;
+        this.transport_axles_list = transport_axles_list;
+    }
+    /** Applies summed max weight and tare to each merged grouper container. */
+    calculate() {
+        for (const grouper of this.merged_containers.list_grouper_indexes()) {
+            const grouped = this.merged_containers.get_container_by_grouper_index(grouper);
+            const sequences = grouped.list_containers_sequence_indexes();
+            const merged = grouped.merged_container;
+            merged.max_supported_weight = 0;
+            merged.tare = 0;
+            for (const axle of this.transport_axles_list) {
+                if (sequences.includes(axle.sequence_index)) {
+                    merged.max_supported_weight += axle.max_supported_weight;
+                    merged.tare += axle.tare;
+                }
+            }
+        }
+    }
+}

package/build/core/physics/transports/containerweight/single_container_weight_calculator.d.ts

@@ -0,0 +1,20 @@
+import type { Transport } from '../transport.js';
+import type { GroupedContainers } from '../grouped_containers.js';
+/**
+ * Splits grouper capacity across containers by lateral area.
+ */
+export declare class SingleContainerWeightCalculator {
+    private readonly grouped_containers;
+    private readonly tare_calculator;
+    private readonly max_calculator;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport: Transport, grouped_containers: GroupedContainers);
+    /** Assigns max_supported_weight and tare per container in grouper. */
+    calculate(): void;
+    private total_lateral_area;
+    private lateral_area;
+}
+//# sourceMappingURL=single_container_weight_calculator.d.ts.map

package/build/core/physics/transports/containerweight/single_container_weight_calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single_container_weight_calculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/single_container_weight_calculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAKjE;;GAEG;AACH,qBAAa,+BAA+B;IAWpC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IATvC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyB;IACzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA8B;IAE7D;;;OAGG;gBAEC,SAAS,EAAE,SAAS,EACH,kBAAkB,EAAE,iBAAiB;IAO1D,sEAAsE;IACtE,SAAS,IAAI,IAAI;IAqBjB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,YAAY;CAIvB"}

package/build/core/physics/transports/containerweight/single_container_weight_calculator.js

@@ -0,0 +1,48 @@
+import { ContainerTareCalculator } from './container_tare_calculator.js';
+import { ContainerMaxWeightCalculator } from './container_max_weight_calculator.js';
+/**
+ * Splits grouper capacity across containers by lateral area.
+ */
+export class SingleContainerWeightCalculator {
+    grouped_containers;
+    tare_calculator;
+    max_calculator;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport, grouped_containers) {
+        this.grouped_containers = grouped_containers;
+        this.tare_calculator = new ContainerTareCalculator(transport, grouped_containers);
+        this.max_calculator = new ContainerMaxWeightCalculator(grouped_containers);
+    }
+    /** Assigns max_supported_weight and tare per container in grouper. */
+    calculate() {
+        const total_area = this.total_lateral_area();
+        const merged = this.grouped_containers.merged_container;
+        const total_max = merged.max_supported_weight;
+        const total_tare = merged.tare;
+        for (const sequence of this.grouped_containers.list_containers_sequence_indexes()) {
+            const container = this.grouped_containers.get_container_by_sequence_index(sequence);
+            const share = this.lateral_area(container) / total_area;
+            const tare = this.tare_calculator.calculate(sequence, share, total_tare);
+            container.max_supported_weight = this.max_calculator.calculate({
+                sequence_index: sequence,
+                percentage_of_weight: share,
+                total_max_supported_weight: total_max,
+                tare
+            });
+            container.tare = tare;
+        }
+    }
+    total_lateral_area() {
+        let total = 0;
+        for (const sequence of this.grouped_containers.list_containers_sequence_indexes()) {
+            total += this.lateral_area(this.grouped_containers.get_container_by_sequence_index(sequence));
+        }
+        return total;
+    }
+    lateral_area(container) {
+        return container.length * container.height;
+    }
+}

package/build/core/physics/transports/grouped_containers.d.ts

@@ -0,0 +1,34 @@
+import { ContainerRecord } from './container_record.js';
+/**
+ * Containers merged per grouper.
+ */
+export declare class GroupedContainers {
+    grouper: number;
+    merged_container: ContainerRecord | null;
+    private containers;
+    /**
+     * @param grouper - Grouper id.
+     */
+    constructor(grouper: number);
+    get length(): number;
+    get container_distance_ahead(): number | null;
+    get main_pin_distance(): number | null;
+    /**
+     * @param container - Container to add.
+     */
+    add_container(container: ContainerRecord): void;
+    /**
+     * Merges segment lengths into first container of grouper.
+     */
+    generate_merged_container(): void;
+    /**
+     * @param sequence_index - Container sequence.
+     * @returns Container record.
+     */
+    get_container_by_sequence_index(sequence_index: number): ContainerRecord;
+    /**
+     * @returns Sorted sequence indexes.
+     */
+    list_containers_sequence_indexes(): number[];
+}
+//# sourceMappingURL=grouped_containers.d.ts.map

package/build/core/physics/transports/grouped_containers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grouped_containers.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/transports/grouped_containers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD;;GAEG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,EAAE,eAAe,GAAG,IAAI,CAAO;IAC/C,OAAO,CAAC,UAAU,CAAqC;IAEvD;;OAEG;gBACS,OAAO,EAAE,MAAM;IAK3B,IAAI,MAAM,IAAI,MAAM,CAGnB;IAED,IAAI,wBAAwB,IAAI,MAAM,GAAG,IAAI,CAG5C;IAED,IAAI,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAGrC;IAED;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAQ/C;;OAEG;IACH,yBAAyB,IAAI,IAAI;IAYjC;;;OAGG;IACH,+BAA+B,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe;IAUxE;;OAEG;IACH,gCAAgC,IAAI,MAAM,EAAE;CAI/C"}

package/build/core/physics/transports/grouped_containers.js

@@ -0,0 +1,68 @@
+import { ContainerRecord } from './container_record.js';
+/**
+ * Containers merged per grouper.
+ */
+export class GroupedContainers {
+    grouper;
+    merged_container = null;
+    containers = new Map();
+    /**
+     * @param grouper - Grouper id.
+     */
+    constructor(grouper) {
+        this.grouper = grouper;
+    }
+    get length() {
+        return this.merged_container.length;
+    }
+    get container_distance_ahead() {
+        return this.merged_container.container_distance_ahead;
+    }
+    get main_pin_distance() {
+        return this.merged_container.main_pin_distance;
+    }
+    /**
+     * @param container - Container to add.
+     */
+    add_container(container) {
+        if (container.grouper === this.grouper) {
+            this.containers.set(container.sequence_index, container);
+        }
+    }
+    /**
+     * Merges segment lengths into first container of grouper.
+     */
+    generate_merged_container() {
+        const sequence_indexes = this.list_containers_sequence_indexes();
+        const first = this.get_container_by_sequence_index(sequence_indexes[0]);
+        this.merged_container = clone_container(first);
+        for (let index = 1; index < sequence_indexes.length; index++) {
+            const next = this.get_container_by_sequence_index(sequence_indexes[index]);
+            this.merged_container.length += next.length;
+        }
+    }
+    /**
+     * @param sequence_index - Container sequence.
+     * @returns Container record.
+     */
+    get_container_by_sequence_index(sequence_index) {
+        const container = this.containers.get(sequence_index);
+        if (!container) {
+            throw new Error(`Missing container ${sequence_index}`);
+        }
+        return container;
+    }
+    /**
+     * @returns Sorted sequence indexes.
+     */
+    list_containers_sequence_indexes() {
+        return [...this.containers.keys()].sort((left, right) => left - right);
+    }
+}
+/**
+ * @param source - Container to clone.
+ * @returns Shallow clone with same wire fields.
+ */
+function clone_container(source) {
+    return new ContainerRecord({ ...source.raw });
+}

package/build/core/physics/transports/merged_containers.d.ts

@@ -0,0 +1,26 @@
+import type { Transport } from './transport.js';
+import { GroupedContainers } from './grouped_containers.js';
+/**
+ * Grouper-level merged container geometry.
+ */
+export declare class MergedContainers {
+    private all_grouped_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @param transport - Parsed transport.
+     */
+    setup(transport: Transport): void;
+    /**
+     * @returns Grouper id list.
+     */
+    list_grouper_indexes(): number[];
+    /**
+     * @param grouper - Grouper id.
+     * @returns Grouped containers.
+     */
+    get_container_by_grouper_index(grouper: number): GroupedContainers;
+}
+//# sourceMappingURL=merged_containers.d.ts.map

package/build/core/physics/transports/merged_containers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merged_containers.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/transports/merged_containers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAE3D;;GAEG;AACH,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,sBAAsB,CAAuC;IAErE;;OAEG;gBACS,SAAS,EAAE,SAAS;IAKhC;;OAEG;IACH,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAmBjC;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAKhC;;;OAGG;IACH,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB;CASrE"}

package/build/core/physics/transports/merged_containers.js

@@ -0,0 +1,45 @@
+import { GroupedContainers } from './grouped_containers.js';
+/**
+ * Grouper-level merged container geometry.
+ */
+export class MergedContainers {
+    all_grouped_containers = new Map();
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.setup(transport);
+    }
+    /**
+     * @param transport - Parsed transport.
+     */
+    setup(transport) {
+        for (const sequence_index of transport.list_containers_sequence_indexes()) {
+            const container = transport.get_container_by_sequence_index(sequence_index);
+            if (!this.all_grouped_containers.has(container.grouper)) {
+                this.all_grouped_containers.set(container.grouper, new GroupedContainers(container.grouper));
+            }
+            this.get_container_by_grouper_index(container.grouper).add_container(container);
+        }
+        for (const grouper of this.all_grouped_containers.keys()) {
+            this.get_container_by_grouper_index(grouper).generate_merged_container();
+        }
+    }
+    /**
+     * @returns Grouper id list.
+     */
+    list_grouper_indexes() {
+        return [...this.all_grouped_containers.keys()];
+    }
+    /**
+     * @param grouper - Grouper id.
+     * @returns Grouped containers.
+     */
+    get_container_by_grouper_index(grouper) {
+        const grouped = this.all_grouped_containers.get(grouper);
+        if (!grouped) {
+            throw new Error(`Grouper ${grouper} not found`);
+        }
+        return grouped;
+    }
+}

package/build/core/physics/transports/tare/bitrem_axle_splitter.d.ts

@@ -0,0 +1,26 @@
+import type { Transport } from '../transport.js';
+import { AxleRecord } from '../axle_record.js';
+/** Splits bitrem shared axle 3 into two axles (DRAGON-98). */
+export declare class BitremAxleSplitter {
+    private readonly transport;
+    readonly new_axle_3: AxleRecord;
+    readonly new_axle_4: AxleRecord;
+    readonly new_axle_5: AxleRecord;
+    private readonly chassi;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @returns Five axle wire rows after split.
+     */
+    generate_splitted_axles_data(): Record<string, unknown>[];
+    calculate_first_proportion(): number;
+    calculate_second_proportion(): number;
+    private generate_new_weight_attributes;
+    private generate_new_axle_distances;
+    private generate_new_axle_container_sequences;
+    private generate_merged_axle_connection;
+    private distance_from_axle_3_to_pin_2;
+}
+//# sourceMappingURL=bitrem_axle_splitter.d.ts.map

package/build/core/physics/transports/tare/bitrem_axle_splitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitrem_axle_splitter.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/tare/bitrem_axle_splitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAG9C,8DAA8D;AAC9D,qBAAa,kBAAkB;IAUf,OAAO,CAAC,QAAQ,CAAC,SAAS;IARtC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B;;OAEG;gBAC0B,SAAS,EAAE,SAAS;IAQjD;;OAEG;IACH,4BAA4B,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;IAezD,0BAA0B,IAAI,MAAM;IAOpC,2BAA2B,IAAI,MAAM;IAQrC,OAAO,CAAC,8BAA8B;IActC,OAAO,CAAC,2BAA2B;IAQnC,OAAO,CAAC,qCAAqC;IAS7C,OAAO,CAAC,+BAA+B;IAKvC,OAAO,CAAC,6BAA6B;CAMxC"}

package/build/core/physics/transports/tare/bitrem_axle_splitter.js

@@ -0,0 +1,84 @@
+import { CHASSI_REFERENCE } from '../../../contracts/chassi_reference.js';
+import { Chassi } from '../chassi.js';
+import { MergedContainers } from '../merged_containers.js';
+import { AxleRecord } from '../axle_record.js';
+import { apply_bitrem_axle_split, compute_bitrem_axle_split } from './bitrem_axle_weight_split.js';
+/** Splits bitrem shared axle 3 into two axles (DRAGON-98). */
+export class BitremAxleSplitter {
+    transport;
+    new_axle_3;
+    new_axle_4;
+    new_axle_5;
+    chassi;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.chassi = new Chassi(transport);
+        this.new_axle_3 = clone_axle(transport.axle_manager.get_axle(2));
+        this.new_axle_4 = clone_axle(transport.axle_manager.get_axle(2));
+        this.new_axle_5 = clone_axle(transport.axle_manager.get_axle(3));
+    }
+    /**
+     * @returns Five axle wire rows after split.
+     */
+    generate_splitted_axles_data() {
+        this.generate_new_weight_attributes();
+        this.generate_new_axle_distances();
+        this.generate_new_axle_container_sequences();
+        this.generate_merged_axle_connection();
+        return [
+            this.transport.axle_manager.get_axle(0).to_wire(),
+            this.transport.axle_manager.get_axle(1).to_wire(),
+            this.new_axle_3.to_wire(),
+            this.new_axle_4.to_wire(),
+            this.new_axle_5.to_wire()
+        ];
+    }
+    calculate_first_proportion() {
+        const a = this.chassi.get_axle_position(1, CHASSI_REFERENCE.GROUPER_1);
+        const b = this.chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1) - a;
+        return a / b;
+    }
+    calculate_second_proportion() {
+        const axle_3 = this.chassi.get_axle_position(2, CHASSI_REFERENCE.TRACTOR);
+        const axle_4 = this.chassi.get_axle_position(3, CHASSI_REFERENCE.TRACTOR);
+        const end = this.chassi.get_grouper_end(2, CHASSI_REFERENCE.TRACTOR);
+        return (end - axle_4) / (axle_4 - axle_3);
+    }
+    generate_new_weight_attributes() {
+        const old = this.transport.axle_manager.get_axle(2);
+        const split = compute_bitrem_axle_split(this.calculate_first_proportion(), this.calculate_second_proportion());
+        apply_bitrem_axle_split({
+            old,
+            axle_3: this.new_axle_3,
+            axle_4: this.new_axle_4,
+            split
+        });
+    }
+    generate_new_axle_distances() {
+        const old_4 = this.transport.axle_manager.get_axle(3);
+        this.new_axle_4.distance_from_previous_axle = this.distance_from_axle_3_to_pin_2();
+        this.new_axle_5.distance_from_previous_axle = old_4.distance_from_previous_axle
+            - this.new_axle_4.distance_from_previous_axle;
+    }
+    generate_new_axle_container_sequences() {
+        const merged = new MergedContainers(this.transport);
+        this.new_axle_3.sequence_index = merged.get_container_by_grouper_index(1)
+            .list_containers_sequence_indexes()[0];
+        this.new_axle_4.sequence_index = merged.get_container_by_grouper_index(2)
+            .list_containers_sequence_indexes()[0];
+    }
+    generate_merged_axle_connection() {
+        this.new_axle_4.is_connected_to = 2;
+    }
+    distance_from_axle_3_to_pin_2() {
+        const axle_3 = this.chassi.get_axle_position(2, CHASSI_REFERENCE.TRACTOR);
+        const pin_2 = this.chassi.get_pin_position(1, CHASSI_REFERENCE.TRACTOR);
+        return pin_2 - axle_3;
+    }
+}
+function clone_axle(source) {
+    return new AxleRecord(source.to_wire());
+}