@jetta/axle-load-calculator 0.1.3 → 0.2.0

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

@@ -1,74 +0,0 @@
-import type { Transport } from '../transports/transport.js'
-import { Chassi } from '../transports/chassi.js'
-import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js'
-import { CenterOfMass } from '../items/center_of_mass.js'
-import { ChassiForces } from './chassi_forces.js'
-import { SimpleTruckBase } from './simple_truck_base.js'
-import { solve_linear_system } from '../../math/gaussian_elimination.js'
-
-/**
- * Bitruck caminhão: equivalent 2-axle truck + front axle pair split.
- */
-export class BiTruckModel
-{
-    private readonly chassi: Chassi
-    readonly equivalent_truck: SimpleTruckBase
-
-    /**
-     * @param transport - Parsed transport.
-     */
-    constructor(transport: Transport)
-    {
-        this.chassi = new Chassi(transport)
-        this.equivalent_truck = new SimpleTruckBase(transport)
-        this.equivalent_truck.set_axles_positions(get_equivalent_positions(this.chassi, transport))
-    }
-
-    /**
-     * @param center_of_mass_by_grouper - CM per grouper.
-     * @returns Three-axle forces.
-     */
-    calculate_chassi_forces_with_load_center_of_mass(
-        center_of_mass_by_grouper: Record<number, CenterOfMass>
-    ): ChassiForces
-    {
-        const equivalent = this.equivalent_truck
-            .calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper)
-        const equivalent_z = this.equivalent_truck.axles_positions[0]
-        const independent = [
-            equivalent.get_force_on_axle(0),
-            equivalent.get_force_on_axle(0) * equivalent_z
-        ]
-        const front = solve_linear_system(generate_front_matrix(this.chassi), independent)
-        const forces = new ChassiForces()
-        forces.add_axle_forces([front[0], front[1], equivalent.get_force_on_axle(1)])
-        return forces
-    }
-}
-
-/**
- * @param chassi - Chassis geometry.
- * @returns 2×2 front axle matrix.
- */
-function generate_front_matrix(chassi: Chassi): number[][]
-{
-    const axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.GROUPER_1)
-    const axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.GROUPER_1)
-    return [[1, 1], [axle_1, axle_2]]
-}
-
-/**
- * @param chassi - Chassis geometry.
- * @param transport - Parsed transport.
- * @returns Equivalent two-axle positions.
- */
-function get_equivalent_positions(chassi: Chassi, transport: Transport): number[]
-{
-    const axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.GROUPER_1)
-    const axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.GROUPER_1)
-    const axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
-    const cap_1 = transport.axle_manager.get_axle(0).max_supported_weight
-    const cap_2 = transport.axle_manager.get_axle(1).max_supported_weight
-    const front_equivalent = (axle_1 * cap_1 + axle_2 * cap_2) / (cap_1 + cap_2)
-    return [front_equivalent, axle_3]
-}

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

