@jetta/blocks-allocator 0.2.1-0 → 0.2.1-2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/blocks-allocator",
-    "version": "0.2.1-0",
+    "version": "0.2.1-2",
     "description": "Blocks wall allocation library",
     "main": "src/index.js",
     "exports": {
@@ -40,6 +40,7 @@
     "author": "",
     "license": "ISC",
     "dependencies": {
+        "@jetta/axle-load-calculator": "^0.4.1",
         "@jetta/empty-spaces-manager": "^0.1.1-0",
         "@jetta/item-amount-controller": "0.1.0-0",
         "@jetta/logger": "^2.0.1",

package/src/Allocation_Attempt.js

@@ -22,12 +22,14 @@ class Allocation_Attempt
     #item_list
     #amount_controller
     #allocator
+    #transport
 
     constructor(input_state)
     {
         this.#item_list  = input_state.items_to_allocate
         this.#amount_controller  = new Item_Amount_Controller(input_state.items_to_allocate)
         this.#allocator          = new Block_Allocator()
+        this.#transport          = input_state.transport
     }
 
     /**
@@ -103,7 +105,8 @@ class Allocation_Attempt
             this.#item_list,
             block_amount_map,
             effective_item_list,
-            picking_continuity_seed
+            picking_continuity_seed,
+            this.#transport
         )
         this.#update_state(container, allocation_output)
         mark_trace_outcome(TRACE_CONTEXT.BLOCK_WALL_ALLOCATED)

package/src/Allocation_Optimization/Block_Allocator.js

@@ -19,7 +19,8 @@ class Block_Allocator
         item_list,
         block_amount_map,
         effective_item_list,
-        picking_continuity_seed
+        picking_continuity_seed,
+        transport
     )
     {
         this.#next_group_id = resolve_next_group_id(container, this.#next_group_id)
@@ -47,7 +48,8 @@ class Block_Allocator
             item_amount_map,
             container,
             picking_continuity_seed,
-            optimized_blocks.block_instance_item_queues
+            optimized_blocks.block_instance_item_queues,
+            transport
         )
 
         if (block_builder_output.allocated_item_list.length === 0)
@@ -85,7 +87,8 @@ class Block_Allocator
         item_amount_map,
         container,
         picking_continuity_seed,
-        block_instance_item_queues
+        block_instance_item_queues,
+        transport
     )
     {
         const block_builder_data = this.#create_blocks_builder_data(
@@ -94,7 +97,8 @@ class Block_Allocator
             item_list,
             item_amount_map,
             container,
-            picking_continuity_seed
+            picking_continuity_seed,
+            transport
         )
         block_builder_data.block_instance_item_queues = block_instance_item_queues ?? new Map()
         const block_builder        = new Block_Builder(block_builder_data)
@@ -109,7 +113,8 @@ class Block_Allocator
         item_list,
         item_amount_map,
         container,
-        picking_continuity_seed
+        picking_continuity_seed,
+        transport
     )
     {
         return {
@@ -119,7 +124,8 @@ class Block_Allocator
             item_amount_map: item_amount_map,
             container: container,
             picking_continuity_seed: picking_continuity_seed,
-            next_group_id: this.#next_group_id
+            next_group_id: this.#next_group_id,
+            transport: transport
         }
     }
 

package/src/Allocation_Optimization/block_builder/Block_Wall_Builder.js

@@ -12,6 +12,7 @@ const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
 const assert_tie_ratio_block_matches_orientation_below = require('./assert_tie_ratio_block_matches_orientation_below')
 const snap_elevated_block_wall_items = require('./snap_elevated_block_wall_items')
 const should_omit_block_group_id = require('./should_omit_block_group_id')
+const assert_layout_fits_axle_load = require('../item_consumption_heuristic/axle_load/assert_layout_fits_axle_load')
 const allocated_items_weight_sum = (item_list) => item_list.reduce((acc, item) => acc + item.get_weight(), 0)
 
 /**
@@ -124,7 +125,8 @@ function build_a_block(chosen_block, is_single_slot, state, wall_data, pending_w
         wall_data.allocated_blocks_amount,
         state.container_supported_weight,
         item_position,
-        state.last_chosen_item_id
+        state.last_chosen_item_id,
+        pending_wall_allocated_items
     )
     let realigned_item_list = item_in_block_list
     try
@@ -143,6 +145,11 @@ function build_a_block(chosen_block, is_single_slot, state, wall_data, pending_w
             state,
             pending_wall_allocated_items
         )
+        assert_layout_fits_axle_load(
+            wall_data,
+            pending_wall_allocated_items,
+            realigned_item_list
+        )
     }
     catch (error)
     {

package/src/Allocation_Optimization/block_builder/Blocks_Builder.js

@@ -15,11 +15,13 @@ module.exports = class Block_Builder
             container: block_builder_data.container,
             picking_continuity_seed: block_builder_data.picking_continuity_seed,
             block_instance_item_queues: block_builder_data.block_instance_item_queues ?? new Map(),
+            transport: block_builder_data.transport,
             heuristic: new Slots_Items_Assigner(
                 block_builder_data.space_to_allocate,
                 block_builder_data.item_list,
                 block_builder_data.item_amount_map.copy(),
-                block_builder_data.container
+                block_builder_data.container,
+                block_builder_data.transport
             ),
             allocated_blocks_amount: {},
             next_group_id: block_builder_data.next_group_id ?? 0

package/src/Allocation_Optimization/block_builder/Slot_Item_Assigner.js

@@ -9,7 +9,8 @@ module.exports = function assign_item_to_slots(
     allocated_blocks_amount,
     container_supported_weight,
     item_position,
-    picking_continuity_seed
+    picking_continuity_seed,
+    pending_wall_allocated_items
 )
 {
     try
@@ -18,7 +19,8 @@ module.exports = function assign_item_to_slots(
             block,
             container_supported_weight,
             item_position,
-            picking_continuity_seed
+            picking_continuity_seed,
+            pending_wall_allocated_items
         )
         return assigned_item_list
     }

package/src/Allocation_Optimization/item_consumption_heuristic/Item_Chooser.js

@@ -1,23 +1,11 @@
 const No_Available_Items_Exception = require('./exceptions/No_Available_Items_Exception')
-const No_Slots_For_Items_Exception = require('./exceptions/No_Slots_For_Items_Exception')
 const Cargo_Profile = require('../../models/Cargo_Profile')
-const No_Suitable_Item_Exception = require('../block_builder/exceptions/No_Suitable_Item_Exception')
-const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
-const Allocated_Item = require('../../models/Allocated_Item')
-const { distribute_items_by_weight_range } = require('./Weight_Slot_Distribution')
-const {
-    resolve_choose_item_heuristic_context,
-    format_slot_label_for_exception
-} = require('./Choose_Item_Heuristic_Context')
-const {
-    calculate_total_stack_slots,
-    sort_stacking_slots_by_proximity
-} = require('./Stack_Slot_Calculator')
-const { order_items_by_capacity_bias } = require('./Capacity_Bias_Item_Order')
+const { select_slot_item, select_preferred_or_heuristic } = require('./select_slot_item')
 
 /**
  * Chooses an item from available items by distributing them into stacking slots by weight
  * and returning the item in the slot closest to the block slot position.
+ * When the axle gate is on, legal SKUs in that band are ranked by hottest-axle ratio.
  * @param {object} data - Input bag.
  * @param {object} [data.slot] - Slot with get_y() and get_height() (production).
  * @param {object} [data.block_slot] - Legacy alias for slot (tests).
@@ -40,120 +28,8 @@ module.exports = function choose_item(data)
     {
         throw new No_Available_Items_Exception()
     }
-    const is_to_prefer_same_id = data.block.get_slot_list().length > 0 && previous_chosen_item_id !== undefined && Cargo_Profile.prefer_block_with_same_item()
-    return is_to_prefer_same_id ? prefer_same_id(data) : choose_item_with_heuristic(data)
-}
-
-function prefer_same_id(data)
-{
-    const { container, item_list, previous_chosen_item_id, item_position } = data
-    const allocation_item = item_list.find(item => item.get_id() === previous_chosen_item_id)
-    if (allocation_item)
-    {
-        const result = is_stacking_valid(container, allocation_item, item_position, data.block)
-        if (result.is_valid)
-        {
-            return result.allocated_item
-        }
-    }
-
-    return choose_item_with_heuristic(data)
-}
-
-/**
- * Heuristic path: weight bands, proximity-ordered bands, stacking validation per candidate.
- * @param {object} data - Input bag (see choose_item).
- * @returns {object} Chosen item.
- */
-function choose_item_with_heuristic(data)
-{
-    const { slot, container, item_position } = resolve_choose_item_heuristic_context(data)
-    const { item_list, qty_of_slots } = data
-    const total_slots = calculate_total_stack_slots(container.get_height(), slot)
-    const stacking_slots = distribute_items_by_weight_range(item_list, total_slots)
-    const ordered_bands = sort_stacking_slots_by_proximity(
-        stacking_slots,
-        slot.get_y(),
-        slot.get_height()
-    )
-
-    for (const band of ordered_bands)
-    {
-        const candidate_items = band.items
-        while (candidate_items.length > 0)
-        {
-            const allocation_item = get_item(candidate_items, qty_of_slots, container)
-            const result = is_stacking_valid(container, allocation_item, item_position, data.block)
-            if (result.is_valid)
-            {
-                return result.allocated_item
-            }
-
-            remove_item_from_candidate_list(candidate_items, allocation_item)
-        }
-    }
-
-    const slot_label = format_slot_label_for_exception(slot)
-    throw new No_Suitable_Item_Exception(ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM, [slot_label])
-}
-
-function is_stacking_valid(container, allocation_item, item_position, block)
-{
-    const allocated_item = new Allocated_Item(
-        allocation_item,
-        item_position.x,
-        item_position.y,
-        item_position.z
-    )
-    if (should_defer_loose_on_block_stacking_validation(block))
-    {
-        return {
-            is_valid: true,
-            allocated_item
-        }
-    }
-    const is_valid = container.is_a_valid_stacking(allocated_item)
-
-    return {
-        is_valid,
-        allocated_item
-    }
-}
-
-function should_defer_loose_on_block_stacking_validation(block)
-{
-    return Cargo_Profile.stack_loose_on_tie_ratio_blocks()
-        && block?.get_slot_list?.().length === 1
-}
-
-function remove_item_from_candidate_list(candidate_item_list, allocation_item)
-{
-    const index = candidate_item_list.indexOf(allocation_item)
-    if (index > -1)
-    {
-        candidate_item_list.splice(index, 1)
-    }
-}
-
-function get_item(item_list, qty_of_slots, container)
-{
-    if (qty_of_slots === undefined)
-    {
-        throw new No_Slots_For_Items_Exception()
-    }
-
-    if (item_list.length === 0)
-    {
-        throw new No_Available_Items_Exception()
-    }
-
-    const ordered_item_list = order_items_by_capacity_bias(item_list, container)
-    const preferable_item_list = ordered_item_list.filter(item => item.get_amount() >= qty_of_slots)
-
-    if (preferable_item_list.length > 0)
-    {
-        return preferable_item_list[0]
-    }
-
-    return ordered_item_list[0]
+    const is_to_prefer_same_id = data.block.get_slot_list().length > 0
+        && previous_chosen_item_id !== undefined
+        && Cargo_Profile.prefer_block_with_same_item()
+    return is_to_prefer_same_id ? select_preferred_or_heuristic(data) : select_slot_item(data)
 }

package/src/Allocation_Optimization/item_consumption_heuristic/Slots_Items_Assigner.js

@@ -1,7 +1,7 @@
 const choose_item_for_slot = require('./Item_For_Slot_Chooser')
 const No_Suitable_Item_Exception = require('../block_builder/exceptions/No_Suitable_Item_Exception')
 const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
-const Allocated_Item = require('../../models/Allocated_Item')
+const assign_one_plan_slot = require('./assign_one_plan_slot')
 const { block_has_sufficient_shape_stock } = require('../block_builder/block_shape_stock')
 const { Logger } = require('@jetta/logger')
 const logger = new Logger('Item Consumption Heuristic')
@@ -26,6 +26,12 @@ function process_one_slot(data)
     return { allocated_item, next_weight }
 }
 
+function pending_items_for_slot(pending_wall_allocated_items, allocated_item_list, index)
+{
+    const filled_slots = allocated_item_list.slice(0, index).filter(Boolean)
+    return (pending_wall_allocated_items ?? []).concat(filled_slots)
+}
+
 /**
  * Assigns items to block slots using a consumption heuristic (slot order and stacking).
  */
@@ -35,18 +41,21 @@ class Item_Consumption_Heuristic
     #item_map = {}
     #item_amount_map
     #container
+    #transport
 
     /**
      * @param {object[]} item_list - Items available for allocation.
      * @param {object} item_amount_map - Tracks remaining amount per item.
      * @param {object} container - Target container.
+     * @param {object} [transport] - Transport holding the axle env template.
      */
-    constructor(empty_space, item_list, item_amount_map, container)
+    constructor(empty_space, item_list, item_amount_map, container, transport)
     {
         this.#empty_space = empty_space
         this.#item_map = build_item_map(item_list)
         this.#item_amount_map = item_amount_map
         this.#container = container
+        this.#transport = transport
     }
 
     /**
@@ -55,9 +64,16 @@ class Item_Consumption_Heuristic
      * @param {number} container_supported_weight - Supported weight for the layer.
      * @param {object} item_position - Base block position { x, y, z } before per-slot offsets (from space / block placement).
      * @param {string|undefined} picking_continuity_seed - Prior SKU id to prefer on the first slot.
+     * @param {object[]} [pending_wall_allocated_items] - Items already chosen in this wall.
      * @returns {object[]|undefined} Allocated items, or undefined if a non-rethrown error occurred.
      */
-    assign_items_to_slots(block, container_supported_weight, item_position, picking_continuity_seed)
+    assign_items_to_slots(
+        block,
+        container_supported_weight,
+        item_position,
+        picking_continuity_seed,
+        pending_wall_allocated_items
+    )
     {
         const slot_count = block.get_slot_list().length
         if (slot_count === 0)
@@ -76,7 +92,8 @@ class Item_Consumption_Heuristic
             block,
             Number(container_supported_weight),
             item_position,
-            picking_continuity_seed
+            picking_continuity_seed,
+            pending_wall_allocated_items
         )
     }
 
