Seeking guidance on MACD Crossover with Trailing Stop Loss (Python)

I have this MACD Crossover strategy I've adapted so that, after each entry position, a stop loss is created and the price of which is subsequently updated so it acts as a trailing stop loss. I am having difficulty getting it to initialize and would appreciate any guidance as to what I may be doing incorrectly (error below). Also, how can I set this so that it will only run once every hour? Every x number of minutes? Thanks in advance!

from AlgorithmImports import *
class MACDTrendAlgorithm(QCAlgorithm):
    
    # establish project objects
    stopMarketTicket = None
    stopMarketOrderFillTime = datetime.min
    stopPrice = 0
    def Initialize(self):
        
        # initialize our algorithm with the basics
        self.SetStartDate(2018, 1, 1)
        self.SetEndDate(2021, 10, 22)
        self.SetCash(25000)
        tqqq = self.AddEquity("TQQQ", Resolution.Daily)
        tqqq.SetDataNormalizationMode(DataNormalizationMode.Raw)
        # define our macd parameters
        self.__macd = self.MACD("TQQQ", 6, 35, 6, MovingAverageType.Exponential, Resolution.Daily)
        self.__previous = datetime.min
        self.PlotIndicator("MACD", True, self.__macd, self.__macd.Signal)
        self.PlotIndicator("TQQQ", self.__macd.Fast, self.__macd.Slow)
    def OnData(self, data):
        
        # wait for our macd to fully initialize
        if not self.__macd.IsReady:
            return
        # define a small tolerance on our checks to avoid bouncing
        tolerance = 0.0025
        holdings = self.Portfolio["TQQQ"].Quantity
        signalDeltaPercent = (self.__macd.Current.Value - self.__macd.Signal.Current.Value)/self.__macd.Fast.Current.Value
        if holdings == 0:
        
            if signalDeltaPercent > tolerance:
                self.SetHoldings("TQQQ", 1.0)
                self.stopMarketTicket = self.StopMarketOrder("TQQQ", -self.Portfolio["TQQQ"].Quantity, 0.9 * self.Portfolio["TQQQ"].Price)
            if signalDeltaPercent < -tolerance:
                self.SetHoldings("TQQQ", -1.0)
                self.stopMarketTicket = self.StopMarketOrder("TQQQ", self.Portfolio["TQQQ"].Quantity, 0.9 * self.Portfolio["TQQQ"].Price)
                
        elif holdings != 0:
        
            if holdings < 0 and signalDeltaPercent > tolerance:
                self.Liquidate("TQQQ")
                self.SetHoldings("TQQQ", 1.0)
                self.stopMarketTicket = self.StopMarketOrder("TQQQ", -self.Portfolio["TQQQ"].Quantity, 0.9 * self.Portfolio["TQQQ"].Price)
            if holdings > 0 and signalDeltaPercent < -tolerance:
                self.Liquidate("TQQQ")
                self.SetHoldings("TQQQ", -1.0)
                self.stopMarketTicket = self.StopMarketOrder("TQQQ", self.Portfolio["TQQQ"].Quantity, 0.9 * self.Portfolio["TQQQ"].Price)
        
        if holdings >=0 and self.Securities["TQQQ"].Close > self.stopPrice:
            self.stopPrice = self.Securities["TQQQ"].Close
            updateFields = UpdateOrderFields()
            updateFields.StopPrice = self.stopPrice * 0.95
            self.stopMarketTicket.Update(updateFields)
            
        elif holdings <=0 and self.Securities["TQQQ"].Close < self.stopPrice:
            self.stopPrice = self.Securities["TQQQ"].Close
            updateFields = UpdateOrderFields()
            updateFields.StopPrice = self.stopPrice * 0.95
            self.stopMarketTicket.Update(updateFields)
        self.__previous = self.Time
+ Expand
- Collapse

Errors:

42 | 17:29:57:

