紧急疏散场景下乘客出口选择概率计算问题求解

问题分析与修复方案 #

问题1：出口选择概率之和不等于1 #

核心原因：密度相关概率（PSd）的计算逻辑未保证互斥性，且最终加权结果未做归一化处理。

修复步骤：

1. 调整PSd的计算逻辑，确保PSd1 + PSd2 = 1：
   • 当两个出口都有人员时，保持原有密度权重计算；
   • 当仅一个出口有人员时，该出口的密度概率设为0（拥挤导致吸引力降低），另一出口设为1；
2. 对最终计算的PS1和PS2做归一化处理，强制两者和为1，消除加权过程中的误差。

问题2：出口附近无人员时的赋值方案 #

当出口区域无人员时，密度因素不再影响选择，此时直接复用距离概率（PSr）的比例作为密度概率（PSd），让选择逻辑回归距离主导，贴合项目“基于密度评估”的核心目标。

修改后的完整代码 #

to go

  ;; Calcolo PP delle uscite nel vicinato di ogni passeggero
  let sorted-turtles sort passengers
  foreach sorted-turtles [ x -> ask x [

    let cell_exit1 min-one-of exit1 [distance myself] ;;mi ritorna la cella dell'uscita 1 che è più vicina a me, sarà il mio riferimento dell'uscita 1 ; è anche Ri
    let cell_exit2 min-one-of exit2 [distance myself] ;;mi ritorna la cella dell'uscita 2 che è più vicina a me, sarà il mio riferimento dell'uscita 2 ; è anche Ri

    let dist1 [distance myself] of cell_exit1  ;distanza effettiva dall'uscita1
    let dist2 [distance myself] of cell_exit2  ;distanza effettiva dall'uscita2

    let sorted-neighbors sort neighbors
    foreach sorted-neighbors [y -> ask y [

      let dist11 [distance myself] of cell_exit1
      let dist22 [distance myself] of cell_exit2

      ifelse (dist11 < dist1) [
        set pcolor pink
      ]
      [
        if (dist22 < dist2)[
          set pcolor blue
        ]
      ]
    ]]


  ]]

;controllo se sono nell'uscita allora muori
  ask turtles-on exit1 [die]
  ask turtles-on exit2 [die]

  let al-sicuro patches with [pcolor = cyan ]
  ask turtles-on al-sicuro [die]
  move
  tick
end


to move


  let sorted-turtles sort passengers
  foreach sorted-turtles [ x -> ask x [


    let cell_exit1 min-one-of exit1 [distance myself] ;;mi ritorna la cella dell'uscita 1 che è più vicina a me, sarà il mio riferimento dell'uscita 1 ; è anche Ri
    let cell_exit2 min-one-of exit2 [distance myself] ;;mi ritorna la cella dell'uscita 2 che è più vicina a me, sarà il mio riferimento dell'uscita 2 ; è anche Ri
    let dist1 [distance myself] of cell_exit1
    let dist2 [distance myself] of cell_exit2


    ;;PS-DISTANZA in base alla distanza
    let N 2
    let r1 (dist1 ^ Kr)
    let r2 (dist2 ^ Kr)
    let R12 (r1 + r2)

    let PSr1 (1 -  (((N - 1) * r1) / R12) )
    let PSr2 (1 -  (((N - 1) * r2) / R12) )

    ;;PS-OD in base al numero di persone all'uscita
    let d1 count turtles-on patches with [pcolor = magenta] ; HERE
    let d2 count turtles-on patches with [pcolor = sky] ; HERE

    let d1k (d1 ^ Kd)
    let d2k (d2 ^ Kd)
    let D12 (d1k + d2k)

    ;; 初始化PSd为PSr比例，无人员时直接复用距离概率
    let PSd1 PSr1
    let PSd2 PSr2

    ;; 调整PSd计算逻辑，保证PSd1 + PSd2 = 1
    if (D12 > 0) [
      if (d1 > 0 and d2 > 0) [
        set PSd1 (1 -  (((N - 1) * d1k) / D12) )
        set PSd2 (1 -  (((N - 1) * d2k) / D12) )
      ] else if (d1 > 0) [
        ;; 仅出口1有人员，拥挤导致吸引力为0，全部选出口2
        set PSd1 0
        set PSd2 1
      ] else if (d2 > 0) [
        ;; 仅出口2有人员，全部选出口1
        set PSd1 1
        set PSd2 0
      ]
    ]

    ;; CALCOLO PS finale in base a SD e OD
    let alpha1 abs (1 -  ((dist1 *  N) / R12)) ^ Kr
    let alpha2 abs (1 -  ((dist2 *  N) / R12)) ^ Kr
    let alpha_tot (alpha1 + alpha2 ) / N

    let beta1 0
    let beta2 0
    let beta_tot 0

    if (D12 > 0)[
      set beta1 abs (1 -  ((d1 *  N) / D12)) ^ Kd
      set beta2 abs (1 -  ((d2 *  N) / D12)) ^ Kd
      set beta_tot (beta1 + beta2 ) / N
    ]

    ;; 处理权重和为0的极端情况
    let weight_sum (alpha_tot + beta_tot)
    set weight_sum ifelse-value (weight_sum = 0) [1] [weight_sum]

    let PS1 ((alpha_tot * PSr1) + (beta_tot * PSd1)) / weight_sum
    let PS2 ((alpha_tot * PSr2) + (beta_tot * PSd2)) / weight_sum

    ;; 归一化处理，强制PS1 + PS2 = 1
    let total_prob (PS1 + PS2)
    set PS1 PS1 / total_prob
    set PS2 PS2 / total_prob

    show PS1 ;probabilità finale di scelgiere l'uscita1
    show PS2 ;probabilità finale di scelgiere l'uscita2
    show (PS1 + PS2) ; 验证和为1

    ;;Scelgo verso quale PP spostarmi (PP più vicina all'uscita)
    let PP1 neighbors with [pcolor = pink] ; HERE
    let PP2 neighbors with [pcolor = blue] ; HERE

    let LPP1 min-one-of PP1 [distance cell_exit1] ; HERE 
    let LPP2 min-one-of PP2 [distance cell_exit2] ; HERE


    ifelse (PS1 > PS2)[ ; HERE
        face cell_exit1
        move-to LPP1
    ]
    [
        face cell_exit2
        move-to LPP2
    ]

    ]
  ]

end

内容的提问来源于stack exchange，提问作者accismns