基于skills实现的Pulse 群体仿真

要实现 100人群体同步仿真、SKILL群体化扩展、实时动态多轮交互 ，核心是围绕 Pulse 的"单主体仿真能力"进行 "群体化封装+并行调度+状态闭环管理"，同时扩展 SKILL 中间层的"群体参数管理"和"交互协议"。以下是分模块、可落地的完整方案，覆盖从 Pulse 底层改造到 SKILL 交互层设计的全流程。

一、核心架构设计（三层联动）

整体架构分为 Pulse 底层封装层、SKILL 群体中间层、交互控制层，三层协同实现"群体同步+多轮交互"：

┌─────────────────────────┐      ┌─────────────────────────────────┐      ┌─────────────────────────┐
│  交互控制层（用户/系统）  │      │  SKILL 群体中间层（核心调度）    │      │  Pulse 底层封装层        │
│  - 多轮交互指令输入       │◀────▶│  - 群体参数管理（100人差异化）   │◀────▶│  - 多实例并行调度        │
│  - 实时结果可视化         │      │  - 并行仿真调度（同步/分批）     │      │  - 群体状态持久化        │
│  - 触发条件配置           │      │  - 多轮状态闭环管理             │      │  - 差异化参数注入        │
└─────────────────────────┘      │  - 实时结果聚合与反馈             │      │  - 同步步长控制          │
                                └─────────────────────────────────┘      └─────────────────────────┘

• 核心目标：100人各自保持生理差异化（如年龄、基础疾病），按统一逻辑时间同步仿真；支持多轮交互（如每轮调整运动强度、给药），每轮仿真基于上一轮的最终状态；实时反馈群体/个体结果。

二、第一步：Pulse 底层改造（C++ 层）------ 支持群体同步仿真

Pulse 原生仅支持 单实例单主体仿真，需通过 C++ 层改造实现"100人实例化、并行调度、同步控制、状态持久化"，为上层 SKILL 提供群体仿真接口。

1. 核心改造1：群体差异化参数生成

100人不能用相同生理参数，需基于"生理分布模型"生成差异化参数，确保仿真真实性：

• 参数维度：基础参数（年龄：20-60岁正态分布、体重：50-90kg均匀分布、性别：男50%/女50%）、健康状态（基础疾病比例：高血压10%、糖尿病5%、正常85%）、基础生理指标（静息心率：60-100bpm、血压：110-130/70-90mmHg）。
• 实现方式 ：在 C++ 封装层新增 PopulationParamGenerator 类，通过随机数生成器（结合生理统计学分布）批量生成100人参数，输出为 JSON 数组（每个元素是1个人的完整参数）。

// 群体参数生成类示例
class PopulationParamGenerator {
public:
  // 生成 n 人的差异化参数
  nlohmann::json GeneratePopulationParams(int n) {
    nlohmann::json population_params = nlohmann::json::array();
    std::random_device rd;
    std::mt19937 gen(rd());

    // 年龄分布：20-60岁正态分布（均值35，方差10）
    std::normal_distribution<> age_dist(35, 10);
    // 体重分布：50-90kg均匀分布
    std::uniform_real_distribution<> weight_dist(50.0, 90.0);
    // 性别分布：50%男/50%女
    std::bernoulli_distribution gender_dist(0.5);
    // 高血压比例：10%
    std::bernoulli_distribution hypertension_dist(0.1);

    for (int i = 0; i < n; ++i) {
      int age = std::clamp(static_cast<int>(age_dist(gen)), 20, 60);
      double weight = weight_dist(gen);
      std::string gender = gender_dist(gen) ? "male" : "female";
      bool has_hypertension = hypertension_dist(gen);

      // 基础疾病对生理参数的影响（如高血压患者基础血压升高20%）
      double sys_bp = has_hypertension ? 
        std::uniform_real_distribution<>(130.0, 150.0)(gen) : 
        std::uniform_real_distribution<>(110.0, 130.0)(gen);
      double dia_bp = has_hypertension ? 
        std::uniform_real_distribution<>(85.0, 100.0)(gen) : 
        std::uniform_real_distribution<>(70.0, 90.0)(gen);

      population_params.push_back({
        {"id", i},  // 个体唯一ID（0-99）
        {"subject", {
          {"age", age},
          {"weight", weight},
          {"gender", gender},
          {"has_hypertension", has_hypertension}
        }},
        {"baseline", {  // 基础生理指标（初始化Pulse时使用）
          {"heart_rate", std::uniform_real_distribution<>(60.0, 100.0)(gen)},
          {"systolic_bp", sys_bp},
          {"diastolic_bp", dia_bp}
        }}
      });
    }
    return population_params;
  }
};

