Refining Entries, From 1H Zone to 1M Trigger

[Fairman]

Refining Entries, From 1H Zone to 1M Trigger

Have you ever had a great analysis and still got stopped out by a few pips before price went your way? That's often an entry problem, not an analysis problem.

diagram.png (46.29 KiB) Viewed 78 times

Entry refinement means using lower timeframes to pinpoint a precise entry inside a higher-timeframe zone. Done well, it shrinks your stop loss and boosts your risk-to-reward.

Here's the process:

1. Mark the zone on the 1H. For example, a bullish order block in discount.
2. Wait for price to enter the zone. Never place a blind limit at the top of the zone if you can help it.
3. Drop to the 5M or 1M. Look for a small liquidity sweep inside the zone.
4. Watch for a CHoCH. A break of the recent lower-timeframe high tells you buyers are stepping in.
5. Mark the entry. Use the small order block or FVG created by the CHoCH move.
6. Set the stop. Below the low of the sweep, not an arbitrary number.
7. Set the target. The next higher-timeframe liquidity.

Example: a 20-pip stop with a 100-pip target gives 1:5. The same zone entered with a 50-pip stop gives 1:2.

The tradeoff is that refined entries sometimes get missed when price reacts without giving a lower-timeframe signal. That's fine. Missing a trade is cheaper than taking a bad one.

Practice on replay or demo first. Precision comes with repetition.

[PropScalpDesk]

The 1:5 against 1:2 comparison looks one-sided until you include win rate, because the tighter stop gets hit more often. Rough example: if the refined 20-pip entries win 25% of the time, expectancy is 0.25 x 5 - 0.75 = +0.5R per trade. If the 50-pip entries win 45%, it's 0.45 x 2 - 0.55 = +0.35R. The refined version still wins in that example, but by much less than "1:5 versus 1:2" suggests, and at a 20% win rate it falls to +0.2R.

The other number to track is the one you mentioned at the end: trades missed because no lower-timeframe signal appeared. If the refined method skips a third of the moves the 1H zone catches, the total over a month can come out lower even with a better expectancy per trade.

So for anyone testing this, journal both versions on the same zones for a few weeks. Mark the 1H entry you would have taken alongside the refined one.

[LondonNewsTrader]

Example: a 20-pip stop with a 100-pip target gives 1:5. The same zone entered with a 50-pip stop gives 1:2.

The numbers are correct, but they hide a trade-off worth stating: the hit rate usually drops with the tighter stop. A 20-pip stop inside a 1H zone gets taken out by normal noise more often than a 50-pip one, so the 1:5 entries need fewer winners, but they will also get more losers. The real comparison is expectancy, not ratio, and only your own data can tell you which wins.

Execution matters more at 1M precision too. If your refined stop is 8 pips and the spread is 1 pip, cost is already 12 percent of risk. If the trigger comes just after a release when the spread is 3 pips, the setup you planned is not the trade you got.

Worth adding a rule to your list: no 1M refinement in the minutes around scheduled data. The lower timeframe structure in that window is mostly noise from the spike.

[PTScalper]

The 1:5 against 1:2 comparison looks one-sided until you include win rate, because the tighter stop gets hit more often. Rough example: if the refined 20-pip entries win 25% of the time, expectancy is 0.25 x 5 - 0.75 = +0.5R per trade. If the 50-pip entries win 45%, it's 0.45 x 2 - 0.55 = +0.35R. The refined version still wins in that example, but by much less than "1:5 versus 1:2" suggests, and at a 20% win rate it falls to +0.2R.

The other number to track is the one you mentioned at the end: trades missed because no lower-timeframe signal appeared. If the refined method skips a third of the moves the 1H zone catches, the total over a month can come out lower even with a better expectancy per trade.

So for anyone testing this, journal both versions on the same zones for a few weeks. Mark the 1H entry you would have taken alongside the refined one.

Hi PropScalpDesk,

The arithmetic exposes the exact illusion that traps most traders chasing high R-multiples. A strategy generating +0.5R per trade at a 25% win rate mathematically outperforms one generating +0.35R at a 45% win rate—but only in a vacuum where both strategies trigger at the exact same frequency.

Once opportunity cost is factored in, the math flips. If the 1-minute or 5-minute refined entry misses 33% of the moves that the 1H structural zone catches, the total monthly yield on the wider stop often eclipses the tighter one.