@@ -1,86 +0,0 @@
-import type { Transport } from '../transports/transport.js'
-import { Chassi } from '../transports/chassi.js'
-import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js'
-import { CenterOfMass } from '../items/center_of_mass.js'
-import { ChassiForces } from './chassi_forces.js'
-import { SemiReboqueBase } from './semi_reboque_base.js'
-import { solve_linear_system } from '../../math/gaussian_elimination.js'
-
-/**
- * Bitruck tractor + semi-trailer variant.
- */
-export class BiTruckTractorSemiTrailerModel
-{
-    private readonly chassi: Chassi
-    readonly equivalent_semi_trailer: SemiReboqueBase
-
-    /**
-     * @param transport - Parsed transport.
-     */
-    constructor(transport: Transport)
-    {
-        this.chassi = new Chassi(transport)
-        this.equivalent_semi_trailer = new SemiReboqueBase(transport)
-        this.equivalent_semi_trailer.set_linear_system_matrix(
-            get_equivalent_positions(this.chassi, transport))
-    }
-
-    /**
-     * @param center_of_mass_by_grouper - CM per grouper.
-     * @returns Four-axle + pin forces.
-     */
-    calculate_chassi_forces_with_load_center_of_mass(
-        center_of_mass_by_grouper: Record<number, CenterOfMass>
-    ): ChassiForces
-    {
-        const equivalent = this.equivalent_semi_trailer
-            .calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper)
-        const equivalent_z = this.equivalent_semi_trailer.chassi_positions[1]
-        const independent = [
-            equivalent.get_force_on_axle(0),
-            equivalent.get_force_on_axle(0) * equivalent_z
-        ]
-        const front = solve_linear_system(generate_tractor_front_matrix(this.chassi), independent)
-        const forces = new ChassiForces()
-        forces.add_axle_forces([
-            front[0],
-            front[1],
-            equivalent.get_force_on_axle(1),
-            equivalent.get_force_on_axle(2)
-        ])
-        forces.add_pin_forces([equivalent.get_force_on_pin(0)])
-        return forces
-    }
-}
-
-/**
- * @param chassi - Chassis geometry.
- * @returns 2×2 tractor front matrix.
- */
-function generate_tractor_front_matrix(chassi: Chassi): number[][]
-{
-    const axle_1 = chassi.get_axle_position(0, CHASSI_REFERENCE.TRACTOR)
-    const axle_2 = chassi.get_axle_position(1, CHASSI_REFERENCE.TRACTOR)
-    return [[1, 1], [axle_1, axle_2]]
-}
-
-/**
- * @param chassi - Chassis geometry.
- * @param transport - Parsed transport.
- * @returns Equivalent semi chassis positions.
- */
-function get_equivalent_positions(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 tractor_axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.TRACTOR)
-    const semi_pin = chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
-    const semi_axle_4 = chassi.get_axle_position(3, CHASSI_REFERENCE.GROUPER_1)
-    const cap_1 = transport.axle_manager.get_axle(0).max_supported_weight
-    const cap_2 = transport.axle_manager.get_axle(1).max_supported_weight
-    const tractor_equivalent = (
-        tractor_axle_1 * cap_1 + tractor_axle_2 * cap_2
-    ) / (cap_1 + cap_2)
-    return [tractor_pin, tractor_equivalent, tractor_axle_3, semi_pin, semi_axle_4]
-}

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

