Fix symbol changed events emission time

Ensure the symbol changed events are emitted after the securities are processes by the main loop in the AlgorithmManager. This way the algorithm has access to the new symbol security since it would be added by the securities processing logic. Also, allow all securities to be properly updated, including prices and cash, before emitting the event, so that the any logic (like placing orders) done by the algorithm on the handler has the correct data.
QuantConnect · Jan 23, 2025 · d117e61 · d117e61
1 parent 9b35411
commit d117e61
Show file tree

Hide file tree

Showing 3 changed files with 213 additions and 22 deletions.
diff --git a/...anualContinuousFuturesPositionRolloverFromSymbolChangedEventHandlerRegressionAlgorithm.cs b/...anualContinuousFuturesPositionRolloverFromSymbolChangedEventHandlerRegressionAlgorithm.cs
@@ -0,0 +1,39 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using QuantConnect.Data.Market;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that the new symbol, on a security changed event,
+    /// is added to the securities collection and is tradable.
+    /// This specific algorithm tests the manual rollover with the symbol changed event
+    /// that is received in the <see cref="OnSymbolChangedEvents(SymbolChangedEvents)"/> handler.
+    /// </summary>
+    public class ManualContinuousFuturesPositionRolloverFromSymbolChangedEventHandlerRegressionAlgorithm
+        : ManualContinuousFuturesPositionRolloverRegressionAlgorithm
+    {
+        public override void OnSymbolChangedEvents(SymbolChangedEvents symbolsChanged)
+        {
+            if (!Portfolio.Invested)
+            {
+                return;
+            }
+
+            ManualPositionsRollover(symbolsChanged);
+        }
+    }
+}
diff --git a/Algorithm.CSharp/ManualContinuousFuturesPositionRolloverRegressionAlgorithm.cs b/Algorithm.CSharp/ManualContinuousFuturesPositionRolloverRegressionAlgorithm.cs
@@ -0,0 +1,152 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+using Futures = QuantConnect.Securities.Futures;
+using QuantConnect.Data.Market;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that the new symbol, on a security changed event,
+    /// is added to the securities collection and is tradable.
+    /// This specific algorithm tests the manual rollover with the symbol changed event
+    /// that is received in the slice in <see cref="OnData(Slice)"/>.
+    /// </summary>
+    public class ManualContinuousFuturesPositionRolloverRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Future _continuousContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 7, 1);
+            SetEndDate(2014, 1, 1);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.LastTradingDay,
+                contractDepthOffset: 0
+            );
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                Order(_continuousContract.Mapped, 1);
+            }
+            else
+            {
+                ManualPositionsRollover(slice.SymbolChangedEvents);
+            }
+        }
+
+        protected void ManualPositionsRollover(SymbolChangedEvents symbolChangedEvents)
+        {
+            foreach (var changedEvent in symbolChangedEvents.Values)
+            {
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+
+                // This access will throw if any of the symbols are not in the securities collection
+                var oldSecurity = Securities[changedEvent.OldSymbol];
+                var newSecurity = Securities[changedEvent.NewSymbol];
+
+                if (!oldSecurity.Invested) continue;
+
+                // Rolling over: liquidate any position of the old mapped contract and switch to the newly mapped contract
+                var quantity = oldSecurity.Holdings.Quantity;
+                var tag = $"Rollover - Symbol changed at {Time}: {changedEvent.OldSymbol} -> {changedEvent.NewSymbol}";
+                Liquidate(symbol: oldSecurity.Symbol, tag: tag);
+                Order(newSecurity.Symbol, quantity, tag: tag);
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug($"{orderEvent}");
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (Transactions.OrdersCount < 3)
+            {
+                throw new RegressionTestException("Expected at least 3 orders.");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 713375;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "3"},
+            {"Average Win", "7.01%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "15.617%"},
+            {"Drawdown", "1.600%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "107578.9"},
+            {"Net Profit", "7.579%"},
+            {"Sharpe Ratio", "1.706"},
+            {"Sortino Ratio", "0.919"},
+            {"Probabilistic Sharpe Ratio", "88.924%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.08"},
+            {"Beta", "0.094"},
+            {"Annual Standard Deviation", "0.059"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "-1.246"},
+            {"Tracking Error", "0.094"},
+            {"Treynor Ratio", "1.06"},
+            {"Total Fees", "$6.45"},
+            {"Estimated Strategy Capacity", "$2900000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Portfolio Turnover", "1.37%"},
+            {"OrderListHash", "4b28a221076b82e98fbbcb38c22b3013"}
+        };
+    }
+}
diff --git a/Engine/AlgorithmManager.cs b/Engine/AlgorithmManager.cs
@@ -224,28 +224,6 @@ public void Run(AlgorithmNodePacket job, IAlgorithm algorithm, ISynchronizer syn
                 // Update the current slice before firing scheduled events or any other task
                 algorithm.SetCurrentSlice(timeSlice.Slice);
 
-                if (timeSlice.Slice.SymbolChangedEvents.Count != 0)
-                {
-                    try
-                    {
-                        algorithm.OnSymbolChangedEvents(timeSlice.Slice.SymbolChangedEvents);
-                    }
-                    catch (Exception err)
-                    {
-                        algorithm.SetRuntimeError(err, "OnSymbolChangedEvents");
-                        return;
-                    }
-
-                    foreach (var symbol in timeSlice.Slice.SymbolChangedEvents.Keys)
-                    {
-                        // cancel all orders for the old symbol
-                        foreach (var ticket in transactions.GetOpenOrderTickets(x => x.Symbol == symbol))
-                        {
-                            ticket.Cancel("Open order cancelled on symbol changed event");
-                        }
-                    }
-                }
-
                 if (timeSlice.SecurityChanges != SecurityChanges.None)
                 {
                     algorithm.ProcessSecurityChanges(timeSlice.SecurityChanges);
@@ -308,6 +286,28 @@ public void Run(AlgorithmNodePacket job, IAlgorithm algorithm, ISynchronizer syn
                 // process fill models on the updated data before entering algorithm, applies to all non-market orders
                 transactions.ProcessSynchronousEvents();
 
+                if (timeSlice.Slice.SymbolChangedEvents.Count != 0)
+                {
+                    try
+                    {
+                        algorithm.OnSymbolChangedEvents(timeSlice.Slice.SymbolChangedEvents);
+                    }
+                    catch (Exception err)
+                    {
+                        algorithm.SetRuntimeError(err, "OnSymbolChangedEvents");
+                        return;
+                    }
+
+                    foreach (var symbol in timeSlice.Slice.SymbolChangedEvents.Keys)
+                    {
+                        // cancel all orders for the old symbol
+                        foreach (var ticket in transactions.GetOpenOrderTickets(x => x.Symbol == symbol))
+                        {
+                            ticket.Cancel("Open order cancelled on symbol changed event");
+                        }
+                    }
+                }
+
                 // fire real time events after we've updated based on the new data
                 realtime.SetTime(timeSlice.Time);