@jetta/axle-load-calculator 0.1.3

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

@@ -0,0 +1,115 @@
+import type { Transport } from '../transports/transport.js'
+import { MergedContainers } from '../transports/merged_containers.js'
+import type { MultiContainerAllocatedItems } from '../items/multi_container_allocated_items.js'
+import {
+    calculate_chassi_forces_from_multi,
+    compute_center_of_mass_by_grouper
+} from '../items/compute_grouper_center_of_mass.js'
+import { VEHICLE_VERSION } from '../../contracts/vehicle_version.js'
+import { CenterOfMass } from '../items/center_of_mass.js'
+import { ChassiForces } from './chassi_forces.js'
+import { SimpleTruckBase } from './simple_truck_base.js'
+import { BiTruckModel } from './bi_truck_model.js'
+
+type TruckDelegate = {
+    calculate_chassi_forces_with_load_center_of_mass: (
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ) => ChassiForces
+}
+
+/**
+ * Caminhão / VUC axle weight (optional bitruck variant).
+ */
+export class SimpleTruckModel
+{
+    private readonly delegate: TruckDelegate & { axles_positions?: number[]; equivalent_truck?: SimpleTruckBase }
+    private readonly transport: Transport
+    private readonly merged_containers: MergedContainers
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport)
+    {
+        this.transport = transport
+        this.merged_containers = new MergedContainers(transport)
+        if (transport.vehicle_version === VEHICLE_VERSION.CAMINHAO_BITRUCK)
+        {
+            this.delegate = new BiTruckModel(transport)
+        }
+        else
+        {
+            const base = new SimpleTruckBase(transport)
+            base.set_axles_positions()
+            this.delegate = base
+        }
+    }
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Loaded weights per axle.
+     */
+    calculate_weight_on_axles(multi_items: MultiContainerAllocatedItems): number[]
+    {
+        const forces = this.calculate_chassi_forces(multi_items)
+        return forces.list_axles_indexes().map((index) => forces.get_force_on_axle(index))
+    }
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces(multi_items: MultiContainerAllocatedItems): ChassiForces
+    {
+        return calculate_chassi_forces_from_multi(
+            this.transport,
+            multi_items,
+            (center_of_mass_by_grouper) =>
+                this.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper))
+    }
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Deflection support pairs.
+     */
+    calculate_support_data(multi_items: MultiContainerAllocatedItems): [number, number][]
+    {
+        if (this.transport.vehicle_version === VEHICLE_VERSION.CAMINHAO_BITRUCK)
+        {
+            const center_of_mass_by_grouper = compute_center_of_mass_by_grouper(
+                multi_items,
+                this.merged_containers)
+            const bi_truck = this.delegate as BiTruckModel
+            const forces = bi_truck.equivalent_truck
+                .calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper)
+            const positions = bi_truck.equivalent_truck.axles_positions
+            return [[positions[0], forces.get_force_on_axle(0)], [positions[1], forces.get_force_on_axle(1)]]
+        }
+        const forces = this.calculate_chassi_forces(multi_items)
+        const base = this.delegate as SimpleTruckBase
+        return [
+            [base.axles_positions[0], forces.get_force_on_axle(0)],
+            [base.axles_positions[1], forces.get_force_on_axle(1)]
+        ]
+    }
+
+    /**
+     * @returns Merged grouper 1 length.
+     */
+    calculate_container_length(): number
+    {
+        return this.merged_containers.get_container_by_grouper_index(1).length
+    }
+
+    /**
+     * @param center_of_mass_by_grouper - CM per grouper.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ): ChassiForces
+    {
+        return this.delegate.calculate_chassi_forces_with_load_center_of_mass(
+            center_of_mass_by_grouper)
+    }
+}

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

@@ -0,0 +1,56 @@
+import { CenterOfMass } from '../items/center_of_mass.js'
+import { AxleWeightModel } from './axle_weight_model.js'
+import type { Transport } from '../transports/transport.js'
+
+/**
+ * Physics-based tare from uniform load at volume centroid.
+ */
+export class SingleContainerTare
+{
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(private readonly transport: Transport)
+    {}
+
+    /**
+     * @returns Calculated tare per axle.
+     */
+    calculate(): number[]
+    {
+        const forces = this.calculate_forces_on_axles(
+            this.calculate_z_centroid(),
+            this.transport.supported_weight)
+        return this.transport.axle_manager.list_axles_indexes().map((index) =>
+        {
+            const axle = this.transport.axle_manager.get_axle(index)
+            return axle.max_supported_weight - forces.get_force_on_axle(index)
+        })
+    }
+
+    private calculate_z_centroid(): number
+    {
+        let z_offset = 0
+        let sum_z = 0
+        let total_volume = 0
+        for (const sequence of this.transport.list_containers_sequence_indexes())
+        {
+            const container = this.transport.get_container_by_sequence_index(sequence)
+            const z_centroid = z_offset + container.length / 2
+            z_offset += container.length
+            const volume = container.volume()
+            sum_z += z_centroid * volume
+            total_volume += volume
+        }
+        return sum_z / total_volume
+    }
+
+    private calculate_forces_on_axles(z_position: number, mass: number)
+    {
+        const model = new AxleWeightModel(this.transport)
+        const center_of_mass = new CenterOfMass()
+        center_of_mass.z = z_position
+        center_of_mass.mass = mass
+        return model.calculate_chassi_forces_with_load_center_of_mass({ 1: center_of_mass })
+    }
+}

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

