Introduction

In this lecture, we detail how the Global Algorithmic Trading Software (GATS) leverages M60 DAATS and GNASD to set stop‐loss floors, breakeven triggers, and trailing stops on all faster timeframes (M30, M15, M5, and M1). While each trade’s initial stop remains anchored to 15 × ATR(200) on the execution timeframe, GATS now offers three supplemental elements for micro‐timeframe risk control:

• M60 DAATS Floor: No stop on TF < M 60 may be narrower than that pair’s hourly DAATS.
• Breakeven Trigger: Once trade profit ≥ 1.39 % of that pair’s M60 DAATS, shift stop to breakeven.
• Post-Breakeven Trail (GNASD Floor): After breakeven, trail by a fixed 42 pips—the M60 “one-sigma” noise unit across our 28-pair portfolio.

These stop-management rules are always applied under the strict Daily MACD (8, 17, 5) bias and the M60 EMA 50/89 regime filters, ensuring micro-trades never act in isolation but within a higher-timeframe context. Documenting this reasoning preserves our firm’s intangible asset of advanced volatility logic.

1. Theoretical Foundation

1.1 Why Anchor Micro-Stops to Hourly Volatility?

• Fractal Volatility: Price exhibits self-similar fluctuations across timeframes. An hourly swing of 40 pips can engulf a micro-TF ATR of 10–20 pips, so using only M1/M5 ATR can lead to premature stop-outs.
• Stop Whipsaw Risk: A native M5 stop (e.g. 15 × ATR(200 @ M5) ≈ 15 × 10 pips = 150 pips) may still underestimate a typical hourly move. By enforcing the M60 DAATS (≈ 240 pips for EURUSD) as a floor, micro-trades are protected from routine hourly chop.
• Unified Noise Budget: The M60 DAATS and the GNASD one-sigma noise unit (≈ 42 pips) represent a portfolio-level volatility reference. This ensures consistency and prevents micro-TF stops from being too tight relative to hourly noise.

1.2 Key Definitions

2. Stop Management Workflow on TF < M 60

Below is the step-by-step logic for any trade executed on M30, M15, M5, or M1. Note that the Daily MACD (8, 17, 5) bias filter and M60 EMA 50/89 regime filters still govern whether you trade; the following rules govern how you stop-manage once you do.

<!-- === GLOBAL INPUTS & CONSTANTS === -->
ATR_TF       := "M60"            <!-- Use M60 ATR for DAATS -->
P            := 200              <!-- ATR lookback period -->
k            := 15               <!-- √P exposures for DAATS -->
BE_pct       := 0.0139           <!-- Breakeven fraction (1.39%) -->
GNASD_pips   := 42               <!-- One-sigma noise unit (Law 7) -->
RiskPct      := 0.005            <!-- 0.5% per-trade risk (Law 6) -->
Equity       := 5000             <!-- Account balance in USD -->
Leverage     := 10000            <!-- 10 000:1 -->
ContractSize := 100000           <!-- Standard lot units -->
PipValue     := 10               <!-- USD per pip per 1.00 lot -->
MinLot       := 0.01             <!-- Broker’s minimum lot -->

<!-- === FUNCTION: GET M60 DAATS === -->
function get_DAATS(pair):
    ATR_M60 = ATR(pair, period=P, timeframe=ATR_TF)
    return k * ATR_M60

<!-- === FUNCTION: ENTRY INITIALIZATION === -->
function initialize_trade(pair, direction, EntryPrice):
    DAATS      = get_DAATS(pair)                    <!-- in pips -->
    BE_Dist    = BE_pct * DAATS                     <!-- in pips -->
    risk$      = Equity * RiskPct                   <!-- e.g. $5000×0.005 = $25 -->
    Lot_risk   = risk$ / (DAATS * PipValue)          <!-- e.g. 25/(240×10)=0.0104 -->
    Lot_margin = Equity / (ContractSize / Leverage)  <!-- ~500 lots, no real limit -->
    lot_size   = max(MinLot, min(Lot_risk, Lot_margin))<!-- e.g. 0.01 lot -->

    if direction == LONG:
        stop_price = EntryPrice - DAATS * PipSize(pair)
    else:
        stop_price = EntryPrice + DAATS * PipSize(pair)

    trade = {
        pair:            pair,
        direction:       direction,
        entry_price:     EntryPrice,
        current_stop:    stop_price,
        DAATS:           DAATS,
        BE_Dist:         BE_Dist,
        is_at_breakeven: false,
        high_since_be:   EntryPrice,  <!-- for longs -->
        low_since_be:    EntryPrice,  <!-- for shorts -->
        lot_size:        lot_size,
        is_open:         true
    }
    return trade

<!-- === FUNCTION: UPDATE TRADE EACH BAR/TICK === -->
function update_trade(trade, current_price):
    if not trade.is_open:
        return

    <!-- A) BEFORE BREAKEVEN: SHIFT STOP TO ENTRY WHEN PROFIT ≥ BE_Dist -->
    if not trade.is_at_breakeven:
        if trade.direction == LONG:
            profit_pips = (current_price - trade.entry_price) / PipSize(trade.pair)
        else:
            profit_pips = (trade.entry_price - current_price) / PipSize(trade.pair)

        if profit_pips >= trade.BE_Dist:
            trade.is_at_breakeven = true
            trade.current_stop   = trade.entry_price
            if trade.direction == LONG:
                trade.high_since_be = current_price
            else:
                trade.low_since_be  = current_price

    <!-- B) AFTER BREAKEVEN: TRAIL BY GNASD (42 pips) -->
    else:
        if trade.direction == LONG:
            trade.high_since_be = max(trade.high_since_be, current_price)
            trail_stop         = trade.high_since_be - GNASD_pips * PipSize(trade.pair)
            trade.current_stop = max(trade.current_stop, trail_stop)
        else:
            trade.low_since_be  = min(trade.low_since_be, current_price)
            trail_stop         = trade.low_since_be + GNASD_pips * PipSize(trade.pair)
            trade.current_stop = min(trade.current_stop, trail_stop)

    <!-- C) ENFORCE M60 DAATS FLOOR (OPTIONAL) -->
    if trade.direction == LONG:
        floor_stop = trade.entry_price - trade.DAATS * PipSize(trade.pair)
        trade.current_stop = max(trade.current_stop, floor_stop)
    else:
        floor_stop = trade.entry_price + trade.DAATS * PipSize(trade.pair)
        trade.current_stop = min(trade.current_stop, floor_stop)

    <!-- D) EXIT CHECK -->
    if (trade.direction == LONG  and current_price <= trade.current_stop) or
       (trade.direction == SHORT and current_price >= trade.current_stop):
        close_trade(trade)