@@ -1,148 +0,0 @@
-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 { CenterOfMass } from '../items/center_of_mass.js'
-import { ChassiForces } from './chassi_forces.js'
-import { solve_linear_system } from '../../math/gaussian_elimination.js'
-
-/**
- * Bitrem interlink + semi static equilibrium (6×6 system).
- */
-export class BitremModel
-{
-    readonly chassi: Chassi
-    private readonly matrix: number[][]
-
-    /**
-     * @param transport - Parsed transport.
-     */
-    constructor(private readonly transport: Transport)
-    {
-        this.chassi = new Chassi(transport)
-        this.matrix = generate_bitrem_matrix(this.chassi)
-    }
-
-    /**
-     * @param multi_items - Allocated items by container sequence.
-     * @returns Loaded weight 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 before rebalance split on axles 3–4.
-     */
-    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 groupers 1 and 2.
-     * @returns Combined chassis forces.
-     */
-    calculate_chassi_forces_with_load_center_of_mass(
-        center_of_mass_by_grouper: Record<number, CenterOfMass>
-    ): ChassiForces
-    {
-        const interlink = center_of_mass_by_grouper[1]
-        const semi = center_of_mass_by_grouper[2]
-        const solution_interlink = solve_interlink_system(this.matrix, interlink)
-        const solution_semi = solve_semi_system(this.matrix, semi)
-        const forces = new ChassiForces()
-        forces.add_pin_forces([
-            solution_interlink[3] + solution_semi[3],
-            solution_interlink[1] + solution_semi[1]
-        ])
-        const loaded = [
-            solution_interlink[5] + solution_semi[5],
-            solution_interlink[4] + solution_semi[4],
-            solution_interlink[2],
-            solution_semi[2],
-            solution_interlink[0] + solution_semi[0]
-        ]
-        forces.add_axle_forces(linked_axle_weight_rebalance(this.transport, loaded))
-        return forces
-    }
-}
-
-/**
- * @param chassi - Chassis geometry.
- * @returns 6×6 matrix coefficients.
- */
-function generate_bitrem_matrix(chassi: Chassi): 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 interlink_pin_1 = chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
-    const interlink_pin_2 = chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_1)
-    const interlink_axle_3 = chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
-    const semi_pin_2 = chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_2)
-    const semi_axle_4 = chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_2)
-    return [
-        [1, 1, 0, 0, 0, 0],
-        [semi_axle_4, semi_pin_2, 0, 0, 0, 0],
-        [0, -1, 1, 1, 0, 0],
-        [0, -interlink_pin_2, interlink_axle_3, interlink_pin_1, 0, 0],
-        [0, 0, 0, -1, 1, 1],
-        [0, 0, 0, -tractor_pin, tractor_axle_2, tractor_axle_1]
-    ]
-}
-
-/**
- * @param matrix - System matrix.
- * @param center_of_mass - Interlink load CM.
- * @returns Solution vector.
- */
-function solve_interlink_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)
-}
-
-/**
- * @param matrix - System matrix.
- * @param center_of_mass - Semi load CM.
- * @returns Solution vector.
- */
-function solve_semi_system(matrix: number[][], center_of_mass: CenterOfMass): number[]
-{
-    const independent = [
-        center_of_mass.mass,
-        center_of_mass.mass * center_of_mass.z,
-        0,
-        0,
-        0,
-        0
-    ]
-    return solve_linear_system(matrix, independent)
-}
-
-/**
- * @param transport - Parsed transport.
- * @param loaded_weights - Raw axle loads before rebalance.
- * @returns Rebalanced axle 3–4 loads.
- */
-function linked_axle_weight_rebalance(transport: Transport, loaded_weights: number[]): number[]
-{
-    const first = transport.axle_manager.get_axle(2)
-    const second = transport.axle_manager.get_axle(3)
-    const first_cap = first.max_supported_weight - first.tare
-    const second_cap = second.max_supported_weight - second.tare
-    const total_cap = first_cap + second_cap
-    const total_load = loaded_weights[2] + loaded_weights[3]
-    loaded_weights[2] = (first_cap / total_cap) * total_load
-    loaded_weights[3] = (second_cap / total_cap) * total_load
-    return loaded_weights
-}

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

@@ -1,50 +0,0 @@
-/**
- * Pin and axle reaction forces from static equilibrium solution.
- */
-export class ChassiForces
-{
-    private pin_forces: number[] = []
-    private axle_forces: number[] = []
-
-    /**
-     * @param pin_forces_list - Pin reaction forces.
-     */
-    add_pin_forces(pin_forces_list: number[]): void
-    {
-        this.pin_forces = pin_forces_list.map((value) => Number(value))
-    }
-
-    /**
-     * @param axle_forces_list - Axle reaction forces (cargo load per axle).
-     */
-    add_axle_forces(axle_forces_list: number[]): void
-    {
-        this.axle_forces = axle_forces_list.map((value) => Number(value))
-    }
-
-    /**
-     * @param axle_index - Zero-based axle index.
-     * @returns Force on axle.
-     */
-    get_force_on_axle(axle_index: number): number
-    {
-        return this.axle_forces[axle_index]
-    }
-
-    /**
-     * @param pin_index - Zero-based pin index.
-     * @returns Force on pin.
-     */
-    get_force_on_pin(pin_index: number): number
-    {
-        return this.pin_forces[pin_index]
-    }
-
-    /**
-     * @returns Axle index list.
-     */
-    list_axles_indexes(): number[]
-    {
-        return this.axle_forces.map((_force, index) => index)
-    }
-}

package/src/core/physics/models/deflection/beam_deflection.ts