2. 核心改造2：多实例并行调度与同步控制

要实现100人"同步测试"，核心是 "逻辑时间同步"（所有个体按相同步长推进仿真，每轮结束后统一进入下一轮），而非物理时间绝对同时。需基于"线程池/进程池"实现并行调度，避免单线程串行导致的效率低下。

方案选择：线程池（轻量高效，适合100人规模）

• 原理：创建固定大小的线程池（如20线程，根据CPU核心数调整），100个个体仿真任务提交到线程池，每轮仿真按统一步长（如0.1秒）推进，所有线程完成当前步长后，再进入下一轮，确保逻辑时间同步。
• 关键控制 ：用 std::barrier（C++20+）或 std::condition_variable 实现"线程同步点"------每轮仿真步长结束后，所有线程等待，直到最后一个线程完成，再开始下一轮。

// 群体仿真调度类示例
class PopulationSimulator {
private:
  int population_size_;  // 群体规模（100）
  std::vector<std::unique_ptr<PulseWrapper>> pulse_instances_;  // 100个Pulse实例
  std::vector<nlohmann::json> individual_states_;  // 每个个体的当前状态（用于多轮交互）
  std::thread_pool pool_;  // 线程池（如20线程）
  std::barrier sync_barrier_;  // 同步屏障（每轮仿真等待所有实例完成）
  double sim_step_;  // 统一仿真步长（0.1秒）

public:
  PopulationSimulator(int size, double step) 
    : population_size_(size), sim_step_(step),
      sync_barrier_(size),  // 屏障等待size个线程（100个个体）
      pool_(20)  // 线程池大小20
  {
    // 1. 生成群体参数
    PopulationParamGenerator param_gen;
    auto population_params = param_gen.GeneratePopulationParams(size);

    // 2. 初始化100个Pulse实例（每个实例对应1个人）
    for (int i = 0; i < size; ++i) {
      auto pulse = std::make_unique<PulseWrapper>();
      auto& params = population_params[i];
      // 初始化Pulse实例（使用个体差异化参数）
      pulse->Init();
      pulse->SetSubjectParameters(params["subject"]);
      pulse->SetBaselinePhysiology(params["baseline"]);  // 自定义接口：设置基础生理指标
      pulse_instances_.push_back(std::move(pulse));
      // 初始化个体状态（初始状态为仿真前）
      individual_states_.push_back({{"id", i}, {"current_time", 0.0}, {"state", params["baseline"]}});
    }
  }

  // 单轮群体同步仿真（持续 duration 秒）
  nlohmann::json RunSingleRoundSimulation(double duration) {
    nlohmann::json round_results = nlohmann::json::array();
    double total_steps = duration / sim_step_;

    for (int step = 0; step < total_steps; ++step) {
      // 提交100个个体的步长仿真任务到线程池
      for (int i = 0; i < population_size_; ++i) {
        pool_.submit([this, i, &round_results, step]() {
          auto& pulse = pulse_instances_[i];
          auto& state = individual_states_[i];

          // 推进当前步长仿真
          pulse->AdvanceStep(sim_step_);  // 自定义接口：单步推进仿真
          double current_time = state["current_time"].get<double>() + sim_step_;
          state["current_time"] = current_time;

          // 获取当前步长的生理状态（如心率、血压）
          auto current_phys = pulse->GetPhysiologyState();
          state["state"] = current_phys;

          // 每1秒记录一次结果（减少数据量）
          if (fmod(current_time, 1.0) < 1e-6) {
            round_results.push_back({
              {"id", i},
              {"time", current_time},
              {"physiology", current_phys}
            });
          }

          // 等待所有个体完成当前步长（同步屏障）
          sync_barrier_.arrive_and_wait();
        });
      }
    }

    // 等待所有线程完成本轮仿真
    pool_.wait();
    return round_results;
  }

