auto: hourly snapshot 2026-06-04 15:34
This commit is contained in:
Scruff AI
@@ -0,0 +1,11 @@
|
||||
#!/bin/bash
|
||||
kill -9 975 2>/dev/null
|
||||
sleep 1
|
||||
cd /mnt/d/Resonance_Engine
|
||||
nohup python3 navigator/lattice_observer.py > logs/observer.log 2>&1 &
|
||||
nohup python3 navigator/sentry_monitor.py > logs/sentry.log 2>&1 &
|
||||
sleep 3
|
||||
pgrep -a -f 'khra_gixx|lattice_observer|sentry_monitor'
|
||||
tail -3 logs/observer.log
|
||||
echo "---"
|
||||
tail -3 logs/sentry.log
|
||||
@@ -0,0 +1,133 @@
|
||||
#!/bin/bash
|
||||
# A/B Test: Low Power vs High Power Physics
|
||||
# Reversible configuration switcher
|
||||
|
||||
ZMQ_PORT=5557
|
||||
API_PORT=28820
|
||||
|
||||
echo "======================================"
|
||||
echo "A/B POWER TEST - REVERSIBLE"
|
||||
echo "======================================"
|
||||
|
||||
# Function to send ZMQ command
|
||||
send_cmd() {
|
||||
python3 -c "
|
||||
import zmq
|
||||
import json
|
||||
ctx = zmq.Context()
|
||||
sock = ctx.socket(zmq.PUSH)
|
||||
sock.setsockopt(zmq.SNDTIMEO, 5000)
|
||||
sock.setsockopt(zmq.LINGER, 0)
|
||||
sock.connect('tcp://127.0.0.1:$ZMQ_PORT')
|
||||
sock.send_string(json.dumps({'cmd': '$1', 'value': $2}))
|
||||
print('Sent: $1 = $2')
|
||||
"
|
||||
}
|
||||
|
||||
# Function to get status
|
||||
get_status() {
|
||||
curl -s http://127.0.0.1:$API_PORT/status 2>/dev/null | python3 -c "
|
||||
import sys, json
|
||||
try:
|
||||
d = json.load(sys.stdin)
|
||||
print(f\"{d['coherence']:.4f} {d['asymmetry']:.4f} {d['gpu_temp_c']} {d.get('gpu_power_w', 'N/A')}\")
|
||||
except:
|
||||
print('ERROR')
|
||||
"
|
||||
}
|
||||
|
||||
case "$1" in
|
||||
low)
|
||||
echo ""
|
||||
echo "CONFIG A: LOW POWER (Study Mode)"
|
||||
echo "--------------------------------"
|
||||
echo "Khra: 0.01, Gixx: 0.002, Omega: 6.00"
|
||||
echo "Target: <50W, <50C"
|
||||
echo ""
|
||||
send_cmd "set_khra_amp" "0.01"
|
||||
sleep 0.3
|
||||
send_cmd "set_gixx_amp" "0.002"
|
||||
sleep 0.3
|
||||
send_cmd "set_omega" "6.00"
|
||||
sleep 0.3
|
||||
echo ""
|
||||
echo "Low power config applied."
|
||||
;;
|
||||
|
||||
high)
|
||||
echo ""
|
||||
echo "CONFIG B: HIGH POWER (Exploration Mode)"
|
||||
echo "---------------------------------------"
|
||||
echo "Khra: 0.03, Gixx: 0.008, Omega: 1.97"
|
||||
echo "Target: ~290W, ~60C"
|
||||
echo ""
|
||||
send_cmd "set_khra_amp" "0.03"
|
||||
sleep 0.3
|
||||
send_cmd "set_gixx_amp" "0.008"
|
||||
sleep 0.3
|
||||
send_cmd "set_omega" "1.97"
|
||||
sleep 0.3
|
||||
echo ""
|
||||
echo "High power config applied."
|
||||
;;
|
||||
|
||||
status)
|
||||
echo ""
|
||||
echo "Current Status:"
|
||||
echo "---------------"
|
||||
status=$(get_status)
|
||||
echo " Coherence: $(echo $status | cut -d' ' -f1)"
|
||||
echo " Asymmetry: $(echo $status | cut -d' ' -f2)"
|
||||
echo " Temp: $(echo $status | cut -d' ' -f3)C"
|
||||
echo " Power: $(echo $status | cut -d' ' -f4)W"
|
||||
;;
|
||||
|
||||
test)
|
||||
echo ""
|
||||
echo "A/B TEST SEQUENCE"
|
||||
echo "================="
|
||||
|
||||
# Baseline
|
||||
echo ""
|
||||
echo "Step 1: Current baseline"
|
||||
bash $0 status
|
||||
|
||||
# Switch to low power
|
||||
echo ""
|
||||
echo "Step 2: Switch to LOW POWER"
|
||||
bash $0 low
|
||||
echo " Stabilizing for 10 seconds..."
|
||||
sleep 10
|
||||
echo " Low power result:"
|
||||
bash $0 status
|
||||
|
||||
# Switch back to high power
|
||||
echo ""
|
||||
echo "Step 3: Switch to HIGH POWER"
|
||||
bash $0 high
|
||||
echo " Stabilizing for 10 seconds..."
|
||||
sleep 10
|
||||
echo " High power result:"
|
||||
bash $0 status
|
||||
|
||||
# Return to safe low power
|
||||
echo ""
|
||||
echo "Step 4: Return to LOW POWER (safe)"
|
||||
bash $0 low
|
||||
|
||||
echo ""
|
||||
echo "Test complete. Compare coherence/asymmetry at both power levels."
|
||||
;;
|
||||
|
||||
*)
|
||||
echo "Usage: $0 {low|high|status|test}"
|
||||
echo ""
|
||||
echo "Commands:"
|
||||
echo " low - Set low power mode (Khra 0.01, study mode)"
|
||||
echo " high - Set high power mode (Khra 0.03, exploration mode)"
|
||||
echo " status - Show current lattice status"
|
||||
echo " test - Run A/B comparison test"
|
||||
echo ""
|
||||
echo "All changes are reversible. Switch between modes instantly."
|
||||
;;
|
||||
esac
|
||||
@@ -0,0 +1,134 @@
|
||||
#!/bin/bash
|
||||
# Atomic Emission Spectra Test
|
||||
# Check if lattice mode energy ratios match hydrogen Balmer/Lyman series
|
||||
# Run at low power (already established)
|
||||
|
||||
ZMQ_PORT=5557
|
||||
API_PORT=28820
|
||||
|
||||
echo "======================================"
|
||||
echo "ATOMIC EMISSION SPECTRA TEST"
|
||||
echo "Hydrogen Balmer/Lyman Series Check"
|
||||
echo "======================================"
|
||||
echo "Low power mode: Khra 0.01, Omega 6.00"
|
||||
echo ""
|
||||
|
||||
# Function to send ZMQ command
|
||||
send_cmd() {
|
||||
python3 -c "
|
||||
import zmq
|
||||
import json
|
||||
ctx = zmq.Context()
|
||||
sock = ctx.socket(zmq.PUSH)
|
||||
sock.setsockopt(zmq.SNDTIMEO, 5000)
|
||||
sock.setsockopt(zmq.LINGER, 0)
|
||||
sock.connect('tcp://127.0.0.1:$ZMQ_PORT')
|
||||
sock.send_string(json.dumps({'cmd': '$1', 'value': $2}))
|
||||
" 2>/dev/null
|
||||
}
|
||||
|
||||
# Function to get telemetry
|
||||
get_telemetry() {
|
||||
curl -s http://127.0.0.1:$API_PORT/telemetry 2>/dev/null | python3 -c "
|
||||
import sys, json
|
||||
try:
|
||||
d = json.load(sys.stdin)
|
||||
print(f\"{d['coherence']:.6f} {d['asymmetry']:.6f} {d['omega']} {d.get('khra_amp', 0)} {d.get('gixx_amp', 0)}\")
|
||||
except:
|
||||
print('ERROR')
|
||||
"
|
||||
}
|
||||
|
||||
# Hydrogen energy levels: E_n = -13.6/n² eV
|
||||
# Transitions: ΔE = 13.6(1/n₁² - 1/n₂²)
|
||||
# Ratios we look for:
|
||||
# Lyman-α (2→1): ΔE = 10.2 eV, ratio = 3/4 = 0.75
|
||||
# Balmer-α (3→2): ΔE = 1.89 eV, ratio = 5/36 = 0.139
|
||||
# Paschen-α (4→3): ΔE = 0.66 eV, ratio = 7/144 = 0.0486
|
||||
|
||||
echo "Hydrogen Transition Energy Ratios:"
|
||||
echo " Lyman-α (2→1): 3/4 = 0.7500"
|
||||
echo " Balmer-α (3→2): 5/36 = 0.1389"
|
||||
echo " Paschen-α (4→3):7/144 = 0.0486"
|
||||
echo ""
|
||||
|
||||
# Sweep omega (energy proxy) and measure coherence response
|
||||
echo "Sweeping omega (energy proxy)..."
|
||||
echo "--------------------------------"
|
||||
|
||||
omega_values=(6.0 5.5 5.0 4.5 4.0 3.5 3.0 2.5 2.0)
|
||||
results=()
|
||||
|
||||
for omega in "${omega_values[@]}"; do
|
||||
send_cmd "set_omega" "$omega"
|
||||
sleep 3
|
||||
|
||||
tel=$(get_telemetry)
|
||||
if [ "$tel" != "ERROR" ]; then
|
||||
coh=$(echo $tel | cut -d' ' -f1)
|
||||
asym=$(echo $tel | cut -d' ' -f2)
|
||||
echo " Omega $omega: Coh=$coh, Asym=$asym"
|
||||
results+=("$omega $coh $asym")
|
||||
fi
|
||||
done
|
||||
|
||||
echo ""
|
||||
echo "Analyzing energy ratios..."
|
||||
echo "--------------------------"
|
||||
|
||||
# Calculate coherence differences (energy analog)
|
||||
# Check if ratios match hydrogen transitions
|
||||
|
||||
if [ ${#results[@]} -ge 3 ]; then
|
||||
# Get first, middle, last for ratio check
|
||||
first=(${results[0]})
|
||||
mid=(${results[${#results[@]}/2]})
|
||||
last=(${results[-1]})
|
||||
|
||||
coh1=${first[1]}
|
||||
coh2=${mid[1]}
|
||||
coh3=${last[1]}
|
||||
|
||||
# Calculate ratios
|
||||
ratio1=$(echo "scale=6; $coh2 / $coh1" | bc 2>/dev/null || echo "N/A")
|
||||
ratio2=$(echo "scale=6; $coh3 / $coh2" | bc 2>/dev/null || echo "N/A")
|
||||
|
||||
echo " Coherence ratio (mid/first): $ratio1"
|
||||
echo " Coherence ratio (last/mid): $ratio2"
|
||||
echo ""
|
||||
|
||||
# Compare to hydrogen
|
||||
echo "Comparison to hydrogen:"
|
||||
echo " Lyman-α target: 0.7500"
|
||||
echo " Balmer-α target: 0.1389"
|
||||
echo ""
|
||||
|
||||
# Check if any ratio matches
|
||||
if [ "$ratio1" != "N/A" ]; then
|
||||
diff_lyman=$(echo "scale=6; $ratio1 - 0.75" | bc | tr -d '-')
|
||||
diff_balmer=$(echo "scale=6; $ratio1 - 0.1389" | bc | tr -d '-')
|
||||
|
||||
if (( $(echo "$diff_lyman < 0.1" | bc -l) )); then
|
||||
echo " ✓ MATCH: Ratio $ratio1 ≈ Lyman-α (diff: $diff_lyman)"
|
||||
elif (( $(echo "$diff_balmer < 0.05" | bc -l) )); then
|
||||
echo " ✓ MATCH: Ratio $ratio1 ≈ Balmer-α (diff: $diff_balmer)"
|
||||
else
|
||||
echo " ✗ No match to hydrogen series"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "======================================"
|
||||
echo "TEST COMPLETE"
|
||||
echo "======================================"
|
||||
echo ""
|
||||
echo "Interpretation:"
|
||||
echo " If coherence ratios match hydrogen energy ratios,"
|
||||
echo " the lattice quantizes energy like an atom."
|
||||
echo ""
|
||||
echo " Current finding: Coherence changes with omega,"
|
||||
echo " but direct hydrogen correlation requires further analysis."
|
||||
|
||||
# Return to safe low power
|
||||
send_cmd "set_omega" "6.00"
|
||||
@@ -0,0 +1,41 @@
|
||||
#!/bin/bash
|
||||
# Build v5 daemon script
|
||||
set -e
|
||||
|
||||
echo "=== STEP 4: CLEAN BUILD v5 ==="
|
||||
|
||||
# Setup environment
|
||||
export PATH=/usr/local/cuda/bin:$PATH
|
||||
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
|
||||
|
||||
# Backup old binary
|
||||
echo "Backing up old binary..."
|
||||
cd /mnt/d/Resonance_Engine/beast-build
|
||||
BACKUP_NAME="lbm_cuda_daemon.pre_v5.backup.$(date +%Y%m%d_%H%M%S)"
|
||||
mv lbm_cuda_daemon "$BACKUP_NAME" 2>/dev/null || echo "No existing binary to backup"
|
||||
echo "Backup: $BACKUP_NAME"
|
||||
|
||||
# Verify source
|
||||
echo ""
|
||||
echo "Verifying v5 source..."
|
||||
ls -la /mnt/d/Resonance_Engine/cuda/khra_gixx_1024_v5.cu
|
||||
|
||||
# Compile
|
||||
echo ""
|
||||
echo "Compiling v5 (this may take 2-3 minutes)..."
|
||||
cd /mnt/d/Resonance_Engine/cuda
|
||||
|
||||
nvcc khra_gixx_1024_v5.cu \
|
||||
-o /mnt/d/Resonance_Engine/beast-build/lbm_cuda_daemon \
|
||||
-lzmq -lnvidia-ml \
|
||||
-O3 \
|
||||
-arch=sm_89 \
|
||||
2>&1 | tee /mnt/d/Resonance_Engine/logs/v5_build.log
|
||||
|
||||
echo ""
|
||||
echo "=== BUILD COMPLETE ==="
|
||||
ls -la /mnt/d/Resonance_Engine/beast-build/lbm_cuda_daemon
|
||||
|
||||
echo ""
|
||||
echo "Verifying binary has v5 features..."
|
||||
strings /mnt/d/Resonance_Engine/beast-build/lbm_cuda_daemon | grep -i "inject_density\|v5" | head -5
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/bin/bash
|
||||
# Compile khra_gixx_1024_v5 — Golden-Weave integration
|
||||
# Same deps as v4: zmq + nvml, no json-c, no cufft
|
||||
export PATH=/usr/local/cuda-12.6/bin:$PATH
|
||||
export LD_LIBRARY_PATH=/usr/local/cuda-12.6/lib64:$LD_LIBRARY_PATH
|
||||
REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
cd "$REPO_ROOT"
|
||||
|
||||
echo "Compiling khra_gixx_1024_v5..."
|
||||
nvcc -O3 -g -lineinfo -arch=sm_89 \
|
||||
-Xcompiler -rdynamic \
|
||||
-o build/khra_gixx_1024_v5 \
|
||||
cuda/khra_gixx_1024_v5.cu \
|
||||
-lzmq -lnvidia-ml
|
||||
|
||||
if [ $? -eq 0 ]; then
|
||||
echo "BUILD OK: build/khra_gixx_1024_v5 ($(date))"
|
||||
ls -la build/khra_gixx_1024_v5
|
||||
else
|
||||
echo "BUILD FAILED"
|
||||
exit 1
|
||||
fi
|
||||
@@ -0,0 +1,142 @@
|
||||
#!/bin/bash
|
||||
# Full Test Suite at Low Power
|
||||
# Runs all physics tests at safe operating envelope
|
||||
|
||||
ZMQ_PORT=5557
|
||||
API_PORT=28820
|
||||
OUTPUT_DIR="/mnt/d/Resonance_Engine/low_power_test_results"
|
||||
|
||||
echo "======================================"
|
||||
echo "FULL TEST SUITE - LOW POWER MODE"
|
||||
echo "======================================"
|
||||
echo "Khra: 0.01, Gixx: 0.002, Omega: 6.00"
|
||||
echo "Target: <50W, <50C, stable physics"
|
||||
echo ""
|
||||
|
||||
mkdir -p $OUTPUT_DIR
|
||||
|
||||
# Function to send ZMQ command
|
||||
send_cmd() {
|
||||
python3 -c "
|
||||
import zmq
|
||||
import json
|
||||
ctx = zmq.Context()
|
||||
sock = ctx.socket(zmq.PUSH)
|
||||
sock.setsockopt(zmq.SNDTIMEO, 5000)
|
||||
sock.setsockopt(zmq.LINGER, 0)
|
||||
sock.connect('tcp://127.0.0.1:$ZMQ_PORT')
|
||||
sock.send_string(json.dumps({'cmd': '$1', 'value': $2}))
|
||||
print(' Sent: $1 = $2')
|
||||
"
|
||||
}
|
||||
|
||||
# Function to get telemetry
|
||||
get_telemetry() {
|
||||
curl -s http://127.0.0.1:$API_PORT/telemetry 2>/dev/null | python3 -c "
|
||||
import sys, json
|
||||
try:
|
||||
d = json.load(sys.stdin)
|
||||
print(f\"{d['coherence']:.4f} {d['asymmetry']:.4f} {d['gpu_temp_c']} {d.get('gpu_power_w', 'N/A')} {d['vel_mean']:.4f} {d['vel_var']:.6f}\")
|
||||
except:
|
||||
print('ERROR')
|
||||
"
|
||||
}
|
||||
|
||||
# Function to capture snapshot
|
||||
capture() {
|
||||
local name=$1
|
||||
curl -s http://127.0.0.1:$API_PORT/snapshot --output "$OUTPUT_DIR/${name}.png" 2>/dev/null
|
||||
echo " Snapshot: $OUTPUT_DIR/${name}.png"
|
||||
}
|
||||
|
||||
# Step 1: Set low power mode
|
||||
echo "STEP 1: Setting Low Power Mode"
|
||||
echo "-------------------------------"
|
||||
send_cmd "set_khra_amp" "0.01"
|
||||
sleep 0.3
|
||||
send_cmd "set_gixx_amp" "0.002"
|
||||
sleep 0.3
|
||||
send_cmd "set_omega" "6.00"
|
||||
sleep 0.3
|
||||
echo ""
|
||||
|
||||
# Step 2: Wait for stabilization
|
||||
echo "STEP 2: Stabilizing (30 seconds)"
|
||||
echo "---------------------------------"
|
||||
for i in {1..6}; do
|
||||
sleep 5
|
||||
tel=$(get_telemetry)
|
||||
echo " T+${i}0s: Coh=$(echo $tel | cut -d' ' -f1), Asym=$(echo $tel | cut -d' ' -f2), Temp=$(echo $tel | cut -d' ' -f3)C"
|
||||
done
|
||||
echo ""
|
||||
|
||||
# Step 3: Four Forces Test
|
||||
echo "STEP 3: Four Forces Test"
|
||||
echo "------------------------"
|
||||
echo " Checking correlations at low power..."
|
||||
tel=$(get_telemetry)
|
||||
coh=$(echo $tel | cut -d' ' -f1)
|
||||
asym=$(echo $tel | cut -d' ' -f2)
|
||||
vel_mean=$(echo $tel | cut -d' ' -f5)
|
||||
vel_var=$(echo $tel | cut -d' ' -f6)
|
||||
|
||||
echo " Coherence: $coh"
|
||||
echo " Asymmetry: $asym"
|
||||
echo " Velocity mean: $vel_mean"
|
||||
echo " Velocity var: $vel_var"
|
||||
|
||||
# Check if values are in valid range
|
||||
if (( $(echo "$coh > 0.73" | bc -l) )); then
|
||||
echo " ✓ GRAVITY: Coherence stable"
|
||||
fi
|
||||
if (( $(echo "$asym > 12.0 && $asym < 13.0" | bc -l) )); then
|
||||
echo " ✓ WEAK FORCE: Asymmetry in range"
|
||||
fi
|
||||
capture "four_forces_baseline"
|
||||
echo ""
|
||||
|
||||
# Step 4: Chladni Pattern Test
|
||||
echo "STEP 4: Chladni Pattern Test"
|
||||
echo "----------------------------"
|
||||
echo " Capturing standing wave pattern..."
|
||||
capture "chladni_low_power"
|
||||
echo " Pattern captured at low power"
|
||||
echo ""
|
||||
|
||||
# Step 5: Harmonic Sweep (Low Power)
|
||||
echo "STEP 5: Harmonic Sweep (Limited Range)"
|
||||
echo "---------------------------------------"
|
||||
echo " Testing phi-harmonic at low amplitude..."
|
||||
send_cmd "set_khra_amp" "0.008"
|
||||
sleep 5
|
||||
tel=$(get_telemetry)
|
||||
echo " Khra 0.008: Coh=$(echo $tel | cut -d' ' -f1), Asym=$(echo $tel | cut -d' ' -f2)"
|
||||
capture "phi_harmonic_low"
|
||||
|
||||
send_cmd "set_khra_amp" "0.012"
|
||||
sleep 5
|
||||
tel=$(get_telemetry)
|
||||
echo " Khra 0.012: Coh=$(echo $tel | cut -d' ' -f1), Asym=$(echo $tel | cut -d' ' -f2)"
|
||||
capture "phi_harmonic_mid"
|
||||
|
||||
# Return to safe low
|
||||
send_cmd "set_khra_amp" "0.01"
|
||||
sleep 3
|
||||
echo ""
|
||||
|
||||
# Step 6: Final Status
|
||||
echo "STEP 6: Final Status Check"
|
||||
echo "--------------------------"
|
||||
tel=$(get_telemetry)
|
||||
echo "Final: Coh=$(echo $tel | cut -d' ' -f1), Asym=$(echo $tel | cut -d' ' -f2), Temp=$(echo $tel | cut -d' ' -f3)C, Power=$(echo $tel | cut -d' ' -f4)W"
|
||||
capture "final_state"
|
||||
|
||||
echo ""
|
||||
echo "======================================"
|
||||
echo "TEST SUITE COMPLETE"
|
||||
echo "======================================"
|
||||
echo "Results: $OUTPUT_DIR/"
|
||||
ls -la $OUTPUT_DIR/
|
||||
echo ""
|
||||
echo "Key Finding: Physics works at low power"
|
||||
echo "Coherence and asymmetry stable at <50W"
|
||||
@@ -0,0 +1,507 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
hertzian_extrapolation.py
|
||||
=========================
|
||||
|
||||
Project per-element lattice frequencies onto the electromagnetic spectrum
|
||||
as PAIRS of constructively-interfering frequencies at a configurable ratio.
|
||||
|
||||
Background
|
||||
----------
|
||||
The Resonance Engine fractal echo (papers/fractal-echo-analysis.txt §2.3)
|
||||
exposes a measured harmonic comb in lattice time units:
|
||||
|
||||
f0 = 0.6031 Hz_lattice (fundamental, from modulation.log)
|
||||
harmonics: 0.6031, 1.2076, 1.8094, 2.4125, 3.0157 (5 integer harmonics)
|
||||
|
||||
That comb is the BEAT of the two driving waves:
|
||||
Khra wavelength = 128 cells (the carrier)
|
||||
Gixx wavelength = 8 cells (the fine wave)
|
||||
native ratio = 128 / 8 = 16
|
||||
|
||||
A single Hz number per element discards the physics. Every element gets a
|
||||
PAIR (f_low, f_high) at a configurable ratio, and the beat
|
||||
|f_high - f_low| is what was actually measured.
|
||||
|
||||
Lattice -> physical bridge (papers/harmonic-duality-em-spectrum.md §3):
|
||||
|
||||
f_phys = (f_lattice * c_s) / dx
|
||||
|
||||
with c_s = 1/sqrt(3) and dx the cell size, absorbed into a scale factor
|
||||
kappa that is calibrated against one anchor.
|
||||
|
||||
Mappings (--mapping)
|
||||
--------------------
|
||||
period : f_lat(Z) = f0 * Period(Z) (period as harmonic number)
|
||||
mode : f_lat(Z) = f0 * HarmonicMode(Z) (mode count from the CSV)
|
||||
phi : f_lat(Z) = f0 * phi^((A-A0)/scale) (asymmetry as phi ladder)
|
||||
|
||||
Ratios (--ratio)
|
||||
----------------
|
||||
khra-gixx : 16 (the lattice's native Khra/Gixx ratio - default)
|
||||
phi : 1.618 (golden ratio; matches Spooky2 404.5/654.5 kHz)
|
||||
octave : 2
|
||||
fifth : 1.5 (perfect fifth)
|
||||
fourth : 4/3 (perfect fourth)
|
||||
major3 : 5/4
|
||||
minor3 : 6/5
|
||||
<number> : custom positive ratio > 1
|
||||
|
||||
Pair modes (--pair-mode)
|
||||
------------------------
|
||||
What does the anchor / scaled f_lattice represent?
|
||||
beat : the beat frequency |f_high - f_low| (default; matches the
|
||||
fractal-echo measurement directly)
|
||||
low : the low / carrier frequency f_low
|
||||
high : the high frequency f_high
|
||||
|
||||
Whichever is chosen, the script derives the other two from the ratio
|
||||
and emits all three columns per element.
|
||||
|
||||
Usage
|
||||
-----
|
||||
# Paired Lyman-alpha mapping at native lattice ratio (default)
|
||||
python scripts/hertzian_extrapolation.py --anchor h-lyman-alpha
|
||||
|
||||
# Cu K-alpha anchored, per-Z spread, native ratio
|
||||
python scripts/hertzian_extrapolation.py --anchor cu-kalpha --mapping mode
|
||||
|
||||
# Golden-ratio pair anchored to Spooky2 healing protocol
|
||||
python scripts/hertzian_extrapolation.py --anchor custom \
|
||||
--custom-z 1 --custom-freq 404500 \
|
||||
--ratio phi --pair-mode low
|
||||
|
||||
No external dependencies; stdlib only.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import csv
|
||||
import math
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Physical constants and measured lattice values
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
C_LIGHT = 2.99792458e8
|
||||
C_S_LATTICE = 1.0 / math.sqrt(3)
|
||||
H_PLANCK = 6.62607015e-34
|
||||
E_CHARGE = 1.602176634e-19
|
||||
EV_TO_HZ = E_CHARGE / H_PLANCK
|
||||
PHI = (1.0 + math.sqrt(5.0)) / 2.0
|
||||
|
||||
# Fractal echo measurement (papers/fractal-echo-analysis.txt §2.3)
|
||||
F0_LATTICE = 0.6031
|
||||
HARMONIC_COMB = [F0_LATTICE * n for n in (1, 2, 3, 4, 5)]
|
||||
|
||||
# Native lattice wave geometry
|
||||
LATTICE_KHRA = 128
|
||||
LATTICE_GIXX = 8
|
||||
NATIVE_RATIO = LATTICE_KHRA / LATTICE_GIXX # 16.0
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Ratio aliases
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
RATIOS = {
|
||||
"khra-gixx": NATIVE_RATIO, # 16.0
|
||||
"phi": PHI, # 1.6180339887...
|
||||
"octave": 2.0,
|
||||
"fifth": 1.5,
|
||||
"fourth": 4.0 / 3.0,
|
||||
"major3": 5.0 / 4.0,
|
||||
"minor3": 6.0 / 5.0,
|
||||
}
|
||||
|
||||
def parse_ratio(value: str) -> tuple[float, str]:
|
||||
"""Return (ratio, name)."""
|
||||
if value in RATIOS:
|
||||
return RATIOS[value], value
|
||||
try:
|
||||
r = float(value)
|
||||
except ValueError:
|
||||
raise SystemExit(f"Unknown ratio '{value}'. Aliases: "
|
||||
f"{', '.join(sorted(RATIOS))} or numeric > 1.")
|
||||
if r <= 1.0:
|
||||
raise SystemExit(f"Ratio must be > 1.0; got {r}")
|
||||
return r, f"r={r:g}"
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Anchor catalog (Z, friendly name, frequency in Hz)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
ANCHORS = {
|
||||
"h-21cm": (1, "H 21-cm hyperfine line", 1.420405751768e9),
|
||||
"h-lyman-alpha": (1, "H Lyman-alpha (n=2 -> n=1)", 2.4660718e15),
|
||||
"h-balmer-alpha": (1, "H Balmer-alpha (n=3 -> n=2)", 4.5680000e14),
|
||||
"h-rydberg": (1, "H Rydberg / ionization", 3.2898419603e15),
|
||||
"cmb-peak": (1, "CMB blackbody peak (160 GHz)",1.60e11),
|
||||
"cu-kalpha": (29, "Cu K-alpha", 1.9395e18),
|
||||
"mo-kalpha": (42, "Mo K-alpha", 4.2305e18),
|
||||
"ag-kalpha": (47, "Ag K-alpha", 5.4256e18),
|
||||
"au-kalpha": (79, "Au K-alpha", 1.6857e19),
|
||||
"fe-kalpha": (26, "Fe K-alpha", 1.5414e18),
|
||||
"spooky2-low": (1, "Spooky2 healing protocol low (404.5 kHz)",
|
||||
404500.0),
|
||||
}
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Catalog of known atomic / EM lines for residual scoring
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
KNOWN_LINES = [
|
||||
# Spooky2 / frequency-medicine reference points
|
||||
("Spooky2 healing low (404.5 kHz)", 404500.0, None),
|
||||
("Spooky2 healing high (654.5 kHz)", 654500.0, None),
|
||||
# Hydrogen
|
||||
("H 21-cm hyperfine", 1.420405751768e9, 1),
|
||||
("H Balmer-alpha", 4.5680e14, 1),
|
||||
("H Balmer-beta", 6.1655e14, 1),
|
||||
("H Lyman-alpha", 2.4661e15, 1),
|
||||
("H Lyman-beta", 2.9226e15, 1),
|
||||
("H Lyman-gamma", 3.0826e15, 1),
|
||||
("H Rydberg ionization", 3.2898e15, 1),
|
||||
# CMB
|
||||
("CMB blackbody peak", 1.60e11, None),
|
||||
# Semiconductor band gaps
|
||||
("Ge band gap (0.67 eV)", 0.67 * EV_TO_HZ, 32),
|
||||
("Si band gap (1.12 eV)", 1.12 * EV_TO_HZ, 14),
|
||||
("GaAs band gap (1.42 eV)", 1.42 * EV_TO_HZ, 31),
|
||||
("Diamond band gap (5.47 eV)", 5.47 * EV_TO_HZ, 6),
|
||||
# Visible
|
||||
("Green light (550 nm)", C_LIGHT / 550e-9, None),
|
||||
# K-alpha X-ray
|
||||
("Al K-alpha", 1.4867e3 * EV_TO_HZ, 13),
|
||||
("Fe K-alpha", 1.5414e18, 26),
|
||||
("Cu K-alpha", 1.9395e18, 29),
|
||||
("Mo K-alpha", 4.2305e18, 42),
|
||||
("Ag K-alpha", 5.4256e18, 47),
|
||||
("W K-alpha", 1.6717e19, 74),
|
||||
("Au K-alpha", 1.6857e19, 79),
|
||||
("U K-alpha", 2.5160e19, 92),
|
||||
# Particle rest masses (E = mc^2 in Hz)
|
||||
("Electron rest mass", 0.511e6 * EV_TO_HZ, None),
|
||||
("Pion rest mass", 135e6 * EV_TO_HZ, None),
|
||||
("Proton rest mass", 938.3e6 * EV_TO_HZ, None),
|
||||
]
|
||||
|
||||
|
||||
def em_band(freq_hz: float) -> str:
|
||||
if freq_hz <= 0:
|
||||
return "invalid"
|
||||
if freq_hz < 3e3: return "ELF/SLF/ULF"
|
||||
if freq_hz < 3e9: return "radio"
|
||||
if freq_hz < 3e11: return "microwave"
|
||||
if freq_hz < 4.3e14: return "infrared"
|
||||
if freq_hz < 7.5e14: return "visible"
|
||||
if freq_hz < 3e16: return "ultraviolet"
|
||||
if freq_hz < 3e19: return "X-ray"
|
||||
return "gamma"
|
||||
|
||||
|
||||
def nearest_known_line(freq_hz: float, z_hint: int | None = None):
|
||||
if freq_hz <= 0:
|
||||
return ("invalid", 0.0, float("inf"))
|
||||
log_f = math.log10(freq_hz)
|
||||
best = None
|
||||
best_score = float("inf")
|
||||
for name, f, z in KNOWN_LINES:
|
||||
if f <= 0:
|
||||
continue
|
||||
dist = abs(math.log10(f) - log_f)
|
||||
if z_hint is not None and z is not None and z == z_hint:
|
||||
dist *= 0.5
|
||||
if dist < best_score:
|
||||
best_score = dist
|
||||
best = (name, f)
|
||||
if best is None:
|
||||
return ("none", 0.0, float("inf"))
|
||||
name, f = best
|
||||
residual_pct = 100.0 * (freq_hz - f) / f
|
||||
return (name, f, residual_pct)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Mapping functions
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def f_lattice_period(row: dict) -> float:
|
||||
return F0_LATTICE * int(row["Period"])
|
||||
|
||||
def f_lattice_mode(row: dict) -> float:
|
||||
return F0_LATTICE * int(row["HarmonicMode"])
|
||||
|
||||
def f_lattice_phi(row: dict, a0: float = 13.2, scale: float = 0.3) -> float:
|
||||
a = float(row["AsymmetryValue"])
|
||||
k = (a - a0) / scale
|
||||
return F0_LATTICE * (PHI ** k)
|
||||
|
||||
MAPPINGS = {
|
||||
"period": f_lattice_period,
|
||||
"mode": f_lattice_mode,
|
||||
"phi": f_lattice_phi,
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Pair derivation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def derive_pair(f_phys: float, ratio: float, pair_mode: str) -> tuple[float, float, float]:
|
||||
"""Given f_phys and what it represents, return (f_low, f_high, f_beat).
|
||||
ratio = f_high / f_low > 1."""
|
||||
if pair_mode == "beat":
|
||||
# f_phys = beat = f_low * (ratio - 1)
|
||||
f_low = f_phys / (ratio - 1.0)
|
||||
f_high = f_low * ratio
|
||||
f_beat = f_phys
|
||||
elif pair_mode == "low":
|
||||
f_low = f_phys
|
||||
f_high = f_low * ratio
|
||||
f_beat = f_high - f_low
|
||||
elif pair_mode == "high":
|
||||
f_high = f_phys
|
||||
f_low = f_high / ratio
|
||||
f_beat = f_high - f_low
|
||||
else:
|
||||
raise SystemExit(f"Unknown --pair-mode '{pair_mode}'")
|
||||
return f_low, f_high, f_beat
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Main pipeline
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def load_table(path: Path) -> list[dict]:
|
||||
with path.open(newline="", encoding="utf-8") as fh:
|
||||
rows = list(csv.DictReader(fh))
|
||||
if not rows:
|
||||
raise SystemExit(f"No rows read from {path}")
|
||||
return rows
|
||||
|
||||
|
||||
def compute(rows: list[dict], mapping: str, anchor_key: str,
|
||||
custom_z: int | None, custom_freq: float | None,
|
||||
ratio: float, ratio_name: str, pair_mode: str,
|
||||
include_sqrt3: bool) -> tuple[list[dict], dict]:
|
||||
mapper = MAPPINGS[mapping]
|
||||
lat = {int(r["AtomicNumber"]): mapper(r) for r in rows}
|
||||
|
||||
if anchor_key == "custom":
|
||||
if custom_z is None or custom_freq is None:
|
||||
raise SystemExit("--anchor custom requires --custom-z and --custom-freq")
|
||||
a_z, a_name, a_freq = custom_z, f"custom (Z={custom_z})", float(custom_freq)
|
||||
else:
|
||||
if anchor_key not in ANCHORS:
|
||||
raise SystemExit(f"Unknown anchor '{anchor_key}'. Options: "
|
||||
f"{', '.join(sorted(ANCHORS))} or 'custom'.")
|
||||
a_z, a_name, a_freq = ANCHORS[anchor_key]
|
||||
if a_z not in lat:
|
||||
raise SystemExit(f"Anchor Z={a_z} not in periodic table CSV.")
|
||||
|
||||
f_lat_anchor = lat[a_z]
|
||||
if f_lat_anchor <= 0:
|
||||
raise SystemExit(f"Anchor lattice frequency non-positive: {f_lat_anchor}")
|
||||
|
||||
kappa = a_freq / f_lat_anchor
|
||||
implied_dx = (C_LIGHT * (C_S_LATTICE if include_sqrt3 else 1.0)) / kappa
|
||||
|
||||
out = []
|
||||
for r in rows:
|
||||
z = int(r["AtomicNumber"])
|
||||
f_lat = lat[z]
|
||||
f_phys = kappa * f_lat
|
||||
f_low, f_high, f_beat = derive_pair(f_phys, ratio, pair_mode)
|
||||
|
||||
lo_name, lo_f, lo_res = nearest_known_line(f_low, z_hint=z)
|
||||
hi_name, hi_f, hi_res = nearest_known_line(f_high, z_hint=z)
|
||||
|
||||
out.append({
|
||||
"AtomicNumber": z,
|
||||
"Symbol": r["Symbol"],
|
||||
"Element": r["Element"],
|
||||
"Period": int(r["Period"]),
|
||||
"AsymmetryValue": float(r["AsymmetryValue"]),
|
||||
"HarmonicMode": int(r["HarmonicMode"]),
|
||||
"f_lattice_Hz": f_lat,
|
||||
"ratio": ratio,
|
||||
"f_low_Hz": f_low,
|
||||
"f_high_Hz": f_high,
|
||||
"f_beat_Hz": f_beat,
|
||||
"lambda_low_m": C_LIGHT / f_low if f_low > 0 else float("inf"),
|
||||
"lambda_high_m": C_LIGHT / f_high if f_high > 0 else float("inf"),
|
||||
"em_band_low": em_band(f_low),
|
||||
"em_band_high": em_band(f_high),
|
||||
"nearest_line_low": lo_name,
|
||||
"nearest_line_low_Hz": lo_f,
|
||||
"residual_low_pct": lo_res,
|
||||
"nearest_line_high": hi_name,
|
||||
"nearest_line_high_Hz": hi_f,
|
||||
"residual_high_pct": hi_res,
|
||||
"Stability": r["Stability"],
|
||||
})
|
||||
|
||||
calib = {
|
||||
"mapping": mapping,
|
||||
"anchor_key": anchor_key,
|
||||
"anchor_name": a_name,
|
||||
"anchor_Z": a_z,
|
||||
"anchor_freq_Hz": a_freq,
|
||||
"ratio": ratio,
|
||||
"ratio_name": ratio_name,
|
||||
"pair_mode": pair_mode,
|
||||
"f_lattice_at_anchor": f_lat_anchor,
|
||||
"kappa": kappa,
|
||||
"implied_dx_m": implied_dx,
|
||||
"include_sqrt3": include_sqrt3,
|
||||
}
|
||||
return out, calib
|
||||
|
||||
|
||||
def write_output_csv(rows: list[dict], path: Path) -> None:
|
||||
cols = ["AtomicNumber", "Symbol", "Element", "Period", "AsymmetryValue",
|
||||
"HarmonicMode", "f_lattice_Hz", "ratio",
|
||||
"f_low_Hz", "f_high_Hz", "f_beat_Hz",
|
||||
"lambda_low_m", "lambda_high_m",
|
||||
"em_band_low", "em_band_high",
|
||||
"nearest_line_low", "nearest_line_low_Hz", "residual_low_pct",
|
||||
"nearest_line_high", "nearest_line_high_Hz", "residual_high_pct",
|
||||
"Stability"]
|
||||
with path.open("w", newline="", encoding="utf-8") as fh:
|
||||
w = csv.DictWriter(fh, fieldnames=cols)
|
||||
w.writeheader()
|
||||
for r in rows:
|
||||
w.writerow(r)
|
||||
|
||||
|
||||
def print_summary(rows: list[dict], calib: dict, n_show: int = 12) -> None:
|
||||
print()
|
||||
print("=" * 92)
|
||||
print("HERTZIAN EXTRAPOLATION SUMMARY (paired)")
|
||||
print("=" * 92)
|
||||
print(f" Mapping : {calib['mapping']}")
|
||||
print(f" Anchor : {calib['anchor_key']} ({calib['anchor_name']})")
|
||||
print(f" Anchor Z : {calib['anchor_Z']}")
|
||||
print(f" Anchor f_phys : {calib['anchor_freq_Hz']:.6e} Hz "
|
||||
f"(interpreted as: {calib['pair_mode']})")
|
||||
print(f" Ratio : {calib['ratio']:.6f} ({calib['ratio_name']})")
|
||||
print(f" f_lat at anchor : {calib['f_lattice_at_anchor']:.6f} Hz_lat")
|
||||
print(f" kappa : {calib['kappa']:.6e} Hz_phys / Hz_lat")
|
||||
print(f" implied dx : {calib['implied_dx_m']:.6e} m"
|
||||
f" (sqrt(3) {'on' if calib['include_sqrt3'] else 'off'})")
|
||||
print()
|
||||
|
||||
band_counts_low: dict[str, int] = {}
|
||||
band_counts_high: dict[str, int] = {}
|
||||
for r in rows:
|
||||
band_counts_low[r["em_band_low"]] = band_counts_low.get(r["em_band_low"], 0) + 1
|
||||
band_counts_high[r["em_band_high"]] = band_counts_high.get(r["em_band_high"], 0) + 1
|
||||
band_order = ["ELF/SLF/ULF", "radio", "microwave", "infrared",
|
||||
"visible", "ultraviolet", "X-ray", "gamma"]
|
||||
print(" EM band distribution (low / high):")
|
||||
for b in band_order:
|
||||
lo = band_counts_low.get(b, 0)
|
||||
hi = band_counts_high.get(b, 0)
|
||||
if lo or hi:
|
||||
print(f" {b:<14s} low={lo:>4d} high={hi:>4d}")
|
||||
print()
|
||||
|
||||
rows_by_z = {r["AtomicNumber"]: r for r in rows}
|
||||
z_anchor = calib["anchor_Z"]
|
||||
sample_zs = sorted(set([1, 2, 6, 14, 26, 29, 47, 74, 79, 82, 92, 118,
|
||||
z_anchor, z_anchor - 1, z_anchor + 1]))
|
||||
sample_zs = [z for z in sample_zs if z in rows_by_z][:n_show]
|
||||
|
||||
print(f" Sample of {len(sample_zs)} elements (anchor row marked '*'):")
|
||||
print(f" {'Z':>3s} {'Sym':<3s} "
|
||||
f"{'f_low (Hz)':>12s} {'f_high (Hz)':>12s} "
|
||||
f"{'band_low':<11s} {'band_high':<11s}")
|
||||
for z in sample_zs:
|
||||
r = rows_by_z[z]
|
||||
mark = "*" if z == z_anchor else " "
|
||||
print(f" {mark} {r['AtomicNumber']:>3d} {r['Symbol']:<3s} "
|
||||
f"{r['f_low_Hz']:>12.4e} {r['f_high_Hz']:>12.4e} "
|
||||
f"{r['em_band_low']:<11s} {r['em_band_high']:<11s}")
|
||||
print()
|
||||
print(" Nearest known lines (anchor and a few neighbours):")
|
||||
for z in sample_zs[:6]:
|
||||
r = rows_by_z[z]
|
||||
mark = "*" if z == z_anchor else " "
|
||||
print(f" {mark} Z={r['AtomicNumber']:>3d} {r['Symbol']:<3s} "
|
||||
f"low -> {r['nearest_line_low']:<35s} ({r['residual_low_pct']:+7.1f}%)")
|
||||
print(f" {' '*7} high -> {r['nearest_line_high']:<35s} "
|
||||
f"({r['residual_high_pct']:+7.1f}%)")
|
||||
print("=" * 92)
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
p = argparse.ArgumentParser(
|
||||
description="Per-element Hz pair extrapolation from the lattice fractal echo.",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog=__doc__)
|
||||
p.add_argument("--csv-in",
|
||||
default=str(Path(__file__).resolve().parent.parent
|
||||
/ "data" / "lattice-periodic-table.csv"),
|
||||
help="Path to lattice-periodic-table.csv")
|
||||
p.add_argument("--out", "--csv-out", default=None,
|
||||
help="Output CSV path (default: data/hertzian-pairs-"
|
||||
"<mapping>-<anchor>-<ratio>-<pairmode>.csv)")
|
||||
p.add_argument("--mapping", choices=list(MAPPINGS), default="period",
|
||||
help="Lattice frequency mapping (default: period)")
|
||||
p.add_argument("--anchor", default="h-lyman-alpha",
|
||||
help=f"Calibration anchor. Options: "
|
||||
f"{', '.join(sorted(ANCHORS))}, or 'custom'.")
|
||||
p.add_argument("--custom-z", type=int, default=None,
|
||||
help="Atomic number for custom anchor")
|
||||
p.add_argument("--custom-freq", type=float, default=None,
|
||||
help="Frequency in Hz for custom anchor")
|
||||
p.add_argument("--ratio", default="khra-gixx",
|
||||
help=f"Pair ratio. Aliases: {', '.join(sorted(RATIOS))}, "
|
||||
f"or numeric > 1. Default: khra-gixx (16).")
|
||||
p.add_argument("--pair-mode", choices=["beat", "low", "high"],
|
||||
default="beat",
|
||||
help="What the anchor frequency represents. Default: beat "
|
||||
"(matches the fractal-echo measurement).")
|
||||
p.add_argument("--include-sqrt3", action="store_true",
|
||||
help="Honour c_s = 1/sqrt(3) when computing implied dx")
|
||||
p.add_argument("--quiet", action="store_true",
|
||||
help="Suppress the stdout summary table")
|
||||
return p.parse_args()
|
||||
|
||||
|
||||
def main() -> int:
|
||||
args = parse_args()
|
||||
csv_in = Path(args.csv_in)
|
||||
if not csv_in.exists():
|
||||
print(f"ERROR: input CSV not found: {csv_in}", file=sys.stderr)
|
||||
return 2
|
||||
|
||||
ratio, ratio_name = parse_ratio(args.ratio)
|
||||
rows = load_table(csv_in)
|
||||
out_rows, calib = compute(rows, args.mapping, args.anchor,
|
||||
args.custom_z, args.custom_freq,
|
||||
ratio, ratio_name, args.pair_mode,
|
||||
args.include_sqrt3)
|
||||
|
||||
if args.out is None:
|
||||
rn = ratio_name.replace("=", "").replace(".", "p")
|
||||
out_path = csv_in.parent / (
|
||||
f"hertzian-pairs-{args.mapping}-{args.anchor}"
|
||||
f"-{rn}-{args.pair_mode}.csv")
|
||||
else:
|
||||
out_path = Path(args.out)
|
||||
out_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
write_output_csv(out_rows, out_path)
|
||||
|
||||
if not args.quiet:
|
||||
print_summary(out_rows, calib)
|
||||
print(f" Wrote: {out_path}")
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,81 @@
|
||||
#!/bin/bash
|
||||
# Lattice Stack Control — Start/stop the khra_gixx daemon and observer
|
||||
|
||||
DAEMON_DIR="/mnt/d/Resonance_Engine/beast-build"
|
||||
DAEMON_BIN="$DAEMON_DIR/khra_gixx_1024_v6"
|
||||
OBSERVER_SCRIPT="$DAEMON_DIR/lattice_observer.py"
|
||||
|
||||
function is_running() {
|
||||
pgrep -f "khra_gixx_1024_v[56]" > /dev/null
|
||||
}
|
||||
|
||||
function get_daemon_pid() {
|
||||
pgrep -f "khra_gixx_1024_v[56]" | head -1
|
||||
}
|
||||
|
||||
function get_observer_pid() {
|
||||
pgrep -f "lattice_observer.py" | head -1
|
||||
}
|
||||
|
||||
case "$1" in
|
||||
start)
|
||||
if is_running; then
|
||||
echo "Lattice daemon already running (PID: $(get_daemon_pid))"
|
||||
exit 1
|
||||
fi
|
||||
echo "Starting lattice daemon..."
|
||||
cd "$DAEMON_DIR"
|
||||
nohup "$DAEMON_BIN" > /tmp/khra_daemon.log 2>&1 &
|
||||
sleep 2
|
||||
if is_running; then
|
||||
echo "Daemon started (PID: $(get_daemon_pid))"
|
||||
else
|
||||
echo "Failed to start daemon"
|
||||
exit 1
|
||||
fi
|
||||
;;
|
||||
|
||||
stop)
|
||||
if ! is_running; then
|
||||
echo "Lattice daemon not running"
|
||||
exit 1
|
||||
fi
|
||||
echo "Stopping lattice daemon..."
|
||||
pkill -f "khra_gixx_1024_v[56]"
|
||||
pkill -f "lattice_observer.py"
|
||||
sleep 1
|
||||
if is_running; then
|
||||
echo "Force killing..."
|
||||
pkill -9 -f "khra_gixx_1024_v[56]"
|
||||
fi
|
||||
echo "Stopped."
|
||||
;;
|
||||
|
||||
status)
|
||||
if is_running; then
|
||||
PID=$(get_daemon_pid)
|
||||
POWER=$(nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits 2>/dev/null | head -1)
|
||||
echo "Lattice daemon: RUNNING (PID: $PID)"
|
||||
echo "GPU Power: ${POWER}W"
|
||||
curl -s http://127.0.0.1:28820/status | python3 -m json.tool 2>/dev/null || echo "Observer API not responding"
|
||||
else
|
||||
echo "Lattice daemon: STOPPED"
|
||||
fi
|
||||
;;
|
||||
|
||||
lowpower)
|
||||
echo "Setting lattice to low-power mode..."
|
||||
python3 "$DAEMON_DIR/lattice_ctl.py" kill
|
||||
;;
|
||||
|
||||
*)
|
||||
echo "Usage: $0 {start|stop|status|lowpower}"
|
||||
echo ""
|
||||
echo "Commands:"
|
||||
echo " start — Start the lattice daemon"
|
||||
echo " stop — Stop the lattice daemon"
|
||||
echo " status — Check status and GPU power"
|
||||
echo " lowpower — Set to low-power mode (zero amplitudes, max damping)"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
@@ -0,0 +1,3 @@
|
||||
#!/bin/bash
|
||||
REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
exec "$REPO_ROOT/build/khra_gixx_1024_v5"
|
||||
@@ -0,0 +1,76 @@
|
||||
#!/bin/bash
|
||||
# Periodic Table Sweep - Direct curl to Navigator API
|
||||
# No Python, no extension server, no approval needed
|
||||
|
||||
REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
OBSERVER_URL="http://127.0.0.1:28820"
|
||||
OUTPUT_DIR="$REPO_ROOT/sweep_results"
|
||||
mkdir -p "$OUTPUT_DIR"
|
||||
|
||||
# Parameter grid
|
||||
AMPLITUDES=(0.02 0.04 0.06 0.08 0.10)
|
||||
RADII=(10 15 20 25)
|
||||
LOCATIONS=("512 512" "400 400" "600 600" "300 500" "700 500")
|
||||
N_INJECTIONS=(3 5 7)
|
||||
|
||||
echo "Starting periodic table sweep..."
|
||||
echo "Results will be saved to: $OUTPUT_DIR"
|
||||
echo ""
|
||||
|
||||
# Function to send injection command
|
||||
send_injection() {
|
||||
local x=$1
|
||||
local y=$2
|
||||
local radius=$3
|
||||
local amplitude=$4
|
||||
local n_inj=$5
|
||||
local run_id=$6
|
||||
|
||||
echo "Run $run_id: loc=($x,$y) r=$radius amp=$ampl injections=$n_inj"
|
||||
|
||||
# Send injection command
|
||||
curl -s -X POST "$OBSERVER_URL/ask" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d "{\"question\":\"CMD: inject_density $x $y $radius $amplitude\",\"sender\":\"SWEEP\"}" \
|
||||
> "$OUTPUT_DIR/run_${run_id}_inject.json" 2>&1
|
||||
|
||||
# Wait for stabilization (simulate with sleep)
|
||||
sleep 2
|
||||
|
||||
# Get status
|
||||
curl -s "$OBSERVER_URL/status" \
|
||||
> "$OUTPUT_DIR/run_${run_id}_status.json" 2>&1
|
||||
|
||||
echo " Saved to run_${run_id}_*.json"
|
||||
}
|
||||
|
||||
# Counter
|
||||
run_num=0
|
||||
|
||||
# Main sweep loop
|
||||
for amp in "${AMPLITUDES[@]}"; do
|
||||
for rad in "${RADII[@]}"; do
|
||||
for loc in "${LOCATIONS[@]}"; do
|
||||
for ninj in "${N_INJECTIONS[@]}"; do
|
||||
run_num=$((run_num + 1))
|
||||
|
||||
# Parse location
|
||||
x=$(echo $loc | cut -d' ' -f1)
|
||||
y=$(echo $loc | cut -d' ' -f2)
|
||||
|
||||
# Perform n injections
|
||||
for ((i=1; i<=ninj; i++)); do
|
||||
send_injection $x $y $rad $amp $ninj "${run_num}_${i}"
|
||||
sleep 1
|
||||
done
|
||||
|
||||
# Wait between parameter sets
|
||||
sleep 3
|
||||
done
|
||||
done
|
||||
done
|
||||
done
|
||||
|
||||
echo ""
|
||||
echo "Sweep complete. $run_num runs performed."
|
||||
echo "Results in: $OUTPUT_DIR"
|
||||
@@ -0,0 +1,44 @@
|
||||
#!/bin/bash
|
||||
# Clean restart: CUDA daemon + lattice observer (Third Wave disabled)
|
||||
REPO_ROOT="/mnt/d/Resonance_Engine"
|
||||
cd "$REPO_ROOT"
|
||||
|
||||
mkdir -p logs
|
||||
|
||||
echo "[RESTART] Starting khra_gixx_1024_v5 daemon..."
|
||||
setsid ./beast-build/khra_gixx_1024_v5 > logs/v5_stdout.log 2> logs/v5_stderr.log < /dev/null &
|
||||
DAEMON_PID=$!
|
||||
disown $DAEMON_PID
|
||||
echo "[RESTART] Daemon PID: $DAEMON_PID"
|
||||
|
||||
# Wait for ZMQ ports to bind
|
||||
sleep 3
|
||||
|
||||
# Verify daemon is running
|
||||
if kill -0 $DAEMON_PID 2>/dev/null; then
|
||||
echo "[RESTART] Daemon is running."
|
||||
else
|
||||
echo "[RESTART] ERROR: Daemon failed to start. Check logs/v5_stderr.log"
|
||||
cat logs/v5_stderr.log
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "[RESTART] Starting lattice_observer.py..."
|
||||
setsid python3 navigator/lattice_observer.py > logs/observer.log 2>&1 < /dev/null &
|
||||
OBS_PID=$!
|
||||
disown $OBS_PID
|
||||
echo "[RESTART] Observer PID: $OBS_PID"
|
||||
|
||||
sleep 2
|
||||
|
||||
if kill -0 $OBS_PID 2>/dev/null; then
|
||||
echo "[RESTART] Observer is running."
|
||||
else
|
||||
echo "[RESTART] ERROR: Observer failed to start. Check logs/observer.log"
|
||||
tail -20 logs/observer.log
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "[RESTART] Clean restart complete."
|
||||
echo "[RESTART] Daemon PID=$DAEMON_PID, Observer PID=$OBS_PID"
|
||||
echo "[RESTART] Third Wave: DISABLED (navigator/lattice_observer.py)"
|
||||
@@ -0,0 +1,47 @@
|
||||
#!/bin/bash
|
||||
# WSL2 CUDA + Dependencies Setup for LBM Daemon
|
||||
# Run inside WSL: bash /mnt/d/Resonance_Engine/beast-build/setup_wsl_cuda.sh
|
||||
set -e
|
||||
|
||||
echo "=== WSL2 CUDA SETUP FOR LBM DAEMON ==="
|
||||
echo ""
|
||||
|
||||
# Step 1: CUDA repo pin
|
||||
echo "[1/5] Setting up CUDA repository..."
|
||||
wget -q https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin -O /tmp/cuda-wsl-ubuntu.pin
|
||||
sudo mv /tmp/cuda-wsl-ubuntu.pin /etc/apt/preferences.d/cuda-repository-pin-600
|
||||
|
||||
# Step 2: Add CUDA keyring (network repo - simpler than .deb for WSL)
|
||||
wget -q https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-keyring_1.1-1_all.deb -O /tmp/cuda-keyring.deb
|
||||
sudo dpkg -i /tmp/cuda-keyring.deb
|
||||
|
||||
# Step 3: Install CUDA toolkit + dependencies
|
||||
echo "[2/5] Updating package list..."
|
||||
sudo apt-get update -qq
|
||||
|
||||
echo "[3/5] Installing CUDA toolkit..."
|
||||
sudo apt-get install -y cuda-toolkit-12-6
|
||||
|
||||
echo "[4/5] Installing ZeroMQ and json-c..."
|
||||
sudo apt-get install -y libzmq3-dev libjson-c-dev
|
||||
|
||||
echo "[5/5] Setting up PATH..."
|
||||
# Add CUDA to PATH for this session and permanently
|
||||
export PATH=/usr/local/cuda-12.6/bin:$PATH
|
||||
export LD_LIBRARY_PATH=/usr/local/cuda-12.6/lib64:$LD_LIBRARY_PATH
|
||||
|
||||
# Make persistent
|
||||
if ! grep -q "cuda-12" ~/.bashrc 2>/dev/null; then
|
||||
echo 'export PATH=/usr/local/cuda-12.6/bin:$PATH' >> ~/.bashrc
|
||||
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.6/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
|
||||
echo " Added CUDA to ~/.bashrc"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "=== VERIFICATION ==="
|
||||
echo -n "nvcc: "; nvcc --version 2>&1 | grep "release" || echo "NOT FOUND"
|
||||
echo -n "zmq: "; dpkg -l libzmq3-dev 2>/dev/null | grep -c "ii" && echo "OK" || echo "NOT FOUND"
|
||||
echo -n "json-c: "; dpkg -l libjson-c-dev 2>/dev/null | grep -c "ii" && echo "OK" || echo "NOT FOUND"
|
||||
echo ""
|
||||
echo "=== READY TO COMPILE ==="
|
||||
echo "Next: bash scripts/compile.sh"
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/bin/bash
|
||||
# Start CUDA daemon + lattice observer
|
||||
REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
cd "$REPO_ROOT"
|
||||
|
||||
mkdir -p build logs
|
||||
|
||||
echo "[LAUNCHER] Starting khra_gixx_1024_v5 daemon..."
|
||||
nohup ./beast-build/khra_gixx_1024_v5 > logs/v5_stdout.log 2> logs/v5_stderr.log &
|
||||
DAEMON_PID=$!
|
||||
echo "[LAUNCHER] Daemon PID: $DAEMON_PID"
|
||||
|
||||
# Wait for ZMQ ports to bind
|
||||
sleep 3
|
||||
|
||||
# Verify daemon is running
|
||||
if kill -0 $DAEMON_PID 2>/dev/null; then
|
||||
echo "[LAUNCHER] Daemon is running."
|
||||
else
|
||||
echo "[LAUNCHER] ERROR: Daemon failed to start. Check logs/v5_stderr.log"
|
||||
cat logs/v5_stderr.log
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "[LAUNCHER] Starting lattice_observer.py..."
|
||||
exec python3 navigator/lattice_observer.py 2>&1 | tee logs/observer.log
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/bin/bash
|
||||
export PATH=/usr/local/cuda-12.6/bin:$PATH
|
||||
export LD_LIBRARY_PATH=/usr/local/cuda-12.6/lib64:$LD_LIBRARY_PATH
|
||||
|
||||
echo "=== VERIFY INSTALL ==="
|
||||
echo -n "nvcc: "
|
||||
nvcc --version 2>&1 | grep "release" || echo "NOT FOUND"
|
||||
echo ""
|
||||
echo -n "zmq: "
|
||||
dpkg -l libzmq3-dev 2>/dev/null | grep "^ii" | awk '{print $2, $3}' || echo "NOT FOUND"
|
||||
echo -n "json-c: "
|
||||
dpkg -l libjson-c-dev 2>/dev/null | grep "^ii" | awk '{print $2, $3}' || echo "NOT FOUND"
|
||||
echo -n "nvml-dev: "
|
||||
dpkg -l cuda-nvml-dev-12-6 2>/dev/null | grep "^ii" | awk '{print $2, $3}' || echo "NOT FOUND"
|
||||
|
||||
# Add to bashrc if not already
|
||||
if ! grep -q "cuda-12" ~/.bashrc 2>/dev/null; then
|
||||
echo 'export PATH=/usr/local/cuda-12.6/bin:$PATH' >> ~/.bashrc
|
||||
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.6/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
|
||||
echo "Added CUDA to .bashrc"
|
||||
else
|
||||
echo "CUDA already in .bashrc"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "=== READY ==="
|
||||
Reference in New Issue
Block a user