orac_gravopt_phase1.py

"""
ORAC-NT v5.4 + GravOpt — Phase 1 Integration
W = Q·D - T  drives  freeze_threshold

High W → healthy  → low threshold  → few frozen  → full accuracy
Low  W → stressed → high threshold → many frozen → save energy

Baseline: standard training, NO parameter freezing (threshold=0)
"""
import numpy as np, random, time
import matplotlib; matplotlib.use('Agg')
import matplotlib.pyplot as plt

# ── ORAC Core ─────────────────────────────────────────────────
class Watchdog_v5:
    def __init__(self, h_limit=4.5, persistence_req=5):
        self.running_avg=0.6366; self.cus_pos=[0.,0.,0.]
        self.k_drift=0.02; self.h_limit=h_limit
        self.pers_req=persistence_req; self.consecutive=0
    def compute(self, sensors):
        faulty=[]
        for i,s in enumerate(sensors):
            inn=abs(s)-self.running_avg
            self.cus_pos[i]=max(0,self.cus_pos[i]+inn-self.k_drift)
            if self.cus_pos[i]>self.h_limit: faulty.append(i)
        fault,score='NONE',0.0
        if faulty:
            self.consecutive+=1
            if self.consecutive>=self.pers_req:
                fault='BYZANTINE_ADVERSARIAL' if len(faulty)>=2 else 'SENSOR_ANOMALY'
                score=0.90; self.cus_pos=[0.,0.,0.]; self.consecutive=0
        else: self.consecutive=max(0,self.consecutive-1)
        healthy=[abs(sensors[i]) for i in range(len(sensors)) if i not in faulty]
        if healthy: self.running_avg=0.998*self.running_avg+0.002*np.mean(healthy)
        return score,fault

class OracController_v5:
    def __init__(self): self.current_mode='NORMAL'
    def decide(self, score, fault, temp, t):
        Q=1.-score; D=1.-(0.7 if self.current_mode=='SURVIVAL' else 0.)
        T=np.clip((temp-25)/60.,0,1); W=Q*D-T
        self.current_mode='SURVIVAL' if (fault!='NONE' or W<0.08) else 'NORMAL'
        return self.current_mode, W

# ── GravOpt ───────────────────────────────────────────────────
E_TUNE_NJ=0.85; THERMAL_K=0.12

class GravOptSimulator:
    def __init__(self, size=512, ambient=25.0):
        self.size=size; self.ambient=ambient; self.temp=ambient
        np.random.seed(42)
        self.grad_mag=np.abs(np.random.randn(size))*0.3+0.1
    def step(self, threshold, noise=0.3):
        g=self.grad_mag+np.random.normal(0,noise,self.size)
        frozen=np.sum(np.abs(g)<threshold); active=self.size-frozen
        energy=(active*E_TUNE_NJ)/1e6
        self.temp=self.ambient+THERMAL_K*energy*1000
        return frozen/self.size, energy, self.temp
    def reset(self): self.temp=self.ambient

def w_to_threshold(W):
    W=np.clip(W,-0.5,1.0)
    return float(np.clip(0.80-0.75*((W+0.5)/1.5),0.05,0.80))

# ── Fault Generator ───────────────────────────────────────────
class FaultGenerator:
    TYPES=["byzantine","thermal_mask","noise_flood","cascade",
           "silent_drift","sensor_inversion","spike_burst"]
    def generate(self,n=None): return random.sample(self.TYPES,n or random.randint(1,3))
    def apply(self,t,s,temp,faults,start,sev=1.5):
        if t<start: return s[0],s[1],s[2],temp
        s1,s2,s3=s; dt=t-start
        for f in faults:
            if f=="byzantine":        s1+=0.002*sev*dt; s2+=0.002*sev*dt
            if f=="thermal_mask":     temp+=0.03*dt; s1-=0.002*(temp-25)
            if f=="noise_flood":      s1+=np.random.normal(0,0.4*sev); s2+=np.random.normal(0,0.4*sev)
            if f=="cascade":          s1-=0.008*sev*dt; s3+=0.010*sev*dt
            if f=="silent_drift":     s2+=0.0015*sev*dt
            if f=="sensor_inversion": s1=-s1*sev
            if f=="spike_burst":
                if random.random()<0.05: s1+=random.uniform(-5,5)*sev
        return s1,s2,s3,temp