@@ -1,105 +0,0 @@
-import type { AllocatedItemManager } from '../../items/allocated_item_manager.js'
-import { DeflectionSupportManager } from './deflection_support_manager.js'
-import { IntegrationConstantCalculator } from './integration_constant_calculator.js'
-
-/**
- * Cantilever beam deflection curve (DRAGON-76).
- */
-export class BeamDeflection
-{
-    private readonly support_manager: DeflectionSupportManager
-    private readonly constant_1: number
-    private readonly constant_2: number
-    private readonly external_forces: [number, number][]
-
-    /**
-     * @param support_data - Support positions and forces.
-     * @param allocated_item_manager - Load items.
-     * @param external_forces - Optional external point loads.
-     */
-    constructor(
-        support_data: [number, number][],
-        private readonly allocated_item_manager: AllocatedItemManager,
-        external_forces: [number, number][] = []
-    )
-    {
-        this.support_manager = new DeflectionSupportManager(support_data)
-        this.external_forces = this.support_manager
-            .add_structural_offset_to_external_forces(external_forces)
-        const integration = new IntegrationConstantCalculator(
-            this.support_manager,
-            this.support_manager.structural_offset)
-        ;[this.constant_1, this.constant_2] = integration.calculate_integration_constants(
-            allocated_item_manager)
-    }
-
-    /**
-     * @param beam_length - Container beam length.
-     * @param number_of_curve_samples - Sample count.
-     * @returns Deflection values along beam.
-     */
-    generate_curve_values(beam_length: number, number_of_curve_samples: number): number[]
-    {
-        const length = beam_length + this.support_manager.structural_offset
-        const y_values: number[] = []
-        for (let index = 0; index < number_of_curve_samples; index++)
-        {
-            const x = (length * index) / (number_of_curve_samples - 1)
-            y_values.push(this.evaluate_at_x(x))
-        }
-        return y_values
-    }
-
-    private evaluate_at_x(x: number): number
-    {
-        let value = this.constant_1 * x + this.constant_2
-        value += this.item_cubic_contribution(x)
-        value += this.support_cubic_contribution(x)
-        value += this.external_cubic_contribution(x)
-        return value
-    }
-
-    private item_cubic_contribution(x: number): number
-    {
-        let value = 0
-        for (const item_index of this.allocated_item_manager.list_item_indexes())
-        {
-            const item = this.allocated_item_manager.get_item(item_index)
-            const position = item.zi + item.length / 2 + this.support_manager.structural_offset
-            const displacement = x - position
-            if (displacement > 0)
-            {
-                value += (-item.weight / 6) * displacement ** 3
-            }
-        }
-        return value
-    }
-
-    private support_cubic_contribution(x: number): number
-    {
-        let value = 0
-        for (const support_index of this.support_manager.list_support_indexes())
-        {
-            const displacement = x - this.support_manager.get_position(support_index)
-            if (displacement > 0)
-            {
-                value += (this.support_manager.get_force(support_index) / 6) * displacement ** 3
-            }
-        }
-        return value
-    }
-
-    private external_cubic_contribution(x: number): number
-    {
-        let value = 0
-        for (const [position, force] of this.external_forces)
-        {
-            const displacement = x - position
-            if (displacement > 0)
-            {
-                value += (force / 6) * displacement ** 3
-            }
-        }
-        return value
-    }
-}

package/src/core/physics/models/deflection/bitrem_deflection.ts

