@jetta/axle-load-calculator 0.1.3 → 0.2.0

package/src/core/orchestration/weight_by_axis_task.ts

@@ -1,140 +0,0 @@
-import { calculate_loaded_weights_for_env } from './axle_weight_physics.js'
-import { build_success_output, build_error_output } from './output_builder.js'
-import { check_cargo_collision } from './collision_checker.js'
-import { parse_weight_by_axis_request } from './request_schema.js'
-
-/**
- * Runs weight-by-axis for ms-faixas JSON input (WeightByAxisTask.run contract).
- * @param json_data - Raw request JSON string.
- * @returns Response JSON string.
- */
-export function run_weight_by_axis_task(json_data: string): string
-{
-    try
-    {
-        const request = parse_weight_by_axis_request(json_data)
-        const envs = request.envs as Record<string, unknown>[]
-        const output_envs = []
-        for (const env of envs)
-        {
-            const loaded_weights = calculate_loaded_weights_for_env(env)
-            apply_loaded_weights_to_env(env, loaded_weights)
-            check_cargo_collision(env)
-            output_envs.push(strip_items_and_bands(env))
-        }
-        return build_success_output(output_envs)
-    }
-    catch (error)
-    {
-        return build_error_output(error)
-    }
-}
-
-/**
- * @param env - Env vehicle object.
- * @param loaded_weights - Forces per axle.
- */
-function apply_loaded_weights_to_env(
-    env: Record<string, unknown>,
-    loaded_weights: number[]
-): void
-{
-    const axles = env.eixos as Record<string, unknown>[]
-    for (let index = 0; index < loaded_weights.length; index++)
-    {
-        const cargo = loaded_weights[index]
-        const axle = axles[index]
-        const tare = Number(axle.tara ?? 0)
-        axle.pesoCarregado = cargo
-        axle.pesoCarregadoFinal = tare + cargo
-    }
-    const containers = env.conteiners ?? env.containers
-    if (!Array.isArray(containers))
-    {
-        return
-    }
-    apply_to_containers(containers as Record<string, unknown>[], loaded_weights, axles)
-}
-
-/**
- * @param containers - Container list on env.
- * @param loaded_weights - Per-axle cargo load.
- * @param axles - Vehicle axles list.
- */
-function apply_to_containers(
-    containers: Record<string, unknown>[],
-    loaded_weights: number[],
-    axles: Record<string, unknown>[]
-): void
-{
-    for (const container of containers)
-    {
-        const peso_eixos = build_peso_eixos_for_container(container, loaded_weights, axles)
-        container.pesoEixos = peso_eixos
-    }
-}
-
-/**
- * @param container - Container on env.
- * @param loaded_weights - All axle loads.
- * @param axles - Vehicle axles.
- * @returns pesoEixos array for container.
- */
-function build_peso_eixos_for_container(
-    container: Record<string, unknown>,
-    loaded_weights: number[],
-    axles: Record<string, unknown>[]
-): Record<string, unknown>[]
-{
-    const sequence = Number(container.sequencia)
-    const result: Record<string, unknown>[] = []
-    for (let index = 0; index < axles.length; index++)
-    {
-        if (Number(axles[index].sequenciaContainer) !== sequence)
-        {
-            continue
-        }
-        result.push(build_peso_eixo_entry(axles[index], loaded_weights[index]))
-    }
-    return result
-}
-
-/**
- * @param axle - Axle record on env.
- * @param cargo - Loaded cargo on axle.
- * @returns Single pesoEixos entry.
- */
-function build_peso_eixo_entry(
-    axle: Record<string, unknown>,
-    cargo: number
-): Record<string, unknown>
-{
-    const tare = Number(axle.tara ?? 0)
-    return {
-        distanciaOrigem: axle.distanciaOrigem,
-        pesoMax: Number(axle.pesoMaxSuportado) - tare,
-        pesoMaxFinal: axle.pesoMaxSuportado,
-        tara: tare,
-        pesoCarregado: cargo,
-        pesoCarregadoFinal: tare + cargo,
-        distanciaOrigemSemPrimeiroEixo: axle.distanciaOrigemSemPrimeiroEixo ?? 0
-    }
-}
-
-/**
- * @param env - Env with updated axle data.
- * @returns Env copy without items/faixas on containers.
- */
-function strip_items_and_bands(env: Record<string, unknown>): Record<string, unknown>
-{
-    const clone = JSON.parse(JSON.stringify(env)) as Record<string, unknown>
-    const key = clone.conteiners ? 'conteiners' : 'containers'
-    const containers = clone[key] as Record<string, unknown>[]
-    for (const container of containers)
-    {
-        container.items = []
-        container.faixas = []
-    }
-    clone.idCaminhao = clone._id
-    return clone
-}