# ── Mission runners ───────────────────────────────────────────
def mission_integrated(steps=500, size=512, record=False):
    wd=Watchdog_v5(); ctrl=OracController_v5(); grav=GravOptSimulator(size)
    gen=FaultGenerator(); faults=gen.generate(); f_start=random.randint(150,350)
    total_e=0.; total_fr=0.; peak_t=25.; detected=False; det_step=None
    log={'t':[],'W':[],'threshold':[],'frozen_pct':[],'temp':[]}
    for t in range(steps):
        base=np.sin(t*0.03)
        s1=base+np.random.normal(0,.02); s2=base+np.random.normal(0,.02); s3=base+np.random.normal(0,.02)
        ts=25+0.01*t
        s1,s2,s3,ts=gen.apply(t,[s1,s2,s3],ts,faults,f_start)
        score,fault_id=wd.compute([s1,s2,s3]); mode,W=ctrl.decide(score,fault_id,ts,t)
        thr=w_to_threshold(W); fr,e,tg=grav.step(thr)
        total_e+=e; total_fr+=fr; peak_t=max(peak_t,tg)
        if fault_id!='NONE' and not detected and t>=f_start: detected=True; det_step=t
        if record:
            log['t'].append(t); log['W'].append(W); log['threshold'].append(thr)
            log['frozen_pct'].append(fr*100); log['temp'].append(tg)
    return {'detected':detected,'latency':max(0,det_step-f_start) if det_step else steps,
            'energy':total_e,'avg_frozen':total_fr/steps*100,'peak_temp':peak_t,'log':log if record else None}

def mission_baseline(steps=500, size=512):
    """No GravOpt — all parameters active every step (threshold=0)."""
    wd=Watchdog_v5(); ctrl=OracController_v5(); grav=GravOptSimulator(size)
    gen=FaultGenerator(); faults=gen.generate(); f_start=random.randint(150,350)
    total_e=0.; peak_t=25.; detected=False
    for t in range(steps):
        base=np.sin(t*0.03)
        s1=base+np.random.normal(0,.02); s2=base+np.random.normal(0,.02); s3=base+np.random.normal(0,.02)
        ts=25+0.01*t
        s1,s2,s3,ts=gen.apply(t,[s1,s2,s3],ts,faults,f_start)
        score,fault_id=wd.compute([s1,s2,s3]); ctrl.decide(score,fault_id,ts,t)
        _,e,tg=grav.step(0.0)  # no freezing
        total_e+=e; peak_t=max(peak_t,tg)
        if fault_id!='NONE' and not detected and t>=f_start: detected=True
    return {'energy':total_e,'peak_temp':peak_t,'detected':detected}

# ── Run ───────────────────────────────────────────────────────
MISSIONS=500
print(f"\n{'='*58}")
print(f"  ORAC-NT v5.4 + GravOpt — Phase 1 Integration")
print(f"  {MISSIONS} missions × 2  (integrated vs no-GravOpt baseline)")
print(f"{'='*58}")
t0=time.time()
int_r=[mission_integrated() for _ in range(MISSIONS)]
bas_r=[mission_baseline()    for _ in range(MISSIONS)]

ie=np.mean([r['energy']    for r in int_r]); be=np.mean([r['energy']   for r in bas_r])
it=np.mean([r['peak_temp'] for r in int_r]); bt=np.mean([r['peak_temp']for r in bas_r])
ifr=np.mean([r['avg_frozen']for r in int_r])
idr=np.mean([r['detected'] for r in int_r])*100
bdr=np.mean([r['detected'] for r in bas_r])*100
es=(1-ie/be)*100

print(f"\n  {'Metric':<38} {'ORAC+GravOpt':>12} {'No GravOpt':>12}")
print(f"  {'-'*64}")
print(f"  {'Detection Rate':<38} {idr:>11.1f}% {bdr:>11.1f}%")
print(f"  {'Avg energy / mission (mJ)':<38} {ie:>12.4f} {be:>12.4f}")
print(f"  {'Energy saved vs baseline':<38} {es:>11.1f}%")
print(f"  {'Avg frozen parameters':<38} {ifr:>11.1f}%")
print(f"  {'Avg peak temperature (°C)':<38} {it:>12.2f} {bt:>12.2f}")
print(f"  {'Temperature reduction':<38} {bt-it:>11.2f}°C")
print(f"  {'Runtime':<38} {time.time()-t0:>11.1f}s")

checks=[("DR > 95%",idr>95),("Energy saved > 10%",es>10),("Temp lower",it<bt)]
print(f"\n  {'='*52}"); all_pass=True
for l,ok in checks:
    if not ok: all_pass=False
    print(f"  {'PASS' if ok else 'FAIL'}  {l}")
print(f"  {'='*52}")
print(f"  {'★ PHASE 1 PASSED' if all_pass else '✗ SOME CHECKS FAILED'}")

# ── Figure ────────────────────────────────────────────────────
print("\n  Generating figure...")
np.random.seed(7); demo=mission_integrated(record=True)
BG='#07070f'; CYAN='#00f5c4'; GRAY='#5a5a7a'; ORANGE='#ff9800'; RED='#ff4444'