@@ -0,0 +1,46 @@
+import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js'
+import type { Transport } from '../transports/transport.js'
+import { OldTareModel } from './old_tare_model.js'
+import { SingleContainerTare } from './single_container_tare.js'
+
+const DISTANCE_TOLERANCE = 0.9
+
+/**
+ * Selects legacy or physics tare model per axle.
+ */
+export class TareModel
+{
+    /**
+     * @param transport - Parsed transport.
+     * @returns Tare per axle.
+     */
+    calculate(transport: Transport): number[]
+    {
+        if (transport.vehicle_type === VEHICLE_TYPE.BITREM
+            || transport.vehicle_type === VEHICLE_TYPE.RODOTREM)
+        {
+            return new OldTareModel().calculate(transport)
+        }
+        const reference = new OldTareModel().calculate(transport)
+        const physics = new SingleContainerTare(transport).calculate()
+        return choose_tare_model(reference, physics)
+    }
+}
+
+/**
+ * @param reference_values - Legacy tare per axle.
+ * @param new_values - Physics tare per axle.
+ * @returns Selected tare list.
+ */
+function choose_tare_model(reference_values: number[], new_values: number[]): number[]
+{
+    for (let index = 0; index < reference_values.length; index++)
+    {
+        const ref = reference_values[index]
+        if (Math.abs(new_values[index] - ref) > ref * DISTANCE_TOLERANCE)
+        {
+            return reference_values
+        }
+    }
+    return new_values
+}

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

