@jetta/axle-load-calculator 0.1.3 → 0.2.0

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

@@ -1,125 +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 { 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

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

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

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

@@ -1,95 +0,0 @@
-/**
- * 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)
-}

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

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

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

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

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

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