simulate_causal.py

import pandas as pd
import numpy as np

def calculate_adx(df, period=14):
    df['h_l'] = df['high'] - df['low']
    df['h_pc'] = (df['high'] - df['close'].shift(1)).abs()
    df['l_pc'] = (df['low'] - df['close'].shift(1)).abs()
    df['tr'] = df[['h_l', 'h_pc', 'l_pc']].max(axis=1)
    
    df['+dm'] = np.where((df['high'] - df['high'].shift(1)) > (df['low'].shift(1) - df['low']), 
                         np.maximum(df['high'] - df['high'].shift(1), 0), 0)
    df['-dm'] = np.where((df['low'].shift(1) - df['low']) > (df['high'] - df['high'].shift(1)), 
                         np.maximum(df['low'].shift(1) - df['low'], 0), 0)
    
    alpha = 1 / period
    df['tr_smooth'] = df['tr'].ewm(alpha=alpha, adjust=False).mean() * period
    df['+dm_smooth'] = df['+dm'].ewm(alpha=alpha, adjust=False).mean() * period
    df['-dm_smooth'] = df['-dm'].ewm(alpha=alpha, adjust=False).mean() * period
    
    df['+di'] = 100 * (df['+dm_smooth'] / df['tr_smooth'])
    df['-di'] = 100 * (df['-dm_smooth'] / df['tr_smooth'])
    
    df['dx'] = 100 * (df['+di'] - df['-di']).abs() / (df['+di'] + df['-di']).replace(0, 1)
    df['adx'] = df['dx'].ewm(alpha=alpha, adjust=False).mean()
    return df