@@ -86,9 +103,16 @@ class Item_Consumption_Heuristic
      * @param {string[]} slot_item_ids - Item ids per slot (same order as ordered slots).
      * @param {number} container_supported_weight
      * @param {object} item_position
+     * @param {object[]} [pending_wall_allocated_items]
      * @returns {object[]}
      */
-    assign_items_from_plan(block, slot_item_ids, container_supported_weight, item_position)
+    assign_items_from_plan(
+        block,
+        slot_item_ids,
+        container_supported_weight,
+        item_position,
+        pending_wall_allocated_items
+    )
     {
         const slot_list = order_slots_by_y(block.get_slot_list())
         const allocated_item_list = []
@@ -97,31 +121,22 @@ class Item_Consumption_Heuristic
         {
             const slot = slot_list[index]
             const item_id = slot_item_ids[index]
-            const allocation_item = this.#item_map[item_id]
-            if (!allocation_item || allocation_item.get_amount() <= 0)
-            {
-                throw new No_Suitable_Item_Exception(
-                    ALLOCATOR_MESSAGE.LP_PLAN_ITEM_UNAVAILABLE,
-                    [String(item_id), slot.to_string()]
-                )
-            }
-
-            const current_item_position = this.#update_item_position(item_position, slot)
-            const allocated_item = new Allocated_Item(
-                allocation_item,
-                current_item_position.x,
-                current_item_position.y,
-                current_item_position.z
-            )
-
-            if (!this.#container.is_a_valid_stacking(allocated_item))
-            {
-                throw new No_Suitable_Item_Exception(
-                    ALLOCATOR_MESSAGE.LP_PLAN_ITEM_STACKING_FAILED,
-                    [String(item_id), slot.to_string()]
-                )
-            }
-
+            const allocated_item = assign_one_plan_slot({
+                item_id,
+                slot,
+                allocation_item: this.#item_map[item_id],
+                item_position: this.#update_item_position(item_position, slot),
+                container: this.#container,
+                axle_probe: {
+                    transport: this.#transport,
+                    container: this.#container,
+                    pending_axle_items: pending_items_for_slot(
+                        pending_wall_allocated_items,
+                        allocated_item_list,
+                        allocated_item_list.length
+                    )
+                }
+            })
             this.#item_amount_map.discount_single_item(allocated_item)
             allocated_item_list.push(allocated_item)
         }
@@ -139,7 +154,13 @@ class Item_Consumption_Heuristic
         }
     }
 