fig,axes=plt.subplots(2,3,figsize=(16,9),facecolor=BG)
fig.suptitle(f'ORAC-NT v5.4 + GravOpt  —  Phase 1 Integration\n'
             f'Energy saved {es:.1f}%  |  DR {idr:.0f}%  |  '
             f'Avg frozen {ifr:.1f}%  |  Temp −{bt-it:.2f}°C',
             color='white',fontsize=12,fontweight='bold')
for ax in axes.flat:
    ax.set_facecolor('#0d0d1a'); ax.spines[:].set_color('#1e1e35'); ax.tick_params(colors=GRAY,labelsize=8)

t_a=np.array(demo['log']['t']); W_a=np.array(demo['log']['W'])
th_a=np.array(demo['log']['threshold']); fr_a=np.array(demo['log']['frozen_pct'])
tmp_a=np.array(demo['log']['temp'])

ax=axes[0,0]; ax.plot(t_a,W_a,color=CYAN,lw=1.2)
ax.axhline(0.08,color=RED,lw=1,linestyle='--',alpha=0.7,label='W=0.08 survival')
ax.fill_between(t_a,W_a.min()-.05,W_a,alpha=0.12,color=CYAN)
ax.set_title('Vitality W = Q·D − T',color='white',fontsize=10)
ax.set_xlabel('Steps',color=GRAY,fontsize=8); ax.set_ylabel('W',color=GRAY,fontsize=8)
ax.legend(fontsize=7,facecolor='#1a1a2e',edgecolor='#333',labelcolor='white')

ax=axes[0,1]; ax.plot(t_a,th_a,color=ORANGE,lw=1.2)
ax.fill_between(t_a,0,th_a,alpha=0.12,color=ORANGE)
ax.set_title('Freeze Threshold  (W → threshold)',color='white',fontsize=10)
ax.set_xlabel('Steps',color=GRAY,fontsize=8); ax.set_ylabel('Threshold',color=GRAY,fontsize=8)

ax=axes[0,2]; ax.plot(t_a,fr_a,color='#42a5f5',lw=1.2)
ax.fill_between(t_a,0,fr_a,alpha=0.12,color='#42a5f5')
ax.set_title('Frozen Parameters %',color='white',fontsize=10)
ax.set_xlabel('Steps',color=GRAY,fontsize=8); ax.set_ylabel('%',color=GRAY,fontsize=8)

ax=axes[1,0]; ax.plot(t_a,tmp_a,color=RED,lw=1.2)
ax.axhline(35,color=ORANGE,lw=1,linestyle='--',alpha=0.7,label='35°C limit')
ax.set_title('Junction Temperature',color='white',fontsize=10)
ax.set_xlabel('Steps',color=GRAY,fontsize=8); ax.set_ylabel('°C',color=GRAY,fontsize=8)
ax.legend(fontsize=7,facecolor='#1a1a2e',edgecolor='#333',labelcolor='white')

ax=axes[1,1]
bars=ax.bar(['ORAC+GravOpt','No GravOpt\n(baseline)'],[ie,be],
            color=[CYAN,'#5a5a7a'],width=0.5,edgecolor='none')
ax.set_title(f'Energy/mission  (saved {es:.1f}%)',color='white',fontsize=10)
ax.set_ylabel('mJ',color=GRAY,fontsize=8)
for bar,val in zip(bars,[ie,be]):
    ax.text(bar.get_x()+bar.get_width()/2,bar.get_height()*1.02,
            f'{val:.4f}',ha='center',color='white',fontsize=8)

ax=axes[1,2]
w_r=np.linspace(-0.5,1.0,200); th_r=[w_to_threshold(w) for w in w_r]
ax.plot(w_r,th_r,color=CYAN,lw=2)
ax.axvline(0.08,color=RED,lw=1,linestyle='--',alpha=0.7)
ax.set_title('W → Threshold Mapping',color='white',fontsize=10)
ax.set_xlabel('W (vitality)',color=GRAY,fontsize=8); ax.set_ylabel('Freeze Threshold',color=GRAY,fontsize=8)
ax.text(0.55,0.78,'High W\n→ low threshold\n→ full accuracy',transform=ax.transAxes,
        color=CYAN,fontsize=7,bbox=dict(boxstyle='round',fc='#0d0d1a',ec=CYAN,lw=0.6))
ax.text(0.02,0.12,'Low W\n→ high threshold\n→ save energy',transform=ax.transAxes,
        color=ORANGE,fontsize=7,bbox=dict(boxstyle='round',fc='#0d0d1a',ec=ORANGE,lw=0.6))

fig.text(0.5,0.01,'ORAC code unchanged  |  Patent pending BG 05.12.2025  |  Simulation',
         ha='center',color=GRAY,fontsize=8)
plt.tight_layout(rect=[0,0.03,1,0.94])
plt.savefig('orac_gravopt_phase1.png',dpi=150,bbox_inches='tight',facecolor=BG)
plt.close()
print("  Figure → orac_gravopt_phase1.png\n")