@jetta/axle-load-calculator 0.1.3

package/src/core/physics/models/deflection/beam_deflection.ts

@@ -0,0 +1,105 @@
+import type { AllocatedItemManager } from '../../items/allocated_item_manager.js'
+import { DeflectionSupportManager } from './deflection_support_manager.js'
+import { IntegrationConstantCalculator } from './integration_constant_calculator.js'
+
+/**
+ * Cantilever beam deflection curve (DRAGON-76).
+ */
+export class BeamDeflection
+{
+    private readonly support_manager: DeflectionSupportManager
+    private readonly constant_1: number
+    private readonly constant_2: number
+    private readonly external_forces: [number, number][]
+
+    /**
+     * @param support_data - Support positions and forces.
+     * @param allocated_item_manager - Load items.
+     * @param external_forces - Optional external point loads.
+     */
+    constructor(
+        support_data: [number, number][],
+        private readonly allocated_item_manager: AllocatedItemManager,
+        external_forces: [number, number][] = []
+    )
+    {
+        this.support_manager = new DeflectionSupportManager(support_data)
+        this.external_forces = this.support_manager
+            .add_structural_offset_to_external_forces(external_forces)
+        const integration = new IntegrationConstantCalculator(
+            this.support_manager,
+            this.support_manager.structural_offset)
+        ;[this.constant_1, this.constant_2] = integration.calculate_integration_constants(
+            allocated_item_manager)
+    }
+
+    /**
+     * @param beam_length - Container beam length.
+     * @param number_of_curve_samples - Sample count.
+     * @returns Deflection values along beam.
+     */
+    generate_curve_values(beam_length: number, number_of_curve_samples: number): number[]
+    {
+        const length = beam_length + this.support_manager.structural_offset
+        const y_values: number[] = []
+        for (let index = 0; index < number_of_curve_samples; index++)
+        {
+            const x = (length * index) / (number_of_curve_samples - 1)
+            y_values.push(this.evaluate_at_x(x))
+        }
+        return y_values
+    }
+
+    private evaluate_at_x(x: number): number
+    {
+        let value = this.constant_1 * x + this.constant_2
+        value += this.item_cubic_contribution(x)
+        value += this.support_cubic_contribution(x)
+        value += this.external_cubic_contribution(x)
+        return value
+    }
+
+    private item_cubic_contribution(x: number): number
+    {
+        let value = 0
+        for (const item_index of this.allocated_item_manager.list_item_indexes())
+        {
+            const item = this.allocated_item_manager.get_item(item_index)
+            const position = item.zi + item.length / 2 + this.support_manager.structural_offset
+            const displacement = x - position
+            if (displacement > 0)
+            {
+                value += (-item.weight / 6) * displacement ** 3
+            }
+        }
+        return value
+    }
+
+    private support_cubic_contribution(x: number): number
+    {
+        let value = 0
+        for (const support_index of this.support_manager.list_support_indexes())
+        {
+            const displacement = x - this.support_manager.get_position(support_index)
+            if (displacement > 0)
+            {
+                value += (this.support_manager.get_force(support_index) / 6) * displacement ** 3
+            }
+        }
+        return value
+    }
+
+    private external_cubic_contribution(x: number): number
+    {
+        let value = 0
+        for (const [position, force] of this.external_forces)
+        {
+            const displacement = x - position
+            if (displacement > 0)
+            {
+                value += (force / 6) * displacement ** 3
+            }
+        }
+        return value
+    }
+}

package/src/core/physics/models/deflection/bitrem_deflection.ts

