@jetta/axle-load-calculator 0.1.3

package/build/core/physics/models/semi_reboque_model.js

@@ -0,0 +1,84 @@
+import { MergedContainers } from '../transports/merged_containers.js';
+import { calculate_chassi_forces_from_multi, compute_center_of_mass_by_grouper } from '../items/compute_grouper_center_of_mass.js';
+import { VEHICLE_VERSION } from '../../contracts/vehicle_version.js';
+import { SemiReboqueBase } from './semi_reboque_base.js';
+import { QuadSemiTrailerModel } from './quad_semi_trailer_model.js';
+import { BiTruckTractorSemiTrailerModel } from './bi_truck_tractor_semi_trailer_model.js';
+/**
+ * Semi-reboque axle weight with quad/bitruck variants.
+ */
+export class SemiReboqueModel {
+    delegate;
+    transport;
+    merged_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.merged_containers = new MergedContainers(transport);
+        if (transport.vehicle_version === VEHICLE_VERSION.SEMIREBOQUE_QUAD
+            || transport.vehicle_version === VEHICLE_VERSION.SEMIREBOQUE_QUAD_ALT) {
+            this.delegate = new QuadSemiTrailerModel(transport);
+        }
+        else if (transport.vehicle_version === VEHICLE_VERSION.SEMIREBOQUE_BITRUCK) {
+            this.delegate = new BiTruckTractorSemiTrailerModel(transport);
+        }
+        else {
+            const base = new SemiReboqueBase(transport);
+            base.set_linear_system_matrix();
+            this.delegate = base;
+        }
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Loaded weights per axle.
+     */
+    calculate_weight_on_axles(multi_items) {
+        const forces = this.calculate_chassi_forces(multi_items);
+        return forces.list_axles_indexes().map((index) => forces.get_force_on_axle(index));
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces(multi_items) {
+        return calculate_chassi_forces_from_multi(this.transport, multi_items, (center_of_mass_by_grouper) => this.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper));
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Deflection support pairs.
+     */
+    calculate_support_data(multi_items) {
+        const quad_or_bitruck = this.transport.vehicle_version === VEHICLE_VERSION.SEMIREBOQUE_QUAD
+            || this.transport.vehicle_version === VEHICLE_VERSION.SEMIREBOQUE_QUAD_ALT
+            || this.transport.vehicle_version === VEHICLE_VERSION.SEMIREBOQUE_BITRUCK;
+        if (quad_or_bitruck) {
+            const center_of_mass_by_grouper = compute_center_of_mass_by_grouper(multi_items, this.merged_containers);
+            const quad = this.delegate;
+            const forces = quad.equivalent_semi_trailer
+                .calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper);
+            const positions = quad.equivalent_semi_trailer.chassi_positions;
+            return [[positions[3], forces.get_force_on_pin(0)], [positions[4], forces.get_force_on_axle(2)]];
+        }
+        const forces = this.calculate_chassi_forces(multi_items);
+        const base = this.delegate;
+        return [
+            [base.chassi_positions[3], forces.get_force_on_pin(0)],
+            [base.chassi_positions[4], forces.get_force_on_axle(2)]
+        ];
+    }
+    /**
+     * @returns Merged grouper 1 length.
+     */
+    calculate_container_length() {
+        return this.merged_containers.get_container_by_grouper_index(1).length;
+    }
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper) {
+        return this.delegate.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper);
+    }
+}

package/build/core/physics/models/simple_truck_base.d.ts

@@ -0,0 +1,29 @@
+import type { Transport } from '../transports/transport.js';
+import { CenterOfMass } from '../items/center_of_mass.js';
+import { ChassiForces } from './chassi_forces.js';
+/**
+ * Two-axle truck lever equilibrium.
+ */
+export declare class SimpleTruckBase {
+    private readonly transport;
+    axles_positions: number[];
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper id.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper: Record<number, CenterOfMass>): ChassiForces;
+    /**
+     * @param axles_positions - Optional preset positions.
+     */
+    set_axles_positions(axles_positions?: number[]): void;
+    /**
+     * @param center_of_mass - Load center of mass.
+     * @returns Axle 1 and 2 cargo reactions.
+     */
+    private solve_linear_system;
+}
+//# sourceMappingURL=simple_truck_base.d.ts.map