@@ -1,68 +0,0 @@
-import { CHASSI_REFERENCE } from '../../../contracts/chassi_reference.js'
-import type { BitremModel } from '../bitrem_model.js'
-import type { ChassiForces } from '../chassi_forces.js'
-import type { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
-import { BeamDeflection } from './beam_deflection.js'
-import { calculate_deflection_indicator } from './deflection_tools.js'
-
-/**
- * Bitrem interlink + semi beam deflection (sum of two indicators).
- */
-export class BitremDeflection
-{
-    /**
-     * @param bitrem_model - Axle weight model.
-     * @param number_of_curve_samples - Curve sample count.
-     */
-    constructor(
-        private readonly bitrem_model: BitremModel,
-        private readonly number_of_curve_samples: number
-    )
-    {}
-
-    /**
-     * @param multi_items - Allocated items.
-     * @returns Combined deflection indicator.
-     */
-    calculate_deflection(multi_items: MultiContainerAllocatedItems): number
-    {
-        const forces = this.bitrem_model.calculate_chassi_forces(multi_items)
-        const interlink = this.interlink_curve(multi_items, forces)
-        const semi = this.semitrailer_curve(multi_items, forces)
-        return calculate_deflection_indicator(interlink)
-            + calculate_deflection_indicator(semi)
-    }
-
-    private interlink_curve(multi_items: MultiContainerAllocatedItems, forces: ChassiForces): number[]
-    {
-        const pin_1 = this.bitrem_model.chassi.get_pin_position(0, CHASSI_REFERENCE.GROUPER_1)
-        const axle_3 = this.bitrem_model.chassi.get_axle_position(2, CHASSI_REFERENCE.GROUPER_1)
-        const support: [number, number][] = [
-            [pin_1, forces.get_force_on_pin(0)],
-            [axle_3, forces.get_force_on_axle(2) + forces.get_force_on_axle(3)]
-        ]
-        const pin_2 = this.bitrem_model.chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_1)
-        const external: [number, number][] = [[pin_2, -forces.get_force_on_pin(1)]]
-        const items = multi_items.get_allocated_items_by_grouper_index(1)
-        const pin_2_pos = pin_2
-        const length = Math.max(pin_2_pos, axle_3)
-        return new BeamDeflection(support, items, external).generate_curve_values(
-            length,
-            this.number_of_curve_samples)
-    }
-
-    private semitrailer_curve(multi_items: MultiContainerAllocatedItems, forces: ChassiForces): number[]
-    {
-        const pin_2 = this.bitrem_model.chassi.get_pin_position(1, CHASSI_REFERENCE.GROUPER_2)
-        const axle_4 = this.bitrem_model.chassi.get_axle_position(4, CHASSI_REFERENCE.GROUPER_2)
-        const support: [number, number][] = [
-            [pin_2, forces.get_force_on_pin(1)],
-            [axle_4, forces.get_force_on_axle(4)]
-        ]
-        const items = multi_items.get_allocated_items_by_grouper_index(2)
-        const length = this.bitrem_model.chassi.get_grouper_end(2, CHASSI_REFERENCE.GROUPER_2)
-        return new BeamDeflection(support, items).generate_curve_values(
-            length,
-            this.number_of_curve_samples)
-    }
-}

package/src/core/physics/models/deflection/create_deflection_delegate.ts

@@ -1,46 +0,0 @@
-import { VEHICLE_TYPE, type VehicleTypeCode } from '../../../contracts/vehicle_type.js'
-import type { Transport } from '../../transports/transport.js'
-import { SemiReboqueModel } from '../semi_reboque_model.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 { SemiReboqueDeflection } from './semi_reboque_deflection.js'
-import { BitremDeflection } from './bitrem_deflection.js'
-import { RodotremDeflection } from './rodotrem_deflection.js'
-import { VanderleiaDeflection } from './vanderleia_deflection.js'
-import { SimpleTruckDeflection } from './simple_truck_deflection.js'
-
-type DeflectionDelegate = {
-    calculate_deflection: (multi: import('../../items/multi_container_allocated_items.js').MultiContainerAllocatedItems) => number
-}
-
-type DelegateFactory = (transport: Transport, samples: number) => DeflectionDelegate
-
-const DELEGATE_BY_TYPE: Partial<Record<VehicleTypeCode, DelegateFactory>> = {
-    [VEHICLE_TYPE.SEMIREBOQUE]: (t, n) => new SemiReboqueDeflection(new SemiReboqueModel(t), n),
-    [VEHICLE_TYPE.REBAIXADO]: (t, n) => new SemiReboqueDeflection(new SemiReboqueModel(t), n),
-    [VEHICLE_TYPE.BITREM]: (t, n) => new BitremDeflection(new BitremModel(t), n),
-    [VEHICLE_TYPE.RODOTREM]: (t, n) => new RodotremDeflection(new RodotremModel(t), n),
-    [VEHICLE_TYPE.VANDERLEIA]: (t, n) => new VanderleiaDeflection(new VanderleiaModel(t), n),
-    [VEHICLE_TYPE.CAMINHAO]: (t, n) => new SimpleTruckDeflection(new SimpleTruckModel(t), n),
-    [VEHICLE_TYPE.VUC]: (t, n) => new SimpleTruckDeflection(new SimpleTruckModel(t), n)
-}
-
-/**
- * @param transport - Parsed transport.
- * @param number_of_curve_samples - Sample count for deflection curve.
- * @returns Vehicle-specific deflection delegate.
- */
-export function create_deflection_delegate(
-    transport: Transport,
-    number_of_curve_samples: number
-): DeflectionDelegate
-{
-    const factory = DELEGATE_BY_TYPE[transport.vehicle_type]
-    if (!factory)
-    {
-        throw new Error('Deflection model of this vehicle is not implemented yet')
-    }
-    return factory(transport, number_of_curve_samples)
-}

