Revision as of 17:24, 5 January 2026

Multi_Timeframe Dynamic Trend Reversion (MTF_DTR)

PART 1: STRATEGY OVERVIEW

What Is This Strategy?

Multi_Timeframe Dynamic Trend Reversion (MTF_DTR) is a systematic intraday trading strategy that requires multiple analytical layers to align before taking a trade. Think of it as a layered cake - each layer must be present for a valid setup.

Layered Architecture (Top-Down)

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   LAYER 1: MULTI-TIMEFRAME ANALYSIS  ◄── THE FOUNDATION    │
│   5 timeframes analyzed for trend alignment                 │
│   Daily → 4H → 1H → 15M → 5M                               │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 2: MARKET STATE ANALYSIS                           │  ← regime/ market state conditions 
│   7 algorithms: Railroad, Creeper, Phase, BOS, etc.         │
│   Calculates penalties and bonuses                          │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 3: SETUP QUALITY GRADING                           │  ←  set up scoring
│   5-factor weighted scoring → Assigns grade A+ to F         │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 4: FILTERS (Trade/No_Trade)              │
│   • Direction: MA21 slope must match trade direction        │Filters
│   • Grade: Only A+, A, B grades can trade                   │
│   • Hours: Block hours ]WIP]                               │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 5: ENTRY TECHNIQUES                                │  ← Final trigger
│                                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Key Insight: A trade only happens when ALL layers align. MTF Analysis is the foundation - must obtain trend alignment scores across timeframes.

PART 2: Core Concept (Why This Works)

The edge comes from requiring multiple independent confirmations before trading. Each layer filters out bad trades:

Layer	What It Filters Out
1. MTF Analysis	Counter-trend trades, choppy markets
2. Market State	Dangerous conditions (creeper moves, institutional fights)
3. Quality Grading	Scores the setup (used by hard filter)
4. Hard Filters	Wrong direction, low grades (C/D/F), blocked hours
5. Entry Technique	Chasing price far from value (MA21)

The Math

If each layer has 70% accuracy independently:

Single layer: 70% edge
2 layers: 70% × 70% = 49% of trades pass, but higher quality
5 layers: Only the best setups survive all filters

Result: Fewer trades, but each trade has multiple confluences supporting it.

PART 3: LAYER 1 - MULTI-TIMEFRAME ANALYSIS (The Foundation)

THIS IS THE FOUNDATION - Everything else builds on top of MTF alignment. If timeframes disagree, we don't trade.

The 5 Timeframes

Timeframe	Role	Weight
Daily (1D)	Overall market bias	Highest
4-Hour (4H)	Primary trend direction	High
1-Hour (1H)	Trend confirmation	Medium
15-Minute (15M)	Entry timing context	Lower
5-Minute (5M)	Execution timeframe	Lowest

What We Analyze Per Timeframe

For each of the 5 timeframes, the system calculates:

Analysis	Description	Source
MA21 Value	21-period Moving Average	trend_analysis_core.py
MA21 Slope	Rising/Flat/Declining	trend_analysis_core.py
MA200 Value	200-period Moving Average	trend_analysis_core.py
Price vs MA21	Above/Below/At the MA	trend_analysis_core.py
Trend Direction	UP/DOWN/NEUTRAL	trend_analysis_core.py

MTF Alignment Score

For each timeframe:
  1. Determine trend direction (UP/DOWN/NEUTRAL)
  2. Check if aligned with trade direction
  3. Apply timeframe weight
  4. Sum weighted alignment scores

Example (LONG trade):
  Daily:  UP (aligned)     × 1.00 weight = 1.00
  4H:     UP (aligned)     × 0.86 weight = 0.86
  1H:     UP (aligned)     × 0.72 weight = 0.72
  15M:    DOWN (not aligned) × 0.58 weight = 0.00
  5M:     UP (aligned)     × 0.44 weight = 0.44
  ─────────────────────────────────────────────
  Total MTF Score: 3.02 / 3.60 = 83.9% aligned

Why MTF Matters

Scenario	MTF Alignment	Action
All 5 timeframes aligned	100%	High conviction trade
4 of 5 aligned	~85%	Trade with normal size
3 of 5 aligned	~70%	Proceed with caution
2 or fewer aligned	<60%	Reduced quality score

PART 4: LAYER 2 - MARKET STATE ANALYSIS

The 7 Market State Algorithms

The system runs 7 independent algorithms to understand current market context:

