@jetta/axle-load-calculator 0.1.3

package/src/core/physics/transports/merged_containers.ts

@@ -0,0 +1,62 @@
+import type { Transport } from './transport.js'
+import { GroupedContainers } from './grouped_containers.js'
+
+/**
+ * Grouper-level merged container geometry.
+ */
+export class MergedContainers
+{
+    private all_grouped_containers = new Map<number, GroupedContainers>()
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport)
+    {
+        this.setup(transport)
+    }
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    setup(transport: Transport): void
+    {
+        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(): number[]
+    {
+        return [...this.all_grouped_containers.keys()]
+    }
+
+    /**
+     * @param grouper - Grouper id.
+     * @returns Grouped containers.
+     */
+    get_container_by_grouper_index(grouper: number): GroupedContainers
+    {
+        const grouped = this.all_grouped_containers.get(grouper)
+        if (!grouped)
+        {
+            throw new Error(`Grouper ${grouper} not found`)
+        }
+        return grouped
+    }
+}

package/src/core/physics/transports/tare/bitrem_axle_splitter.ts

@@ -0,0 +1,107 @@
+import { CHASSI_REFERENCE } from '../../../contracts/chassi_reference.js'
+import type { Transport } from '../transport.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
+{
+    readonly new_axle_3: AxleRecord
+    readonly new_axle_4: AxleRecord
+    readonly new_axle_5: AxleRecord
+    private readonly chassi: Chassi
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(private readonly 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(): Record<string, unknown>[]
+    {
+        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(): number
+    {
+        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(): number
+    {
+        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)
+    }
+
+    private generate_new_weight_attributes(): void
+    {
+        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
+        })
+    }
+
+    private generate_new_axle_distances(): void
+    {
+        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
+    }
+
+    private generate_new_axle_container_sequences(): void
+    {
+        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]
+    }
+
+    private generate_merged_axle_connection(): void
+    {
+        this.new_axle_4.is_connected_to = 2
+    }
+
+    private distance_from_axle_3_to_pin_2(): number
+    {
+        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: AxleRecord): AxleRecord
+{
+    return new AxleRecord(source.to_wire())
+}

package/src/core/physics/transports/tare/bitrem_axle_weight_split.ts

@@ -0,0 +1,55 @@
+import type { AxleRecord } from '../axle_record.js'
+
+export type BitremAxleSplit = {
+    mult: number
+    on_axle_3: boolean
+}
+
+/**
+ * @param first_proportion - First proportion from splitter.
+ * @param second_proportion - Second proportion from splitter.
+ * @returns Multiplier and target axle flag.
+ */
+export function compute_bitrem_axle_split(
+    first_proportion: number,
+    second_proportion: number
+): BitremAxleSplit
+{
+    const diff = first_proportion - second_proportion
+    if (diff > 0)
+    {
+        return { mult: 0.17 + 1 / (Math.abs(diff) + 2), on_axle_3: true }
+    }
+    if (diff < 0)
+    {
+        return { mult: -0.17 + 1 / (Math.abs(diff) + 2), on_axle_3: false }
+    }
+    return { mult: 0.5, on_axle_3: true }
+}
+
+export type BitremAxleSplitTarget = {
+    old: AxleRecord
+    axle_3: AxleRecord
+    axle_4: AxleRecord
+    split: BitremAxleSplit
+}
+
+/**
+ * @param target - Axles and split multipliers.
+ */
+export function apply_bitrem_axle_split(target: BitremAxleSplitTarget): void
+{
+    const { old, axle_3, axle_4, split } = target
+    if (split.on_axle_3)
+    {
+        axle_3.max_supported_weight = old.max_supported_weight * split.mult
+        axle_4.max_supported_weight = old.max_supported_weight - axle_3.max_supported_weight
+        axle_3.tare = old.tare * split.mult
+        axle_4.tare = old.tare - axle_3.tare
+        return
+    }
+    axle_4.max_supported_weight = old.max_supported_weight * split.mult
+    axle_3.max_supported_weight = old.max_supported_weight - axle_4.max_supported_weight
+    axle_4.tare = old.tare * split.mult
+    axle_3.tare = old.tare - axle_4.tare
+}

package/src/core/physics/transports/transport.ts

