@jetta/axle-load-calculator 0.1.3

package/src/core/physics/items/item_templates.ts

@@ -0,0 +1,65 @@
+import type { RotationCode } from '../../contracts/rotation_enum.js'
+import { ROTATION } from '../../contracts/rotation_enum.js'
+import { rotate_dimensions } from './rotation_transforms.js'
+
+/**
+ * Item dimensions and weights keyed by template index.
+ */
+export class ItemTemplates
+{
+    ids: string[] = []
+    weights: number[] = []
+    lengths: number[] = []
+    widths: number[] = []
+    heights: number[] = []
+    private dimensions: [number, number, number][] = []
+
+    /**
+     * @param item_id - Template id string.
+     * @returns Template index.
+     */
+    index_of(item_id: string): number
+    {
+        const index = this.ids.indexOf(item_id)
+        if (index < 0)
+        {
+            throw new Error(`Unknown item id ${item_id}`)
+        }
+        return index
+    }
+
+    /**
+     * @param item_data - Ms-faixas or math input item definition.
+     */
+    add_template_from_item_data(item_data: Record<string, unknown>): void
+    {
+        const id = String(item_data.id ?? item_data._id)
+        this.ids.push(id)
+        this.weights.push(Number(item_data.peso ?? item_data.weight ?? 0))
+        const width = Number(item_data.largura ?? item_data.width ?? 0)
+        const length = Number(item_data.comprimento ?? item_data.length ?? 0)
+        const height = Number(item_data.altura ?? item_data.height ?? 0)
+        this.widths.push(width)
+        this.lengths.push(length)
+        this.heights.push(height)
+        this.dimensions.push([width, length, height])
+    }
+
+    /**
+     * @param template_index - Template index.
+     * @param rotation - Rotation code.
+     * @returns Length along chassis z for rotation.
+     */
+    get_length(template_index: number, rotation: RotationCode = ROTATION.POS1): number
+    {
+        return rotate_dimensions(rotation, this.dimensions[template_index])[1]
+    }
+
+    /**
+     * @param item_data - Math input item row.
+     */
+    add_template_from_math_item(item_data: Record<string, unknown>): void
+    {
+        this.add_template_from_item_data(item_data)
+    }
+}

package/src/core/physics/items/multi_container_allocated_items.ts

