Apparently unusual behavior of StopMarketOrder

The reason I make this request is that I have good empirical evidence that MarketOrder and StopMarketOrder do not work this way, at least during backtesting. 

I am trying to get my algorithm ready for live deployment, but there is no way I will go live, risking tens of thousands of dollars of my real money, with serious discrepancies in these backtest results.

My algorithm is a version of Early Range Breakout, inspired by the ERB algorithm presented during Bootcamp. It downloads a basket of equities from a file every end-of-week, and trades those equities daily, looking for breakout high or breakout low from a bar captured at market open. If a trade is made, it is closed by market exit time, which is currently 2 pm local trading time for the equity in question.

Here is the backtest result trading TSLA from 2021-2-25 – 2021-7-24, starting with $35k. In this case, the StopMarketOrder is commented out, so no StopMarketOrder is issued.

This is the Execute method in class OrderExecution. As you see, algorithm.StopMarketOrder is commented out, and will not execute.

    def Execute(self, algorithm, targets):
        ''' Immediately submits orders for the specified portfolio targets.
            Implicit Args:
                stopPrices  Stop prices for symbols being traded
            Args:
                algorithm:  The algorithm instance
                targets:    The portfolio targets to be ordered
                            Positive quantity denotes an equity purchase
                            Negative quantity denotes an equity sale
                            Zero quantity denotes an equity liquidation
        '''

        for target in targets:
            # Get quantity to be ordered.
            quantity = target.Quantity
            if quantity != 0:
                # BUY or SHORT the equity.
                algorithm.Log("Market order for {} shares of {}".format(quantity, target.Symbol.Value))
                algorithm.MarketOrder(target.Symbol, quantity)
                # Create StopMarketOrder with price calculated by the AlphaModel.
                # algorithm.Log("Stop Market order for {} shares of {} at ${:.2f}".format(quantity, target.Symbol.Value, self.stopPrices[target.Symbol]))
                # algorithm.StopMarketOrder(target.Symbol, quantity, self.stopPrices[target.Symbol])
                _direction = OrderDirection.Buy if quantity > 0 else OrderDirection.Sell
                algorithm.Log("Available cash ${:.2f}, remaining margin ${:.2f}".format(algorithm.Portfolio.Cash, 
                    algorithm.Portfolio.GetMarginRemaining(target.Symbol, _direction)))
                # Remove the Stop Market Order Price, which is matched to each BUY or SHORT.
                # If we do not maintain queue discipline, this will eventually provoke a run time exception.
                del self.stopPrices[target.Symbol]
            else:
                # Liquidating position. Will also cancel any StopMarket order.
                algorithm.Log("Liquidating {}".format(target.Symbol.Value))
                algorithm.Liquidate(target.Symbol)
                algorithm.Log("Available cash now ${:.2f}".format(algorithm.Portfolio.Cash))

This backtest resulted in a Return of 14.19% and a Net Profit of $5,835.24

In this next backtest, StopMarketOrder is implemented as per my understanding in my original post. Here is the Execute method.

    def Execute(self, algorithm, targets):
        ''' Immediately submits orders for the specified portfolio targets.
            Implicit Args:
                stopPrices  Stop prices for symbols being traded
            Args:
                algorithm:  The algorithm instance
                targets:    The portfolio targets to be ordered
                            Positive quantity denotes an equity purchase
                            Negative quantity denotes an equity sale
                            Zero quantity denotes an equity liquidation
        '''

        for target in targets:
            # Get quantity to be ordered.
            quantity = target.Quantity
            if quantity != 0:
                # BUY or SHORT the equity.
                algorithm.Log("Market order for {} shares of {}".format(quantity, target.Symbol.Value))
                algorithm.MarketOrder(target.Symbol, quantity)
                # Create StopMarketOrder with price calculated by the AlphaModel.
                algorithm.Log("Stop Market order for {} shares of {} at ${:.2f}".format(-quantity, target.Symbol.Value, self.stopPrices[target.Symbol]))
                algorithm.StopMarketOrder(target.Symbol, -quantity, self.stopPrices[target.Symbol])
                _direction = OrderDirection.Buy if quantity > 0 else OrderDirection.Sell
                algorithm.Log("Available cash ${:.2f}, remaining margin ${:.2f}".format(algorithm.Portfolio.Cash, 
                    algorithm.Portfolio.GetMarginRemaining(target.Symbol, _direction)))
                # Remove the Stop Market Order Price, which is matched to each BUY or SHORT.
                # If we do not maintain queue discipline, this will eventually provoke a run time exception.
                del self.stopPrices[target.Symbol]
            else:
                # Liquidating position. Will also cancel any StopMarket order.
                algorithm.Log("Liquidating {}".format(target.Symbol.Value))
                algorithm.Liquidate(target.Symbol)
                algorithm.Log("Available cash now ${:.2f}".format(algorithm.Portfolio.Cash))