@@ -0,0 +1,125 @@
+import type { Transport } from '../transports/transport.js'
+import type { MultiContainerAllocatedItems } from '../items/multi_container_allocated_items.js'
+import { calculate_chassi_forces_from_multi } from '../items/compute_grouper_center_of_mass.js'
+import { Chassi } from '../transports/chassi.js'
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js'
+import { SUSPENSION_TYPE } from '../../contracts/suspension_type.js'
+import { CenterOfMass } from '../items/center_of_mass.js'
+import { ChassiForces } from './chassi_forces.js'
+import { solve_linear_system } from '../../math/gaussian_elimination.js'
+
+/**
+ * Vanderleia five-axle static model with suspension-dependent coupling.
+ */
+export class VanderleiaModel
+{
+    readonly chassi: Chassi
+    private readonly matrix: number[][]
+
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(private readonly transport: Transport)
+    {
+        this.chassi = new Chassi(transport)
+        this.matrix = generate_vanderleia_matrix(this.chassi, transport)
+    }
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Loaded weights per axle.
+     */
+    calculate_weight_on_axles(multi_items: MultiContainerAllocatedItems): number[]
+    {
+        const forces = this.calculate_chassi_forces(multi_items)
+        return forces.list_axles_indexes().map((index) => forces.get_force_on_axle(index))
+    }
+
+    /**
+     * @param multi_items - Allocated items.
+     * @returns Chassis forces.
+     */
+    calculate_chassi_forces(multi_items: MultiContainerAllocatedItems): ChassiForces
+    {
+        return calculate_chassi_forces_from_multi(
+            this.transport,
+            multi_items,
+            (center_of_mass_by_grouper) =>
+                this.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper))
+    }
+
+    /**
+     * @param center_of_mass_by_grouper - CM for grouper 1.
+     * @returns Chassis forces on five axles.
+     */
+    calculate_chassi_forces_with_load_center_of_mass(
+        center_of_mass_by_grouper: Record<number, CenterOfMass>
+    ): ChassiForces
+    {
+        const solution = solve_vanderleia_system(this.matrix, center_of_mass_by_grouper[1])
+        const forces = new ChassiForces()
+        forces.add_pin_forces([solution[3]])
+        forces.add_axle_forces([
+            solution[5],
+            solution[4],
+            solution[2],
+            solution[1],
+            solution[0]
+        ])
+        return forces
+    }
+}
+
+/**
+ * @param chassi - Chassis geometry.
+ * @param transport - Parsed transport (suspension type).
+ * @returns 6×6 matrix.
+ */
+function generate_vanderleia_matrix(chassi: Chassi, transport: Transport): number[][]
+{
+    const tractor_pin = chassi.get_pin_position(0, CHASSI_REFERENCE.TRACTOR)
+    const tractor_axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.TRACTOR)
+    const tractor_axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.TRACTOR)
+    const pin_1 = chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
+    const axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
+    const axle_4 = chassi.get_axle_position(3, CHASSI_REFERENCE.GROUPER_1)
+    const axle_5 = chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_1)
+    const relation = reactions_relation(transport)
+    return [
+        [1, 0, -relation[0], 0, 0, 0],
+        [0, 1, -relation[1], 0, 0, 0],
+        [1, 1, 1, 1, 0, 0],
+        [axle_5, axle_4, axle_3, pin_1, 0, 0],
+        [0, 0, 0, -1, 1, 1],
+        [0, 0, 0, -tractor_pin, tractor_axle_2, tractor_axle_1]
+    ]
+}
+
+/**
+ * @param transport - Parsed transport.
+ * @returns Reaction coupling factors.
+ */
+function reactions_relation(transport: Transport): [number, number]
+{
+    const raw = transport.suspension_type
+    if (raw === SUSPENSION_TYPE.PNEUMATICA || raw === 'Pneumatica')
+    {
+        return [1, 1]
+    }
+    if (raw === SUSPENSION_TYPE.MECANICA || raw === 'Mecanica')
+    {
+        return [0.867469880, 0.542168675]
+    }
+    throw new Error(`Unrecognized suspension type: ${String(raw)}`)
+}
+
+/**
+ * @param matrix - System matrix.
+ * @param center_of_mass - Load CM.
+ * @returns Solution vector.
+ */
+function solve_vanderleia_system(matrix: number[][], center_of_mass: CenterOfMass): number[]
+{
+    const independent = [0, 0, center_of_mass.mass, center_of_mass.mass * center_of_mass.z, 0, 0]
+    return solve_linear_system(matrix, independent)
+}

package/src/core/physics/services/axle_weight_output_builder.ts