#	Algorithm	What It Detects	Impact
1	Railroad Tracks	Strong momentum bars in sequence	+15% bonus
2	Creeper Move	Slow grinding trend (dangerous)	-50% penalty
3	Two-Day Trend	Trend visible on Daily for 2+ days	Required for A+
4	Phase Analysis	Accumulation/Distribution/Markup/Markdown	Phase mismatch = -25%
5	Institutional Activity	Big player accumulation/distribution	Fight = 0.7× multiplier
6	Break of Structure (BOS)	Key level breaks	Affects stop placement
7	Volatility Regime	High/Normal/Low volatility	Adjusts expectations

Penalty System

Condition	Penalty	Rationale
Creeper Move Detected	-50 points	Slow trends often reverse suddenly
MA Struggle (price fighting MA)	-30 points	Indecision, likely to chop
No Two-Day Trend	-30 points	Trend not established enough
Phase Mismatch	-25 points	Trading against market phase
No Key Level Nearby	-50 points	No technical confluence
Institutional Fight	×0.70 multiplier	Big players fighting each other

Bonus System

Condition	Bonus	Rationale
Railroad Tracks	+15 points	Strong momentum confirmation
At Key Level	+10 points	Technical confluence present
Clean Entry Setup	+10 points	Clear technical pattern

PART 5: LAYER 3 - SETUP QUALITY GRADING

The 5-Factor Scoring System

Every potential trade is scored on 5 factors:

Factor	Weight	What It Measures
Timeframe Alignment	30%	How well all 5 timeframes agree
Trend Strength	20%	Quality of the trend (Railroad vs Creeper)
Key Level Proximity	20%	Is entry near significant S/R level?
Entry Quality	15%	How clean is the entry technique?
Risk:Reward	15%	Is the R:R ratio favorable?

Note: Weights sum to 100%. Timeframe Alignment has highest weight (30%) because MTF is the foundation.

Grade Thresholds

Grade	Score Range	Action	Position Size
A+	90-100	Trade with full conviction	2 lots
A	80-89	Trade with confidence	1 lot
B	70-79	Trade normally	1 lot
C	60-69	NO TRADE	-
D	50-59	NO TRADE	-
F	<50	NO TRADE	-

A+ Grade Special Requirements

To achieve A+ grade, ALL conditions must be true:

Final score ≥ 90
All 5 timeframes aligned with trade direction
Entry within ±25 points of MA21
Two-day trend present on Daily
No institutional fight detected

Score Calculation Example

Trade Setup: LONG on 5-min chart

Factor Scores (0-100 each):
  Timeframe Alignment: 85  × 0.30 = 25.5
  Trend Strength:      90  × 0.20 = 18.0
  Key Level Proximity: 70  × 0.20 = 14.0
  Entry Quality:       80  × 0.15 = 12.0
  Risk:Reward:         75  × 0.15 = 11.25
                              ──────────
  Base Score:                    80.75

Penalties Applied:
  - No Railroad Tracks: 0
  - No Creeper: 0
  - Has Two-Day: 0
                              ──────────
  Final Score: 80.75 → Grade: A

PART 6: LAYER 4 - HARD FILTERS (The Gate)

HARD FILTERS block trades completely. If ANY hard filter fails, NO TRADE happens regardless of how good the setup looks.

The Three Hard Filters

Filter	Rule	Effect
1. Direction Filter	MA21 slope must match trade direction	Wrong direction = BLOCKED
2. Grade Filter	Only A+, A, B grades allowed	C/D/F grades = BLOCKED
3. Hour Filter	Block hours 9, 22, 23	Blocked hours = BLOCKED

Filter 1: Direction (MA21 Slope)

MA21 Slope	Allowed Direction	Logic
Rising (↗)	LONG only	Trade with uptrend, never short
Declining (↘)	SHORT only	Trade with downtrend, never long
Flat (→)	Use MTF direction	Higher timeframes decide

Slope Calculation:
  Slope % = (MA21[current] - MA21[previous]) / MA21[previous] × 100

Thresholds:
  > +0.01%  → RISING (LONG only)
  < -0.01%  → DECLINING (SHORT only)
  ±0.01%   → FLAT (use MTF consensus)

Filter 2: Grade

Grade	Action
A+, A, B	PASS - Proceed to entry
C, D, F	BLOCKED - No trade

Source: signal_generation_trade_management.py:568

if setup_quality.grade in [SetupQualityGrade.C, SetupQualityGrade.D, SetupQualityGrade.F]:

   return None  # No signal generated - trade blocked

</source>

Filter 3: Hour