3. Worked Examples

3.1 EURUSD M 5 Micro-Trade

• M60 ATR: 16 pips ⇒ DAATS_M60 = 15×16 = 240 pips.
• Breakeven Distance: 1.39 % × 240 ≈ 3.34 pips.
• Entry: 1.1000 (long).
• Initial Stop: 1.1000 − 0.0240 = 1.0760 (240 × 0.0001 = 0.0240).
• Trade Flow:
  1. Price → 1.1034 (+3.4 pips ≥ 3.34) ⇒ stop → 1.1000 (breakeven).
  2. Price → 1.1050 ⇒ high_since_be = 1.1050 ⇒ trail_stop = 1.1050 − 0.0042 = 1.1008 ⇒ stop → 1.1008.
  3. Price → 1.1015 ⇒ high_since_be unchanged (1.1050) ⇒ trail_stop = 1.1050 − 0.0042 = 1.1008 ⇒ stop remains 1.1008.
  4. Price → 1.0980 (≤ 1.1008) ⇒ exit @ 1.1008 = +8.0 pips on M 5.

3.2 GBPUSD M 1 Micro-Trade

• M60 ATR: 18.05 pips ⇒ DAATS_M60 ≈ 18.05×15 = 270.75 ≈ 271 pips.
• Breakeven Distance: 1.39 % × 271 ≈ 3.77 pips.
• Entry: 1.3000 (long).
• Initial Stop: 1.3000 − 0.0271 = 1.2729 (271 × 0.0001).
• Trade Flow:
  1. Price → 1.3005 (+0.5 pips < 3.77): no change.
  2. Price → 1.3038 (+3.8 pips ≥ 3.77): stop → 1.3000 (breakeven).
  3. Price → 1.3020 (≤ new high 1.3038): trail_stop = 1.3038 − 0.0042 = 1.2996 ⇒ stop remains 1.3000.
  4. Price → 1.3010 (> 1.3000): still above stop.
  5. Price → 1.2990 (≤ 1.3000): exit @ 1.3000 = +0 pips net (no loss) on M 1.

4. Position Sizing Recap (Law 6)

Every trade’s risk-based lot size is computed against its M60 DAATS:

risk$   = Equity × RiskPct           <!-- e.g. $5000×0.005 = $25 -->
DAATS    = get_DAATS(pair)             <!-- e.g. 240 pips for EURUSD -->
pipValue = ContractSize / 10000        <!-- $10 per pip per 1.00 lot -->
Lot_risk = risk$ ÷ (DAATS × pipValue)  <!-- e.g. 25 ÷ (240×10) = 0.0104 lots -->
Lot_final= max(MinLot, Lot_risk)       <!-- e.g. 0.01 lot (broker min) -->

No micro-trade ever exceeds margin capacity, since Lot_margin_max = Equity ÷ (ContractSize ÷ Leverage) is extremely large under 10 000 :1. Thus Lot_final = 0.01 lot on most micro-examples.

5. Practical Considerations & Edge Cases

1. Very Small DAATS Pairs:
   If DAATS_M60 <300 pips (e.g. EURGBP = 1 325 pips), then breakeven ≈ 1.39 % × 1 325 ≈ 18 pips. However, GNASD (42 pips) still supersedes as the fixed trailing floor if the local ATR(TF) is much tighter.
2. Volatility Spikes:
   In case of a sudden ATR_M60 surge (e.g. major news), temporarily widen the GNASD floor by using a Chebyshev or boxplot upper fence to avoid being taken out prematurely.
3. Multiple Concurrent Positions:
   Each pair is trailed independently by 42 pips from its own high/low. Optionally, implement a portfolio-equity trail at 1.39 % of total PnL to protect overall equity.
4. Tick-Size Rounding:
   Round breakeven and trailing levels to the nearest tick increment (e.g. 3.34 pips → 3.4 or 4 pips, whichever is safer).

6. About the Author

Dr. Glen Brown
Founder, President & CEO of Global Accountancy Institute, Inc. and Global Financial Engineering, Inc. With over 25 years of proprietary trading and quantitative research, Dr. Brown developed the Seven-Law Volatility Stop-Loss framework and the GATS platform. His research remains fully in-house, generating all revenue from direct market trading.

Business Model Clarification

Global Accountancy Institute, Inc. and Global Financial Engineering, Inc. operate on a fully closed research-and-trade model. We do not license software, accept external capital, or charge management fees. All intellectual property—including GATS algorithms, risk frameworks, and automation logic—remains proprietary. Our sole revenue source is from trading the markets directly, ensuring continuous alignment of research with trading performance.

Risk Disclaimer

This material is educational only and does not constitute financial advice. Trading involves substantial risk of loss. Past performance is not indicative of future results. Consult a qualified advisor before making any trading decisions, and only trade with capital you can afford to lose.