def run_simulation():
    print("--- V14.19 Quatum Pendulum Simulator ---")
    print("Loading OHLC Parquet data...")
    m1 = pd.read_parquet('native_rates_M1.parquet')
    m5 = pd.read_parquet('native_rates_M5.parquet')
    m15 = pd.read_parquet('native_rates_M15.parquet')
    
    m1['time_dt'] = pd.to_datetime(m1['time'], unit='s')
    m5['time_dt'] = pd.to_datetime(m5['time'], unit='s')
    m15['time_dt'] = pd.to_datetime(m15['time'], unit='s')
    
    print("Calculating ADX & DMI Vectors...")
    m1 = calculate_adx(m1, 14)
    m5 = calculate_adx(m5, 14)
    m15 = calculate_adx(m15, 14)
    
    m1.set_index('time_dt', inplace=True)
    m5.set_index('time_dt', inplace=True)
    m15.set_index('time_dt', inplace=True)
    
    df = m1[['open', 'high', 'low', 'close', 'adx', '+di', '-di']].copy()
    df.rename(columns={'adx': 'adx_M1', '+di': 'di_plus_M1', '-di': 'di_minus_M1'}, inplace=True)
    
    m5_cols = m5[['adx', '+di', '-di']].rename(columns={'adx': 'adx_M5', '+di': 'di_plus_M5', '-di': 'di_minus_M5'})
    m5_cols.index = m5_cols.index + pd.Timedelta(minutes=5)
    df = df.join(m5_cols)
    df[['adx_M5', 'di_plus_M5', 'di_minus_M5']] = df[['adx_M5', 'di_plus_M5', 'di_minus_M5']].ffill()
    
    m15_cols = m15[['adx', '+di', '-di']].rename(columns={'adx': 'adx_M15', '+di': 'di_plus_M15', '-di': 'di_minus_M15'})
    m15_cols.index = m15_cols.index + pd.Timedelta(minutes=15)
    df = df.join(m15_cols)
    df[['adx_M15', 'di_plus_M15', 'di_minus_M15']] = df[['adx_M15', 'di_plus_M15', 'di_minus_M15']].ffill()
    
    df.dropna(inplace=True)
    
    # Static thresholds based on average spread
    t_M1 = 18.0
    t_M5 = 18.0 
    t_M15 = 18.0
    
    print("Mapping 8 Quantum Phases...")
    a1 = (df['adx_M1'] >= t_M1).astype(int)
    a5 = (df['adx_M5'] >= t_M5).astype(int)
    a15 = (df['adx_M15'] >= t_M15).astype(int)
    
    # 8-Phase Mapping (Binary Logic)
    df['phase'] = 1
    df.loc[(a15==0) & (a5==0) & (a1==0), 'phase'] = 1
    df.loc[(a15==0) & (a5==0) & (a1==1), 'phase'] = 2
    df.loc[(a15==0) & (a5==1) & (a1==0), 'phase'] = 3
    df.loc[(a15==1) & (a5==0) & (a1==0), 'phase'] = 4
    df.loc[(a15==0) & (a5==1) & (a1==1), 'phase'] = 5
    df.loc[(a15==1) & (a5==0) & (a1==1), 'phase'] = 6
    df.loc[(a15==1) & (a5==1) & (a1==0), 'phase'] = 7
    df.loc[(a15==1) & (a5==1) & (a1==1), 'phase'] = 8
    
    df['phase_prev'] = df['phase'].shift(1)
    df['phase_transition'] = df['phase'] != df['phase_prev']
    
    # DMI Score (using M15 as commanding direction)
    sum_di = df['di_plus_M15'] + df['di_minus_M15']
    df['dmi_dir'] = np.where(df['di_plus_M15'] > df['di_minus_M15'], 1, -1)
    df['dmi_score'] = (df[['di_plus_M15', 'di_minus_M15']].max(axis=1) / sum_di) * 100
    
    # DMI Score M5 (for Death Zone check)
    sum_di_m5 = df['di_plus_M5'] + df['di_minus_M5']
    df['dmi_dir_m5'] = np.where(df['di_plus_M5'] > df['di_minus_M5'], 1, -1)
    df['dmi_score_m5'] = (df[['di_plus_M5', 'di_minus_M5']].max(axis=1) / sum_di_m5) * 100

    # Tick Phase Age
    age = []
    current_age = 0
    curr_p = df['phase'].iloc[0]
    for p in df['phase']:
        if p == curr_p:
            current_age += 1
        else:
            current_age = 1
            curr_p = p
        age.append(current_age)
    df['phase_age'] = age
    
    print("Executing FULL 4-Pendulum Trigger Matrix V14.19...\n")
    
    stats = {
        'L0_Mega': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 3.0},
        'L0_Snipe': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 2.0},
        'L0_Scout': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.0},
        'D0_Grinder': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.0},
        'R0_Fade': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.5},
        'DeathZone_Trap': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.0}
    }
    
    stats_L0_Trap = {'dodges': 0}

    # Simulate entries
    tp_pips = 30.0
    sl_pips = 30.0
    tp_d0 = 15.0 # D0 takes smaller cuts
    sl_d0 = 15.0
    tp_r0 = 20.0 # R0 (Fade) takes quick mean-reversion scalps
    sl_r0 = 20.0
    
    for i in range(1, len(df)-60):
        if df['phase_transition'].iloc[i]:
            pf_prev = df['phase_prev'].iloc[i]
            pf_curr = df['phase'].iloc[i]
            dmi_score = df['dmi_score'].iloc[i]
            dir_mult = df['dmi_dir'].iloc[i] 
            
            entry_price = df['close'].iloc[i]
            gun = None
            is_d0 = False
            is_r0 = False
            is_deathzone = False
            
            # --- Pendulum 4 (#5 -> #8): Mega & Snipe ---
            if pf_prev == 5 and pf_curr == 8:
                if dmi_score > 75:
                    gun = 'L0_Mega'
                elif dmi_score > 65:
                    gun = 'L0_Snipe'
                    
            # --- The Return Stroke (#8 -> #7): R0 Fade ---
            elif pf_prev == 8 and pf_curr == 7:
                # Trạng thái rớt đài của siêu Trend (M1 rụng), nảy sinh nhịp Pullback ngược hướng
                gun = 'R0_Fade'
                is_r0 = True
                dir_mult = dir_mult * -1  # Bắn ngược lại với hướng Trend chính
                    
            # --- Pendulum 2 (#4 -> #7) : Scout ---
            elif pf_prev == 4 and pf_curr == 7:
                if dmi_score > 55:
                    gun = 'L0_Scout'
                    
            # --- Pendulum 1 (#1 <-> #2) : D0 Grinder ---
            elif (pf_prev == 1 and pf_curr == 2) or (pf_prev == 2 and pf_curr == 1):
                if dmi_score < 60: # Neutral DMI
                    gun = 'D0_Grinder'
                    is_d0 = True
                    dir_mult = 1 if df['close'].iloc[i] < df['open'].iloc[i] else -1

            # --- Pendulum 3 (#3 <-> #6) : DEATH ZONE TRAP ---
            elif pf_prev == 3 and pf_curr == 6:
                gun = 'DeathZone_Trap'
                dir_mult = df['dmi_dir_m5'].iloc[i] 
                is_deathzone = True
                
            if gun is None:
                continue
                
            future_highs = df['high'].iloc[i+1:i+61]
            future_lows = df['low'].iloc[i+1:i+61]
            
            pnl = 0
            win = 0
            
            # Dynamic TP/SL setup
            t_tp = tp_pips
            t_sl = sl_pips
            if is_d0:
                t_tp, t_sl = tp_d0, sl_d0
            elif is_r0:
                t_tp, t_sl = tp_r0, sl_r0
            
            if dir_mult == 1: 
                for h, l in zip(future_highs, future_lows):
                    if h >= entry_price + (t_tp * 0.01):
                        pnl = t_tp
                        win = 1
                        break
                    elif l <= entry_price - (t_sl * 0.01):
                        pnl = -t_sl
                        win = 0
                        break
            else: 
                for h, l in zip(future_highs, future_lows):
                    if l <= entry_price - (t_tp * 0.01):
                        pnl = t_tp
                        win = 1
                        break
                    elif h >= entry_price + (t_sl * 0.01):
                        pnl = -t_sl
                        win = 0
                        break
                        
            # If no exit hit in 60 mins (closed by time)
            if pnl == 0:
                pnl = ((df['close'].iloc[i+60] - entry_price) / 0.01) * dir_mult
                if pnl > 0: win = 1
            
            stats[gun]['trades'] += 1
            stats[gun]['wins'] += win
            stats[gun]['total_pips'] += pnl
                
        # --- Trap Dodge Verification ---
        if df['phase'].iloc[i] == 8 and df['phase_age'].iloc[i] == 50:
            stats_L0_Trap['dodges'] += 1
    
    # Print Dashboard
    print(f"|=================================================|")
    print(f"|    FULL 4-PENDULUM MATRIX BACKTEST (10 DAYS)    |")
    print(f"|=================================================|")
    
    for name, s in stats.items():
        tr = s['trades']
        if tr == 0:
            print(f" * {name:<14} | Trades: 0")
            continue
        wr = (s['wins']/tr)*100
        net_profit = s['total_pips'] * s['mult']
        if "DeathZone" in name:
            print(f" ☠️ {name:<14} | Trades: {tr:<4} | WinRate: {wr:>5.1f}% | Net Margin Delta: {net_profit:+.1f} units")
        else:
            print(f" * {name:<14} | Trades: {tr:<4} | WinRate: {wr:>5.1f}% | Net Margin Delta: {net_profit:+.1f} units")
        
    print(f"\\n - L0_Trap (Old L0 Top Execution Prevented): Avoided {stats_L0_Trap['dodges']} exact local tops/bottoms.")
    print(f"|=================================================|")

if __name__ == '__main__':
    run_simulation()