@@ -0,0 +1,63 @@
+import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js'
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js'
+import type { Transport } from '../transports/transport.js'
+import type { Chassi } from '../transports/chassi.js'
+
+/**
+ * @param transport - Parsed transport.
+ * @param grouper - Grouper index.
+ * @returns Axle indexes for grouper output.
+ */
+export function select_axles_for_grouper(transport: Transport, grouper: number): number[]
+{
+    const type = transport.vehicle_type
+    if (type === VEHICLE_TYPE.RODOTREM || type === VEHICLE_TYPE.BITREM)
+    {
+        return grouper === 1 ? [0, 1, 2] : [3, 4]
+    }
+    return transport.axle_manager.list_axles_indexes()
+}
+
+/**
+ * @param axles_indexes - Axle indexes in output row.
+ * @returns Chassi reference for distance helper.
+ */
+export function find_grouper_reference(
+    axles_indexes: number[]
+): typeof CHASSI_REFERENCE.GROUPER_1 | typeof CHASSI_REFERENCE.GROUPER_2
+{
+    return axles_indexes.includes(0) ? CHASSI_REFERENCE.GROUPER_1 : CHASSI_REFERENCE.GROUPER_2
+}
+
+type AxleWeightOutputInput = {
+    transport: Transport
+    chassi: Chassi
+    axles_indexes: number[]
+    weight_on_axles: number[]
+}
+
+/**
+ * @param input - Transport, chassi, axles, and cargo loads.
+ * @returns pesoEixos wire rows.
+ */
+export function build_axle_weights_output(input: AxleWeightOutputInput): Record<string, unknown>[]
+{
+    return input.axles_indexes.map((axle_index) =>
+    {
+        const axle = input.transport.axle_manager.get_axle(axle_index)
+        const cargo = input.weight_on_axles[axle_index]
+        return {
+            distanciaOrigem: axle.distance_from_previous_axle,
+            pesoMaxFinal: axle.max_supported_weight,
+            tara: axle.tare,
+            pesoMax: axle.max_supported_weight - axle.tare,
+            pesoCarregado: cargo,
+            pesoCarregadoFinal: axle.tare + cargo,
+            distanciaOrigemSemPrimeiroEixo: axle_index === 0
+                ? 0
+                : input.chassi.get_axle_position(
+                    axle_index,
+                    find_grouper_reference(input.axles_indexes))
+        }
+    })
+}

package/src/core/physics/services/axle_weight_service.ts

@@ -0,0 +1,116 @@
+import { MsFaixasContract } from '../../contracts/ms_faixas_contract.js'
+import { Transport } from '../transports/transport.js'
+import { Chassi } from '../transports/chassi.js'
+import { MergedContainers } from '../transports/merged_containers.js'
+import { AxleWeightModel } from '../models/axle_weight_model.js'
+import {
+    build_axle_weights_output,
+    select_axles_for_grouper
+} from './axle_weight_output_builder.js'
+
+const TRANSPORT_LIST_FLAG = 'envs'
+const TRANSPORT_ID_FLAG = 'idCaminhao'
+const CONTAINERS_FLAG = 'conteiners'
+const SEQUENCE_FLAG = 'sequencia'
+const FAIXAS_FLAG = 'faixas'
+const TARE_FLAG = 'tara'
+const ITEMS_FLAG = 'items'
+const MAX_SUPPORTED_FLAG = 'pesoSuportado'
+const CENTER_OF_GRAVITY_FLAG = 'centroGravidade'
+const AXLE_WEIGHTS_FLAG = 'pesoEixos'
+
+/**
+ * Full ms-faixas axle weight pipeline (Python AxleWeightService port).
+ */
+export class AxleWeightService
+{
+    private readonly transport: Transport
+    private readonly chassi: Chassi
+    private readonly allocated_by_sequence: Record<number, import('../items/allocated_item_manager.js').AllocatedItemManager>
+
+    /**
+     * @param input_data - Ms-faixas payload with envs.
+     */
+    constructor(input_data: Record<string, unknown>)
+    {
+        const contract = new MsFaixasContract(input_data)
+        this.transport = new Transport(contract.transport_data)
+        this.chassi = new Chassi(this.transport)
+        this.allocated_by_sequence = contract.allocated_items_by_sequence_id
+    }
+
+    /**
+     * @returns Math output with envs and pesoEixos per container.
+     */
+    run(): Record<string, unknown>
+    {
+        return {
+            [TRANSPORT_LIST_FLAG]: [{
+                [TRANSPORT_ID_FLAG]: this.transport.id,
+                [CONTAINERS_FLAG]: this.build_containers_data()
+            }]
+        }
+    }
+
+    private build_containers_data(): Record<string, unknown>[]
+    {
+        const weights_by_sequence = this.evaluate_weight_on_axles()
+        const center_of_gravity: Record<number, number> = {}
+        for (const sequence of this.transport.list_containers_sequence_indexes())
+        {
+            center_of_gravity[sequence] = 0
+        }
+        return this.transport.list_containers_sequence_indexes().map((sequence) =>
+        {
+            const container = this.transport.get_container_by_sequence_index(sequence)
+            return {
+                [SEQUENCE_FLAG]: container.sequence_index,
+                [FAIXAS_FLAG]: [],
+                [TARE_FLAG]: 0,
+                [ITEMS_FLAG]: [],
+                [MAX_SUPPORTED_FLAG]: container.max_supported_weight,
+                [CENTER_OF_GRAVITY_FLAG]: center_of_gravity[sequence],
+                [AXLE_WEIGHTS_FLAG]: weights_by_sequence[sequence] ?? []
+            }
+        })
+    }
+
+    private evaluate_weight_on_axles(): Record<number, Record<string, unknown>[]>
+    {
+        const model = new AxleWeightModel(this.transport)
+        const weight_on_axles = model.calculate_weight_on_axles(this.allocated_by_sequence)
+        const merged = new MergedContainers(this.transport)
+        const result: Record<number, Record<string, unknown>[]> = {}
+        for (const grouper of merged.list_grouper_indexes())
+        {
+            this.assign_grouper_axle_outputs({
+                grouper,
+                grouped: merged.get_container_by_grouper_index(grouper),
+                weight_on_axles,
+                result
+            })
+        }
+        return result
+    }
+
+    private assign_grouper_axle_outputs(input: {
+        grouper: number
+        grouped: import('../transports/grouped_containers.js').GroupedContainers
+        weight_on_axles: number[]
+        result: Record<number, Record<string, unknown>[]>
+    }): void
+    {
+        const sequences = input.grouped.list_containers_sequence_indexes()
+        const axles = select_axles_for_grouper(this.transport, input.grouper)
+        input.result[sequences[0]] = build_axle_weights_output({
+            transport: this.transport,
+            chassi: this.chassi,
+            axles_indexes: axles,
+            weight_on_axles: input.weight_on_axles
+        })
+        for (let index = 1; index < sequences.length; index++)
+        {
+            input.result[sequences[index]] = []
+        }
+    }
+}