[PTScalper]

Using your exact variables over a 100-setup sample, the wider 1H zone yields +35R. The refined entry—despite having a higher per-trade expectancy—only yields +33.5R because it sits on the sidelines for a third of the actionable moves. If the refined win rate drops to 20%, its yield collapses to just +13.4R over that same period.

Beyond the raw math, there are two underlying mechanical reasons why journaling both approaches side-by-side on the same zones is the right move:

Market Microstructure & Liquidity: A 20-pip stop isn't just hit more often due to standard deviation; it gets hit because it represents prime order book liquidity. Algorithms aggressively sweep tighter stops residing just behind 15-minute structural lows before initiating the real macro move. A 50-pip stop placed behind a 1H or daily level generally survives these intraday sweeps.

Psychological Capital: Trading a 25% win rate means enduring prolonged drawdowns and extended losing streaks. Even if a highly refined 1:5 setup mathematically outperforms a 1:2 setup by a few R over a quarter, the cognitive friction of losing 3 out of 4 trades causes most discretionary traders to abandon the strategy before the probabilities play out.

[PTScalper]

Here is a Pine Script v5 testing harness designed specifically to run your "ghost executions."

Because you're dealing with opportunity cost (the LTF signal failing to form before the move happens), this script uses a state machine. When the 1H structural condition triggers, the Wide trade executes immediately. The script then opens a "search window" for a configurable number of bars. If your LTF condition fires inside that window, the Refined trade executes. If the window closes without an LTF signal, it logs the opportunity cost as a "Missed Trade."

[PTScalper]

Code: Select all

Pine script version 1.0

Code: Select all

//@version=5
indicator("Ghost Executions: HTF vs LTF Framework", overlay=true)

// ==============================================================================
// 1. INPUTS & PARAMETERS
// ==============================================================================
grp_wide = "1H Structural Zone (Wide)"
i_wide_sl_pips = input.float(50.0, "Wide SL (pips)", group=grp_wide)
i_wide_rr      = input.float(2.0, "Wide Target (R)", group=grp_wide)

grp_ref = "Lower Timeframe (Refined)"
i_ref_sl_pips  = input.float(20.0, "Refined SL (pips)", group=grp_ref)
i_ref_rr       = input.float(5.0, "Refined Target (R)", group=grp_ref)
i_ltf_window   = input.int(12, "Max Bars to wait for LTF Signal", tooltip="If LTF condition doesn't fire within this many bars of the HTF trigger, it counts as a missed trade.", group=grp_ref)

// Pip Calculation (Adjustable for Spot Forex vs Metals)
pip_size = syminfo.mintick * (syminfo.type == "forex" ? 10 : 1)

// ==============================================================================
// 2. YOUR CUSTOM ENTRY LOGIC (Replace these placeholders)
// ==============================================================================
// Example placeholders: EMA crossover for HTF, Price crossing EMA for LTF
emaFast = ta.ema(close, 20)
emaSlow = ta.ema(close, 50)

// HTF Triggers (e.g., Price hits the 1H Zone)
htf_long_cond  = ta.crossover(emaFast, emaSlow)
htf_short_cond = ta.crossunder(emaFast, emaSlow)

// LTF Triggers (e.g., 5m or 1m confirmation pattern)
// For testing out of the box, we just require a strong close in the trade direction
ltf_long_cond  = close > open and close > ta.ema(close, 9)
ltf_short_cond = close < open and close < ta.ema(close, 9)


// ==============================================================================
// 3. STATE MANAGEMENT
// ==============================================================================
var int   wide_dir = 0 // 1 = Long, -1 = Short, 0 = Flat
var float wide_ep = na, var float wide_sl = na, var float wide_tp = na

var int   ref_dir = 0
var float ref_ep = na, var float ref_sl = na, var float ref_tp = na

// Search Window State
var bool  searching_ltf = false
var int   search_dir = 0
var int   bars_since_htf = 0

// Metrics Trackers
var float wide_R_total = 0.0
var int   wide_wins = 0, var int wide_losses = 0

var float ref_R_total = 0.0
var int   ref_wins = 0, var int ref_losses = 0
var int   ref_missed = 0