  // 多轮交互：更新个体参数（基于上一轮状态）
  bool UpdateIndividualParams(int individual_id, const nlohmann::json& new_params) {
    if (individual_id < 0 || individual_id >= population_size_) {
      std::cerr << "Invalid individual ID: " << individual_id << std::endl;
      return false;
    }
    // 基于上一轮的最终状态，更新参数（如调整运动强度、给药）
    auto& pulse = pulse_instances_[individual_id];
    auto& state = individual_states_[individual_id];
    pulse->UpdateParameters(new_params, state["state"]);  // 自定义接口：基于当前状态更新参数
    return true;
  }

  // 获取所有个体的当前状态（用于多轮交互前的状态展示）
  nlohmann::json GetCurrentPopulationState() {
    nlohmann::json states = nlohmann::json::array();
    for (auto& state : individual_states_) {
      states.push_back(state);
    }
    return states;
  }
};

3. 核心改造3：状态持久化与增量更新

多轮交互的关键是 "状态延续"------每轮仿真的初始状态是上一轮的最终状态，而非重新初始化。需在 Pulse 封装层支持：

• 状态序列化：将每个个体的当前生理状态（如心血管、呼吸、代谢系统的核心参数）序列化为 JSON/Binary，保存到内存（实时交互）或文件（离线多轮）；
• 增量参数更新：支持基于当前状态调整参数（如给ID=10的人注射药物、将所有人的运动强度从0.8调整为0.5），避免覆盖历史状态。

Pulse 原生支持 Serialize 和 Deserialize 接口（通过 Protobuf），可封装为 JSON 格式供上层调用：

// PulseWrapper 类新增状态序列化/更新接口
class PulseWrapper {
public:
  // 获取当前生理状态（序列化为JSON）
  nlohmann::json GetPhysiologyState() {
    // 调用Pulse原生Serialize接口（Protobuf）
    std::string proto_buf;
    engine_->Serialize(proto_buf);
    // 转换为JSON（需编写Protobuf→JSON的映射逻辑）
    return ProtobufToJson(proto_buf);
  }

  // 基于当前状态更新参数（如运动强度、药物剂量）
  bool UpdateParameters(const nlohmann::json& new_params, const nlohmann::json& current_state) {
    // 1. 反序列化当前状态，恢复Pulse引擎状态
    std::string proto_buf = JsonToProtobuf(current_state);
    engine_->Deserialize(proto_buf);

    // 2. 应用新参数（如运动强度、给药）
    if (new_params.contains("exercise_intensity")) {
      double intensity = new_params["exercise_intensity"].get<double>();
      physiology::conditions::Exercise exercise;
      exercise.Intensity(intensity);
      engine_->ProcessCondition(exercise);
    }
    if (new_params.contains("drug_dosage")) {
      // 处理药物注射逻辑（Pulse支持药物模型）
      double dosage = new_params["drug_dosage"].get<double>();
      ApplyDrug(dosage);
    }
    return true;
  }
};

三、第二步：SKILL 中间层扩展------群体仿真与交互调度

基于之前的 SKILL 中间层，新增 "群体管理""多轮交互控制""实时结果处理" 模块，将单主体 SKILL 扩展为支持100人群体的仿真接口，同时适配实时交互需求。

1. 扩展1：群体配置与参数管理模块

新增 pulse_group_config 函数，支持配置群体规模、参数分布、基础疾病比例等，输出标准化群体配置 JSON，供 Pulse 底层调用：