Runtime Error: InvalidOperationException : Sequence contains no elements
at System.Linq.ThrowHelper.ThrowNoElementsException()
at System.Linq.Enumerable.Last[TSource](IEnumerable`1 source)
at QuantConnect.Orders.OrderTicket.Update(UpdateOrderFields fields) in /LeanCloud/CI.Builder/bin/Debug/src/QuantConnect/Lean/Common/Orders/OrderTicket.cs:line 279
at OnData
self.stopMarketTicket.Update(updateFields)
===
at Python.Runtime.PyObject.Invoke(PyTuple args in main.py: line 66 (Open Stacktrace)

43 | 17:30:07:

Algorithm Id:(15bdaac636f5d7f605a7df768009cb99) completed in 10.63 seconds at 0k data points per second. Processing total of 328 data points.

44 | 17:30:07:

Backtest Handled Error: Unable to submit order with id -10 that has zero quantity.

James Hawkins,

Here is the same algorithm with requested options:

It runs every minute.

You can uncomment line 11

self.stock.SetDataNormalizationMode(DataNormalizationMode.Raw)

and see what happens on split history dates.

TQQQ Split History Table

Date Ratio

02/25/2011 2 for 1

05/11/2012 2 for 1

01/24/2014 2 for 1

01/12/2017 2 for 1

05/24/2018 3 for 1

01/21/2021 2 for 1

So I don't recommend it.

You can find details about

self.SetRiskManagement(MaximumDrawdownPercentPerSecurity(0.10))

on github.com

If you are satisfied with my answer, please accept it.

The material on this website is provided for informational purposes only and does not constitute an offer to sell, a solicitation to buy, or a recommendation or endorsement for any security or strategy, nor does it constitute an offer to provide investment advisory services by QuantConnect. In addition, the material offers no opinion with respect to the suitability of any security or specific investment. QuantConnect makes no guarantees as to the accuracy or completeness of the views expressed in the website. The views are subject to change, and may have become unreliable for various reasons, including changes in market conditions or economic circumstances. All investments involve risk, including loss of principal. You should consult with an investment professional before making any investment decisions.

James Hawkins,

Here is the "MACD Signal Delta Percent simplified".

It runs once an hour and has the build-in

self.SetRiskManagement(MaximumDrawdownPercentPerSecurity(0.10)).

If this is what you are looking for, please accept it.

class MACDTrendAlgorithm(QCAlgorithm):
def Initialize(self):
self.SetStartDate(2021, 1, 1)
self.SetEndDate(2021, 10, 22)
self.SetCash(25000)
self.stock = self.AddEquity("TQQQ", Resolution.Minute).Symbol
self.macd = self.MACD(self.stock, 6, 35, 6, MovingAverageType.Exponential, Resolution.Daily)
self.PlotIndicator("MACD", True, self.macd, self.macd.Signal)
self.PlotIndicator("TQQQ", self.macd.Fast, self.macd.Slow)
self.SetWarmUp(5*41, Resolution.Daily)
self.SetRiskManagement(MaximumDrawdownPercentPerSecurity(0.05))
for minute in range(1, 361, 1):
self.Schedule.On(self.DateRules.EveryDay(self.stock), self.TimeRules.AfterMarketOpen(self.stock, minute),
self.trade)
def trade(self):
if self.IsWarmingUp or not self.macd.IsReady: return
tolerance = 0.0025
holdings = self.Portfolio[self.stock].Quantity
signalDeltaPercent = (self.macd.Current.Value - self.macd.Signal.Current.Value)/self.macd.Fast.Current.Value
if holdings <= 0 and signalDeltaPercent > tolerance:
self.Liquidate(self.stock)
self.SetHoldings(self.stock, 1.0)
elif holdings > 0 and signalDeltaPercent < -tolerance:
self.Liquidate(self.stock)
self.SetHoldings(self.stock, -1.0)

+ Expand

#trigger for initial position ONLY
if not self.Securities[self.stock].Invested:
if holdings == 0 and signalDeltaPercent > tolerance:
self.SetHoldings(self.stock, 1.0)
elif holdings == 0 and signalDeltaPercent < -tolerance:
self.SetHoldings(self.stock, -1.0)
#trigger for subsequent positions ONLY
else:
#To avoid re-entry after drawdown liquidation, only go long if previous fill was a short cover
if holdings < 0 and signalDeltaPercent > tolerance and orderEvent.quantity > 0:
self.Liquidate()
self.SetHoldings(self.stock, 1.0)
#To avoid re-entry after drawdown liquidation, only go long if previous fill was a long liquidation
elif holdings > 0 and signalDeltaPercent < -tolerance and orderEvent.quantity < 0:
self.Liquidate()
self.SetHoldings(self.stock, -1.0)
#self.__previous = self.Time
def OnOrderEvent(self, orderEvent):
quantity = orderEvent.FillQuantity
return

+ Expand

Vladimir INVESTOR

October 2021

Upvote

2 people upvoted this

James Hawkins INVESTOR

Thanks, Vladimir 💪!!! A few follow up questions if you don't mind 😁:

What's the difference between an object and a self.object?
How do I set the data normalization mode to raw on the self.stock object?
I am testing this algo every minute instead of hour, and when MACD signals long/short and the stop/drawdown is hit, the algo will re-enter long/short (logically so). How can I modify this so that, after a stop/drawdown is hit, the algo will wait for the signal to reverse to take a position?
With regards to the drawdown, does this act like a Stop or a Trailing Stop? My goal is to use a Trailing Stop.
Finally, how can I modify this so that I can use 30-minute bars? I know how to setup a consolidator, but how can I modify the MACD to use 30-minute bars too (i.e. 6 30-minute bars and 35 30-minute bars)?

 class MACDTrendAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2021, 1, 1)
        self.SetEndDate(2021, 10, 22)
        self.SetCash(25000)
        
        self.stock = self.AddEquity("TQQQ", Resolution.Minute).Symbol
        self.macd = self.MACD(self.stock, 6, 35, 6, MovingAverageType.Exponential, Resolution.Daily)
        self.PlotIndicator("MACD", True, self.macd, self.macd.Signal)
        self.PlotIndicator("TQQQ", self.macd.Fast, self.macd.Slow)
        
        self.SetWarmUp(5*41, Resolution.Daily)
        
        self.SetRiskManagement(MaximumDrawdownPercentPerSecurity(0.05))
        for minute in range(1, 361, 1):
            self.Schedule.On(self.DateRules.EveryDay(self.stock), self.TimeRules.AfterMarketOpen(self.stock, minute), 
                self.trade)
    def trade(self):
        if self.IsWarmingUp or not self.macd.IsReady: return
        tolerance = 0.0025
        
        holdings = self.Portfolio[self.stock].Quantity
        signalDeltaPercent = (self.macd.Current.Value - self.macd.Signal.Current.Value)/self.macd.Fast.Current.Value
        if holdings <= 0 and signalDeltaPercent > tolerance:
            self.Liquidate(self.stock)
            self.SetHoldings(self.stock, 1.0)
                
        elif holdings > 0 and signalDeltaPercent < -tolerance:
            self.Liquidate(self.stock)
            self.SetHoldings(self.stock, -1.0)
+ Expand
- Collapse

Vladimir - thanks! Each time I go long/short, I am protected by the drawdown. However, if I am liquidated before the indicator reverses, I will re-enter/exit on drawdown multiple times before the indicator switches (and vice versa). I need to logically tell the algorithm that once the drawdown is hit, DO NOT enter a new position until the indicator flips. I.E. Go Long→drawdown hit→ wait for indicator reversal→ indicator reversal→ go short

 #trigger for initial position ONLY
        if not self.Securities[self.stock].Invested:
            if holdings == 0 and signalDeltaPercent > tolerance:
                self.SetHoldings(self.stock, 1.0)
                
            elif holdings == 0 and signalDeltaPercent < -tolerance:
                self.SetHoldings(self.stock, -1.0)
        
        #trigger for subsequent positions ONLY
        else:
            #To avoid re-entry after drawdown liquidation, only go long if previous fill was a short cover
            if holdings < 0 and signalDeltaPercent > tolerance and orderEvent.quantity > 0:
                self.Liquidate()
                self.SetHoldings(self.stock, 1.0)
            
            #To avoid re-entry after drawdown liquidation, only go long if previous fill was a long liquidation    
            elif holdings > 0 and signalDeltaPercent < -tolerance and orderEvent.quantity < 0:
                self.Liquidate()
                self.SetHoldings(self.stock, -1.0)
        #self.__previous = self.Time
        
    def OnOrderEvent(self, orderEvent):
        quantity = orderEvent.FillQuantity
        return
+ Expand
- Collapse

Platform

Radically Open-Source Algorithmic Trading Engine

Join Our Discord Channel

Quarterly Open-Source Trading Competition

Draft Discussions

Bookmarked Discussions

SEARCH DISCUSSIONS

370,400 Quants.

VOTE FOR UPCOMING FEATURES

JOIN OUR Community MAILING LIST

IN THIS RESEARCH

PARTICIPANTS

Actions

Join QuantConnect for Free