-    #assign_items_for_ordered_slots(block, initial_weight, starting_item_position, picking_continuity_seed)
+    #assign_items_for_ordered_slots(
+        block,
+        initial_weight,
+        starting_item_position,
+        picking_continuity_seed,
+        pending_wall_allocated_items
+    )
     {
         const slot_list = order_slots_by_y(block.get_slot_list())
         const allocated_item_list = new Array(slot_list.length)
@@ -162,7 +183,13 @@ class Item_Consumption_Heuristic
                 item_amount_map: provisional_amount_map,
                 previous_chosen_item_id,
                 qty_of_slots,
-                item_position: current_item_position
+                item_position: current_item_position,
+                transport: this.#transport,
+                pending_axle_items: pending_items_for_slot(
+                    pending_wall_allocated_items,
+                    allocated_item_list,
+                    index
+                )
             })
             allocated_item_list[index] = result.allocated_item
             current_weight = result.next_weight

package/src/Allocation_Optimization/item_consumption_heuristic/assign_one_plan_slot.js

@@ -0,0 +1,53 @@
+const Allocated_Item = require('../../models/Allocated_Item')
+const No_Suitable_Item_Exception = require('../block_builder/exceptions/No_Suitable_Item_Exception')
+const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
+const candidate_item_fits_axle_load = require('./axle_load/candidate_item_fits_axle_load')
+
+/**
+ * Places one LP-plan item onto a slot, validating stacking and axle load.
+ * @param {object} data
+ * @returns {object}
+ */
+function assign_one_plan_slot(data)
+{
+    const allocated_item = create_plan_allocated_item(data)
+    if (!data.container.is_a_valid_stacking(allocated_item))
+    {
+        throw new No_Suitable_Item_Exception(
+            ALLOCATOR_MESSAGE.LP_PLAN_ITEM_STACKING_FAILED,
+            [String(data.item_id), data.slot.to_string()]
+        )
+    }
+    if (!candidate_item_fits_axle_load(data.axle_probe, allocated_item))
+    {
+        throw new No_Suitable_Item_Exception(
+            ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM,
+            [data.slot.to_string()]
+        )
+    }
+    return allocated_item
+}
+
+/**
+ * @param {object} data
+ * @returns {object}
+ */
+function create_plan_allocated_item(data)
+{
+    const allocation_item = data.allocation_item
+    if (!allocation_item || allocation_item.get_amount() <= 0)
+    {
+        throw new No_Suitable_Item_Exception(
+            ALLOCATOR_MESSAGE.LP_PLAN_ITEM_UNAVAILABLE,
+            [String(data.item_id), data.slot.to_string()]
+        )
+    }
+    return new Allocated_Item(
+        allocation_item,
+        data.item_position.x,
+        data.item_position.y,
+        data.item_position.z
+    )
+}
+
+module.exports = assign_one_plan_slot

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/assert_layout_fits_axle_load.js

