修复股票池卖单回报后未继续执行买入阶段

2026-09-13 23:43:26 +08:00
parent 53af3a6a85
commit c98bcc3eb2
5 changed files with 844 additions and 18 deletions
@@ -3,6 +3,35 @@ use super::*;
 use crate::holding_policy::HoldingLifecycleEvidence;
 use crate::stock_pool_execution as pool;
 use rust_decimal::{Decimal, prelude::ToPrimitive};
+use chrono::Timelike;
+
+#[derive(Debug)]
+pub(super) struct DeferredStockPoolExecution {
+    date: NaiveDate,
+    contract: Box<pool::FrozenStockPoolIntent>,
+    buy_only: bool,
+    symbols: BTreeSet<String>,
+    initial_holdings: BTreeSet<String>,
+}
+
+impl<C, R> BrokerSimulator<C, R> {
+    pub(crate) fn pending_stock_pool_symbols(&self) -> BTreeSet<String> {
+        self.deferred_stock_pools.borrow().values().flat_map(|pending| pending.symbols.iter().cloned()).collect()
+    }
+
+    pub(crate) fn has_pending_stock_pool_execution(&self) -> bool {
+        !self.deferred_stock_pools.borrow().is_empty()
+    }
+
+    pub(crate) fn finish_stock_pool_session(&self, date: NaiveDate, report: &mut BrokerExecutionReport) {
+        self.deferred_stock_pools.borrow_mut().retain(|_, pending| {
+            if pending.date <= date {
+                report.diagnostics.push(format!("stock_pool_unsubmitted_phase_expired generation={} date={date} no_buy_order_created=true",pending.contract.generation));
+                false
+            } else { true }
+        });
+    }
+}

 fn decimal(value: f64, label: &str) -> Result<Decimal, BacktestError> {
    if !value.is_finite() {
@@ -41,6 +70,48 @@ fn pool_positions(
 }

 impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
+    pub(super) fn resume_stock_pool_executions(&self, date: NaiveDate, portfolio: &mut PortfolioState, data: &DataSet,
+        session: &mut BrokerExecutionSession, report: &mut BrokerExecutionReport) -> Result<(), BacktestError> {
+        let clock = self.runtime_intraday_start_time.get().or(self.intraday_execution_start_time);
+        let mut expired = Vec::new();
+        for (id, pending) in self.deferred_stock_pools.borrow().iter() {
+            let end = NaiveTime::parse_from_str(&pending.contract.rule.window_end, "%H:%M")
+                .map_err(|_| BacktestError::Execution("stock_pool_execution_window_invalid".into()))?;
+            if pending.date != date || clock.is_some_and(|clock| clock >= end) { expired.push(id.clone()); }
+        }
+        for id in expired {
+            if let Some(pending) = self.deferred_stock_pools.borrow_mut().remove(&id) {
+                report.diagnostics.push(format!("stock_pool_unsubmitted_phase_expired generation={} date={date} no_buy_order_created=true",pending.contract.generation));
+            }
+        }
+        if self.has_open_orders() || clock.is_none() { return Ok(()); }
+        let pending = std::mem::take(&mut *self.deferred_stock_pools.borrow_mut());
+        for (id, pending) in pending {
+            let now = clock.expect("clock checked above");
+            let start = NaiveTime::parse_from_str(&pending.contract.rule.window_start, "%H:%M")
+                .map_err(|_| BacktestError::Execution("stock_pool_execution_window_invalid".into()))?;
+            if now < start || !pool::stock_pool_is_trading_minute(now.hour() * 60 + now.minute()) {
+                self.deferred_stock_pools.borrow_mut().insert(id, pending);
+                continue;
+            }
+            let prior_followup = self.runtime_stock_pool_followup.replace(true);
+            let prior_decision = self.runtime_decision_date.replace(Some(pending.contract.signal_date));
+            let prior_created = self.runtime_order_created_date.replace(Some(date));
+            let order_start = report.order_events.len();
+            let fill_start = report.fill_events.len();
+            report.diagnostics.push(format!("stock_pool_resume_after_order_reports generation={} clock={} cash={}",pending.contract.generation,clock.unwrap(),portfolio.cash()));
+            let result = self.process_stock_pool_contract_phase(date, portfolio, data, &pending.contract,
+                &mut session.intraday_turnover, &mut session.execution_cursors, &mut session.global_execution_cursor,
+                &mut session.commission_state, report, pending.buy_only, Some(&pending.initial_holdings));
+            self.runtime_stock_pool_followup.set(prior_followup);
+            self.runtime_decision_date.set(prior_decision);
+            self.runtime_order_created_date.set(prior_created);
+            result?;
+            Self::annotate_report_range(report, order_start, fill_start, pending.contract.signal_date, date, date);
+        }
+        Ok(())
+    }
+
    fn pool_quote_inputs(
        &self,
        date: NaiveDate,
@@ -102,7 +173,7 @@ impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
                            snapshot,
                            quote,
                            OrderSide::Buy,
-                            self.matching_type,
+                            self.matching_type_for_algo_request(None),
                        )
                        .ok_or_else(|| {
                            BacktestError::Execution(format!(
@@ -114,7 +185,7 @@ impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
                            snapshot,
                            quote,
                            OrderSide::Sell,
-                            self.matching_type,
+                            self.matching_type_for_algo_request(None),
                        )
                        .ok_or_else(|| {
                            BacktestError::Execution(format!(
@@ -226,6 +297,17 @@ impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
        global_execution_cursor: &mut Option<NaiveDateTime>,
        commission_state: &mut BTreeMap<u64, f64>,
        report: &mut BrokerExecutionReport,
+    ) -> Result<(), BacktestError> {
+        self.process_stock_pool_contract_phase(date, portfolio, data, contract, intraday_turnover,
+            execution_cursors, global_execution_cursor, commission_state, report, false, None)
+    }
+
+    fn process_stock_pool_contract_phase(
+        &self, date: NaiveDate, portfolio: &mut PortfolioState, data: &DataSet,
+        contract: &pool::FrozenStockPoolIntent, intraday_turnover: &mut BTreeMap<String, u32>,
+        execution_cursors: &mut IntradayExecutionLedger, global_execution_cursor: &mut Option<NaiveDateTime>,
+        commission_state: &mut BTreeMap<u64, f64>, report: &mut BrokerExecutionReport, buy_only: bool,
+        initial_holdings: Option<&BTreeSet<String>>,
    ) -> Result<(), BacktestError> {
        if contract.signal_date > date
            || contract.frozen_equity < Decimal::ZERO
@@ -266,6 +348,7 @@ impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
            .cloned()
            .collect::<BTreeSet<_>>();
        scope.extend(portfolio.positions().keys().cloned());
+        let before_positions = initial_holdings.cloned().unwrap_or_else(|| portfolio.positions().keys().cloned().collect());
        let official_dates = data.calendar().iter().collect::<Vec<_>>();
        let initial_positions = pool_positions(portfolio, date)?;
        let state = portfolio
@@ -284,6 +367,9 @@ impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
        let superseded = self.deferred_etf_targets.borrow_mut().replace_generation(&contract.pool_id, &contract.generation);
        if superseded > 0 { report.diagnostics.push(format!("etf_daily_open_fallback:superseded pool={} generation={} targets={superseded}", contract.pool_id, contract.generation)); }
        if self.has_open_orders() {
+            self.deferred_stock_pools.borrow_mut().insert(contract.pool_id.clone(), DeferredStockPoolExecution {
+                date, contract: Box::new(contract.clone()), buy_only, symbols: scope, initial_holdings: before_positions,
+            });
            report
                .diagnostics
                .push("stock_pool_waiting_for_active_orders no_new_intent=true".into());
@@ -329,15 +415,19 @@ impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
                    .push("paused".into());
            }
        }
-        let before_positions = portfolio
-            .positions()
-            .keys()
-            .cloned()
-            .collect::<BTreeSet<_>>();
        // All delayed symbols in a generation share immutable configuration.
        // Do not duplicate an N-member pool N times in a large mixed pool.
        let mut deferred_configuration = None;
        for side in [pool::OrderSide::Sell, pool::OrderSide::Buy] {
+            if buy_only && side == pool::OrderSide::Sell { continue; }
+            if side == pool::OrderSide::Buy && self.has_open_orders()
+                && self.effective_rebalance_cash_mode() == RebalanceCashMode::SellThenBuy {
+                self.deferred_stock_pools.borrow_mut().insert(contract.pool_id.clone(), DeferredStockPoolExecution {
+                    date, contract: Box::new(contract.clone()), buy_only: true, symbols: quote_scope.clone(), initial_holdings: before_positions.clone(),
+                });
+                report.diagnostics.push(format!("stock_pool_waiting_for_sell_reports generation={} no_buy_order_created=true",contract.generation));
+                break;
+            }
            let mut fallback_references = BTreeMap::new();
            for symbol in &quote_scope {
                if let Some(reference) = self.pool_etf_fallback_reference(date, data, symbol, *global_execution_cursor)? {