@jetta/axle-load-calculator 0.1.3

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

@@ -0,0 +1,45 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js'
+import { AxleRecord } from './axle_record.js'
+import type { TransportRecord } from '../../contracts/transport_record.js'
+
+/**
+ * Ordered axle list for a transport.
+ */
+export class AxleManager
+{
+    axles: AxleRecord[]
+
+    /**
+     * @param transport_data - Raw transport JSON.
+     */
+    constructor(transport_data: TransportRecord)
+    {
+        const axles_data = transport_data[WIRE_FLAGS.AXLE_LIST]
+        this.axles = []
+        if (!Array.isArray(axles_data))
+        {
+            return
+        }
+        for (const axle_data of axles_data)
+        {
+            this.axles.push(new AxleRecord(axle_data as Record<string, unknown>))
+        }
+    }
+
+    /**
+     * @returns Axle index list [0..n-1].
+     */
+    list_axles_indexes(): number[]
+    {
+        return this.axles.map((_axle, index) => index)
+    }
+
+    /**
+     * @param axle_index - Zero-based axle index.
+     * @returns Axle at index.
+     */
+    get_axle(axle_index: number): AxleRecord
+    {
+        return this.axles[axle_index]
+    }
+}

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

@@ -0,0 +1,68 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js'
+
+/**
+ * Single axle geometry and capacity from wire JSON.
+ */
+export class AxleRecord
+{
+    distance_from_previous_axle: number
+    max_supported_weight: number
+    sequence_index: number
+    dnit_weight_limit: number
+    tare: number
+    loaded_weight: number
+    is_connected_to: number | null
+
+    /**
+     * @param axle_data - Raw axle object from transport JSON.
+     */
+    constructor(axle_data: Record<string, unknown>)
+    {
+        this.distance_from_previous_axle = read_number(axle_data, WIRE_FLAGS.DISTANCE_FROM_ORIGIN)
+        this.max_supported_weight = read_number(axle_data, WIRE_FLAGS.MAX_SUPPORTED_WEIGHT)
+        this.sequence_index = read_number(axle_data, WIRE_FLAGS.SEQUENCE_CONTAINER)
+        this.dnit_weight_limit = read_number(axle_data, WIRE_FLAGS.DNIT_WEIGHT)
+        this.tare = read_number(axle_data, WIRE_FLAGS.TARE)
+        this.loaded_weight = read_optional_number(axle_data, 'pesoCarregado') ?? 0
+        this.is_connected_to = read_optional_number(axle_data, 'mergeOnAxleIndex')
+    }
+
+    /**
+     * @returns Shallow copy of axle wire fields.
+     */
+    to_wire(): Record<string, unknown>
+    {
+        return {
+            distanciaOrigem: this.distance_from_previous_axle,
+            pesoMaxSuportado: this.max_supported_weight,
+            pesoDnit: this.dnit_weight_limit,
+            tara: this.tare,
+            sequenciaContainer: this.sequence_index,
+            mergeOnAxleIndex: this.is_connected_to
+        }
+    }
+}
+
+/**
+ * @param data - Source object.
+ * @param key - Field key.
+ * @returns Parsed number.
+ */
+function read_number(data: Record<string, unknown>, key: string): number
+{
+    return Number(data[key])
+}
+
+/**
+ * @param data - Source object.
+ * @param key - Field key.
+ * @returns Parsed number or null.
+ */
+function read_optional_number(data: Record<string, unknown>, key: string): number | null
+{
+    if (data[key] === undefined || data[key] === null)
+    {
+        return null
+    }
+    return Number(data[key])
+}

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