package/src/core/physics/services/cm_axle_weight_service.ts

@@ -0,0 +1,45 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js'
+import type { TransportRecord } from '../../contracts/transport_record.js'
+import { CenterOfMass } from '../items/center_of_mass.js'
+import { AxleWeightModel } from '../models/axle_weight_model.js'
+
+/**
+ * Center-of-mass-driven axle weight service (port of CMAxleWeightService).
+ */
+export class CmAxleWeightService
+{
+    /**
+     * @param cm_axle_weight_data - Transport dict with center_of_mass map.
+     * @returns Loaded cargo weight per axle.
+     */
+    calculate(cm_axle_weight_data: TransportRecord): number[]
+    {
+        const model = new AxleWeightModel(cm_axle_weight_data)
+        const center_of_mass_by_grouper = read_center_of_mass_map(
+            cm_axle_weight_data[WIRE_FLAGS.CM_SERVICE_CENTER_OF_MASS] as Record<string, unknown>)
+        const chassi_forces = model.calculate_chassi_forces_with_load_center_of_mass(
+            center_of_mass_by_grouper)
+        return chassi_forces.list_axles_indexes().map(
+            (index) => chassi_forces.get_force_on_axle(index))
+    }
+}
+
+/**
+ * @param cm_data - Wire center_of_mass map.
+ * @returns Grouper id to CenterOfMass.
+ */
+function read_center_of_mass_map(
+    cm_data: Record<string, unknown>
+): Record<number, CenterOfMass>
+{
+    const result: Record<number, CenterOfMass> = {}
+    for (const grouper_key of Object.keys(cm_data))
+    {
+        const entry = cm_data[grouper_key] as Record<string, unknown>
+        const center_of_mass = new CenterOfMass()
+        center_of_mass.mass = Number(entry[WIRE_FLAGS.CM_SERVICE_MASS])
+        center_of_mass.z = Number(entry[WIRE_FLAGS.CM_SERVICE_Z])
+        result[Number(grouper_key)] = center_of_mass
+    }
+    return result
+}