@@ -0,0 +1,120 @@
+import type { MergedContainers } from '../transports/merged_containers.js'
+import { AllocatedItem } from './allocated_item.js'
+import { AllocatedItemManager } from './allocated_item_manager.js'
+import type { ItemTemplates } from './item_templates.js'
+
+/**
+ * Allocated items grouped by container sequence and merged by grouper.
+ */
+export class MultiContainerAllocatedItems
+{
+    allocated_items_by_sequence_index: Record<number, AllocatedItemManager>
+    allocated_items_by_grouper_index: Record<number, AllocatedItemManager> = {}
+
+    /**
+     * @param allocated_items_by_sequence_index - Items per container sequence.
+     */
+    constructor(allocated_items_by_sequence_index: Record<number, AllocatedItemManager>)
+    {
+        this.allocated_items_by_sequence_index = allocated_items_by_sequence_index
+    }
+
+    /**
+     * @param sequence_index - Container sequence id.
+     * @returns Manager for sequence.
+     */
+    get_allocated_items_by_sequence_index(sequence_index: number): AllocatedItemManager
+    {
+        return this.allocated_items_by_sequence_index[sequence_index]
+    }
+
+    /**
+     * @param grouper_index - Grouper id.
+     * @returns Manager for grouper.
+     */
+    get_allocated_items_by_grouper_index(grouper_index: number): AllocatedItemManager
+    {
+        return this.allocated_items_by_grouper_index[grouper_index]
+    }
+
+    /**
+     * @param grouper_index_list - Grouper ids to initialize.
+     */
+    create_allocated_items_by_grouper(grouper_index_list: number[]): void
+    {
+        const templates = this.get_item_templates()
+        for (const grouper_index of grouper_index_list)
+        {
+            this.allocated_items_by_grouper_index[grouper_index] = new AllocatedItemManager(templates)
+        }
+    }
+
+    /**
+     * @param merged_containers - Merged container geometry.
+     */
+    merge_allocated_items(merged_containers: MergedContainers): void
+    {
+        if (Object.keys(this.allocated_items_by_grouper_index).length > 0)
+        {
+            return
+        }
+        this.create_allocated_items_by_grouper(merged_containers.list_grouper_indexes())
+        for (const grouper of merged_containers.list_grouper_indexes())
+        {
+            merge_grouper_items(this, merged_containers, grouper)
+        }
+    }
+
+    /**
+     * @returns Shared item templates.
+     */
+    get_item_templates(): ItemTemplates
+    {
+        const keys = Object.keys(this.allocated_items_by_sequence_index)
+        const first_key = Number(keys[0])
+        return this.allocated_items_by_sequence_index[first_key].templates
+    }
+}
+
+/**
+ * @param multi - Multi-container item holder.
+ * @param merged - Merged containers.
+ * @param grouper - Grouper id.
+ */
+function merge_grouper_items(
+    multi: MultiContainerAllocatedItems,
+    merged: MergedContainers,
+    grouper: number
+): void
+{
+    const grouped = merged.get_container_by_grouper_index(grouper)
+    let last_end = 0
+    for (const sequence_index of grouped.list_containers_sequence_indexes())
+    {
+        const sequence_items = multi.get_allocated_items_by_sequence_index(sequence_index)
+        const grouper_items = multi.get_allocated_items_by_grouper_index(grouper)
+        for (const item_index of sequence_items.list_item_indexes())
+        {
+            const source = sequence_items.get_item(item_index)
+            const item = clone_allocated_item(source)
+            item.zi += last_end
+            grouper_items.add_allocated_items([item])
+        }
+        const container = grouped.get_container_by_sequence_index(sequence_index)
+        last_end += container.length
+    }
+}
+
+/**
+ * @param source - Sequence-level allocated item.
+ * @returns Copy safe to offset for grouper merge.
+ */
+function clone_allocated_item(source: AllocatedItem): AllocatedItem
+{
+    const item = new AllocatedItem(source.templates, source.template_index)
+    item.xi = source.xi
+    item.yi = source.yi
+    item.zi = source.zi
+    item.rotation = source.rotation
+    return item
+}

package/src/core/physics/items/rotation_transforms.ts

@@ -0,0 +1,29 @@
+import type { RotationCode } from '../../contracts/rotation_enum.js'
+import { ROTATION } from '../../contracts/rotation_enum.js'
+
+const WIDTH = 0
+const LENGTH = 1
+const HEIGHT = 2
+
+const ROTATION_DIM_INDEX: Record<RotationCode, [number, number, number]> = {
+    [ROTATION.POS1]: [WIDTH, LENGTH, HEIGHT],
+    [ROTATION.POS2]: [WIDTH, HEIGHT, LENGTH],
+    [ROTATION.POS3]: [HEIGHT, LENGTH, WIDTH],
+    [ROTATION.POS4]: [LENGTH, WIDTH, HEIGHT],
+    [ROTATION.POS5]: [HEIGHT, WIDTH, LENGTH],
+    [ROTATION.POS6]: [LENGTH, HEIGHT, WIDTH]
+}
+
+/**
+ * @param rotation - Rotation code.
+ * @param dimensions - [width, length, height].
+ * @returns Rotated [width, length, height].
+ */
+export function rotate_dimensions(
+    rotation: RotationCode,
+    dimensions: [number, number, number]
+): [number, number, number]
+{
+    const index = ROTATION_DIM_INDEX[rotation]
+    return [dimensions[index[0]], dimensions[index[1]], dimensions[index[2]]]
+}

package/src/core/physics/models/axle_weight_model.ts