package/src/core/physics/items/allocated_item.ts

@@ -1,41 +0,0 @@
-import type { RotationCode } from '../../contracts/rotation_enum.js'
-import { ROTATION } from '../../contracts/rotation_enum.js'
-import type { ItemTemplates } from './item_templates.js'
-
-/**
- * Allocated cargo item with position in container coordinates.
- */
-export class AllocatedItem
-{
-    xi = 0
-    yi = 0
-    zi = 0
-    rotation: RotationCode = ROTATION.POS1
-    readonly template_index: number
-    readonly templates: ItemTemplates
-
-    /**
-     * @param templates - Shared templates.
-     * @param template_index - Template index.
-     */
-    constructor(templates: ItemTemplates, template_index: number)
-    {
-        this.templates = templates
-        this.template_index = template_index
-    }
-
-    get weight(): number
-    {
-        return this.templates.weights[this.template_index]
-    }
-
-    get length(): number
-    {
-        return this.templates.get_length(this.template_index, this.rotation)
-    }
-
-    get center_of_gravity_z(): number
-    {
-        return this.zi + this.length / 2
-    }
-}

package/src/core/physics/items/allocated_item_manager.ts

@@ -1,50 +0,0 @@
-import { AllocatedItem } from './allocated_item.js'
-import type { ItemTemplates } from './item_templates.js'
-
-/**
- * Items allocated inside one container sequence.
- */
-export class AllocatedItemManager
-{
-    private items: AllocatedItem[] = []
-
-    /**
-     * @param templates - Item templates for this container.
-     */
-    constructor(readonly templates: ItemTemplates)
-    {
-    }
-
-    /**
-     * @param items - Items to add.
-     */
-    add_allocated_items(items: AllocatedItem[]): void
-    {
-        this.items.push(...items)
-    }
-
-    /**
-     * @returns Item count.
-     */
-    count_items(): number
-    {
-        return this.items.length
-    }
-
-    /**
-     * @returns Item indexes.
-     */
-    list_item_indexes(): number[]
-    {
-        return this.items.map((_item, index) => index)
-    }
-
-    /**
-     * @param item_index - Item index.
-     * @returns Item instance.
-     */
-    get_item(item_index: number): AllocatedItem
-    {
-        return this.items[item_index]
-    }
-}

package/src/core/physics/items/center_of_mass.ts

@@ -1,31 +0,0 @@
-import type { AllocatedItemManager } from './allocated_item_manager.js'
-
-/**
- * Center of mass for a load grouper (longitudinal z in chassis coordinates).
- */
-export class CenterOfMass
-{
-    mass = 0
-    z = 0
-
-    /**
-     * Computes center of mass from allocated items.
-     * @param allocated_items - Item manager for one grouper.
-     */
-    set_center_of_mass_with_allocated_items(allocated_items: AllocatedItemManager): void
-    {
-        let accumulated_weighted_positions = 0
-        this.mass = 0
-        for (const item_index of allocated_items.list_item_indexes())
-        {
-            const item = allocated_items.get_item(item_index)
-            accumulated_weighted_positions += item.center_of_gravity_z * item.weight
-            this.mass += item.weight
-        }
-        if (this.mass === 0)
-        {
-            return
-        }
-        this.z = accumulated_weighted_positions / this.mass
-    }
-}

package/src/core/physics/items/compute_grouper_center_of_mass.ts