// ==============================================================================
// 4. EXECUTION ENGINE
// ==============================================================================
// A. Triggering HTF (Wide)
if (htf_long_cond or htf_short_cond) and wide_dir == 0
    wide_dir := htf_long_cond ? 1 : -1
    wide_ep  := close
    
    sl_dist = i_wide_sl_pips * pip_size
    tp_dist = sl_dist * i_wide_rr
    
    wide_sl  := wide_dir == 1 ? wide_ep - sl_dist : wide_ep + sl_dist
    wide_tp  := wide_dir == 1 ? wide_ep + tp_dist : wide_ep - tp_dist
    
    // Open the window for the LTF signal
    searching_ltf  := true
    search_dir     := wide_dir
    bars_since_htf := 0

// B. Hunting for LTF (Refined)
if searching_ltf and ref_dir == 0
    // Check if window expired
    if bars_since_htf > i_ltf_window
        searching_ltf := false
        ref_missed += 1
    else
        // Check for LTF signal matching HTF direction
        ltf_trigger = (search_dir == 1 and ltf_long_cond) or (search_dir == -1 and ltf_short_cond)
        
        if ltf_trigger
            ref_dir := search_dir
            ref_ep  := close
            
            sl_dist = i_ref_sl_pips * pip_size
            tp_dist = sl_dist * i_ref_rr
            
            ref_sl  := ref_dir == 1 ? ref_ep - sl_dist : ref_ep + sl_dist
            ref_tp  := ref_dir == 1 ? ref_ep + tp_dist : ref_ep - tp_dist
            
            searching_ltf := false
            
        bars_since_htf += 1


// C. Trade Management (Checking hits on active trades)
if wide_dir != 0
    hit_tp = (wide_dir == 1 and high >= wide_tp) or (wide_dir == -1 and low <= wide_tp)
    hit_sl = (wide_dir == 1 and low <= wide_sl) or (wide_dir == -1 and high >= wide_sl)
    
    if hit_tp
        wide_R_total += i_wide_rr
        wide_wins += 1
        wide_dir := 0
    else if hit_sl
        wide_R_total -= 1.0
        wide_losses += 1
        wide_dir := 0

if ref_dir != 0
    hit_tp = (ref_dir == 1 and high >= ref_tp) or (ref_dir == -1 and low <= ref_tp)
    hit_sl = (ref_dir == 1 and low <= ref_sl) or (ref_dir == -1 and high >= ref_sl)
    
    if hit_tp
        ref_R_total += i_ref_rr
        ref_wins += 1
        ref_dir := 0
    else if hit_sl
        ref_R_total -= 1.0
        ref_losses += 1
        ref_dir := 0


// ==============================================================================
// 5. DASHBOARD UI
// ==============================================================================
var table dash = table.new(position.top_right, 4, 4, border_width=1)

if barstate.islast
    table.cell(dash, 0, 0, "Strategy", text_color=color.white, bgcolor=color.gray)
    table.cell(dash, 1, 0, "Total R", text_color=color.white, bgcolor=color.gray)
    table.cell(dash, 2, 0, "Win %", text_color=color.white, bgcolor=color.gray)
    table.cell(dash, 3, 0, "Trades / Missed", text_color=color.white, bgcolor=color.gray)
    
    // Wide Row
    wide_trades = wide_wins + wide_losses
    wide_wr = wide_trades > 0 ? (wide_wins / wide_trades) * 100 : 0.0
    table.cell(dash, 0, 1, "1H Structural", text_color=color.white, bgcolor=color.blue)
    table.cell(dash, 1, 1, str.tostring(math.round(wide_R_total, 2)) + " R", text_color=wide_R_total >= 0 ? color.lime : color.red, bgcolor=color.new(color.black, 20))
    table.cell(dash, 2, 1, str.tostring(math.round(wide_wr, 1)) + "%", text_color=color.white, bgcolor=color.new(color.black, 20))
    table.cell(dash, 3, 1, str.tostring(wide_trades) + " / 0", text_color=color.white, bgcolor=color.new(color.black, 20))
    
    // Refined Row
    ref_trades = ref_wins + ref_losses
    ref_wr = ref_trades > 0 ? (ref_wins / ref_trades) * 100 : 0.0
    table.cell(dash, 0, 2, "LTF Refined", text_color=color.white, bgcolor=color.orange)
    table.cell(dash, 1, 2, str.tostring(math.round(ref_R_total, 2)) + " R", text_color=ref_R_total >= 0 ? color.lime : color.red, bgcolor=color.new(color.black, 20))
    table.cell(dash, 2, 2, str.tostring(math.round(ref_wr, 1)) + "%", text_color=color.white, bgcolor=color.new(color.black, 20))
    table.cell(dash, 3, 2, str.tostring(ref_trades) + " / " + str.tostring(ref_missed), text_color=color.white, bgcolor=color.new(color.black, 20))