@@ -0,0 +1,26 @@
+const No_Suitable_Item_Exception = require('../../block_builder/exceptions/No_Suitable_Item_Exception')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+const layout_fits_axle_load = require('./layout_fits_axle_load')
+
+/**
+ * Throws when the realigned block items would overload axles.
+ * @param {object} wall_data
+ * @param {object[]} pending_wall_allocated_items
+ * @param {object[]} realigned_item_list
+ * @returns {void}
+ */
+function assert_layout_fits_axle_load(wall_data, pending_wall_allocated_items, realigned_item_list)
+{
+    const extra_items = (pending_wall_allocated_items ?? []).concat(realigned_item_list)
+    const fits = layout_fits_axle_load({
+        transport: wall_data.transport,
+        container: wall_data.container,
+        extra_items
+    })
+    if (!fits)
+    {
+        throw new No_Suitable_Item_Exception(ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM)
+    }
+}
+
+module.exports = assert_layout_fits_axle_load

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/axle_load_exceeds_limit.js

@@ -0,0 +1,62 @@
+const { gt } = require('@jetta/number-compare')
+
+/**
+ * Hottest axle load as a fraction of the folga-adjusted cap. Above 1 is over limit.
+ * @param {object} env - Calculator output env with containers[].pesoEixos.
+ * @param {number} folga_percent - Slack percent (10 means 110% of pesoMaxFinal).
+ * @returns {number}
+ */
+function max_axle_load_ratio(env, folga_percent)
+{
+    let hottest_ratio = 0
+    for (const axle of collect_peso_eixos_rows(env))
+    {
+        hottest_ratio = Math.max(hottest_ratio, axle_row_ratio(axle, folga_percent))
+    }
+    return hottest_ratio
+}
+
+/**
+ * Whether any container axle row exceeds the folga-adjusted final max.
+ * @param {object} env - Calculator output env with containers[].pesoEixos.
+ * @param {number} folga_percent - Slack percent (10 means 110% of pesoMaxFinal).
+ * @returns {boolean}
+ */
+function axle_load_exceeds_limit(env, folga_percent)
+{
+    return gt(max_axle_load_ratio(env, folga_percent), 1)
+}
+
+/**
+ * @param {object} env
+ * @returns {object[]}
+ */
+function collect_peso_eixos_rows(env)
+{
+    const rows = []
+    for (const container of env.containers ?? [])
+    {
+        rows.push(...(container.pesoEixos ?? []))
+    }
+    return rows
+}
+
+/**
+ * @param {object} axle
+ * @param {number} folga_percent
+ * @returns {number}
+ */
+function axle_row_ratio(axle, folga_percent)
+{
+    const loaded_kilograms = Number(axle.pesoCarregadoFinal ?? 0)
+    const max_kilograms = Number(axle.pesoMaxFinal ?? 0)
+    const limit_kilograms = max_kilograms * (1 + folga_percent / 100)
+    if (limit_kilograms === 0)
+    {
+        return loaded_kilograms > 0 ? Number.POSITIVE_INFINITY : 0
+    }
+    return loaded_kilograms / limit_kilograms
+}
+
+module.exports = axle_load_exceeds_limit
+module.exports.max_axle_load_ratio = max_axle_load_ratio

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/candidate_item_axle_score.js

@@ -0,0 +1,42 @@
+const { gt } = require('@jetta/number-compare')
+const Cargo_Profile = require('../../../models/Cargo_Profile')
+const { score_layout_axle_load } = require('./evaluate_layout_axle_load')
+const layout_fits_axle_load = require('./layout_fits_axle_load')
+
+/**
+ * Axle score for one candidate. fits is false when the cap is exceeded or physics fails.
+ * When the gate is off, ratio is 0 and fits is true.
+ * @param {object} data
+ * @param {object} allocated_item
+ * @returns {{ fits: boolean, ratio: number|undefined }}
+ */
+function candidate_item_axle_score(data, allocated_item)
+{
+    if (!Cargo_Profile.enable_axle_load_slot_gate() || !layout_fits_axle_load.transport_has_axles(data.transport))
+    {
+        return { fits: true, ratio: 0 }
+    }
+    const ratio = score_layout_axle_load(layout_probe(data, allocated_item))
+    if (ratio === undefined)
+    {
+        return { fits: false, ratio: undefined }
+    }
+    return { fits: gt(ratio, 1) === false, ratio }
+}
+
+/**
+ * @param {object} data
+ * @param {object} allocated_item
+ * @returns {object}
+ */
+function layout_probe(data, allocated_item)
+{
+    const pending_axle_items = data.pending_axle_items ?? []
+    return {
+        transport: data.transport,
+        container: data.container,
+        extra_items: pending_axle_items.concat(allocated_item)
+    }
+}
+
+module.exports = candidate_item_axle_score