@@ -1,44 +0,0 @@
-import type { Transport } from '../transports/transport.js'
-import { MergedContainers } from '../transports/merged_containers.js'
-import { CenterOfMass } from './center_of_mass.js'
-import type { MultiContainerAllocatedItems } from './multi_container_allocated_items.js'
-import type { ChassiForces } from '../models/chassi_forces.js'
-
-/**
- * @param multi_items - Allocated items across containers.
- * @param merged - Merged container layout.
- * @returns Center of mass map keyed by grouper id.
- */
-export function compute_center_of_mass_by_grouper(
-    multi_items: MultiContainerAllocatedItems,
-    merged: MergedContainers
-): Record<number, CenterOfMass>
-{
-    multi_items.merge_allocated_items(merged)
-    const result: Record<number, CenterOfMass> = {}
-    for (const grouper of merged.list_grouper_indexes())
-    {
-        const center_of_mass = new CenterOfMass()
-        center_of_mass.set_center_of_mass_with_allocated_items(
-            multi_items.get_allocated_items_by_grouper_index(grouper))
-        result[grouper] = center_of_mass
-    }
-    return result
-}
-
-/**
- * @param transport - Parsed transport.
- * @param multi_items - Allocated items.
- * @param solve - Model solver from CM map.
- * @returns Chassis forces.
- */
-export function calculate_chassi_forces_from_multi(
-    transport: Transport,
-    multi_items: MultiContainerAllocatedItems,
-    solve: (center_of_mass_by_grouper: Record<number, CenterOfMass>) => ChassiForces
-): ChassiForces
-{
-    const merged = new MergedContainers(transport)
-    const center_of_mass_by_grouper = compute_center_of_mass_by_grouper(multi_items, merged)
-    return solve(center_of_mass_by_grouper)
-}

package/src/core/physics/items/item_templates.ts

@@ -1,65 +0,0 @@
-import type { RotationCode } from '../../contracts/rotation_enum.js'
-import { ROTATION } from '../../contracts/rotation_enum.js'
-import { rotate_dimensions } from './rotation_transforms.js'
-
-/**
- * Item dimensions and weights keyed by template index.
- */
-export class ItemTemplates
-{
-    ids: string[] = []
-    weights: number[] = []
-    lengths: number[] = []
-    widths: number[] = []
-    heights: number[] = []
-    private dimensions: [number, number, number][] = []
-
-    /**
-     * @param item_id - Template id string.
-     * @returns Template index.
-     */
-    index_of(item_id: string): number
-    {
-        const index = this.ids.indexOf(item_id)
-        if (index < 0)
-        {
-            throw new Error(`Unknown item id ${item_id}`)
-        }
-        return index
-    }
-
-    /**
-     * @param item_data - Ms-faixas or math input item definition.
-     */
-    add_template_from_item_data(item_data: Record<string, unknown>): void
-    {
-        const id = String(item_data.id ?? item_data._id)
-        this.ids.push(id)
-        this.weights.push(Number(item_data.peso ?? item_data.weight ?? 0))
-        const width = Number(item_data.largura ?? item_data.width ?? 0)
-        const length = Number(item_data.comprimento ?? item_data.length ?? 0)
-        const height = Number(item_data.altura ?? item_data.height ?? 0)
-        this.widths.push(width)
-        this.lengths.push(length)
-        this.heights.push(height)
-        this.dimensions.push([width, length, height])
-    }
-
-    /**
-     * @param template_index - Template index.
-     * @param rotation - Rotation code.
-     * @returns Length along chassis z for rotation.
-     */
-    get_length(template_index: number, rotation: RotationCode = ROTATION.POS1): number
-    {
-        return rotate_dimensions(rotation, this.dimensions[template_index])[1]
-    }
-
-    /**
-     * @param item_data - Math input item row.
-     */
-    add_template_from_math_item(item_data: Record<string, unknown>): void
-    {
-        this.add_template_from_item_data(item_data)
-    }
-}

package/src/core/physics/items/multi_container_allocated_items.ts