package/build/core/physics/models/simple_truck_base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple_truck_base.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/models/simple_truck_base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAG3D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD;;GAEG;AACH,qBAAa,eAAe;IAOZ,OAAO,CAAC,QAAQ,CAAC,SAAS;IALtC,eAAe,EAAE,MAAM,EAAE,CAAK;IAE9B;;OAEG;gBAC0B,SAAS,EAAE,SAAS;IAKjD;;;OAGG;IACH,gDAAgD,CAC5C,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GACxD,YAAY;IASf;;OAEG;IACH,mBAAmB,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;IAcrD;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAY9B"}

package/build/core/physics/models/simple_truck_base.js

@@ -0,0 +1,57 @@
+import { Chassi } from '../transports/chassi.js';
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js';
+import { ChassiForces } from './chassi_forces.js';
+/**
+ * Two-axle truck lever equilibrium.
+ */
+export class SimpleTruckBase {
+    transport;
+    axles_positions = [];
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.set_axles_positions();
+    }
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper id.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper) {
+        const center_of_mass = center_of_mass_by_grouper[1];
+        const [axle_1, axle_2] = this.solve_linear_system(center_of_mass);
+        const forces = new ChassiForces();
+        forces.add_axle_forces([axle_1, axle_2]);
+        return forces;
+    }
+    /**
+     * @param axles_positions - Optional preset positions.
+     */
+    set_axles_positions(axles_positions) {
+        if (axles_positions) {
+            this.axles_positions = axles_positions;
+            return;
+        }
+        const chassi = new Chassi(this.transport);
+        this.axles_positions = [
+            chassi.get_axle_position(0, CHASSI_REFERENCE.GROUPER_1),
+            chassi.get_axle_position(1, CHASSI_REFERENCE.GROUPER_1)
+        ];
+    }
+    /**
+     * @param center_of_mass - Load center of mass.
+     * @returns Axle 1 and 2 cargo reactions.
+     */
+    solve_linear_system(center_of_mass) {
+        const axle_1_position = this.axles_positions[0];
+        const axle_2_position = this.axles_positions[1];
+        const axle_1 = center_of_mass.mass
+            * (center_of_mass.z - axle_2_position)
+            / (axle_1_position - axle_2_position);
+        const axle_2 = center_of_mass.mass
+            * (axle_1_position - center_of_mass.z)
+            / (axle_1_position - axle_2_position);
+        return [axle_1, axle_2];
+    }
+}

package/build/core/physics/models/simple_truck_model.d.ts

@@ -0,0 +1,41 @@
+import type { Transport } from '../transports/transport.js';
+import type { MultiContainerAllocatedItems } from '../items/multi_container_allocated_items.js';
+import { CenterOfMass } from '../items/center_of_mass.js';
+import { ChassiForces } from './chassi_forces.js';
+/**
+ * Caminhão / VUC axle weight (optional bitruck variant).
+ */
+export declare class SimpleTruckModel {
+    private readonly delegate;
+    private readonly transport;
+    private readonly merged_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Loaded weights per axle.
+     */
+    calculate_weight_on_axles(multi_items: MultiContainerAllocatedItems): number[];
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces(multi_items: MultiContainerAllocatedItems): ChassiForces;
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Deflection support pairs.
+     */
+    calculate_support_data(multi_items: MultiContainerAllocatedItems): [number, number][];
+    /**
+     * @returns Merged grouper 1 length.
+     */
+    calculate_container_length(): number;
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper: Record<number, CenterOfMass>): ChassiForces;
+}
+//# sourceMappingURL=simple_truck_model.d.ts.map

package/build/core/physics/models/simple_truck_model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple_truck_model.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/models/simple_truck_model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAA;AAM/F,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAUjD;;GAEG;AACH,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoF;IAC7G,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkB;IAEpD;;OAEG;gBACS,SAAS,EAAE,SAAS;IAgBhC;;;OAGG;IACH,yBAAyB,CAAC,WAAW,EAAE,4BAA4B,GAAG,MAAM,EAAE;IAM9E;;;OAGG;IACH,uBAAuB,CAAC,WAAW,EAAE,4BAA4B,GAAG,YAAY;IAShF;;;OAGG;IACH,sBAAsB,CAAC,WAAW,EAAE,4BAA4B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;IAqBrF;;OAEG;IACH,0BAA0B,IAAI,MAAM;IAKpC;;;OAGG;IACH,gDAAgD,CAC5C,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GACxD,YAAY;CAKlB"}

package/build/core/physics/models/simple_truck_model.js