@@ -0,0 +1,109 @@
+import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js'
+import type { TransportRecord } from '../../contracts/transport_record.js'
+import { Transport } from '../transports/transport.js'
+import { BitremModel } from './bitrem_model.js'
+import { RodotremModel } from './rodotrem_model.js'
+import { VanderleiaModel } from './vanderleia_model.js'
+import { SimpleTruckModel } from './simple_truck_model.js'
+import { SemiReboqueModel } from './semi_reboque_model.js'
+import { CenterOfMass } from '../items/center_of_mass.js'
+import type { AllocatedItemManager } from '../items/allocated_item_manager.js'
+import { MultiContainerAllocatedItems } from '../items/multi_container_allocated_items.js'
+import { ChassiForces } from './chassi_forces.js'
+import { PercentageOnAxlesCalculator } from './percentage_on_axles_calculator.js'
+
+type VehicleModel = {
+    calculate_chassi_forces_with_load_center_of_mass: (
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ) => ChassiForces
+    calculate_weight_on_axles: (
+        multi_items: import('../items/multi_container_allocated_items.js').MultiContainerAllocatedItems
+    ) => number[]
+}
+
+/**
+ * Dispatches to vehicle-specific axle weight models.
+ */
+export class AxleWeightModel
+{
+    private readonly model: VehicleModel
+    private readonly transport: Transport
+
+    /**
+     * @param transport_or_data - Parsed transport or raw wire dict.
+     */
+    constructor(transport_or_data: Transport | TransportRecord)
+    {
+        this.transport = transport_or_data instanceof Transport
+            ? transport_or_data
+            : new Transport(transport_or_data)
+        this.model = select_vehicle_model(this.transport)
+    }
+
+    /**
+     * @param center_of_mass_by_grouper - Precomputed CM per grouper.
+     * @returns Chassis force result.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ): ChassiForces
+    {
+        return this.model.calculate_chassi_forces_with_load_center_of_mass(
+            center_of_mass_by_grouper)
+    }
+
+    /**
+     * @param allocated_by_sequence - Items per container sequence index.
+     * @returns Loaded cargo per axle.
+     */
+    calculate_weight_on_axles(
+        allocated_by_sequence: Record<number, AllocatedItemManager>
+    ): number[]
+    {
+        const multi = new MultiContainerAllocatedItems(allocated_by_sequence)
+        return this.model.calculate_weight_on_axles(multi)
+    }
+
+    /**
+     * @param allocated_by_sequence - Items per container sequence index.
+     * @returns Utilization percentage per axle.
+     */
+    calculate_percentages_on_axles(
+        allocated_by_sequence: Record<number, AllocatedItemManager>
+    ): number[]
+    {
+        const weights = this.calculate_weight_on_axles(allocated_by_sequence)
+        return new PercentageOnAxlesCalculator(this.transport)
+            .weight_on_axles_to_percentages(weights)
+    }
+}
+
+/**
+ * @param transport - Parsed transport.
+ * @returns Vehicle model implementation.
+ */
+function select_vehicle_model(transport: Transport): VehicleModel
+{
+    const type = transport.vehicle_type
+    if (type === VEHICLE_TYPE.SEMIREBOQUE || type === VEHICLE_TYPE.REBAIXADO)
+    {
+        return new SemiReboqueModel(transport)
+    }
+    if (type === VEHICLE_TYPE.BITREM)
+    {
+        return new BitremModel(transport)
+    }
+    if (type === VEHICLE_TYPE.RODOTREM)
+    {
+        return new RodotremModel(transport)
+    }
+    if (type === VEHICLE_TYPE.VANDERLEIA)
+    {
+        return new VanderleiaModel(transport)
+    }
+    if (type === VEHICLE_TYPE.CAMINHAO || type === VEHICLE_TYPE.VUC)
+    {
+        return new SimpleTruckModel(transport)
+    }
+    throw new Error(`Unsupported vehicle type: ${type}`)
+}

package/src/core/physics/models/bi_truck_model.ts

@@ -0,0 +1,74 @@
+import type { Transport } from '../transports/transport.js'
+import { Chassi } from '../transports/chassi.js'
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js'
+import { CenterOfMass } from '../items/center_of_mass.js'
+import { ChassiForces } from './chassi_forces.js'
+import { SimpleTruckBase } from './simple_truck_base.js'
+import { solve_linear_system } from '../../math/gaussian_elimination.js'
+
+/**
+ * Bitruck caminhão: equivalent 2-axle truck + front axle pair split.
+ */
+export class BiTruckModel
+{
+    private readonly chassi: Chassi
+    readonly equivalent_truck: SimpleTruckBase
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport)
+    {
+        this.chassi = new Chassi(transport)
+        this.equivalent_truck = new SimpleTruckBase(transport)
+        this.equivalent_truck.set_axles_positions(get_equivalent_positions(this.chassi, transport))
+    }
+
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper.
+     * @returns Three-axle forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ): ChassiForces
+    {
+        const equivalent = this.equivalent_truck
+            .calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper)
+        const equivalent_z = this.equivalent_truck.axles_positions[0]
+        const independent = [
+            equivalent.get_force_on_axle(0),
+            equivalent.get_force_on_axle(0) * equivalent_z
+        ]
+        const front = solve_linear_system(generate_front_matrix(this.chassi), independent)
+        const forces = new ChassiForces()
+        forces.add_axle_forces([front[0], front[1], equivalent.get_force_on_axle(1)])
+        return forces
+    }
+}
+
+/**
+ * @param chassi - Chassis geometry.
+ * @returns 2×2 front axle matrix.
+ */
+function generate_front_matrix(chassi: Chassi): number[][]
+{
+    const axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.GROUPER_1)
+    const axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.GROUPER_1)
+    return [[1, 1], [axle_1, axle_2]]
+}
+
+/**
+ * @param chassi - Chassis geometry.
+ * @param transport - Parsed transport.
+ * @returns Equivalent two-axle positions.
+ */
+function get_equivalent_positions(chassi: Chassi, transport: Transport): number[]
+{
+    const axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.GROUPER_1)
+    const axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.GROUPER_1)
+    const axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
+    const cap_1 = transport.axle_manager.get_axle(0).max_supported_weight
+    const cap_2 = transport.axle_manager.get_axle(1).max_supported_weight
+    const front_equivalent = (axle_1 * cap_1 + axle_2 * cap_2) / (cap_1 + cap_2)
+    return [front_equivalent, axle_3]
+}

package/src/core/physics/models/bi_truck_tractor_semi_trailer_model.ts