@@ -0,0 +1,130 @@
+import { CHASSI_REFERENCE, type ChassiReference } from '../../contracts/chassi_reference.js'
+import type { Transport } from './transport.js'
+import { MergedContainers } from './merged_containers.js'
+
+/**
+ * Chassis geometry reference frame for equilibrium models.
+ */
+export class Chassi
+{
+    private first_axle_distance: number
+    private axle_positions: number[] = []
+    private pin_positions: number[] = []
+    private grouper_start: number[] = []
+    private grouper_end: number[] = []
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport)
+    {
+        this.first_axle_distance = transport.first_axle_distance
+        const merged = new MergedContainers(transport)
+        this.calculate_groupers_positions(merged)
+        this.calculate_axles_positions(transport)
+        this.calculate_pins_positions(merged)
+    }
+
+    /**
+     * @param axle_index - Zero-based axle index.
+     * @param chassi_reference - Reference frame.
+     * @returns Axle position.
+     */
+    get_axle_position(axle_index: number, chassi_reference: ChassiReference): number
+    {
+        return this.axle_positions[axle_index]
+            + this.chassi_reference_change_value(chassi_reference)
+    }
+
+    /**
+     * @param pin_index - Zero-based pin index.
+     * @param chassi_reference - Reference frame.
+     * @returns Pin position.
+     */
+    get_pin_position(pin_index: number, chassi_reference: ChassiReference): number
+    {
+        return this.pin_positions[pin_index]
+            + this.chassi_reference_change_value(chassi_reference)
+    }
+
+    /**
+     * @param grouper_index - Grouper id (1-based).
+     * @param chassi_reference - Reference frame.
+     * @returns Grouper end position.
+     */
+    get_grouper_end(grouper_index: number, chassi_reference: ChassiReference): number
+    {
+        return this.grouper_end[grouper_index - 1]
+            + this.chassi_reference_change_value(chassi_reference)
+    }
+
+    /**
+     * @param chassi_reference - Reference frame.
+     * @returns Offset for reference change.
+     */
+    private chassi_reference_change_value(chassi_reference: ChassiReference): number
+    {
+        if (chassi_reference === CHASSI_REFERENCE.GROUPER_1)
+        {
+            return 0
+        }
+        if (chassi_reference === CHASSI_REFERENCE.GROUPER_2)
+        {
+            return -this.grouper_start[1]
+        }
+        return this.first_axle_distance
+    }
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    private calculate_axles_positions(transport: Transport): void
+    {
+        this.axle_positions = [-this.first_axle_distance]
+        const indexes = transport.axle_manager.list_axles_indexes()
+        for (let index = 1; index < indexes.length; index++)
+        {
+            const axle = transport.axle_manager.get_axle(index)
+            const previous = this.axle_positions[index - 1]
+            this.axle_positions.push(previous + axle.distance_from_previous_axle)
+        }
+    }
+
+    /**
+     * @param merged_containers - Merged grouper geometry.
+     */
+    private calculate_groupers_positions(merged_containers: MergedContainers): void
+    {
+        const first = merged_containers.get_container_by_grouper_index(1)
+        this.grouper_start = [0]
+        this.grouper_end = [first.length]
+        if (merged_containers.list_grouper_indexes().length <= 1)
+        {
+            return
+        }
+        const second = merged_containers.get_container_by_grouper_index(2)
+        const second_start = this.grouper_end[0] + (second.container_distance_ahead ?? 0)
+        this.grouper_start.push(second_start)
+        this.grouper_end.push(second_start + second.length)
+    }
+
+    /**
+     * @param merged_containers - Merged grouper geometry.
+     */
+    private calculate_pins_positions(merged_containers: MergedContainers): void
+    {
+        const first = merged_containers.get_container_by_grouper_index(1)
+        this.pin_positions = [first.main_pin_distance ?? 0]
+        if (merged_containers.list_grouper_indexes().length <= 1)
+        {
+            return
+        }
+        const second = merged_containers.get_container_by_grouper_index(2)
+        if (second.main_pin_distance === null)
+        {
+            return
+        }
+        const second_pin = this.grouper_start[1] + second.main_pin_distance
+        this.pin_positions.push(second_pin)
+    }
+}

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

@@ -0,0 +1,58 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js'
+
+/**
+ * Container segment from wire JSON.
+ */
+export class ContainerRecord
+{
+    length: number
+    width: number
+    height: number
+    sequence_index: number
+    main_pin_distance: number | null
+    container_distance_ahead: number | null
+    grouper: number
+    max_supported_weight: number
+    tare: number
+    supported_weight: number
+    raw: Record<string, unknown>
+
+    /**
+     * @param data - Raw container object.
+     */
+    constructor(data: Record<string, unknown>)
+    {
+        this.length = Number(data[WIRE_FLAGS.LENGTH])
+        this.width = Number(data[WIRE_FLAGS.WIDTH])
+        this.height = Number(data[WIRE_FLAGS.HEIGHT])
+        this.sequence_index = Number(data[WIRE_FLAGS.SEQUENCE])
+        this.main_pin_distance = read_optional(data[WIRE_FLAGS.MAIN_PIN_DISTANCE])
+        this.container_distance_ahead = read_optional(data[WIRE_FLAGS.CONTAINER_DISTANCE_AHEAD])
+        this.grouper = Number(data[WIRE_FLAGS.GROUPER])
+        this.max_supported_weight = Number(data[WIRE_FLAGS.MAX_SUPPORTED_WEIGHT] ?? 0)
+        this.tare = Number(data[WIRE_FLAGS.TARE] ?? 0)
+        this.supported_weight = this.max_supported_weight - this.tare
+        this.raw = { ...data }
+    }
+
+    /**
+     * @returns Container volume (length × width × height).
+     */
+    volume(): number
+    {
+        return this.length * this.width * this.height
+    }
+}
+
+/**
+ * @param value - Wire field value.
+ * @returns Number or null.
+ */
+function read_optional(value: unknown): number | null
+{
+    if (value === undefined || value === null)
+    {
+        return null
+    }
+    return Number(value)
+}

package/src/core/physics/transports/containerweight/container_max_weight_calculator.ts

@@ -0,0 +1,59 @@
+import type { GroupedContainers } from '../grouped_containers.js'
+
+type MaxWeightInput = {
+    sequence_index: number
+    percentage_of_weight: number
+    total_max_supported_weight: number
+    tare: number
+}
+
+const MAX_NECK_SUPPORTED = 6000
+
+/**
+ * Applies neck weight cap and redistributes excess to second container.
+ */
+export class ContainerMaxWeightCalculator
+{
+    private neck_weight_reduction = 0
+
+    /**
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(private readonly grouped_containers: GroupedContainers)
+    {}
+
+    /**
+     * @param input - Sequence, share, capacity, and tare.
+     * @returns Max supported weight for container.
+     */
+    calculate(input: MaxWeightInput): number
+    {
+        const max_supported = input.total_max_supported_weight * input.percentage_of_weight
+        if (this.is_neck(input.sequence_index))
+        {
+            const supported = max_supported - input.tare
+            if (supported > MAX_NECK_SUPPORTED)
+            {
+                this.neck_weight_reduction = supported - MAX_NECK_SUPPORTED
+                return input.tare + MAX_NECK_SUPPORTED
+            }
+        }
+        else if (this.is_second_container(input.sequence_index))
+        {
+            return max_supported + this.neck_weight_reduction
+        }
+        return max_supported
+    }
+
+    private is_neck(sequence_index: number): boolean
+    {
+        const list = this.grouped_containers.list_containers_sequence_indexes()
+        return list.length >= 2 && list[0] === sequence_index
+    }
+
+    private is_second_container(sequence_index: number): boolean
+    {
+        const list = this.grouped_containers.list_containers_sequence_indexes()
+        return list.length >= 2 && list[1] === sequence_index
+    }
+}

package/src/core/physics/transports/containerweight/container_tare_calculator.ts

@@ -0,0 +1,76 @@
+import type { Transport } from '../transport.js'
+import type { GroupedContainers } from '../grouped_containers.js'
+
+const NECK_SEQUENCE = 1
+
+/**
+ * Distributes grouper tare across containers (neck gets axle-1 share).
+ */
+export class ContainerTareCalculator
+{
+    private revised_tare_percentage = 0
+    private first_neck_tare = 0
+
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(
+        private readonly transport: Transport,
+        private readonly grouped_containers: GroupedContainers
+    )
+    {}
+
+    /**
+     * @param sequence_index - Container sequence.
+     * @param percentage_of_weight - Lateral area share.
+     * @param total_tare - Grouper total tare.
+     * @returns Container tare.
+     */
+    calculate(
+        sequence_index: number,
+        percentage_of_weight: number,
+        total_tare: number
+    ): number
+    {
+        if (this.is_first_neck(sequence_index))
+        {
+            this.calculate_tare_of_first_neck(percentage_of_weight)
+            this.tare_percentage_review(percentage_of_weight, total_tare)
+            return this.first_neck_tare
+        }
+        return (percentage_of_weight + this.revised_tare_percentage) * total_tare
+    }
+
+    private is_first_neck(sequence_index: number): boolean
+    {
+        return this.grouped_containers.list_containers_sequence_indexes().length >= 2
+            && sequence_index === NECK_SEQUENCE
+    }
+
+    private calculate_tare_of_first_neck(percentage_of_weight: number): void
+    {
+        const neck = this.grouped_containers.get_container_by_sequence_index(NECK_SEQUENCE)
+        const axle1 = this.axle1_on_neck_tare_contribution(neck.length)
+        const remaining = percentage_of_weight * (
+            this.transport.axle_manager.get_axle(1).tare
+            + this.transport.axle_manager.get_axle(2).tare)
+        this.first_neck_tare = axle1 + remaining
+    }
+
+    private tare_percentage_review(percentage_of_weight: number, total_tare: number): void
+    {
+        const tare = percentage_of_weight * total_tare
+        const change = (this.first_neck_tare - tare) / total_tare
+        const count = this.grouped_containers.list_containers_sequence_indexes().length
+        this.revised_tare_percentage = -change / (count - 1)
+    }
+
+    private axle1_on_neck_tare_contribution(neck_length: number): number
+    {
+        const end_container = this.transport.first_axle_distance + neck_length
+        const end_grouper = this.transport.first_axle_distance + this.grouped_containers.length
+        const share = end_container / end_grouper
+        return share * this.transport.axle_manager.get_axle(0).tare
+    }
+}

package/src/core/physics/transports/containerweight/container_weight_model.ts

@@ -0,0 +1,38 @@
+import type { Transport } from '../transport.js'
+import { MergedContainers } from '../merged_containers.js'
+import { MergedContainersWeightCalculator } from './merged_containers_weight_calculator.js'
+import { SingleContainerWeightCalculator } from './single_container_weight_calculator.js'
+
+/**
+ * Computes per-container supported cargo capacity.
+ */
+export class ContainerWeightModel
+{
+    private readonly merged_containers: MergedContainers
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(private readonly transport: Transport)
+    {
+        this.merged_containers = new MergedContainers(transport)
+    }
+
+    /** Updates container supported_weight on transport. */
+    calculate(): void
+    {
+        const axles = this.transport.axle_manager.list_axles_indexes()
+            .map((index) => this.transport.axle_manager.get_axle(index))
+        new MergedContainersWeightCalculator(this.merged_containers, axles).calculate()
+        for (const grouper of this.merged_containers.list_grouper_indexes())
+        {
+            const grouped = this.merged_containers.get_container_by_grouper_index(grouper)
+            new SingleContainerWeightCalculator(this.transport, grouped).calculate()
+        }
+        for (const sequence of this.transport.list_containers_sequence_indexes())
+        {
+            const container = this.transport.get_container_by_sequence_index(sequence)
+            container.supported_weight = container.max_supported_weight - container.tare
+        }
+    }
+}

package/src/core/physics/transports/containerweight/merged_containers_weight_calculator.ts

@@ -0,0 +1,39 @@
+import type { MergedContainers } from '../merged_containers.js'
+import type { AxleRecord } from '../axle_record.js'
+
+/**
+ * Sums axle capacity and tare onto merged grouper containers.
+ */
+export class MergedContainersWeightCalculator
+{
+    /**
+     * @param merged_containers - Grouper layout.
+     * @param transport_axles_list - All axles.
+     */
+    constructor(
+        private readonly merged_containers: MergedContainers,
+        private readonly transport_axles_list: AxleRecord[]
+    )
+    {}
+
+    /** Applies summed max weight and tare to each merged grouper container. */
+    calculate(): void
+    {
+        for (const grouper of this.merged_containers.list_grouper_indexes())
+        {
+            const grouped = this.merged_containers.get_container_by_grouper_index(grouper)
+            const sequences = grouped.list_containers_sequence_indexes()
+            const merged = grouped.merged_container!
+            merged.max_supported_weight = 0
+            merged.tare = 0
+            for (const axle of this.transport_axles_list)
+            {
+                if (sequences.includes(axle.sequence_index))
+                {
+                    merged.max_supported_weight += axle.max_supported_weight
+                    merged.tare += axle.tare
+                }
+            }
+        }
+    }
+}

package/src/core/physics/transports/containerweight/single_container_weight_calculator.ts

@@ -0,0 +1,65 @@
+import type { Transport } from '../transport.js'
+import type { GroupedContainers } from '../grouped_containers.js'
+import type { ContainerRecord } from '../container_record.js'
+import { ContainerTareCalculator } from './container_tare_calculator.js'
+import { ContainerMaxWeightCalculator } from './container_max_weight_calculator.js'
+
+/**
+ * Splits grouper capacity across containers by lateral area.
+ */
+export class SingleContainerWeightCalculator
+{
+    private readonly tare_calculator: ContainerTareCalculator
+    private readonly max_calculator: ContainerMaxWeightCalculator
+
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(
+        transport: Transport,
+        private readonly grouped_containers: GroupedContainers
+    )
+    {
+        this.tare_calculator = new ContainerTareCalculator(transport, grouped_containers)
+        this.max_calculator = new ContainerMaxWeightCalculator(grouped_containers)
+    }
+
+    /** Assigns max_supported_weight and tare per container in grouper. */
+    calculate(): void
+    {
+        const total_area = this.total_lateral_area()
+        const merged = this.grouped_containers.merged_container!
+        const total_max = merged.max_supported_weight
+        const total_tare = merged.tare
+        for (const sequence of this.grouped_containers.list_containers_sequence_indexes())
+        {
+            const container = this.grouped_containers.get_container_by_sequence_index(sequence)
+            const share = this.lateral_area(container) / total_area
+            const tare = this.tare_calculator.calculate(sequence, share, total_tare)
+            container.max_supported_weight = this.max_calculator.calculate({
+                sequence_index: sequence,
+                percentage_of_weight: share,
+                total_max_supported_weight: total_max,
+                tare
+            })
+            container.tare = tare
+        }
+    }
+
+    private total_lateral_area(): number
+    {
+        let total = 0
+        for (const sequence of this.grouped_containers.list_containers_sequence_indexes())
+        {
+            total += this.lateral_area(
+                this.grouped_containers.get_container_by_sequence_index(sequence))
+        }
+        return total
+    }
+
+    private lateral_area(container: ContainerRecord): number
+    {
+        return container.length * container.height
+    }
+}

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

@@ -0,0 +1,91 @@
+import { ContainerRecord } from './container_record.js'
+
+/**
+ * Containers merged per grouper.
+ */
+export class GroupedContainers
+{
+    grouper: number
+    merged_container: ContainerRecord | null = null
+    private containers = new Map<number, ContainerRecord>()
+
+    /**
+     * @param grouper - Grouper id.
+     */
+    constructor(grouper: number)
+    {
+        this.grouper = grouper
+    }
+
+    get length(): number
+    {
+        return this.merged_container!.length
+    }
+
+    get container_distance_ahead(): number | null
+    {
+        return this.merged_container!.container_distance_ahead
+    }
+
+    get main_pin_distance(): number | null
+    {
+        return this.merged_container!.main_pin_distance
+    }
+
+    /**
+     * @param container - Container to add.
+     */
+    add_container(container: ContainerRecord): void
+    {
+        if (container.grouper === this.grouper)
+        {
+            this.containers.set(container.sequence_index, container)
+        }
+    }
+
+    /**
+     * Merges segment lengths into first container of grouper.
+     */
+    generate_merged_container(): void
+    {
+        const sequence_indexes = this.list_containers_sequence_indexes()
+        const first = this.get_container_by_sequence_index(sequence_indexes[0])
+        this.merged_container = clone_container(first)
+        for (let index = 1; index < sequence_indexes.length; index++)
+        {
+            const next = this.get_container_by_sequence_index(sequence_indexes[index])
+            this.merged_container.length += next.length
+        }
+    }
+
+    /**
+     * @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(`Missing container ${sequence_index}`)
+        }
+        return container
+    }
+
+    /**
+     * @returns Sorted sequence indexes.
+     */
+    list_containers_sequence_indexes(): number[]
+    {
+        return [...this.containers.keys()].sort((left, right) => left - right)
+    }
+}
+
+/**
+ * @param source - Container to clone.
+ * @returns Shallow clone with same wire fields.
+ */
+function clone_container(source: ContainerRecord): ContainerRecord
+{
+    return new ContainerRecord({ ...source.raw })
+}