@@ -0,0 +1,76 @@
+import { MergedContainers } from '../transports/merged_containers.js';
+import { calculate_chassi_forces_from_multi, compute_center_of_mass_by_grouper } from '../items/compute_grouper_center_of_mass.js';
+import { VEHICLE_VERSION } from '../../contracts/vehicle_version.js';
+import { SimpleTruckBase } from './simple_truck_base.js';
+import { BiTruckModel } from './bi_truck_model.js';
+/**
+ * Caminhão / VUC axle weight (optional bitruck variant).
+ */
+export class SimpleTruckModel {
+    delegate;
+    transport;
+    merged_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.merged_containers = new MergedContainers(transport);
+        if (transport.vehicle_version === VEHICLE_VERSION.CAMINHAO_BITRUCK) {
+            this.delegate = new BiTruckModel(transport);
+        }
+        else {
+            const base = new SimpleTruckBase(transport);
+            base.set_axles_positions();
+            this.delegate = base;
+        }
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Loaded weights per axle.
+     */
+    calculate_weight_on_axles(multi_items) {
+        const forces = this.calculate_chassi_forces(multi_items);
+        return forces.list_axles_indexes().map((index) => forces.get_force_on_axle(index));
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces(multi_items) {
+        return calculate_chassi_forces_from_multi(this.transport, multi_items, (center_of_mass_by_grouper) => this.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper));
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Deflection support pairs.
+     */
+    calculate_support_data(multi_items) {
+        if (this.transport.vehicle_version === VEHICLE_VERSION.CAMINHAO_BITRUCK) {
+            const center_of_mass_by_grouper = compute_center_of_mass_by_grouper(multi_items, this.merged_containers);
+            const bi_truck = this.delegate;
+            const forces = bi_truck.equivalent_truck
+                .calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper);
+            const positions = bi_truck.equivalent_truck.axles_positions;
+            return [[positions[0], forces.get_force_on_axle(0)], [positions[1], forces.get_force_on_axle(1)]];
+        }
+        const forces = this.calculate_chassi_forces(multi_items);
+        const base = this.delegate;
+        return [
+            [base.axles_positions[0], forces.get_force_on_axle(0)],
+            [base.axles_positions[1], forces.get_force_on_axle(1)]
+        ];
+    }
+    /**
+     * @returns Merged grouper 1 length.
+     */
+    calculate_container_length() {
+        return this.merged_containers.get_container_by_grouper_index(1).length;
+    }
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper) {
+        return this.delegate.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper);
+    }
+}

package/build/core/physics/models/single_container_tare.d.ts

@@ -0,0 +1,18 @@
+import type { Transport } from '../transports/transport.js';
+/**
+ * Physics-based tare from uniform load at volume centroid.
+ */
+export declare class SingleContainerTare {
+    private readonly transport;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @returns Calculated tare per axle.
+     */
+    calculate(): number[];
+    private calculate_z_centroid;
+    private calculate_forces_on_axles;
+}
+//# sourceMappingURL=single_container_tare.d.ts.map

package/build/core/physics/models/single_container_tare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single_container_tare.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/models/single_container_tare.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE3D;;GAEG;AACH,qBAAa,mBAAmB;IAKhB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAHtC;;OAEG;gBAC0B,SAAS,EAAE,SAAS;IAGjD;;OAEG;IACH,SAAS,IAAI,MAAM,EAAE;IAYrB,OAAO,CAAC,oBAAoB;IAiB5B,OAAO,CAAC,yBAAyB;CAQpC"}

package/build/core/physics/models/single_container_tare.js

@@ -0,0 +1,45 @@
+import { CenterOfMass } from '../items/center_of_mass.js';
+import { AxleWeightModel } from './axle_weight_model.js';
+/**
+ * Physics-based tare from uniform load at volume centroid.
+ */
+export class SingleContainerTare {
+    transport;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * @returns Calculated tare per axle.
+     */
+    calculate() {
+        const forces = this.calculate_forces_on_axles(this.calculate_z_centroid(), this.transport.supported_weight);
+        return this.transport.axle_manager.list_axles_indexes().map((index) => {
+            const axle = this.transport.axle_manager.get_axle(index);
+            return axle.max_supported_weight - forces.get_force_on_axle(index);
+        });
+    }
+    calculate_z_centroid() {
+        let z_offset = 0;
+        let sum_z = 0;
+        let total_volume = 0;
+        for (const sequence of this.transport.list_containers_sequence_indexes()) {
+            const container = this.transport.get_container_by_sequence_index(sequence);
+            const z_centroid = z_offset + container.length / 2;
+            z_offset += container.length;
+            const volume = container.volume();
+            sum_z += z_centroid * volume;
+            total_volume += volume;
+        }
+        return sum_z / total_volume;
+    }
+    calculate_forces_on_axles(z_position, mass) {
+        const model = new AxleWeightModel(this.transport);
+        const center_of_mass = new CenterOfMass();
+        center_of_mass.z = z_position;
+        center_of_mass.mass = mass;
+        return model.calculate_chassi_forces_with_load_center_of_mass({ 1: center_of_mass });
+    }
+}

package/build/core/physics/models/tare_model.d.ts

@@ -0,0 +1,12 @@
+import type { Transport } from '../transports/transport.js';
+/**
+ * Selects legacy or physics tare model per axle.
+ */
+export declare class TareModel {
+    /**
+     * @param transport - Parsed transport.
+     * @returns Tare per axle.
+     */
+    calculate(transport: Transport): number[];
+}
+//# sourceMappingURL=tare_model.d.ts.map

package/build/core/physics/models/tare_model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tare_model.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/models/tare_model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAM3D;;GAEG;AACH,qBAAa,SAAS;IAElB;;;OAGG;IACH,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,EAAE;CAW5C"}

package/build/core/physics/models/tare_model.js

@@ -0,0 +1,36 @@
+import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js';
+import { OldTareModel } from './old_tare_model.js';
+import { SingleContainerTare } from './single_container_tare.js';
+const DISTANCE_TOLERANCE = 0.9;
+/**
+ * Selects legacy or physics tare model per axle.
+ */
+export class TareModel {
+    /**
+     * @param transport - Parsed transport.
+     * @returns Tare per axle.
+     */
+    calculate(transport) {
+        if (transport.vehicle_type === VEHICLE_TYPE.BITREM
+            || transport.vehicle_type === VEHICLE_TYPE.RODOTREM) {
+            return new OldTareModel().calculate(transport);
+        }
+        const reference = new OldTareModel().calculate(transport);
+        const physics = new SingleContainerTare(transport).calculate();
+        return choose_tare_model(reference, physics);
+    }
+}
+/**
+ * @param reference_values - Legacy tare per axle.
+ * @param new_values - Physics tare per axle.
+ * @returns Selected tare list.
+ */
+function choose_tare_model(reference_values, new_values) {
+    for (let index = 0; index < reference_values.length; index++) {
+        const ref = reference_values[index];
+        if (Math.abs(new_values[index] - ref) > ref * DISTANCE_TOLERANCE) {
+            return reference_values;
+        }
+    }
+    return new_values;
+}

package/build/core/physics/models/vanderleia_model.d.ts