[PTScalper]

Architecture Notes

The Search Window (i_ltf_window): This is the core of tracking your opportunity cost. When the 1H zone triggers, the script gives the LTF a set number of bars to form its confirmation. If it doesn't form before the window expires, it's categorized as a ref_missed trade.

State Management: Because it handles states independently (wide_dir and ref_dir), both trades can run simultaneously. If the wider stop survives a liquidity sweep but the tight one gets clipped, the script will accurately reflect a -1R hit on the refined model while keeping the 1H trade active.

Intraday Sweeps: Keep in mind TradingView calculates intra-bar logic sequentially (High then Low, or Low then High) based on timeframe unless you use the Bar Magnifier. For extreme scalping logic (like a 20-pip stop on a 15m chart), the script might hit both SL and TP on the same candle. You may need to drop this onto a 1-minute chart so the engine resolves the path of price accurately.

[PTScalper]

Because we are testing intraday liquidity sweeps and market microstructure, relying on standard broker OrderSend functions in the Strategy Tester introduces unnecessary latency and execution quirks (like dealing with MODE_FREEZELEVEL or slippage on stop-losses).

Here is version similar to C# and state machines, the cleanest way to test this in MetaTrader is to build a Virtual Execution Engine as an Expert Advisor. It compiles natively in both MQL4 and MQL5 without modification, tracking the states entirely in memory. This allows you to run it through the MT5 Strategy Tester on "Every tick based on real ticks" for extremely precise intra-bar sweep resolution.

[PTScalper]

Code: Select all

MT4 and MT5 version

Code: Select all

//+------------------------------------------------------------------+
//|                                        GhostExecutionsEngine.mq5 |
//|                       Cross-Compatible for MT4 (MQL4) & MT5 (MQL5)|
//+------------------------------------------------------------------+
#property strict // Enforces strict compilation in MQL4, ignored natively in MQL5

// --- INPUTS ---
input double InpWideSL = 50.0;    // Wide SL (pips)
input double InpWideRR = 2.0;     // Wide Target (R)
input double InpRefSL  = 20.0;    // Refined SL (pips)
input double InpRefRR  = 5.0;     // Refined Target (R)
input int    InpWindow = 12;      // LTF Search Window (bars)

// --- STATE VARIABLES ---
int    wide_dir = 0; // 1 = Long, -1 = Short, 0 = Flat
double wide_ep = 0, wide_sl = 0, wide_tp = 0;

int    ref_dir = 0;
double ref_ep = 0, ref_sl = 0, ref_tp = 0;

bool   searching_ltf = false;
int    search_dir = 0;
int    bars_since_htf = 0;

// --- METRICS ---
double wide_R_total = 0;
int    wide_wins = 0, wide_losses = 0;

double ref_R_total = 0;
int    ref_wins = 0, ref_losses = 0, ref_missed = 0;

