Fibonacci Pivot Breakout Trading Strategy with Scaled Entries and Trailing Stops

This article describes a trading strategy implemented in Backtrader that focuses on breakout opportunities using simplified pivot points, with scaled entries to manage position sizing and trailing stops for risk management. The strategy incorporates momentum and accumulation/distribution signals to enhance trade decisions.

Strategy Overview

The Fibonacci Pivot Breakout Trading Strategy integrates the following components:

• Simplified Pivot Points: Calculates a basic pivot level as the average of the previous day’s high, low, and close, with a simplified resistance level (R1) to identify breakout points.
• Momentum Proxy: Uses a 14-day percentage change in price as a proxy for the Chande Momentum Oscillator (CMO) to gauge price momentum.
• Accumulation/Distribution Proxy: Employs the Williams Accumulation/Distribution (AD) line and its 3-day Rate of Change (ROC) to confirm buying or selling pressure.
• Scaled Entries: Allows up to three entries, each using 33% of available cash, spaced at 0.2% price intervals to build positions during breakouts.
• Trailing Stops: Applies a 2.8% trailing stop-loss on the first entry to protect against adverse price movements while allowing profits to run.
• Exit Condition: Closes positions if the price falls below the pivot level, indicating a potential trend reversal.

Code Implementation

Below is the complete Backtrader code for the strategy:

import backtrader as bt

class FibonacciPivotBreakoutStrategy(bt.Strategy):
    params = (
        ('cmo_period', 14),
        ('ad_roc_period', 3),           # Period to check if AD line is rising
        ('trail_percent', 0.028),       # 2.8% trailing stop
        ('entry_size_pct', 0.33),       # 33% per entry (3 entries total)
        ('max_entries', 3),             # Maximum number of scale-in entries
        ('entry_spacing', 0.002),       # 0.2% spacing
    )
    
    def __init__(self):
        # Fibonacci Pivot Points
        self.fib_pivot = bt.indicators.FibonacciPivotPoint()
        
        # Chande Momentum Oscillator
        self.cmo = bt.indicators.PctChange(period=self.params.cmo_period)  # Using PctChange as CMO proxy
        
        # Accumulation/Distribution Line (using WilliamsAD as proxy)
        self.ad_line = bt.indicators.WilliamsAD()
        
        # AD Line rising (ROC of AD line)
        self.ad_roc = bt.indicators.ROC(self.ad_line, period=self.params.ad_roc_period)
        
        # State tracking
        self.order = None
        self.entry_count = 0
        self.first_entry_price = None
        self.pivot_level = None
    
    def next(self):
        if self.order or len(self.data) < 30:
            return
        
        # Get current values - SIMPLIFIED PIVOT CALCULATION
        current_price = self.data.close[0]
        
        # Simple manual pivot calculation (always works)
        if len(self.data) > 1:
            high_prev = self.data.high[-1]
            low_prev = self.data.low[-1] 
            close_prev = self.data.close[-1]
            pivot_level = (high_prev + low_prev + close_prev) / 3
            r1_level = pivot_level + (pivot_level - low_prev)  # Simplified R1
        else:
            pivot_level = self.data.close[0]
            r1_level = self.data.close[0] * 1.01  # 1% above current price
        
        # Entry conditions - VERY SIMPLE
        if self.entry_count < self.params.max_entries:
            # Initial entry - just price above yesterday's high
            if self.entry_count == 0:
                if len(self.data) > 1 and current_price > self.data.high[-1]:
                    self._make_entry(current_price)
                    self.pivot_level = pivot_level
            
            # Scale-in entries
            elif self.entry_count > 0 and self.first_entry_price:
                entry_spacing_price = self.first_entry_price * (1 + self.params.entry_spacing * self.entry_count)
                if current_price > entry_spacing_price:
                    self._make_entry(current_price)
        
        # Exit conditions
        if self.position and self.pivot_level is not None:
            # Exit if price falls below pivot level
            if current_price < self.pivot_level:
                self.order = self.close()
                self._reset_entries()
    
    def _make_entry(self, entry_price):
        """Execute a scaled entry"""
        cash = self.broker.getcash()
        size = int(cash * self.params.entry_size_pct / entry_price)
        
        if size > 0:
            self.order = self.buy(size=size)
            self.entry_count += 1
            
            # Track first entry price
            if self.entry_count == 1:
                self.first_entry_price = entry_price
            
            # Set trailing stop (only on first entry to avoid multiple stops)
            if self.entry_count == 1:
                self.sell(exectype=bt.Order.StopTrail, 
                         trailpercent=self.params.trail_percent)
    
    def _reset_entries(self):
        """Reset entry tracking variables"""
        self.entry_count = 0
        self.first_entry_price = None
        self.pivot_level = None
    
    def notify_order(self, order):
        if order.status in [order.Completed, order.Canceled, order.Margin, order.Rejected]:
            self.order = None
    
    def notify_trade(self, trade):
        if trade.isclosed:
            self._reset_entries()