@@ -0,0 +1,86 @@
+import type { Transport } from '../transports/transport.js'
+import { Chassi } from '../transports/chassi.js'
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js'
+import { CenterOfMass } from '../items/center_of_mass.js'
+import { ChassiForces } from './chassi_forces.js'
+import { SemiReboqueBase } from './semi_reboque_base.js'
+import { solve_linear_system } from '../../math/gaussian_elimination.js'
+
+/**
+ * Bitruck tractor + semi-trailer variant.
+ */
+export class BiTruckTractorSemiTrailerModel
+{
+    private readonly chassi: Chassi
+    readonly equivalent_semi_trailer: SemiReboqueBase
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport)
+    {
+        this.chassi = new Chassi(transport)
+        this.equivalent_semi_trailer = new SemiReboqueBase(transport)
+        this.equivalent_semi_trailer.set_linear_system_matrix(
+            get_equivalent_positions(this.chassi, transport))
+    }
+
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper.
+     * @returns Four-axle + pin forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ): ChassiForces
+    {
+        const equivalent = this.equivalent_semi_trailer
+            .calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper)
+        const equivalent_z = this.equivalent_semi_trailer.chassi_positions[1]
+        const independent = [
+            equivalent.get_force_on_axle(0),
+            equivalent.get_force_on_axle(0) * equivalent_z
+        ]
+        const front = solve_linear_system(generate_tractor_front_matrix(this.chassi), independent)
+        const forces = new ChassiForces()
+        forces.add_axle_forces([
+            front[0],
+            front[1],
+            equivalent.get_force_on_axle(1),
+            equivalent.get_force_on_axle(2)
+        ])
+        forces.add_pin_forces([equivalent.get_force_on_pin(0)])
+        return forces
+    }
+}
+
+/**
+ * @param chassi - Chassis geometry.
+ * @returns 2×2 tractor front matrix.
+ */
+function generate_tractor_front_matrix(chassi: Chassi): number[][]
+{
+    const axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.TRACTOR)
+    const axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.TRACTOR)
+    return [[1, 1], [axle_1, axle_2]]
+}
+
+/**
+ * @param chassi - Chassis geometry.
+ * @param transport - Parsed transport.
+ * @returns Equivalent semi chassis positions.
+ */
+function get_equivalent_positions(chassi: Chassi, transport: Transport): number[]
+{
+    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 tractor_axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.TRACTOR)
+    const semi_pin = chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
+    const semi_axle_4 = chassi.get_axle_position(3, CHASSI_REFERENCE.GROUPER_1)
+    const cap_1 = transport.axle_manager.get_axle(0).max_supported_weight
+    const cap_2 = transport.axle_manager.get_axle(1).max_supported_weight
+    const tractor_equivalent = (
+        tractor_axle_1 * cap_1 + tractor_axle_2 * cap_2
+    ) / (cap_1 + cap_2)
+    return [tractor_pin, tractor_equivalent, tractor_axle_3, semi_pin, semi_axle_4]
+}

package/src/core/physics/models/bitrem_model.ts