Hour	Status	Reason
9 (9:00-9:59 AM)	BLOCKED	Market open volatility
10-21 (10:00 AM - 9:59 PM)	ALLOWED	Normal trading hours
22 (10:00-10:59 PM)	BLOCKED	Near market close
23 (11:00-11:59 PM)	BLOCKED	Market close

Why 80% of Trades Were SHORT

In the backtest period, MA21 was predominantly declining:

Market was in a sustained downtrend
Rising MA periods were shorter/fewer
This is expected behavior - strategy adapts to market conditions

PART 7: LAYER 5 - ENTRY TECHNIQUE

The MA21 Zone Principle

"The MA is a ZONE, not a thin line"
Entry is allowed within ±25 points of MA21, not just at the exact MA value.

Why ±25 Points?

Price rarely touches MA exactly
Allows for normal market noise
Captures the "value zone" around the average
Based on typical Crude Oil volatility

Available Entry Techniques

Technique	Direction	Description
NEAR_MA	Both	Price within ±25 pts of MA21 (most common)
MA_BOUNCE_LONG	Long	Price touches MA21 and bounces up
MA_BOUNCE_SHORT	Short	Price touches MA21 and rejects down
GREEN_BAR_AFTER_PULLBACK	Long	Bullish candle after pullback to MA
RED_BAR_AFTER_RALLY	Short	Bearish candle after rally to MA
BOS_ENTRY_LONG	Long	Break of structure to upside
BOS_ENTRY_SHORT	Short	Break of structure to downside

Entry Selection Logic

<source lang="python"> def select_entry_technique(price, ma21, direction, market_state):

   """
   Select best entry technique based on conditions.
   Source: signal_generation_trade_management.py
   """
   ma_distance = abs(price - ma21)

   # Most common: price in MA zone
   if ma_distance <= 25:  # ±25 points
       return NEAR_MA

   # Break of structure detected
   if market_state.has_bos:
       return BOS_ENTRY_LONG if direction == LONG else BOS_ENTRY_SHORT

   # Pullback/Rally pattern
   if market_state.has_pullback:
       return GREEN_BAR_AFTER_PULLBACK if direction == LONG else RED_BAR_AFTER_RALLY

   return NEAR_MA  # Default

</source>

PART 8: STOP LOSS CALCULATION

Stop Loss Methods (Priority Order)

Priority	Method	Description
1	BOS-Based Stop	Below/above break of structure level
2	Swing-Based Stop	Below recent swing low (LONG) or above swing high (SHORT)
3	Default Stop	Fixed 40 points from entry

Minimum Stop Distance

MINIMUM: 40 points - Stops closer than 40 points are automatically widened to 40.

This prevents:

Getting stopped out by normal noise
Excessive trading costs from tight stops
Whipsaws in volatile Crude Oil market

Stop Calculation Algorithm

<source lang="python"> def calculate_stop_loss(entry_price, direction, market_state):

   """
   Calculate stop loss with minimum enforcement.
   Source: signal_generation_trade_management.py
   """
   MIN_STOP_DISTANCE = 40.0  # points

   # Try BOS-based stop first
   if market_state.bos_level:
       stop = market_state.bos_level - 5  # 5pt buffer

   # Try swing-based stop
   elif market_state.swing_low and direction == LONG:
       stop = market_state.swing_low - 5

   # Default stop
   else:
       if direction == LONG:
           stop = entry_price - MIN_STOP_DISTANCE
       else:
           stop = entry_price + MIN_STOP_DISTANCE

   # ENFORCE MINIMUM
   actual_distance = abs(entry_price - stop)
   if actual_distance < MIN_STOP_DISTANCE:
       if direction == LONG:
           stop = entry_price - MIN_STOP_DISTANCE
       else:
           stop = entry_price + MIN_STOP_DISTANCE

   return stop

</source>

PART 9: TARGET CALCULATION

The 50% Rule

Target = 50% of distance to MA21

For mean reversion trades, we target halfway back to the moving average.

Why 50%?

Conservative target ensures higher hit rate
Based on "divide the move in half" principle
Captures partial reversion without being greedy
Works well with trailing stop to capture more

Minimum Target Rule

Minimum Target = Risk × 1.5

Example:
  Entry: 5700
  Stop: 5660 (40 points risk)

  50% to MA might give: 30 points
  But minimum is: 40 × 1.5 = 60 points

  Final Target: 5760 (60 points)

Target Calculation