Strategy Explanation

1. FibonacciPivotBreakoutStrategy

The strategy uses simplified pivot points and scaled entries to trade breakouts, with risk management via trailing stops:

• Indicators:

  • Simplified Pivot Points: Calculates the pivot level as the average of the previous day’s high, low, and close. The resistance level (R1) is computed as the pivot plus the difference between the pivot and the previous low.
  • Momentum Proxy: Uses a 14-day percentage change in price as a substitute for the Chande Momentum Oscillator to assess price momentum.
  • Accumulation/Distribution Proxy: Tracks buying/selling pressure with the Williams AD line and its 3-day Rate of Change (ROC).

• Trading Logic (next):

  • Data Check: Requires at least 30 days of data to ensure indicator stability.
  • Pending Order Check: Skips trading if an order is pending to avoid overlapping trades.
  • Pivot Calculation:
    • Uses the previous day’s high, low, and close to compute the pivot level and a simplified R1.
    • For the first bar (if no previous data), sets the pivot to the current close and R1 to 1% above it.
  • Entry Conditions:
    • Initial Entry: Enters a buy order if the current price exceeds the previous day’s high, indicating a breakout. Uses 33% of available cash and sets the pivot level.
    • Scale-In Entries: Allows up to two additional entries (total of three) if the price rises 0.2% above the first entry price times the entry count (e.g., 0.2% for second entry, 0.4% for third).
  • Exit Condition: Closes the position if the current price falls below the pivot level, signaling a potential trend reversal.

• Helper Methods:

  • **_make_entry**: Executes a buy order with 33% of available cash, tracks the entry count and first entry price, and sets a 2.8% trailing stop on the first entry.
  • **_reset_entries**: Resets entry tracking variables (entry count, first entry price, pivot level) after a trade closes or an exit occurs.

• Order Management (notify_order):

  • Resets the order tracker when an order is completed, canceled, rejected, or margin-called, ensuring no pending orders interfere with new trades.

• Trade Management (notify_trade):

  • Resets entry tracking variables when a trade is closed to prepare for new trade opportunities.

Key Features

• Simplified Pivot Breakout: Uses a basic pivot calculation to identify breakout opportunities above the previous day’s high, ensuring robustness even with limited data.
• Scaled Entries: Builds positions gradually with up to three entries, each using 33% of cash, spaced at 0.2% price intervals to capitalize on sustained breakouts.
• Trailing Stop Risk Management: Applies a 2.8% trailing stop on the first entry to protect profits while allowing the trade to follow the trend.
• Pivot-Based Exit: Closes positions when the price falls below the pivot level, providing a clear exit signal for trend reversals.
• Disciplined Execution: Limits entries to three and prevents overlapping orders, maintaining clear trade logic.

Potential Improvements

• Incorporate Momentum and AD Signals: Use cmo and ad_roc in entry conditions to confirm momentum and buying/selling pressure, enhancing signal reliability.
• Parameter Tuning: Adjust cmo_period, ad_roc_period, trail_percent, entry_size_pct, or entry_spacing to optimize for specific assets or market conditions.
• Additional Filters: Add volume or other trend indicators (e.g., ADX) to reduce false breakouts.
• Fixed Stop-Loss: Include a fixed stop-loss alongside trailing stops for additional risk control.
• Performance Metrics: Add analyzers for returns, Sharpe ratio, drawdown, and trade statistics to evaluate strategy effectiveness.

This strategy is designed for markets with strong breakout potential, such as stocks or forex, and can be backtested to evaluate its performance across various timeframes and assets.