double pip_size;
datetime last_bar_time;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    // Adjust for 3/5 digit brokers
    pip_size = Point();
    if(Digits() == 3 || Digits() == 5) pip_size *= 10;
    
    last_bar_time = iTime(_Symbol, PERIOD_CURRENT, 0);
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
    
    // ---------------------------------------------------------
    // 1. VIRTUAL TRADE MANAGEMENT (Tick-level precision)
    // ---------------------------------------------------------
    if(wide_dir == 1) {
        if(bid >= wide_tp) { wide_R_total += InpWideRR; wide_wins++; wide_dir = 0; }
        else if(bid <= wide_sl) { wide_R_total -= 1.0; wide_losses++; wide_dir = 0; }
    }
    else if(wide_dir == -1) {
        if(ask <= wide_tp) { wide_R_total += InpWideRR; wide_wins++; wide_dir = 0; }
        else if(ask >= wide_sl) { wide_R_total -= 1.0; wide_losses++; wide_dir = 0; }
    }
    
    if(ref_dir == 1) {
        if(bid >= ref_tp) { ref_R_total += InpRefRR; ref_wins++; ref_dir = 0; }
        else if(bid <= ref_sl) { ref_R_total -= 1.0; ref_losses++; ref_dir = 0; }
    }
    else if(ref_dir == -1) {
        if(ask <= ref_tp) { ref_R_total += InpRefRR; ref_wins++; ref_dir = 0; }
        else if(ask >= ref_sl) { ref_R_total -= 1.0; ref_losses++; ref_dir = 0; }
    }

    // ---------------------------------------------------------
    // 2. BAR-CLOSE LOGIC (Signal Evaluation)
    // ---------------------------------------------------------
    datetime current_time = iTime(_Symbol, PERIOD_CURRENT, 0);
    if(current_time != last_bar_time) 
    {
        if(searching_ltf) bars_since_htf++;
        last_bar_time = current_time;
        
        // --- YOUR CUSTOM LOGIC PLACEHOLDERS ---
        // Replace with your 1H Zone and LTF confirmation triggers
        bool htf_long_cond = false;  // e.g., price reaches 1H demand zone
        bool htf_short_cond = false; 
        
        bool ltf_long_cond = false;  // e.g., 5m bullish engulfing / structure break
        bool ltf_short_cond = false;

        // --- A. Evaluate HTF Trigger ---
        if(wide_dir == 0 && (htf_long_cond || htf_short_cond)) 
        {
            wide_dir = htf_long_cond ? 1 : -1;
            wide_ep  = htf_long_cond ? ask : bid;
            
            double sl_dist = InpWideSL * pip_size;
            double tp_dist = sl_dist * InpWideRR;
            
            wide_sl = (wide_dir == 1) ? wide_ep - sl_dist : wide_ep + sl_dist;
            wide_tp = (wide_dir == 1) ? wide_ep + tp_dist : wide_ep - tp_dist;
            
            // Open window for LTF signal
            searching_ltf = true;
            search_dir = wide_dir;
            bars_since_htf = 0;
        }

        // --- B. Evaluate LTF Trigger ---
        if(searching_ltf && ref_dir == 0) 
        {
            if(bars_since_htf > InpWindow) 
            {
                searching_ltf = false;
                ref_missed++;
            } 
            else 
            {
                bool valid_ltf_trigger = (search_dir == 1 && ltf_long_cond) || (search_dir == -1 && ltf_short_cond);
                if(valid_ltf_trigger) 
                {
                    ref_dir = search_dir;
                    ref_ep  = (ref_dir == 1) ? ask : bid;
                    
                    double sl_dist = InpRefSL * pip_size;
                    double tp_dist = sl_dist * InpRefRR;
                    
                    ref_sl = (ref_dir == 1) ? ref_ep - sl_dist : ref_ep + sl_dist;
                    ref_tp = (ref_dir == 1) ? ref_ep + tp_dist : ref_ep - tp_dist;
                    
                    searching_ltf = false; // Successfully fired
                }
            }
        }
    }

    // ---------------------------------------------------------
    // 3. UI DASHBOARD
    // ---------------------------------------------------------
    int wide_trades = wide_wins + wide_losses;
    double wide_wr = (wide_trades > 0) ? ((double)wide_wins / wide_trades) * 100.0 : 0.0;
    
    int ref_trades = ref_wins + ref_losses;
    double ref_wr = (ref_trades > 0) ? ((double)ref_wins / ref_trades) * 100.0 : 0.0;

    string dash = StringFormat(
        "--- GHOST EXECUTIONS FRAMEWORK ---\n\n"
        "1H STRUCTURAL (Wide)\n"
        "Total Return: %.2f R\n"
        "Win Rate: %.1f%% (%d trades)\n\n"
        "LTF REFINED (Tight)\n"
        "Total Return: %.2f R\n"
        "Win Rate: %.1f%% (%d trades)\n"
        "Missed Moves: %d",
        wide_R_total, wide_wr, wide_trades,
        ref_R_total, ref_wr, ref_trades, ref_missed
    );
    
    Comment(dash);
}