How do you use RelativeDailyVolume with minute resolution and universe selection?

Here is your corrected code with the necessary namespace references:

using System;
using System.Collections.Generic;
using QuantConnect;
using QuantConnect.Algorithm;
using QuantConnect.Data;
using QuantConnect.Algorithm.Framework;
using QuantConnect.Indicators; // For RelativeDailyVolume
using QuantConnect.Data.UniverseSelection; // For CoarseFundamental
using QuantConnect.Algorithm.Framework.Alphas; // For SecurityChanges

namespace QuantConnect.Algorithm.CSharp
{
    public class Test : QCAlgorithm
    {
        private const decimal _gapThreshold = 5m;
        private const decimal _minRDV = 2m;
        private const int _volumeLookback = 30;
        private readonly Dictionary<Symbol, decimal> _previousCloses = new Dictionary<Symbol, decimal>();
        private readonly Dictionary<Symbol, RelativeDailyVolume> _rdvIndicators = new Dictionary<Symbol, RelativeDailyVolume>();
        private readonly List<Symbol> _gapUpSymbols = new List<Symbol>();

        public override void Initialize()
        {
            SetStartDate(2025, 2, 13);
            SetCash(100000);
            UniverseSettings.ExtendedMarketHours = true;
            UniverseSettings.Resolution = Resolution.Minute;
            UniverseSettings.Leverage = 1.0m;
            AddUniverse(CoarseSelectionFilter);
            var openTicker = AddEquity("SPY").Symbol;

            Schedule.On(DateRules.EveryDay(),
                TimeRules.BeforeMarketOpen(openTicker, 15, true),
                CheckPreMarketGaps
            );

            Schedule.On(DateRules.EveryDay(),
                TimeRules.AfterMarketOpen(openTicker, 0),
                ExecuteTrades
            );

            Schedule.On(DateRules.EveryDay(),
                TimeRules.BeforeMarketClose(openTicker, 0),
                LiquidateAllPositions
            );
        }

        private IEnumerable<Symbol> CoarseSelectionFilter(IEnumerable<CoarseFundamental> coarse)
        {
            return coarse
                .Where(x => x.HasFundamentalData && x.Price > 5 && x.Price < 100 && x.DollarVolume > 1000000)
                .OrderByDescending(x => x.DollarVolume)
                .Take(2000)
                .Select(x => x.Symbol);
        }

        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            foreach (var security in changes.AddedSecurities)
            {
                var rdv = new RelativeDailyVolume(_volumeLookback);
                _rdvIndicators[security.Symbol] = rdv;
                RegisterIndicator(security.Symbol, rdv, Resolution.Daily);

                var history = History<TradeBar>(security.Symbol, _volumeLookback + 1, Resolution.Daily);
                foreach (var bar in history)
                {
                    rdv.Update(bar);
                }

                var dailyHistory = History(security.Symbol, 1, Resolution.Daily)
                    .Where(b => b.EndTime.TimeOfDay == TimeSpan.Zero);

                if (dailyHistory.Any())
                {
                    _previousCloses[security.Symbol] = dailyHistory.Last().Close;
                }
            }

            foreach (var security in changes.RemovedSecurities)
            {
                _rdvIndicators.Remove(security.Symbol);
                _previousCloses.Remove(security.Symbol);
            }
        }

        private void CheckPreMarketGaps()
        {
            _gapUpSymbols.Clear();
            foreach (var kvp in _previousCloses)
            {
                var symbol = kvp.Key;
                var security = Securities[symbol];
                var bar = security.GetLastData();
                if (bar == null || bar.EndTime < Time.AddMinutes(-5)) continue;
                var currentPrice = bar.Price;
                var previousClose = kvp.Value;
                if (previousClose == 0 || currentPrice == 0) continue;
                var gapPercentage = ((currentPrice - previousClose) / previousClose) * 100;
                var rdv = _rdvIndicators[symbol];
                if (!rdv.IsReady) continue;
                if (gapPercentage >= _gapThreshold && rdv.Current.Value >= _minRDV)
                {
                    _gapUpSymbols.Add(symbol);
                }
            }
        }

        private void ExecuteTrades()
        {
            if (_gapUpSymbols.Count == 0) return;
            var weight = 0.9m / _gapUpSymbols.Count;
            foreach (var symbol in _gapUpSymbols)
            {
                if (_rdvIndicators[symbol].Current.Value < _minRDV)
                {
                    continue;
                }
                var quantity = CalculateOrderQuantity(symbol, weight);
                MarketOrder(symbol, quantity);
            }
        }

        private void LiquidateAllPositions()
        {
            Liquidate();
            _gapUpSymbols.Clear();
        }

        public override void OnData(Slice data)
        {
        }
    }
}

This includes the necessary references for RelativeDailyVolume, CoarseFundamental, and SecurityChanges. Make sure you have these dependencies available in your development environment.

Sources: Sector Rotation Based On News Sentiment, Coarse Fine Fundamental Combo Algorithm, Opening Range Breakout for Stocks in Play, Coarse Fundamental Top3 Algorithm

You guys gotta improve this AI agent. Literally all it did was remove the code comments.

Hi Michael

We recommend that you work within the selection function:

private Dictionary<Symbol, SymbolData> _symbolDataBySymbol = new();

private IEnumerable<Symbol> Filter(IEnumerable<Fundamental> fundamental)
{
    var filtered = fundamental.Where(x => x.HasFundamentalData && x.Price > 5 && x.Price < 100 && x.DollarVolume > 1000000).ToList();
    
	foreach (var f in filtered)
	{
        if (!_symbolDataBySymbol.TryGetValue(f.Symbol, out var symbolData))
        {
            _symbolDataBySymbol[f.Symbol] = symbolData = new SymbolData(f.Symbol. _volumeLookBack);
        }
        symbolData.Update(f.EndTime, f.Volume);
    }
    
    // Other filtering maybe?
    
    return _symbolDataBySymbol.Where(x => x.Value.RelativeDailyVol > 1)
        .Select(x => x.Key);
}

public class SymbolData
{
    public Symbol Symbol { get; set; }
    public RelativeDailyVolume RelativeDailyVol { get; set; }
    
    public SymbolData(Symbol symbol, int lookback)
    {
        Symbol = symbol;
        RelativeDailyVol = new RelativeDailyVolume(lookback);
        // Warm up
        var history = History<TradeBar>(symbol, lookback + 1, Resolution.Daily);
        // Skip last to avoid double updating
        foreach (var bar in history.SkipLast())
        {
            RelativeDailyVol.Update(bar);
        }
    }
    
    public void Update(DateTime time, decimal volume)
    {
        // Create a trade bar for updating, price is not important
        var bar = new TradeBar(time, 0m, 0m, 0m, 0m, volume);
        RelativeDailyVol.Update(bar);
    }
}

Best
Louis

But universe selection runs at midnight, right? I'd want to filter stocks that have high relative volume at the open (or after the first candle, anyway).

Hi Michael

Yes, it runs at midnight for backtesting and around 8 a.m. for live deployment. In your case, you will need to pre-select a large number of stocks and further filter by the first bar or the last pre-open bar. Note that, given the heavy computational work, you will need a large node to run the backtest or live algorithm.

Best
Louis