@@ -0,0 +1,137 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js'
+import { VEHICLE_TYPE, type VehicleTypeCode } from '../../contracts/vehicle_type.js'
+import { VEHICLE_VERSION } from '../../contracts/vehicle_version.js'
+import type { TransportRecord } from '../../contracts/transport_record.js'
+import { AxleManager } from './axle_manager.js'
+import { ContainerRecord } from './container_record.js'
+
+/**
+ * Parsed transport matching jettainterface.Transport behavior used by axleweight.
+ */
+export class Transport
+{
+    id: string
+    containers: Map<number, ContainerRecord>
+    amount: number
+    supported_weight: number
+    tare: number
+    axle_manager: AxleManager
+    first_axle_distance: number
+    vehicle_type: VehicleTypeCode
+    vehicle_version: number
+    suspension_type: string | null
+
+    /**
+     * @param transport_data - Raw transport dict.
+     */
+    constructor(transport_data: TransportRecord)
+    {
+        this.id = String(transport_data[WIRE_FLAGS.TRANSPORT_ID])
+        this.containers = read_containers(transport_data)
+        this.amount = Number(transport_data[WIRE_FLAGS.AMOUNT] ?? 0)
+        this.supported_weight = Number(transport_data[WIRE_FLAGS.SUPPORTED_WEIGHT])
+        this.tare = Number(transport_data.tara ?? 0)
+        this.axle_manager = new AxleManager(transport_data)
+        this.first_axle_distance = Number(
+            transport_data[WIRE_FLAGS.FIRST_AXLE_DISTANCE] ?? 0)
+        this.vehicle_type = read_vehicle_type(transport_data)
+        this.vehicle_version = read_vehicle_version(transport_data)
+        this.suspension_type = read_suspension_type(transport_data)
+    }
+
+    /**
+     * @returns Sorted container sequence indexes.
+     */
+    list_containers_sequence_indexes(): number[]
+    {
+        return [...this.containers.keys()].sort((left, right) => left - right)
+    }
+
+    /**
+     * @param sequence_index - Container sequence.
+     * @returns Container record.
+     */
+    get_container_by_sequence_index(sequence_index: number): ContainerRecord
+    {
+        const container = this.containers.get(sequence_index)
+        if (!container)
+        {
+            throw new Error(`Container sequence ${sequence_index} not found`)
+        }
+        return container
+    }
+}
+
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Containers keyed by sequence.
+ */
+function read_containers(transport_data: TransportRecord): Map<number, ContainerRecord>
+{
+    const map = new Map<number, ContainerRecord>()
+    const list = transport_data[WIRE_FLAGS.CONTAINERS]
+    if (!Array.isArray(list))
+    {
+        return map
+    }
+    for (const entry of list)
+    {
+        const container = new ContainerRecord(entry as Record<string, unknown>)
+        map.set(container.sequence_index, container)
+    }
+    return map
+}
+
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Vehicle type code.
+ */
+function read_vehicle_type(transport_data: TransportRecord): VehicleTypeCode
+{
+    const raw = transport_data[WIRE_FLAGS.VEHICLE_TYPE]
+    if (raw === undefined || raw === null)
+    {
+        return VEHICLE_TYPE.CONTAINER
+    }
+    return Number(raw) as VehicleTypeCode
+}
+
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Resolved vehicle version code.
+ */
+function read_vehicle_version(transport_data: TransportRecord): number
+{
+    const vehicle_type = read_vehicle_type(transport_data)
+    const version_code = Number(transport_data[WIRE_FLAGS.VEHICLE_VERSION] ?? 0)
+    if (vehicle_type === VEHICLE_TYPE.CAMINHAO && version_code === 4)
+    {
+        return VEHICLE_VERSION.CAMINHAO_BITRUCK
+    }
+    if (vehicle_type === VEHICLE_TYPE.SEMIREBOQUE)
+    {
+        if (version_code === 5 || version_code === 7)
+        {
+            return VEHICLE_VERSION.SEMIREBOQUE_QUAD
+        }
+        if (version_code === 6)
+        {
+            return VEHICLE_VERSION.SEMIREBOQUE_BITRUCK
+        }
+    }
+    return VEHICLE_VERSION.DEFAULT
+}
+
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Suspension wire string or null.
+ */
+function read_suspension_type(transport_data: TransportRecord): string | null
+{
+    const raw = transport_data[WIRE_FLAGS.SUSPENSION_TYPE]
+    if (raw === undefined || raw === null)
+    {
+        return null
+    }
+    return String(raw)
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+import { run_weight_by_axis_task } from './core/orchestration/weight_by_axis_task.js'
+
+/**
+ * Calculates loaded cargo weight per axle for each transport in the payload.
+ * Same contract as WeightByAxisTask.run() in ms-faixas-porcentuais.
+ * @param json_data - Raw JSON string with `{ envs, config? }`.
+ * @returns JSON string with `envs` and axle weights, or error payload.
+ */
+export function calculate_weight_on_axles_physics(json_data: string): string
+{
+    return run_weight_by_axis_task(json_data)
+}