@@ -1,120 +0,0 @@
-import type { MergedContainers } from '../transports/merged_containers.js'
-import { AllocatedItem } from './allocated_item.js'
-import { AllocatedItemManager } from './allocated_item_manager.js'
-import type { ItemTemplates } from './item_templates.js'
-
-/**
- * Allocated items grouped by container sequence and merged by grouper.
- */
-export class MultiContainerAllocatedItems
-{
-    allocated_items_by_sequence_index: Record<number, AllocatedItemManager>
-    allocated_items_by_grouper_index: Record<number, AllocatedItemManager> = {}
-
-    /**
-     * @param allocated_items_by_sequence_index - Items per container sequence.
-     */
-    constructor(allocated_items_by_sequence_index: Record<number, AllocatedItemManager>)
-    {
-        this.allocated_items_by_sequence_index = allocated_items_by_sequence_index
-    }
-
-    /**
-     * @param sequence_index - Container sequence id.
-     * @returns Manager for sequence.
-     */
-    get_allocated_items_by_sequence_index(sequence_index: number): AllocatedItemManager
-    {
-        return this.allocated_items_by_sequence_index[sequence_index]
-    }
-
-    /**
-     * @param grouper_index - Grouper id.
-     * @returns Manager for grouper.
-     */
-    get_allocated_items_by_grouper_index(grouper_index: number): AllocatedItemManager
-    {
-        return this.allocated_items_by_grouper_index[grouper_index]
-    }
-
-    /**
-     * @param grouper_index_list - Grouper ids to initialize.
-     */
-    create_allocated_items_by_grouper(grouper_index_list: number[]): void
-    {
-        const templates = this.get_item_templates()
-        for (const grouper_index of grouper_index_list)
-        {
-            this.allocated_items_by_grouper_index[grouper_index] = new AllocatedItemManager(templates)
-        }
-    }
-
-    /**
-     * @param merged_containers - Merged container geometry.
-     */
-    merge_allocated_items(merged_containers: MergedContainers): void
-    {
-        if (Object.keys(this.allocated_items_by_grouper_index).length > 0)
-        {
-            return
-        }
-        this.create_allocated_items_by_grouper(merged_containers.list_grouper_indexes())
-        for (const grouper of merged_containers.list_grouper_indexes())
-        {
-            merge_grouper_items(this, merged_containers, grouper)
-        }
-    }
-
-    /**
-     * @returns Shared item templates.
-     */
-    get_item_templates(): ItemTemplates
-    {
-        const keys = Object.keys(this.allocated_items_by_sequence_index)
-        const first_key = Number(keys[0])
-        return this.allocated_items_by_sequence_index[first_key].templates
-    }
-}
-
-/**
- * @param multi - Multi-container item holder.
- * @param merged - Merged containers.
- * @param grouper - Grouper id.
- */
-function merge_grouper_items(
-    multi: MultiContainerAllocatedItems,
-    merged: MergedContainers,
-    grouper: number
-): void
-{
-    const grouped = merged.get_container_by_grouper_index(grouper)
-    let last_end = 0
-    for (const sequence_index of grouped.list_containers_sequence_indexes())
-    {
-        const sequence_items = multi.get_allocated_items_by_sequence_index(sequence_index)
-        const grouper_items = multi.get_allocated_items_by_grouper_index(grouper)
-        for (const item_index of sequence_items.list_item_indexes())
-        {
-            const source = sequence_items.get_item(item_index)
-            const item = clone_allocated_item(source)
-            item.zi += last_end
-            grouper_items.add_allocated_items([item])
-        }
-        const container = grouped.get_container_by_sequence_index(sequence_index)
-        last_end += container.length
-    }
-}
-
-/**
- * @param source - Sequence-level allocated item.
- * @returns Copy safe to offset for grouper merge.
- */
-function clone_allocated_item(source: AllocatedItem): AllocatedItem
-{
-    const item = new AllocatedItem(source.templates, source.template_index)
-    item.xi = source.xi
-    item.yi = source.yi
-    item.zi = source.zi
-    item.rotation = source.rotation
-    return item
-}

package/src/core/physics/items/rotation_transforms.ts

@@ -1,29 +0,0 @@
-import type { RotationCode } from '../../contracts/rotation_enum.js'
-import { ROTATION } from '../../contracts/rotation_enum.js'
-
-const WIDTH = 0
-const LENGTH = 1
-const HEIGHT = 2
-
-const ROTATION_DIM_INDEX: Record<RotationCode, [number, number, number]> = {
-    [ROTATION.POS1]: [WIDTH, LENGTH, HEIGHT],
-    [ROTATION.POS2]: [WIDTH, HEIGHT, LENGTH],
-    [ROTATION.POS3]: [HEIGHT, LENGTH, WIDTH],
-    [ROTATION.POS4]: [LENGTH, WIDTH, HEIGHT],
-    [ROTATION.POS5]: [HEIGHT, WIDTH, LENGTH],
-    [ROTATION.POS6]: [LENGTH, HEIGHT, WIDTH]
-}
-
-/**
- * @param rotation - Rotation code.
- * @param dimensions - [width, length, height].
- * @returns Rotated [width, length, height].
- */
-export function rotate_dimensions(
-    rotation: RotationCode,
-    dimensions: [number, number, number]
-): [number, number, number]
-{
-    const index = ROTATION_DIM_INDEX[rotation]
-    return [dimensions[index[0]], dimensions[index[1]], dimensions[index[2]]]
-}

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