package/src/core/physics/models/deflection/deflection_model.ts

@@ -1,33 +0,0 @@
-import type { Transport } from '../../transports/transport.js'
-import type { AllocatedItemManager } from '../../items/allocated_item_manager.js'
-import { MultiContainerAllocatedItems } from '../../items/multi_container_allocated_items.js'
-import { create_deflection_delegate } from './create_deflection_delegate.js'
-
-type DeflectionDelegate = ReturnType<typeof create_deflection_delegate>
-
-/**
- * Vehicle-specific beam deflection facade (DRAGON-76).
- */
-export class DeflectionModel
-{
-    private readonly delegate: DeflectionDelegate
-
-    /**
-     * @param transport - Parsed transport.
-     * @param number_of_curve_samples - Curve sample count.
-     */
-    constructor(transport: Transport, number_of_curve_samples: number)
-    {
-        this.delegate = create_deflection_delegate(transport, number_of_curve_samples)
-    }
-
-    /**
-     * @param allocated_by_sequence - Items per container sequence.
-     * @returns Deflection indicator.
-     */
-    calculate_deflection(allocated_by_sequence: Record<number, AllocatedItemManager>): number
-    {
-        const multi = new MultiContainerAllocatedItems(allocated_by_sequence)
-        return this.delegate.calculate_deflection(multi)
-    }
-}

package/src/core/physics/models/deflection/deflection_support_manager.ts

@@ -1,56 +0,0 @@
-/**
- * Ordered support positions and reaction forces for beam deflection.
- */
-export class DeflectionSupportManager
-{
-    structural_offset = 0
-    private readonly support_data: [number, number][]
-
-    /**
-     * @param support_data - [[position, force], ...] sorted by position.
-     */
-    constructor(support_data: [number, number][])
-    {
-        this.support_data = support_data.map((row) => [...row] as [number, number])
-        this.evaluate_structural_offset()
-    }
-
-    list_support_indexes(): number[]
-    {
-        return this.support_data.map((_row, index) => index)
-    }
-
-    get_position(support_index: number): number
-    {
-        return this.support_data[support_index][0]
-    }
-
-    get_force(support_index: number): number
-    {
-        return this.support_data[support_index][1]
-    }
-
-    /**
-     * @param external_forces - Optional extra point loads.
-     * @returns Forces with structural offset applied to positions.
-     */
-    add_structural_offset_to_external_forces(
-        external_forces: [number, number][]
-    ): [number, number][]
-    {
-        return external_forces.map(([position, force]) => [
-            position + this.structural_offset,
-            force
-        ])
-    }
-
-    private evaluate_structural_offset(): void
-    {
-        const leftmost = Math.min(...this.support_data.map((row) => row[0]))
-        this.structural_offset = leftmost < 0 ? -leftmost : 0
-        for (const row of this.support_data)
-        {
-            row[0] += this.structural_offset
-        }
-    }
-}

package/src/core/physics/models/deflection/deflection_tools.ts

@@ -1,11 +0,0 @@
-/**
- * @param curve_values - Beam deflection samples.
- * @returns Scalar deflection indicator.
- */
-export function calculate_deflection_indicator(curve_values: number[]): number
-{
-    const mean = curve_values.reduce((sum, value) => sum + value, 0) / curve_values.length
-    const variance = curve_values.reduce((sum, value) => sum + (value - mean) ** 2, 0)
-        / curve_values.length
-    return Math.sqrt(variance) + Math.abs(mean)
-}