@@ -0,0 +1,33 @@
+import type { Transport } from '../transports/transport.js';
+import type { MultiContainerAllocatedItems } from '../items/multi_container_allocated_items.js';
+import { Chassi } from '../transports/chassi.js';
+import { CenterOfMass } from '../items/center_of_mass.js';
+import { ChassiForces } from './chassi_forces.js';
+/**
+ * Vanderleia five-axle static model with suspension-dependent coupling.
+ */
+export declare class VanderleiaModel {
+    private readonly transport;
+    readonly chassi: Chassi;
+    private readonly matrix;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Loaded weights per axle.
+     */
+    calculate_weight_on_axles(multi_items: MultiContainerAllocatedItems): number[];
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces(multi_items: MultiContainerAllocatedItems): ChassiForces;
+    /**
+     * @param center_of_mass_by_grouper - CM for grouper 1.
+     * @returns Chassis forces on five axles.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper: Record<number, CenterOfMass>): ChassiForces;
+}
+//# sourceMappingURL=vanderleia_model.d.ts.map

package/build/core/physics/models/vanderleia_model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vanderleia_model.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/models/vanderleia_model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAA;AAE/F,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAGhD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGjD;;GAEG;AACH,qBAAa,eAAe;IAQZ,OAAO,CAAC,QAAQ,CAAC,SAAS;IANtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IAEnC;;OAEG;gBAC0B,SAAS,EAAE,SAAS;IAMjD;;;OAGG;IACH,yBAAyB,CAAC,WAAW,EAAE,4BAA4B,GAAG,MAAM,EAAE;IAM9E;;;OAGG;IACH,uBAAuB,CAAC,WAAW,EAAE,4BAA4B,GAAG,YAAY;IAShF;;;OAGG;IACH,gDAAgD,CAC5C,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GACxD,YAAY;CAclB"}

package/build/core/physics/models/vanderleia_model.js

@@ -0,0 +1,100 @@
+import { calculate_chassi_forces_from_multi } from '../items/compute_grouper_center_of_mass.js';
+import { Chassi } from '../transports/chassi.js';
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js';
+import { SUSPENSION_TYPE } from '../../contracts/suspension_type.js';
+import { ChassiForces } from './chassi_forces.js';
+import { solve_linear_system } from '../../math/gaussian_elimination.js';
+/**
+ * Vanderleia five-axle static model with suspension-dependent coupling.
+ */
+export class VanderleiaModel {
+    transport;
+    chassi;
+    matrix;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.chassi = new Chassi(transport);
+        this.matrix = generate_vanderleia_matrix(this.chassi, transport);
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Loaded weights per axle.
+     */
+    calculate_weight_on_axles(multi_items) {
+        const forces = this.calculate_chassi_forces(multi_items);
+        return forces.list_axles_indexes().map((index) => forces.get_force_on_axle(index));
+    }
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces(multi_items) {
+        return calculate_chassi_forces_from_multi(this.transport, multi_items, (center_of_mass_by_grouper) => this.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper));
+    }
+    /**
+     * @param center_of_mass_by_grouper - CM for grouper 1.
+     * @returns Chassis forces on five axles.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper) {
+        const solution = solve_vanderleia_system(this.matrix, center_of_mass_by_grouper[1]);
+        const forces = new ChassiForces();
+        forces.add_pin_forces([solution[3]]);
+        forces.add_axle_forces([
+            solution[5],
+            solution[4],
+            solution[2],
+            solution[1],
+            solution[0]
+        ]);
+        return forces;
+    }
+}
+/**
+ * @param chassi - Chassis geometry.
+ * @param transport - Parsed transport (suspension type).
+ * @returns 6×6 matrix.
+ */
+function generate_vanderleia_matrix(chassi, transport) {
+    const tractor_pin = chassi.get_pin_position(0, CHASSI_REFERENCE.TRACTOR);
+    const tractor_axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.TRACTOR);
+    const tractor_axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.TRACTOR);
+    const pin_1 = chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1);
+    const axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1);
+    const axle_4 = chassi.get_axle_position(3, CHASSI_REFERENCE.GROUPER_1);
+    const axle_5 = chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_1);
+    const relation = reactions_relation(transport);
+    return [
+        [1, 0, -relation[0], 0, 0, 0],
+        [0, 1, -relation[1], 0, 0, 0],
+        [1, 1, 1, 1, 0, 0],
+        [axle_5, axle_4, axle_3, pin_1, 0, 0],
+        [0, 0, 0, -1, 1, 1],
+        [0, 0, 0, -tractor_pin, tractor_axle_2, tractor_axle_1]
+    ];
+}
+/**
+ * @param transport - Parsed transport.
+ * @returns Reaction coupling factors.
+ */
+function reactions_relation(transport) {
+    const raw = transport.suspension_type;
+    if (raw === SUSPENSION_TYPE.PNEUMATICA || raw === 'Pneumatica') {
+        return [1, 1];
+    }
+    if (raw === SUSPENSION_TYPE.MECANICA || raw === 'Mecanica') {
+        return [0.867469880, 0.542168675];
+    }
+    throw new Error(`Unrecognized suspension type: ${String(raw)}`);
+}
+/**
+ * @param matrix - System matrix.
+ * @param center_of_mass - Load CM.
+ * @returns Solution vector.
+ */
+function solve_vanderleia_system(matrix, center_of_mass) {
+    const independent = [0, 0, center_of_mass.mass, center_of_mass.mass * center_of_mass.z, 0, 0];
+    return solve_linear_system(matrix, independent);
+}

package/build/core/physics/services/axle_weight_output_builder.d.ts