Note in particular that the algorithm.StopMarketOrder call uses the negative of the order quantity, as my original post specifies.

The stopPrices[target.Symbol] quantity is calculated in alpha.py using this code, which determines the midpoint between the openingBar.High and openingBar.Low.

        def CalcMidpoint(_high, _low):
            mid = abs((_high - _low) / 2)
            base = _low if _low < _high else _high
            return mid + base

 This should result in a stop price which is lower than the breakout high, and higher than the breakout low, which is correct in my understanding.

This backtest used the same parameters as before, and resulted in a return of 2.90% and a profit of $1,1171.98. For a protective maneuver, it seriously hurt the profits.

Something is wrong.

Conversely, if I change the Execute method to issue a StopMarketOrder with a quantity with the same sign as the MarketOrder, the profits soar!

Why does doing it wrong work so well?

Here is the Execute method.

    def Execute(self, algorithm, targets):
        ''' Immediately submits orders for the specified portfolio targets.
            Implicit Args:
                stopPrices  Stop prices for symbols being traded
            Args:
                algorithm:  The algorithm instance
                targets:    The portfolio targets to be ordered
                            Positive quantity denotes an equity purchase
                            Negative quantity denotes an equity sale
                            Zero quantity denotes an equity liquidation
        '''

        for target in targets:
            # Get quantity to be ordered.
            quantity = target.Quantity
            if quantity != 0:
                # BUY or SHORT the equity.
                algorithm.Log("Market order for {} shares of {}".format(quantity, target.Symbol.Value))
                algorithm.MarketOrder(target.Symbol, quantity)
                # Create StopMarketOrder with price calculated by the AlphaModel.
                algorithm.Log("Stop Market order for {} shares of {} at ${:.2f}".format(quantity, target.Symbol.Value, self.stopPrices[target.Symbol]))
                algorithm.StopMarketOrder(target.Symbol, quantity, self.stopPrices[target.Symbol])
                _direction = OrderDirection.Buy if quantity > 0 else OrderDirection.Sell
                algorithm.Log("Available cash ${:.2f}, remaining margin ${:.2f}".format(algorithm.Portfolio.Cash, 
                    algorithm.Portfolio.GetMarginRemaining(target.Symbol, _direction)))
                # Remove the Stop Market Order Price, which is matched to each BUY or SHORT.
                # If we do not maintain queue discipline, this will eventually provoke a run time exception.
                del self.stopPrices[target.Symbol]
            else:
                # Liquidating position. Will also cancel any StopMarket order.
                algorithm.Log("Liquidating {}".format(target.Symbol.Value))
                algorithm.Liquidate(target.Symbol)
                algorithm.Log("Available cash now ${:.2f}".format(algorithm.Portfolio.Cash))

As you see, the algorithm.StopMarketOrder uses a quantity with the same sign as algorithm.MarketOrder.

This backtest results in a return of 35.99%, with net profit of $12,829.57.

Clearly, I should use this code, right? It makes much more money.

But I don't trust a result that directly contradicts my understanding of how these calls are supposed to work.

I could see that perhaps Dancing Green Kitten represents a case of buying on margin, but that doesn't explain why buying on margin when the market moves against me makes me more money.

I hope folks can understand why I feel confused.

I've done these tests now dozens of times. Earlier in the runs, I had determined that the signs for the quantity in MarketOrder and StopMarketOrder must be the same, because that always gave me much better profits.

But reviewing the documentation again sure seemed to imply that StopMarketOrder wants to sell when liquidating a long buy, and wants to buy when liquidating a short sell.

Unless StopMarketOrder inverts the quantity deliberately, I can't explain the results I consistently get, and the documentation does not say it does that.