package/src/core/physics/services/container_corner_forces.ts

@@ -0,0 +1,95 @@
+/**
+ * Container corner force distribution (ISSUE-349).
+ */
+export class ContainerCornerForces
+{
+    private readonly x_box_center: number[] = []
+    private readonly z_box_center: number[] = []
+    private readonly y_box_center: number[] = []
+    private readonly weight_box: number[] = []
+    private total_mass = 0
+    private x_cm = 0
+    private y_cm = 0
+    private z_cm = 0
+    private force_on_door: number | null = null
+    private force_on_right_corner_door = 0
+    private force_on_left_corner_door = 0
+    private force_on_end_wall = 0
+    private force_on_right_corner_end_wall = 0
+    private force_on_left_corner_end_wall = 0
+
+    /**
+     * @param input_data - Items and container dimensions.
+     */
+    constructor(private readonly input_data: Record<string, unknown>)
+    {
+        const items = input_data.items as Record<string, unknown>[]
+        for (const item of items)
+        {
+            this.x_box_center.push(Number(item.x) + 0.5 * Number(item.width))
+            this.z_box_center.push(Number(item.z) + 0.5 * Number(item.length))
+            this.y_box_center.push(Number(item.y) + 0.5 * Number(item.height))
+            this.weight_box.push(Number(item.weight))
+        }
+        this.total_mass = this.weight_box.reduce((sum, weight) => sum + weight, 0)
+    }
+
+    /** Computes center of gravity from item boxes. */
+    calculate_cm(): void
+    {
+        this.x_cm = dot(this.x_box_center, this.weight_box) / this.total_mass
+        this.z_cm = dot(this.z_box_center, this.weight_box) / this.total_mass
+        this.y_cm = dot(this.y_box_center, this.weight_box) / this.total_mass
+    }
+
+    /** Computes corner reaction forces including container tare split. */
+    calculate_corner_forces(): void
+    {
+        const container = this.input_data.container as Record<string, unknown>
+        const container_length = Number(container.length)
+        const container_width = Number(container.width)
+        this.force_on_door = (this.z_cm * this.total_mass) / container_length
+        this.force_on_right_corner_door = (this.x_cm * this.force_on_door) / container_width
+        this.force_on_left_corner_door = this.force_on_door - this.force_on_right_corner_door
+        this.force_on_end_wall = this.total_mass - this.force_on_door
+        this.force_on_right_corner_end_wall = (this.x_cm * this.force_on_end_wall) / container_width
+        this.force_on_left_corner_end_wall = this.force_on_end_wall - this.force_on_right_corner_end_wall
+        const tare_quarter = 0.25 * Number(container.tare)
+        this.force_on_right_corner_door += tare_quarter
+        this.force_on_left_corner_door += tare_quarter
+        this.force_on_right_corner_end_wall += tare_quarter
+        this.force_on_left_corner_end_wall += tare_quarter
+    }
+
+    /**
+     * @returns Response JSON.
+     */
+    json(): Record<string, unknown>
+    {
+        const response: Record<string, unknown> = {
+            centerOfGravity: { x: this.x_cm, y: this.y_cm, z: this.z_cm }
+        }
+        if (this.force_on_door !== null)
+        {
+            response.corner_forces = {
+                force_on_door: this.force_on_door,
+                force_on_right_corner_door: this.force_on_right_corner_door,
+                force_on_left_corner_door: this.force_on_left_corner_door,
+                force_on_end_wall: this.force_on_end_wall,
+                force_on_right_corner_end_wall: this.force_on_right_corner_end_wall,
+                force_on_left_corner_end_wall: this.force_on_left_corner_end_wall
+            }
+        }
+        return response
+    }
+}
+
+/**
+ * @param values - Value list.
+ * @param weights - Weight list.
+ * @returns Weighted sum.
+ */
+function dot(values: number[], weights: number[]): number
+{
+    return values.reduce((sum, value, index) => sum + value * weights[index], 0)
+}