@@ -0,0 +1,148 @@
+import type { Transport } from '../transports/transport.js'
+import type { MultiContainerAllocatedItems } from '../items/multi_container_allocated_items.js'
+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 { CenterOfMass } from '../items/center_of_mass.js'
+import { ChassiForces } from './chassi_forces.js'
+import { solve_linear_system } from '../../math/gaussian_elimination.js'
+
+/**
+ * Bitrem interlink + semi static equilibrium (6×6 system).
+ */
+export class BitremModel
+{
+    readonly chassi: Chassi
+    private readonly matrix: number[][]
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(private readonly transport: Transport)
+    {
+        this.chassi = new Chassi(transport)
+        this.matrix = generate_bitrem_matrix(this.chassi)
+    }
+
+    /**
+     * @param multi_items - Allocated items by container sequence.
+     * @returns Loaded weight per axle.
+     */
+    calculate_weight_on_axles(multi_items: MultiContainerAllocatedItems): number[]
+    {
+        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 before rebalance split on axles 3–4.
+     */
+    calculate_chassi_forces(multi_items: MultiContainerAllocatedItems): ChassiForces
+    {
+        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 groupers 1 and 2.
+     * @returns Combined chassis forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ): ChassiForces
+    {
+        const interlink = center_of_mass_by_grouper[1]
+        const semi = center_of_mass_by_grouper[2]
+        const solution_interlink = solve_interlink_system(this.matrix, interlink)
+        const solution_semi = solve_semi_system(this.matrix, semi)
+        const forces = new ChassiForces()
+        forces.add_pin_forces([
+            solution_interlink[3] + solution_semi[3],
+            solution_interlink[1] + solution_semi[1]
+        ])
+        const loaded = [
+            solution_interlink[5] + solution_semi[5],
+            solution_interlink[4] + solution_semi[4],
+            solution_interlink[2],
+            solution_semi[2],
+            solution_interlink[0] + solution_semi[0]
+        ]
+        forces.add_axle_forces(linked_axle_weight_rebalance(this.transport, loaded))
+        return forces
+    }
+}
+
+/**
+ * @param chassi - Chassis geometry.
+ * @returns 6×6 matrix coefficients.
+ */
+function generate_bitrem_matrix(chassi: Chassi): number[][]
+{
+    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 interlink_pin_1 = chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
+    const interlink_pin_2 = chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_1)
+    const interlink_axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
+    const semi_pin_2 = chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_2)
+    const semi_axle_4 = chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_2)
+    return [
+        [1, 1, 0, 0, 0, 0],
+        [semi_axle_4, semi_pin_2, 0, 0, 0, 0],
+        [0, -1, 1, 1, 0, 0],
+        [0, -interlink_pin_2, interlink_axle_3, interlink_pin_1, 0, 0],
+        [0, 0, 0, -1, 1, 1],
+        [0, 0, 0, -tractor_pin, tractor_axle_2, tractor_axle_1]
+    ]
+}
+
+/**
+ * @param matrix - System matrix.
+ * @param center_of_mass - Interlink load CM.
+ * @returns Solution vector.
+ */
+function solve_interlink_system(matrix: number[][], center_of_mass: CenterOfMass): number[]
+{
+    const independent = [0, 0, center_of_mass.mass, center_of_mass.mass * center_of_mass.z, 0, 0]
+    return solve_linear_system(matrix, independent)
+}
+
+/**
+ * @param matrix - System matrix.
+ * @param center_of_mass - Semi load CM.
+ * @returns Solution vector.
+ */
+function solve_semi_system(matrix: number[][], center_of_mass: CenterOfMass): number[]
+{
+    const independent = [
+        center_of_mass.mass,
+        center_of_mass.mass * center_of_mass.z,
+        0,
+        0,
+        0,
+        0
+    ]
+    return solve_linear_system(matrix, independent)
+}
+
+/**
+ * @param transport - Parsed transport.
+ * @param loaded_weights - Raw axle loads before rebalance.
+ * @returns Rebalanced axle 3–4 loads.
+ */
+function linked_axle_weight_rebalance(transport: Transport, loaded_weights: number[]): number[]
+{
+    const first = transport.axle_manager.get_axle(2)
+    const second = transport.axle_manager.get_axle(3)
+    const first_cap = first.max_supported_weight - first.tare
+    const second_cap = second.max_supported_weight - second.tare
+    const total_cap = first_cap + second_cap
+    const total_load = loaded_weights[2] + loaded_weights[3]
+    loaded_weights[2] = (first_cap / total_cap) * total_load
+    loaded_weights[3] = (second_cap / total_cap) * total_load
+    return loaded_weights
+}

package/src/core/physics/models/chassi_forces.ts

@@ -0,0 +1,50 @@
+/**
+ * Pin and axle reaction forces from static equilibrium solution.
+ */
+export class ChassiForces
+{
+    private pin_forces: number[] = []
+    private axle_forces: number[] = []
+
+    /**
+     * @param pin_forces_list - Pin reaction forces.
+     */
+    add_pin_forces(pin_forces_list: number[]): void
+    {
+        this.pin_forces = pin_forces_list.map((value) => Number(value))
+    }
+
+    /**
+     * @param axle_forces_list - Axle reaction forces (cargo load per axle).
+     */
+    add_axle_forces(axle_forces_list: number[]): void
+    {
+        this.axle_forces = axle_forces_list.map((value) => Number(value))
+    }
+
+    /**
+     * @param axle_index - Zero-based axle index.
+     * @returns Force on axle.
+     */
+    get_force_on_axle(axle_index: number): number
+    {
+        return this.axle_forces[axle_index]
+    }
+
+    /**
+     * @param pin_index - Zero-based pin index.
+     * @returns Force on pin.
+     */
+    get_force_on_pin(pin_index: number): number
+    {
+        return this.pin_forces[pin_index]
+    }
+
+    /**
+     * @returns Axle index list.
+     */
+    list_axles_indexes(): number[]
+    {
+        return this.axle_forces.map((_force, index) => index)
+    }
+}