@@ -0,0 +1,68 @@
+import { CHASSI_REFERENCE } from '../../../contracts/chassi_reference.js'
+import type { BitremModel } from '../bitrem_model.js'
+import type { ChassiForces } from '../chassi_forces.js'
+import type { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
+import { BeamDeflection } from './beam_deflection.js'
+import { calculate_deflection_indicator } from './deflection_tools.js'
+
+/**
+ * Bitrem interlink + semi beam deflection (sum of two indicators).
+ */
+export class BitremDeflection
+{
+    /**
+     * @param bitrem_model - Axle weight model.
+     * @param number_of_curve_samples - Curve sample count.
+     */
+    constructor(
+        private readonly bitrem_model: BitremModel,
+        private readonly number_of_curve_samples: number
+    )
+    {}
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Combined deflection indicator.
+     */
+    calculate_deflection(multi_items: MultiContainerAllocatedItems): number
+    {
+        const forces = this.bitrem_model.calculate_chassi_forces(multi_items)
+        const interlink = this.interlink_curve(multi_items, forces)
+        const semi = this.semitrailer_curve(multi_items, forces)
+        return calculate_deflection_indicator(interlink)
+            + calculate_deflection_indicator(semi)
+    }
+
+    private interlink_curve(multi_items: MultiContainerAllocatedItems, forces: ChassiForces): number[]
+    {
+        const pin_1 = this.bitrem_model.chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
+        const axle_3 = this.bitrem_model.chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
+        const support: [number, number][] = [
+            [pin_1, forces.get_force_on_pin(0)],
+            [axle_3, forces.get_force_on_axle(2) + forces.get_force_on_axle(3)]
+        ]
+        const pin_2 = this.bitrem_model.chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_1)
+        const external: [number, number][] = [[pin_2, -forces.get_force_on_pin(1)]]
+        const items = multi_items.get_allocated_items_by_grouper_index(1)
+        const pin_2_pos = pin_2
+        const length = Math.max(pin_2_pos, axle_3)
+        return new BeamDeflection(support, items, external).generate_curve_values(
+            length,
+            this.number_of_curve_samples)
+    }
+
+    private semitrailer_curve(multi_items: MultiContainerAllocatedItems, forces: ChassiForces): number[]
+    {
+        const pin_2 = this.bitrem_model.chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_2)
+        const axle_4 = this.bitrem_model.chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_2)
+        const support: [number, number][] = [
+            [pin_2, forces.get_force_on_pin(1)],
+            [axle_4, forces.get_force_on_axle(4)]
+        ]
+        const items = multi_items.get_allocated_items_by_grouper_index(2)
+        const length = this.bitrem_model.chassi.get_grouper_end(2, CHASSI_REFERENCE.GROUPER_2)
+        return new BeamDeflection(support, items).generate_curve_values(
+            length,
+            this.number_of_curve_samples)
+    }
+}

package/src/core/physics/models/deflection/create_deflection_delegate.ts

@@ -0,0 +1,46 @@
+import { VEHICLE_TYPE, type VehicleTypeCode } from '../../../contracts/vehicle_type.js'
+import type { Transport } from '../../transports/transport.js'
+import { SemiReboqueModel } from '../semi_reboque_model.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 { SemiReboqueDeflection } from './semi_reboque_deflection.js'
+import { BitremDeflection } from './bitrem_deflection.js'
+import { RodotremDeflection } from './rodotrem_deflection.js'
+import { VanderleiaDeflection } from './vanderleia_deflection.js'
+import { SimpleTruckDeflection } from './simple_truck_deflection.js'
+
+type DeflectionDelegate = {
+    calculate_deflection: (multi: import('../../items/multi_container_allocated_items.js').MultiContainerAllocatedItems) => number
+}
+
+type DelegateFactory = (transport: Transport, samples: number) => DeflectionDelegate
+
+const DELEGATE_BY_TYPE: Partial<Record<VehicleTypeCode, DelegateFactory>> = {
+    [VEHICLE_TYPE.SEMIREBOQUE]: (t, n) => new SemiReboqueDeflection(new SemiReboqueModel(t), n),
+    [VEHICLE_TYPE.REBAIXADO]: (t, n) => new SemiReboqueDeflection(new SemiReboqueModel(t), n),
+    [VEHICLE_TYPE.BITREM]: (t, n) => new BitremDeflection(new BitremModel(t), n),
+    [VEHICLE_TYPE.RODOTREM]: (t, n) => new RodotremDeflection(new RodotremModel(t), n),
+    [VEHICLE_TYPE.VANDERLEIA]: (t, n) => new VanderleiaDeflection(new VanderleiaModel(t), n),
+    [VEHICLE_TYPE.CAMINHAO]: (t, n) => new SimpleTruckDeflection(new SimpleTruckModel(t), n),
+    [VEHICLE_TYPE.VUC]: (t, n) => new SimpleTruckDeflection(new SimpleTruckModel(t), n)
+}
+
+/**
+ * @param transport - Parsed transport.
+ * @param number_of_curve_samples - Sample count for deflection curve.
+ * @returns Vehicle-specific deflection delegate.
+ */
+export function create_deflection_delegate(
+    transport: Transport,
+    number_of_curve_samples: number
+): DeflectionDelegate
+{
+    const factory = DELEGATE_BY_TYPE[transport.vehicle_type]
+    if (!factory)
+    {
+        throw new Error('Deflection model of this vehicle is not implemented yet')
+    }
+    return factory(transport, number_of_curve_samples)
+}