@@ -1,109 +0,0 @@
-import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js'
-import type { TransportRecord } from '../../contracts/transport_record.js'
-import { Transport } from '../transports/transport.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 { SemiReboqueModel } from './semi_reboque_model.js'
-import { CenterOfMass } from '../items/center_of_mass.js'
-import type { AllocatedItemManager } from '../items/allocated_item_manager.js'
-import { MultiContainerAllocatedItems } from '../items/multi_container_allocated_items.js'
-import { ChassiForces } from './chassi_forces.js'
-import { PercentageOnAxlesCalculator } from './percentage_on_axles_calculator.js'
-
-type VehicleModel = {
-    calculate_chassi_forces_with_load_center_of_mass: (
-        center_of_mass_by_grouper: Record<number, CenterOfMass>
-    ) => ChassiForces
-    calculate_weight_on_axles: (
-        multi_items: import('../items/multi_container_allocated_items.js').MultiContainerAllocatedItems
-    ) => number[]
-}
-
-/**
- * Dispatches to vehicle-specific axle weight models.
- */
-export class AxleWeightModel
-{
-    private readonly model: VehicleModel
-    private readonly transport: Transport
-
-    /**
-     * @param transport_or_data - Parsed transport or raw wire dict.
-     */
-    constructor(transport_or_data: Transport | TransportRecord)
-    {
-        this.transport = transport_or_data instanceof Transport
-            ? transport_or_data
-            : new Transport(transport_or_data)
-        this.model = select_vehicle_model(this.transport)
-    }
-
-    /**
-     * @param center_of_mass_by_grouper - Precomputed CM per grouper.
-     * @returns Chassis force result.
-     */
-    calculate_chassi_forces_with_load_center_of_mass(
-        center_of_mass_by_grouper: Record<number, CenterOfMass>
-    ): ChassiForces
-    {
-        return this.model.calculate_chassi_forces_with_load_center_of_mass(
-            center_of_mass_by_grouper)
-    }
-
-    /**
-     * @param allocated_by_sequence - Items per container sequence index.
-     * @returns Loaded cargo per axle.
-     */
-    calculate_weight_on_axles(
-        allocated_by_sequence: Record<number, AllocatedItemManager>
-    ): number[]
-    {
-        const multi = new MultiContainerAllocatedItems(allocated_by_sequence)
-        return this.model.calculate_weight_on_axles(multi)
-    }
-
-    /**
-     * @param allocated_by_sequence - Items per container sequence index.
-     * @returns Utilization percentage per axle.
-     */
-    calculate_percentages_on_axles(
-        allocated_by_sequence: Record<number, AllocatedItemManager>
-    ): number[]
-    {
-        const weights = this.calculate_weight_on_axles(allocated_by_sequence)
-        return new PercentageOnAxlesCalculator(this.transport)
-            .weight_on_axles_to_percentages(weights)
-    }
-}
-
-/**
- * @param transport - Parsed transport.
- * @returns Vehicle model implementation.
- */
-function select_vehicle_model(transport: Transport): VehicleModel
-{
-    const type = transport.vehicle_type
-    if (type === VEHICLE_TYPE.SEMIREBOQUE || type === VEHICLE_TYPE.REBAIXADO)
-    {
-        return new SemiReboqueModel(transport)
-    }
-    if (type === VEHICLE_TYPE.BITREM)
-    {
-        return new BitremModel(transport)
-    }
-    if (type === VEHICLE_TYPE.RODOTREM)
-    {
-        return new RodotremModel(transport)
-    }
-    if (type === VEHICLE_TYPE.VANDERLEIA)
-    {
-        return new VanderleiaModel(transport)
-    }
-    if (type === VEHICLE_TYPE.CAMINHAO || type === VEHICLE_TYPE.VUC)
-    {
-        return new SimpleTruckModel(transport)
-    }
-    throw new Error(`Unsupported vehicle type: ${type}`)
-}