@@ -0,0 +1,27 @@
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js';
+import type { Transport } from '../transports/transport.js';
+import type { Chassi } from '../transports/chassi.js';
+/**
+ * @param transport - Parsed transport.
+ * @param grouper - Grouper index.
+ * @returns Axle indexes for grouper output.
+ */
+export declare function select_axles_for_grouper(transport: Transport, grouper: number): number[];
+/**
+ * @param axles_indexes - Axle indexes in output row.
+ * @returns Chassi reference for distance helper.
+ */
+export declare function find_grouper_reference(axles_indexes: number[]): typeof CHASSI_REFERENCE.GROUPER_1 | typeof CHASSI_REFERENCE.GROUPER_2;
+type AxleWeightOutputInput = {
+    transport: Transport;
+    chassi: Chassi;
+    axles_indexes: number[];
+    weight_on_axles: number[];
+};
+/**
+ * @param input - Transport, chassi, axles, and cargo loads.
+ * @returns pesoEixos wire rows.
+ */
+export declare function build_axle_weights_output(input: AxleWeightOutputInput): Record<string, unknown>[];
+export {};
+//# sourceMappingURL=axle_weight_output_builder.d.ts.map

package/build/core/physics/services/axle_weight_output_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axle_weight_output_builder.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/services/axle_weight_output_builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAErD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAQxF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAClC,aAAa,EAAE,MAAM,EAAE,GACxB,OAAO,gBAAgB,CAAC,SAAS,GAAG,OAAO,gBAAgB,CAAC,SAAS,CAGvE;AAED,KAAK,qBAAqB,GAAG;IACzB,SAAS,EAAE,SAAS,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,eAAe,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAoBjG"}

package/build/core/physics/services/axle_weight_output_builder.js

@@ -0,0 +1,42 @@
+import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js';
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js';
+/**
+ * @param transport - Parsed transport.
+ * @param grouper - Grouper index.
+ * @returns Axle indexes for grouper output.
+ */
+export function select_axles_for_grouper(transport, grouper) {
+    const type = transport.vehicle_type;
+    if (type === VEHICLE_TYPE.RODOTREM || type === VEHICLE_TYPE.BITREM) {
+        return grouper === 1 ? [0, 1, 2] : [3, 4];
+    }
+    return transport.axle_manager.list_axles_indexes();
+}
+/**
+ * @param axles_indexes - Axle indexes in output row.
+ * @returns Chassi reference for distance helper.
+ */
+export function find_grouper_reference(axles_indexes) {
+    return axles_indexes.includes(0) ? CHASSI_REFERENCE.GROUPER_1 : CHASSI_REFERENCE.GROUPER_2;
+}
+/**
+ * @param input - Transport, chassi, axles, and cargo loads.
+ * @returns pesoEixos wire rows.
+ */
+export function build_axle_weights_output(input) {
+    return input.axles_indexes.map((axle_index) => {
+        const axle = input.transport.axle_manager.get_axle(axle_index);
+        const cargo = input.weight_on_axles[axle_index];
+        return {
+            distanciaOrigem: axle.distance_from_previous_axle,
+            pesoMaxFinal: axle.max_supported_weight,
+            tara: axle.tare,
+            pesoMax: axle.max_supported_weight - axle.tare,
+            pesoCarregado: cargo,
+            pesoCarregadoFinal: axle.tare + cargo,
+            distanciaOrigemSemPrimeiroEixo: axle_index === 0
+                ? 0
+                : input.chassi.get_axle_position(axle_index, find_grouper_reference(input.axles_indexes))
+        };
+    });
+}

package/build/core/physics/services/axle_weight_service.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Full ms-faixas axle weight pipeline (Python AxleWeightService port).
+ */
+export declare class AxleWeightService {
+    private readonly transport;
+    private readonly chassi;
+    private readonly allocated_by_sequence;
+    /**
+     * @param input_data - Ms-faixas payload with envs.
+     */
+    constructor(input_data: Record<string, unknown>);
+    /**
+     * @returns Math output with envs and pesoEixos per container.
+     */
+    run(): Record<string, unknown>;
+    private build_containers_data;
+    private evaluate_weight_on_axles;
+    private assign_grouper_axle_outputs;
+}
+//# sourceMappingURL=axle_weight_service.d.ts.map

package/build/core/physics/services/axle_weight_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axle_weight_service.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/services/axle_weight_service.ts"],"names":[],"mappings":"AAqBA;;GAEG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAmF;IAEzH;;OAEG;gBACS,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAQ/C;;OAEG;IACH,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAU9B,OAAO,CAAC,qBAAqB;IAuB7B,OAAO,CAAC,wBAAwB;IAkBhC,OAAO,CAAC,2BAA2B;CAoBtC"}