package/src/core/physics/models/deflection/deflection_model.ts

@@ -0,0 +1,33 @@
+import type { Transport } from '../../transports/transport.js'
+import type { AllocatedItemManager } from '../../items/allocated_item_manager.js'
+import { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
+import { create_deflection_delegate } from './create_deflection_delegate.js'
+
+type DeflectionDelegate = ReturnType<typeof create_deflection_delegate>
+
+/**
+ * Vehicle-specific beam deflection facade (DRAGON-76).
+ */
+export class DeflectionModel
+{
+    private readonly delegate: DeflectionDelegate
+
+    /**
+     * @param transport - Parsed transport.
+     * @param number_of_curve_samples - Curve sample count.
+     */
+    constructor(transport: Transport, number_of_curve_samples: number)
+    {
+        this.delegate = create_deflection_delegate(transport, number_of_curve_samples)
+    }
+
+    /**
+     * @param allocated_by_sequence - Items per container sequence.
+     * @returns Deflection indicator.
+     */
+    calculate_deflection(allocated_by_sequence: Record<number, AllocatedItemManager>): number
+    {
+        const multi = new MultiContainerAllocatedItems(allocated_by_sequence)
+        return this.delegate.calculate_deflection(multi)
+    }
+}

package/src/core/physics/models/deflection/deflection_support_manager.ts

@@ -0,0 +1,56 @@
+/**
+ * Ordered support positions and reaction forces for beam deflection.
+ */
+export class DeflectionSupportManager
+{
+    structural_offset = 0
+    private readonly support_data: [number, number][]
+
+    /**
+     * @param support_data - [[position, force], ...] sorted by position.
+     */
+    constructor(support_data: [number, number][])
+    {
+        this.support_data = support_data.map((row) => [...row] as [number, number])
+        this.evaluate_structural_offset()
+    }
+
+    list_support_indexes(): number[]
+    {
+        return this.support_data.map((_row, index) => index)
+    }
+
+    get_position(support_index: number): number
+    {
+        return this.support_data[support_index][0]
+    }
+
+    get_force(support_index: number): number
+    {
+        return this.support_data[support_index][1]
+    }
+
+    /**
+     * @param external_forces - Optional extra point loads.
+     * @returns Forces with structural offset applied to positions.
+     */
+    add_structural_offset_to_external_forces(
+        external_forces: [number, number][]
+    ): [number, number][]
+    {
+        return external_forces.map(([position, force]) => [
+            position + this.structural_offset,
+            force
+        ])
+    }
+
+    private evaluate_structural_offset(): void
+    {
+        const leftmost = Math.min(...this.support_data.map((row) => row[0]))
+        this.structural_offset = leftmost < 0 ? -leftmost : 0
+        for (const row of this.support_data)
+        {
+            row[0] += this.structural_offset
+        }
+    }
+}

package/src/core/physics/models/deflection/deflection_tools.ts

@@ -0,0 +1,11 @@
+/**
+ * @param curve_values - Beam deflection samples.
+ * @returns Scalar deflection indicator.
+ */
+export function calculate_deflection_indicator(curve_values: number[]): number
+{
+    const mean = curve_values.reduce((sum, value) => sum + value, 0) / curve_values.length
+    const variance = curve_values.reduce((sum, value) => sum + (value - mean) ** 2, 0)
+        / curve_values.length
+    return Math.sqrt(variance) + Math.abs(mean)
+}

package/src/core/physics/models/deflection/integration_constant_calculator.ts

@@ -0,0 +1,62 @@
+import type { AllocatedItemManager } from '../../items/allocated_item_manager.js'
+import { solve_linear_system } from '../../../math/gaussian_elimination.js'
+import type { DeflectionSupportManager } from './deflection_support_manager.js'
+
+/**
+ * Integration constants for beam elastic curve (two supports).
+ */
+export class IntegrationConstantCalculator
+{
+    private readonly b_constants: number[]
+
+    /**
+     * @param deflection_supports - Support manager.
+     * @param structural_offset - Beam offset.
+     */
+    constructor(
+        private readonly deflection_supports: DeflectionSupportManager,
+        private readonly structural_offset: number
+    )
+    {
+        this.b_constants = deflection_supports.list_support_indexes().map(() => 0)
+    }
+
+    /**
+     * @param allocated_items - Load items.
+     * @returns Integration constants C1 and C2.
+     */
+    calculate_integration_constants(
+        allocated_items: AllocatedItemManager
+    ): [number, number]
+    {
+        this.calculate_b_constants(allocated_items)
+        const a_matrix = this.deflection_supports.list_support_indexes().map((index) => [
+            this.deflection_supports.get_position(index),
+            1
+        ])
+        const displacement = this.deflection_supports.get_position(1)
+            - this.deflection_supports.get_position(0)
+        const second_term = (-this.deflection_supports.get_force(0) / 6)
+            * displacement * displacement * displacement
+        const solution = solve_linear_system(a_matrix, [this.b_constants[0], this.b_constants[1] + second_term])
+        return [solution[0], solution[1]]
+    }
+
+    private calculate_b_constants(allocated_items: AllocatedItemManager): void
+    {
+        for (const item_index of allocated_items.list_item_indexes())
+        {
+            const item = allocated_items.get_item(item_index)
+            const center = item.zi + item.length / 2 + this.structural_offset
+            const factor = item.weight / 6
+            for (const support_index of this.deflection_supports.list_support_indexes())
+            {
+                const displacement = this.deflection_supports.get_position(support_index) - center
+                if (displacement > 0)
+                {
+                    this.b_constants[support_index] += factor * displacement ** 3
+                }
+            }
+        }
+    }
+}

package/src/core/physics/models/deflection/rodotrem_deflection.ts

@@ -0,0 +1,57 @@
+import { CHASSI_REFERENCE } from '../../../contracts/chassi_reference.js'
+import type { RodotremModel } from '../rodotrem_model.js'
+import type { ChassiForces } from '../chassi_forces.js'
+import type { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
+import { BeamDeflection } from './beam_deflection.js'
+import { calculate_deflection_indicator } from './deflection_tools.js'
+
+/**
+ * Rodotrem semi + simple trailer deflection indicator sum.
+ */
+export class RodotremDeflection
+{
+    /**
+     * @param rodotrem_model - Axle weight model.
+     * @param number_of_curve_samples - Curve sample count.
+     */
+    constructor(
+        private readonly rodotrem_model: RodotremModel,
+        private readonly number_of_curve_samples: number
+    )
+    {}
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Combined deflection indicator.
+     */
+    calculate_deflection(multi_items: MultiContainerAllocatedItems): number
+    {
+        const forces = this.rodotrem_model.calculate_chassi_forces(multi_items)
+        const semi = this.semi_curve(multi_items, forces)
+        const simple = this.simple_curve(multi_items, forces)
+        return calculate_deflection_indicator(semi) + calculate_deflection_indicator(simple)
+    }
+
+    private semi_curve(multi_items: MultiContainerAllocatedItems, forces: ChassiForces): number[]
+    {
+        const pin = this.rodotrem_model.chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
+        const axle_3 = this.rodotrem_model.chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
+        const support: [number, number][] = [[pin, forces.get_force_on_pin(0)], [axle_3, forces.get_force_on_axle(2)]]
+        const items = multi_items.get_allocated_items_by_grouper_index(1)
+        const length = this.rodotrem_model.chassi.get_grouper_end(1, CHASSI_REFERENCE.GROUPER_1)
+        return new BeamDeflection(support, items).generate_curve_values(length, this.number_of_curve_samples)
+    }
+
+    private simple_curve(multi_items: MultiContainerAllocatedItems, forces: ChassiForces): number[]
+    {
+        const axle_4 = this.rodotrem_model.chassi.get_axle_position(3, CHASSI_REFERENCE.GROUPER_2)
+        const axle_5 = this.rodotrem_model.chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_2)
+        const support: [number, number][] = [
+            [axle_4, forces.get_force_on_axle(3)],
+            [axle_5, forces.get_force_on_axle(4)]
+        ]
+        const items = multi_items.get_allocated_items_by_grouper_index(2)
+        const length = this.rodotrem_model.chassi.get_grouper_end(2, CHASSI_REFERENCE.GROUPER_2)
+        return new BeamDeflection(support, items).generate_curve_values(length, this.number_of_curve_samples)
+    }
+}

package/src/core/physics/models/deflection/semi_reboque_deflection.ts

@@ -0,0 +1,40 @@
+import type { SemiReboqueModel } from '../semi_reboque_model.js'
+import type { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
+import { BeamDeflection } from './beam_deflection.js'
+import { calculate_deflection_indicator } from './deflection_tools.js'
+
+/**
+ * Semi-reboque beam deflection indicator.
+ */
+export class SemiReboqueDeflection
+{
+    /**
+     * @param semi_reboque_model - Axle weight model.
+     * @param number_of_curve_samples - Curve sample count.
+     */
+    constructor(
+        private readonly semi_reboque_model: SemiReboqueModel,
+        private readonly number_of_curve_samples: number
+    )
+    {}
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Deflection indicator scalar.
+     */
+    calculate_deflection(multi_items: MultiContainerAllocatedItems): number
+    {
+        const curve = this.calculate_deflection_curve(multi_items)
+        return calculate_deflection_indicator(curve)
+    }
+
+    private calculate_deflection_curve(multi_items: MultiContainerAllocatedItems): number[]
+    {
+        const support = this.semi_reboque_model.calculate_support_data(multi_items)
+        const allocated = multi_items.get_allocated_items_by_grouper_index(1)
+        const beam = new BeamDeflection(support, allocated)
+        return beam.generate_curve_values(
+            this.semi_reboque_model.calculate_container_length(),
+            this.number_of_curve_samples)
+    }
+}

package/src/core/physics/models/deflection/simple_truck_deflection.ts

@@ -0,0 +1,35 @@
+import type { SimpleTruckModel } from '../simple_truck_model.js'
+import type { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
+import { BeamDeflection } from './beam_deflection.js'
+import { calculate_deflection_indicator } from './deflection_tools.js'
+
+/**
+ * Caminhão beam deflection indicator.
+ */
+export class SimpleTruckDeflection
+{
+    /**
+     * @param simple_truck_model - Axle weight model.
+     * @param number_of_curve_samples - Curve sample count.
+     */
+    constructor(
+        private readonly simple_truck_model: SimpleTruckModel,
+        private readonly number_of_curve_samples: number
+    )
+    {}
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Deflection indicator scalar.
+     */
+    calculate_deflection(multi_items: MultiContainerAllocatedItems): number
+    {
+        const support = this.simple_truck_model.calculate_support_data(multi_items)
+        const allocated = multi_items.get_allocated_items_by_grouper_index(1)
+        const beam = new BeamDeflection(support, allocated)
+        const curve = beam.generate_curve_values(
+            this.simple_truck_model.calculate_container_length(),
+            this.number_of_curve_samples)
+        return calculate_deflection_indicator(curve)
+    }
+}

package/src/core/physics/models/deflection/vanderleia_deflection.ts

@@ -0,0 +1,48 @@
+import { CHASSI_REFERENCE } from '../../../contracts/chassi_reference.js'
+import type { VanderleiaModel } from '../vanderleia_model.js'
+import type { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
+import { BeamDeflection } from './beam_deflection.js'
+import { calculate_deflection_indicator } from './deflection_tools.js'
+
+/**
+ * Vanderleia trailer beam deflection indicator.
+ */
+export class VanderleiaDeflection
+{
+    /**
+     * @param vanderleia_model - Axle weight model.
+     * @param number_of_curve_samples - Curve sample count.
+     */
+    constructor(
+        private readonly vanderleia_model: VanderleiaModel,
+        private readonly number_of_curve_samples: number
+    )
+    {}
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Deflection indicator scalar.
+     */
+    calculate_deflection(multi_items: MultiContainerAllocatedItems): number
+    {
+        const support = this.generate_support_data(multi_items)
+        const allocated = multi_items.get_allocated_items_by_grouper_index(1)
+        const beam = new BeamDeflection(support, allocated)
+        const length = this.vanderleia_model.chassi.get_grouper_end(1, CHASSI_REFERENCE.GROUPER_1)
+        const curve = beam.generate_curve_values(length, this.number_of_curve_samples)
+        return calculate_deflection_indicator(curve)
+    }
+
+    private generate_support_data(multi_items: MultiContainerAllocatedItems): [number, number][]
+    {
+        const forces = this.vanderleia_model.calculate_chassi_forces(multi_items)
+        const trailer_force = forces.get_force_on_axle(2)
+            + forces.get_force_on_axle(3)
+            + forces.get_force_on_axle(4)
+        const pin = this.vanderleia_model.chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
+        const axle_3 = this.vanderleia_model.chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
+        const axle_5 = this.vanderleia_model.chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_1)
+        const mean_axle = 0.5 * (axle_5 - axle_3) + axle_3
+        return [[pin, forces.get_force_on_pin(0)], [mean_axle, trailer_force]]
+    }
+}

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

@@ -0,0 +1,51 @@
+import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js'
+import type { Transport } from '../transports/transport.js'
+import { scale_tare } from './old_tare_scale.js'
+import { semireboque_tare } from './old_tare_semireboque.js'
+import { vanderleia_tare } from './old_tare_vanderleia.js'
+import { truck_tare } from './old_tare_truck.js'
+
+/**
+ * Legacy tare split by vehicle type (Python OldTareModel).
+ */
+export class OldTareModel
+{
+    /**
+     * @param transport - Parsed transport.
+     * @returns Tare per axle.
+     */
+    calculate(transport: Transport): number[]
+    {
+        return old_tare_by_vehicle(transport)
+    }
+}
+
+/**
+ * @param transport - Parsed transport.
+ * @returns Tare per axle for vehicle type.
+ */
+export function old_tare_by_vehicle(transport: Transport): number[]
+{
+    const type = transport.vehicle_type
+    if (type === VEHICLE_TYPE.BITREM)
+    {
+        return scale_tare(transport.tare, [0.23, 0.255, 0.285, 0.23])
+    }
+    if (type === VEHICLE_TYPE.RODOTREM)
+    {
+        return scale_tare(transport.tare, [0.19, 0.28, 0.21, 0.16, 0.16])
+    }
+    if (type === VEHICLE_TYPE.SEMIREBOQUE || type === VEHICLE_TYPE.REBAIXADO)
+    {
+        return semireboque_tare(transport)
+    }
+    if (type === VEHICLE_TYPE.VANDERLEIA)
+    {
+        return vanderleia_tare(transport)
+    }
+    if (type === VEHICLE_TYPE.CAMINHAO || type === VEHICLE_TYPE.VUC)
+    {
+        return truck_tare(transport)
+    }
+    return []
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @param tare - Total vehicle tare.
+ * @param multipliers - Per-axle factors.
+ * @returns Scaled tare list.
+ */
+export function scale_tare(tare: number, multipliers: number[]): number[]
+{
+    return multipliers.map((factor) => tare * factor)
+}