<source lang="python"> def calculate_target(entry_price, stop_price, ma21, direction):

   """
   PDF-based target: 50% of distance to MA, with minimum.
   Source: signal_generation_trade_management.py
   """
   risk_distance = abs(entry_price - stop_price)
   min_target = risk_distance * 1.5  # Minimum 1.5:1 R:R

   # Calculate 50% move toward MA
   distance_to_ma = abs(entry_price - ma21)
   target_distance = distance_to_ma * 0.5

   # Enforce minimum
   target_distance = max(target_distance, min_target)

   if direction == LONG:
       return entry_price + target_distance
   else:
       return entry_price - target_distance

</source>

PART 10: DYNAMIC STOP MANAGEMENT

Two-Phase Protection

After entry, stops are managed dynamically in two phases:

Phase	Trigger	Action
Phase 1: Breakeven	+25 points profit	Move stop to entry + 2 points
Phase 2: Trailing	+20 points profit	Trail stop using ATR × 2

Phase 1: Breakeven Stop

Configuration:
  breakeven_activation = 25 points
  breakeven_buffer = 2 points

Example (LONG from 5700):
  Price reaches 5725 (+25 pts profit)
  → Stop moves from 5660 to 5702 (entry + 2)
  → Trade is now "risk-free"

Phase 2: Trailing Stop

Configuration:
  trailing_stop_activation = 20 points
  trailing_stop_method = ATR_MULTIPLE
  atr_period = 14 bars
  atr_multiplier = 2.0
  minimum_trail_distance = 15 points

Example (LONG from 5700, ATR = 12):
  Trailing Distance = 12 × 2 = 24 points

  Price at 5740:
  → Trail stop = 5740 - 24 = 5716

  Price at 5760:
  → Trail stop = 5760 - 24 = 5736 (moved UP)

  Price drops to 5736:
  → STOPPED OUT at 5736 (profit locked)

Why Both Phases?

Phase	Purpose
Breakeven	Eliminate risk quickly once trade moves in favor
Trailing	Let winners run while protecting accumulated profit

PART 11: SLIPPAGE & COSTS

Realistic Slippage Model

Event	Slippage	Rationale
Entry	+1.0 point	Normal market fill
Stop Loss Exit	+2.0 points	Stops slip more in fast moves
Target Exit	+0.5 points	Limit orders have minimal slippage

Cost Structure

Cost Type	Value
Commission	Rs 20 per lot per side
STT	0.01% on sell side
Exchange Fees	~Rs 2 per lot
Stamp Duty	State-dependent

Why Model Slippage?

Backtest results must reflect real trading
Prevents over-optimistic performance estimates
Stop loss slippage is higher because stops often trigger during fast moves
Total costs ~Rs 79 per round-trip lot

PART 12: EXIT RULES

Three Exit Conditions

Exit Type	Condition	% of Exits
Stop Loss	Price hits stop (original or trailing)	72.3%
Target	Price hits take profit level	22.8%
Timeout	End of day (no overnight holds)	5.0%

Why 72% Stop Exits but 57% Win Rate?

This seems contradictory but makes sense:

Trailing stops lock in profits - many "stop exits" are actually winning trades
Breakeven stops trigger at +25 pts, trailing at +20 pts
A trade can be stopped out at +30 pts profit (counted as stop exit but is a WIN)

End-of-Day Exit

All positions closed before market close:
  - Market closes at 11:30 PM IST
  - 15-minute buffer before close
  - Prevents overnight gap risk

PART 13: PUTTING IT ALL TOGETHER

Trade Flow

┌─────────────────────────────────────────────────────────────────┐
│  STEP 1: Load data for all 5 timeframes                         │
│  Daily, 4H, 1H, 15M, 5M OHLCV data                             │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 2: LAYER 1 - MTF Analysis (Foundation)                    │
│  Calculate MA21, MA200, trend direction for each timeframe      │
│  Compute MTF alignment score                                    │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 3: LAYER 2 - Market State Analysis                        │
│  Run 7 algorithms: Railroad, Creeper, Phase, BOS, etc.          │
│  Calculate penalties and bonuses                                │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 4: LAYER 3 - Setup Quality Grading                        │
│  Score 5 factors, apply penalties/bonuses                       │
│  Assign grade: A+ / A / B / C / D / F                           │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 5: LAYER 4 - HARD FILTERS (The Gate)  ◄── PASS/FAIL      │
│  • Direction: MA21 slope matches trade direction?               │
│  • Grade: Is grade A+, A, or B?                                 │
│  • Hour: Is current hour allowed (not 9, 22, 23)?               │
│  ANY FAIL → NO TRADE                                            │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 6: LAYER 5 - Entry Technique                              │
│  Is price within ±25 points of MA21?                            │
│  Select entry technique (NEAR_MA, BOS_ENTRY, etc.)              │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 7: Calculate Stop Loss                                    │
│  BOS-based → Swing-based → Default (40 pts minimum)             │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 8: Calculate Target                                       │
│  50% of distance to MA (minimum 1.5× risk)                      │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 9: Execute Trade                                          │
│  Apply entry slippage (+1 pt), create trade record              │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 10: Manage Trade                                          │
│  Monitor: Breakeven at +25 pts → Trail at +20 pts               │
│  Exit: Stop hit | Target hit | Timeout                          │
└─────────────────────────────────────────────────────────────────┘