;; SKILL 群体配置函数：生成100人群体参数配置
(defun pulse_group_config (
  &key
  (population_size 100)  ; 群体规模（默认100）
  (age_range '(20 60))   ; 年龄范围
  (hypertension_rate 0.1)  ; 高血压比例
  (diabetes_rate 0.05)    ; 糖尿病比例
)
  ;; 构造群体配置JSON（传递给Pulse底层）
  (setq group_config_json (format nil "{\n"))
  (setq group_config_json (format nil "~a  \"population_size\": ~d,\n" group_config_json population_size))
  (setq group_config_json (format nil "~a  \"age_range\": [~d, ~d],\n" group_config_json (car age_range) (cadr age_range)))
  (setq group_config_json (format nil "~a  \"disease_rates\": {\n" group_config_json))
  (setq group_config_json (format nil "~a    \"hypertension\": ~f,\n" group_config_json hypertension_rate))
  (setq group_config_json (format nil "~a    \"diabetes\": ~f\n" group_config_json diabetes_rate))
  (setq group_config_json (format nil "~a  }\n" group_config_json))
  (setq group_config_json (format nil "~a}" group_config_json))

  ;; 保存配置文件（供Pulse底层读取）
  (setq config_file "/tmp/pulse_group_config.json")
  (setq f (outfile config_file "w"))
  (puts f group_config_json)
  (close f)
  (pulse_mw_log "INFO" (format nil "Group config saved to: %s" config_file))
  return config_file
)

2. 扩展2：群体仿真调度模块

新增 pulse_group_run_simulation 函数，支持：

• 启动/停止群体同步仿真；
• 控制单轮仿真时长；
• 接收群体结果（个体结果+统计结果）；
• 与交互模块联动，支持多轮参数调整。

;; 全局变量：保存群体仿真状态（当前轮次、个体状态、交互规则）
global(pulse_group_state)
pulse_group_state = list(
  "is_running" nil       ; 是否正在仿真
  "current_round" 0      ; 当前轮次
  "population_state" nil ; 所有个体的当前状态
  "group_config" nil     ; 群体配置
)

;; SKILL 群体仿真调度函数：启动单轮群体同步仿真
(defun pulse_group_run_simulation (
  group_config_file  ; 群体配置文件路径（pulse_group_config输出）
  &key
  (round_duration 60.0)  ; 单轮仿真时长（秒）
  (sim_step 0.1)         ; 仿真步长（秒）
  (output_file "/tmp/pulse_group_round_result.json")  ; 轮次结果文件
)
  ;; 1. 检查仿真状态（避免并行冲突）
  (if (cadr (assoc "is_running" pulse_group_state))
    (progn
      (pulse_mw_log "ERROR" "Group simulation is already running!")
      return nil
    )
  )

  ;; 2. 更新群体状态
  (setq pulse_group_state (list
    "is_running" t
    "current_round" (+ (cadr (assoc "current_round" pulse_group_state)) 1)
    "group_config" group_config_file
  ))

  ;; 3. 调用Pulse群体仿真可执行程序（C++改造后的程序）
  (setq pulse_group_exe "/opt/Pulse/bin/pulse_group_sim")  ; 群体仿真封装程序
  (setq cmd (format nil "~a ~a ~f ~f ~a" 
    pulse_group_exe 
    group_config_file 
    round_duration 
    sim_step 
    output_file
  ))
  (pulse_mw_log "INFO" (format nil "Running group simulation round %d: %s" 
    (cadr (assoc "current_round" pulse_group_state)) 
    cmd
  ))

  ;; 4. 执行命令（实时获取输出，支持中断）
  (setq return_code (shell cmd))
  (if (= return_code 0)
    (progn
      (pulse_mw_log "INFO" "Round simulation completed successfully")
      ;; 5. 解析轮次结果（群体结果+个体结果）
      (setq parse_result (pulse_group_parse_result output_file))
      ;; 6. 更新个体当前状态（用于下一轮交互）
      (setq pulse_group_state (append pulse_group_state (list "population_state" (cadr (assoc "population_state" parse_result)))))
      ;; 7. 标记仿真结束
      (setq pulse_group_state (append pulse_group_state (list "is_running" nil)))
      return parse_result
    )
    (progn
      (pulse_mw_log "ERROR" (format nil "Round simulation failed (code: %d)" return_code))
      (setq pulse_group_state (append pulse_group_state (list "is_running" nil)))
      return nil
    )
  )
)

3. 扩展3：多轮交互控制模块

新增 pulse_group_interact 函数，支持 基于个体ID/群体标签的参数调整（如"给ID=5的人给药""将所有高血压患者的运动强度降低0.3"），实现多轮闭环交互：

;; SKILL 群体多轮交互函数：调整个体/群体参数，进入下一轮仿真
(defun pulse_group_interact (
  interaction_rules  ; 交互规则（plist列表）
  &key
  (next_round_duration 60.0)  ; 下一轮仿真时长
)
  ;; 1. 检查当前状态（必须完成上一轮仿真）
  (if (not (cadr (assoc "population_state" pulse_group_state)))
    (progn
      (pulse_mw_log "ERROR" "No previous round state found! Run pulse_group_run_simulation first.")
      return nil
    )
  )

  ;; 2. 解析交互规则，生成参数更新JSON（传递给Pulse底层）
  (setq update_params_json (format nil "{\n"))
  (setq update_params_json (format nil "~a  \"interaction_round\": ~d,\n" update_params_json (cadr (assoc "current_round" pulse_group_state))))
  (setq update_params_json (format nil "~a  \"updates\": [\n" update_params_json))

  (foreach rule interaction_rules
    (setq target_type (cadr (assoc "target_type" rule)))  ; 目标类型："individual"（个体）/"group"（群体标签）
    (setq target_id (cadr (assoc "target_id" rule)))      ; 个体ID（target_type=individual时）
    (setq target_tag (cadr (assoc "target_tag" rule)))    ; 群体标签（如"hypertension"，target_type=group时）
    (setq new_params (cadr (assoc "new_params" rule)))    ; 新参数（如(list "exercise_intensity" 0.5 "drug_dosage" 10.0)）

    ;; 构造单个更新项
    (setq update_item (format nil "    {\n"))
    (if (string= target_type "individual")
      (setq update_item (format nil "~a      \"target_type\": \"individual\",\n      \"target_id\": ~d,\n" update_item target_id))
      (setq update_item (format nil "~a      \"target_type\": \"group\",\n      \"target_tag\": \"~a\",\n" update_item target_tag))
    )
    (setq update_item (format nil "~a      \"new_params\": {\n" update_item))
    (foreach param new_params index
      (if (evenp index)
        (progn
          (setq key (nth index new_params))
          (setq val (nth (+ index 1) new_params))
          (setq update_item (format nil "~a        \"~a\": ~f,\n" update_item key val))
        )
      )
    )
    (setq update_item (format nil "~a      }\n    }," update_item))
    (setq update_params_json (format nil "~a~a" update_params_json update_item))
  )

  (setq update_params_json (format nil "~a  ]\n}" update_params_json))

  ;; 3. 保存参数更新文件
  (setq update_file "/tmp/pulse_group_update.json")
  (setq f (outfile update_file "w"))
  (puts f update_params_json)
  (close f)

  ;; 4. 调用Pulse底层更新参数，并启动下一轮仿真
  (setq pulse_group_exe "/opt/Pulse/bin/pulse_group_sim")
  (setq cmd (format nil "~a ~a ~f ~f ~a --update ~a"
    pulse_group_exe
    (cadr (assoc "group_config" pulse_group_state))
    next_round_duration
    0.1
    (format nil "/tmp/pulse_group_round_%d_result.json" (+ (cadr (assoc "current_round" pulse_group_state)) 1))
    update_file
  ))

  (setq return_code (shell cmd))
  (if (= return_code 0)
    (progn
      (pulse_mw_log "INFO" "Next round simulation started after interaction")
      return t
    )
    (progn
      (pulse_mw_log "ERROR" "Interaction failed to start next round")
      return nil
    )
  )
)

4. 扩展4：实时结果聚合与可视化模块

新增 pulse_group_parse_result 函数，解析群体仿真结果，输出 个体明细 和 群体统计指标（如心率均值、血压分布、异常个体占比），并支持实时可视化：

;; SKILL 群体结果解析函数：聚合个体结果与群体统计
(defun pulse_group_parse_result (result_file)
  ;; 1. 读取结果文件
  (setq f (infile result_file "r"))
  (setq json_str (concat (readlines f)))
  (close f)

  ;; 2. 解析个体结果（ID、时间、生理指标）
  (setq individual_results (pulse_mw_parse_json_array json_str "\"results\""))
  ;; 3. 解析个体当前状态（用于下一轮交互）
  (setq population_state (pulse_mw_parse_json_array json_str "\"population_state\""))

  ;; 4. 计算群体统计指标（以心率为例）
  (setq hr_list nil)
  (foreach individual individual_results
    (setq hr (cadr (assoc "heart_rate" (cadr (assoc "physiology" individual)))))
    (setq hr_list (append hr_list (list hr)))
  )
  (setq hr_mean (apply #'+ hr_list) / (length hr_list))
  (setq hr_max (apply #'max hr_list))
  (setq hr_min (apply #'min hr_list))
  (setq abnormal_hr_count (length (filter (lambda (x) (or (< x 60) (> x 100))) hr_list)))
  (setq abnormal_hr_rate (/ abnormal_hr_count (length hr_list)))

  ;; 5. 构造统计结果
  (setq stats_result (list
    "heart_rate" (list
      "mean" hr_mean
      "max" hr_max
      "min" hr_min
      "abnormal_count" abnormal_hr_count
      "abnormal_rate" abnormal_hr_rate
    )
    ;; 可扩展血压、血氧等其他指标的统计
  ))

  ;; 6. 实时可视化（调用SKILL plot函数）
  (pulse_group_plot_stats stats_result)

  return (list
    "status" "success"
    "individual_results" individual_results
    "population_state" population_state
    "stats_result" stats_result
  )
)

;; SKILL 群体统计可视化函数：绘制心率分布直方图
(defun pulse_group_plot_stats (stats_result)
  (setq hr_stats (cadr (assoc "heart_rate" stats_result)))
  (setq x_labels '("Mean" "Max" "Min" "Abnormal Rate"))
  (setq y_values (list
    (cadr (assoc "mean" hr_stats))
    (cadr (assoc "max" hr_stats))
    (cadr (assoc "min" hr_stats))
    (* 100 (cadr (assoc "abnormal_rate" hr_stats)))
  ))
  (plot x_labels y_values
    :title "Population Physiology Stats (Round %d)" (cadr (assoc "current_round" pulse_group_state))
    :xlabel "Indicator"
    :ylabel "Value"
    :grid t
  )
)

四、第三步：实时动态多轮持续交互的实现

实时动态多轮交互的核心是 "闭环反馈机制"------每轮仿真后，基于结果触发交互（自动/手动），调整参数后启动下一轮，持续循环直到满足停止条件（如轮次结束、异常指标恢复）。

1. 交互触发机制设计

支持两种交互触发方式，满足不同场景需求：

（1）自动触发交互（基于预设条件）

定义触发规则（如"心率>150bpm的个体自动降低运动强度""高血压患者血压>160/100mmHg时给药"），仿真后自动匹配规则并执行参数更新：

;; 自动交互规则定义
(defun pulse_group_auto_interaction_rules ()
  (setq current_state (cadr (assoc "population_state" pulse_group_state)))
  (setq auto_rules nil)

  (foreach individual current_state
    (setq id (cadr (assoc "id" individual)))
    (setq phys (cadr (assoc "state" individual)))
    (setq hr (cadr (assoc "heart_rate" phys)))
    (setq has_hypertension (cadr (assoc "has_hypertension" phys)))
    (setq sys_bp (cadr (assoc "systolic_bp" phys)))

    ;; 规则1：心率>150bpm → 运动强度降低0.3
    (if (> hr 150)
      (setq auto_rules (append auto_rules (list
        (list
          "target_type" "individual"
          "target_id" id
          "new_params" (list "exercise_intensity" (- 0.8 0.3))
        )
      )))
    )

    ;; 规则2：高血压患者收缩压>160 → 给药10mg
    (if (and has_hypertension (> sys_bp 160))
      (setq auto_rules (append auto_rules (list
        (list
          "target_type" "individual"
          "target_id" id
          "new_params" (list "drug_dosage" 10.0)
        )
      )))
    )
  )

  return auto_rules
)

（2）手动触发交互（用户实时干预）

用户通过 SKILL 命令行或 GUI 输入交互指令（如"给ID=25的人停止运动""将所有人体重增加5kg"），中间层解析指令并执行：

;; 手动交互指令解析函数
(defun pulse_group_manual_interact (manual_cmd)
  ;; 手动指令格式示例："individual:25:exercise_intensity=0.0" → 个体ID=25，运动强度设为0.0
  ;; 或 "group:hypertension:drug_dosage=15.0" → 所有高血压患者，给药15mg
  (setq cmd_parts (strsplit manual_cmd ":"))
  (setq target_type (nth 0 cmd_parts))
  (setq target_id_or_tag (nth 1 cmd_parts))
  (setq param_pair (strsplit (nth 2 cmd_parts) "="))
  (setq param_key (nth 0 param_pair))
  (setq param_val (read (nth 1 param_pair)))

  (setq manual_rule (list
    "target_type" target_type
    (if (string= target_type "individual") "target_id" "target_tag") target_id_or_tag
    "new_params" (list param_key param_val)
  ))

  ;; 执行交互
  (pulse_group_interact (list manual_rule))
  return t
)

2. 多轮持续交互的完整流程示例

;; 群体多轮持续交互主函数（5轮仿真，自动+手动交互结合）
(defun pulse_group_multi_round_interaction ()
  ;; 步骤1：生成群体配置（100人）
  (setq group_config_file (pulse_group_config :population_size 100 :hypertension_rate 0.1))

  ;; 步骤2：启动首轮仿真（无交互，基础状态）
  (setq round1_result (pulse_group_run_simulation group_config_file :round_duration 60.0))
  (if (not round1_result) return nil)

  ;; 步骤3：第二轮（自动交互：心率异常个体调整运动强度）
  (setq auto_rules1 (pulse_group_auto_interaction_rules))
  (pulse_group_interact auto_rules1 :next_round_duration 60.0)

  ;; 步骤4：第三轮（手动交互：给ID=25的人给药）
  (pulse_group_manual_interact "individual:25:drug_dosage=12.0")

  ;; 步骤5：第四轮（自动交互：高血压患者调整血压药物）
  (setq auto_rules2 (pulse_group_auto_interaction_rules))
  (pulse_group_interact auto_rules2 :next_round_duration 60.0)

  ;; 步骤6：第五轮（手动交互：所有人体运动强度提高到0.6）
  (pulse_group_manual_interact "group:all:exercise_intensity=0.6")

  ;; 步骤7：结束后导出所有轮次结果
  (pulse_group_export_all_results "/tmp/pulse_group_final_report.csv")
  (pulse_mw_log "INFO" "Multi-round interaction completed!")
  return t
)

五、关键技术难点与解决方案

1. 100人并行仿真的资源限制

• 问题：100个Pulse实例同时运行，占用大量内存（每个实例≈50MB，100个≈5GB）和CPU核心，可能导致系统卡顿。
• 解决方案 ：
  • 分批调度：将100人分为5批（每批20人），按轮次分批仿真，每批结束后释放部分资源；
  • 资源监控：在C++层添加内存/CPU监控，当占用率超过80%时自动降低并行度；
  • 轻量化实例：禁用Pulse中不需要的生理系统（如骨骼、内分泌），仅保留心血管、呼吸、代谢核心系统，减少内存占用。

2. 多轮交互的状态一致性

• 问题：多轮仿真中，个体状态可能因网络延迟、参数更新错误导致不一致（如某个体上一轮状态未保存）。
• 解决方案 ：
  • 状态校验：每轮仿真前，校验个体状态的时间戳和完整性，缺失状态则从历史结果中恢复；
  • 事务化更新：参数更新时采用"原子操作"，要么全部个体更新成功，要么回滚到上一轮状态；
  • 日志追溯：每轮状态和参数更新都记录日志，支持异常时回滚到任意轮次。

3. 实时交互的低延迟要求

• 问题：交互指令下发后，需快速响应并更新仿真，避免延迟导致结果失真。
• 解决方案 ：
  • 轻量化数据传输：仅传递关键参数（如运动强度、药物剂量），不传输完整状态；
  • 步长优化：实时交互时将仿真步长从0.1秒调整为0.5秒，减少计算量；
  • 异步指令处理：SKILL侧异步下发指令，C++侧后台处理，不阻塞前端交互。

六、总结

要实现 Pulse 的100人群体同步仿真、SKILL 群体扩展、实时多轮交互，核心是三层协同：

1. Pulse C++层：通过"多实例线程池+逻辑时间同步+状态序列化"，突破单主体限制，支持群体差异化仿真和状态延续；
2. SKILL 中间层：扩展"群体配置、并行调度、结果聚合、交互控制"模块，将底层能力封装为易用的群体接口，同时支持自动/手动交互；
3. 交互层：通过"规则触发+状态反馈+参数更新"的闭环机制，实现多轮持续交互，满足实时动态调整需求。

该方案兼顾了仿真真实性（群体差异化）、效率（并行调度）、灵活性（多轮交互），可应用于群体生理研究、公共卫生应急模拟、医疗设备群体测试等场景。