@jetta/axle-load-calculator 0.1.3 → 0.3.1

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

@@ -1,62 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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)
-}