PART 14: HARD vs SOFT FILTERS

Understanding the Difference

Filter Type	Behavior	Examples
HARD	Blocks trade completely	Direction filter, Hour filter, Grade C/D/F
SOFT	Affects quality score	MTF alignment, Market state penalties

Complete Filter List

Filter	Type	Effect
MA21 Direction	HARD	Wrong direction = NO TRADE
Hour Filter	HARD	Hours 9, 22, 23 = NO TRADE
Grade < B	HARD	C/D/F grades = NO TRADE
MTF Alignment	SOFT	Low alignment = reduced score (30% weight)
Creeper Move	SOFT	-50 points penalty
No Two-Day Trend	SOFT	-30 points penalty
Institutional Fight	SOFT	0.7× score multiplier
Far from MA21	SOFT	-40 points penalty

APPENDIX A: CONFIGURATION VALUES

Entry Configuration

Parameter	Value	Source File
entry_timeframe	5-Minute	main.py:165
ma_buffer_points	25 points	signal_generation_trade_management.py:68
blocked_hours	[9, 22, 23]	signal_generation_trade_management.py:137

Stop/Target Configuration

Parameter	Value	Source File
min_stop_distance	40 points	signal_generation_trade_management.py:59
default_risk_reward	1.5	signal_generation_trade_management.py:62
bos_stop_buffer_points	5 points	signal_generation_trade_management.py:81

Dynamic Stop Configuration

Parameter	Value	Source File
enable_trailing_stop	True	trade_execution_engine.py:58
trailing_stop_method	ATR_MULTIPLE	trade_execution_engine.py:63
atr_period	14 bars	trade_execution_engine.py:64
atr_multiplier	2.0	trade_execution_engine.py:65
trailing_stop_activation	20 points	trade_execution_engine.py:60
enable_breakeven_stop	True	trade_execution_engine.py:69
breakeven_activation	25 points	trade_execution_engine.py:70
breakeven_buffer	2 points	trade_execution_engine.py:71
minimum_trail_distance	15 points	trade_execution_engine.py:370

Slippage Configuration

Parameter	Value	Source File
base_slippage_points	1.0 point	trade_execution_engine.py:38
stop_loss_slippage	2.0 points	trade_execution_engine.py:50
take_profit_slippage	0.5 points	trade_execution_engine.py:51

Grading Configuration

Parameter	Value	Source File
timeframe_alignment_weight	30%	setup_quality_detection.py:44
trend_strength_weight	20%	setup_quality_detection.py:45
key_level_proximity_weight	20%	setup_quality_detection.py:47
entry_technique_weight	15%	setup_quality_detection.py:46
risk_reward_weight	15%	setup_quality_detection.py:48
a_plus_min_score	90	setup_quality_detection.py:51
a_min_score	80	setup_quality_detection.py:52
b_min_score	70	setup_quality_detection.py:53

APPENDIX B: SOURCE CODE REFERENCE

File	Purpose
`main.py`	Entry point, timeframe configuration
`trend_analysis_core.py`	MA calculation, slope detection, trend direction
`multi_timeframe_analysis.py`	MTF alignment scoring across 5 timeframes
`market_state_analysis.py`	7 market state detection algorithms
`setup_quality_detection.py`	5-factor grading system with penalties/bonuses
`probability_zone_analysis.py`	Halves/Thirds, Three-Finger Spread, Crash Bar
`signal_generation_trade_management.py`	Entry/Exit logic, stop/target calculation
`trade_execution_engine.py`	Breakeven, Trailing stop, Slippage modeling
`data_manager.py`	OHLCV data loading and management

Document generated from source code analysis - January 2026

Strategy: Multi-Layer Confluence (MLC) v1.0

@@ Line 48: / Line 48: @@
 ----
-= PART 2: THE EDGE (Why This Works) =
+= PART 2: Core Concept (Why This Works) =
-== Core Philosophy ==
 The edge comes from '''requiring multiple independent confirmations''' before trading. Each layer filters out bad trades: