@jetta/axle-load-calculator 0.1.3 → 0.2.0

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

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

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

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

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

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

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

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

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
-}