Deutsch DE
Auf GitHub ansehen

Strategie Volume Spike Trend

Volume Spike Trend überwacht plötzliche Anstiege im gehandelten Volumen. Wenn das aktuelle Volumen den jüngsten Durchschnitt um einen festgelegten Multiplikator überschreitet, signalisiert es eine starke Marktbeteiligung.

Tests zeigen eine durchschnittliche jährliche Rendite von etwa 175%. Am besten funktioniert es im Aktienmarkt.

Wenn das Volumen spikt und der Preis über dem gleitenden Durchschnitt liegt, kauft die Strategie; wenn das Volumen bei einem Preis unter dem Durchschnitt spikt, wird eine Short-Position eröffnet. Trades enden, wenn das Volumen wieder unter den Durchschnitt fällt oder der Stop-Loss erreicht wird.

Diese Methode versucht, Bewegungen zu erfassen, die durch einen Aktivitätsausbruch angetrieben werden.

Details

  • Einstiegskriterien: Volumenänderung überschreitet VolumeSpikeMultiplier mal den Durchschnitt.
  • Long/Short: Beide Richtungen.
  • Ausstiegskriterien: Volumen fällt unter den Durchschnitt oder Stop.
  • Stops: Ja.
  • Standardwerte:
    • MAPeriod = 20
    • VolAvgPeriod = 20
    • VolumeSpikeMultiplier = 2.0m
    • CandleType = TimeSpan.FromMinutes(5)
  • Filter:
    • Kategorie: Ausbruch
    • Richtung: Beide
    • Indikatoren: Volumen, MA
    • Stops: Ja
    • Komplexität: Grundlegend
    • Zeitrahmen: Intraday
    • Saisonalität: Nein
    • Neuronale Netze: Nein
    • Divergenz: Nein
    • Risikolevel: Mittel
using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Volume Spike strategy.
/// Enters when volume spikes above average and price is above/below MA.
/// </summary>
public class VolumeSpikeStrategy : Strategy
{
	private readonly StrategyParam<int> _maPeriod;
	private readonly StrategyParam<decimal> _volumeSpikeMultiplier;
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _cooldownBars;

	private decimal _previousVolume;
	private int _cooldown;

	/// <summary>
	/// MA Period.
	/// </summary>
	public int MAPeriod
	{
		get => _maPeriod.Value;
		set => _maPeriod.Value = value;
	}

	/// <summary>
	/// Volume Spike Multiplier.
	/// </summary>
	public decimal VolumeSpikeMultiplier
	{
		get => _volumeSpikeMultiplier.Value;
		set => _volumeSpikeMultiplier.Value = value;
	}

	/// <summary>
	/// Candle type for strategy calculation.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Cooldown bars between trades.
	/// </summary>
	public int CooldownBars
	{
		get => _cooldownBars.Value;
		set => _cooldownBars.Value = value;
	}

	/// <summary>
	/// Initialize the Volume Spike strategy.
	/// </summary>
	public VolumeSpikeStrategy()
	{
		_maPeriod = Param(nameof(MAPeriod), 20)
			.SetDisplay("MA Period", "Period for Moving Average calculation", "Indicators")
			.SetOptimize(10, 50, 10);

		_volumeSpikeMultiplier = Param(nameof(VolumeSpikeMultiplier), 2.0m)
			.SetDisplay("Volume Spike Multiplier", "Minimum volume increase for signal", "Entry")
			.SetOptimize(1.5m, 3.0m, 0.5m);

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(1).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles to use", "General");

		_cooldownBars = Param(nameof(CooldownBars), 500)
			.SetRange(1, 1000)
			.SetDisplay("Cooldown Bars", "Bars to wait between trades", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_previousVolume = default;
		_cooldown = default;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_previousVolume = 0;
		_cooldown = 0;

		var ma = new SimpleMovingAverage { Length = MAPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ma, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, ma);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal maValue)
	{
		if (candle.State != CandleStates.Finished)
			return;

		if (!IsFormedAndOnlineAndAllowTrading())
			return;

		if (_previousVolume == 0)
		{
			_previousVolume = candle.TotalVolume;
			return;
		}

		if (_cooldown > 0)
		{
			_cooldown--;
			_previousVolume = candle.TotalVolume;
			return;
		}

		var volumeChange = _previousVolume > 0 ? candle.TotalVolume / _previousVolume : 0;

		if (Position == 0 && volumeChange >= VolumeSpikeMultiplier)
		{
			if (candle.ClosePrice > maValue)
			{
				BuyMarket();
				_cooldown = CooldownBars;
			}
			else if (candle.ClosePrice < maValue)
			{
				SellMarket();
				_cooldown = CooldownBars;
			}
		}
		else if (Position > 0 && candle.TotalVolume < _previousVolume)
		{
			SellMarket();
			_cooldown = CooldownBars;
		}
		else if (Position < 0 && candle.TotalVolume < _previousVolume)
		{
			BuyMarket();
			_cooldown = CooldownBars;
		}

		_previousVolume = candle.TotalVolume;
	}
}