Skip to content
TheChatArchiveThe Chat Archive
GLMGLM-5 / Pony Alpha· unknownHugging Face Frontier Reasoning Traces

Build a gravitational wave parameter estimation with different waveform families.

  1. User

    Build a gravitational wave parameter estimation with different waveform families.

  2. GLM Assistant

    The user wants a gravitational wave parameter estimation tool with different waveform families. This is a complex scientific visualization tool that simulates gravitational waveforms from compact binary coalescences (CBC) like binary black holes, binary neutron stars, etc.

    Let me design a comprehensive single-page application that:

    1. Waveform Families:

      • IMRPhenom (Phenomenological waveforms)
      • EOBNR (Effective One Body-Numerical Relativity)
      • TaylorF2 (Post-Newtonian approximation)
      • NRSur (Numerical Relativity Surrogate)
    2. Parameters to estimate/visualize:

      • Masses (m1, m2)
      • Spins (chi1, chi2)
      • Distance
      • Inclination angle
      • Phase
      • Merger frequency
      • SNR (Signal-to-Noise Ratio)
    3. Features:

      • Interactive waveform visualization (time domain and frequency domain)
      • Parameter sliders for real-time adjustment
      • Waveform comparison between families
      • Parameter estimation visualization (likelihood/posterior-like display)
      • Animated gravitational wave strain
    4. Visual Design:

      • Dark theme (scientific/data visualization aesthetic)
      • Grid backgrounds for charts
      • Glowing waveforms
      • Professional scientific look
      • Particle effects for background depth

    Let me create this:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Gravitational Wave Parameter Estimation</title>
        <style>
            /* CSS styles */
        </style>
    </head>
    <body>
        <!-- Content -->
        <script>
            // JavaScript for waveform generation and visualization
        </script>
    </body>
    </html>
    

    I'll implement simplified but physically-motivated waveform models:

    • TaylorF2: Post-Newtonian inspiral
    • IMRPhenom: Phenomenological full IMR
    • EOBNR: EOB-based
    • NRSur: Surrogate model

    The waveforms will be generated using analytical approximations that capture the key features:

    • Inspiral: Increasing amplitude and frequency (chirp)
    • Merger: Peak amplitude
    • Ringdown: Exponentially damped sinusoid

    Let me write comprehensive code for this.

    Gravitational Wave Parameter Estimation Tool

    This is a comprehensive scientific visualization tool for gravitational wave analysis. I'll create an interactive application featuring:

    1. Multiple Waveform Families: IMRPhenomD, EOBNR, TaylorF2, and NRSurrogate
    2. Interactive Parameters: Masses, spins, distance, inclination, etc.
    3. Visualizations: Time-domain strain, frequency-domain, and parameter estimation
    4. Real-time Comparison: Compare different waveform models
    5. Animated Effects: Particle background, glowing waveforms, dynamic updates
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Gravitational Wave Parameter Estimation</title>
        <style>
            * {
                margin: 0;
                padding: 0;
                box-sizing: border-box;
            }
    
            body {
                font-family: 'Segoe UI', system-ui, sans-serif;
                background: #0a0a12;
                color: #e0e0e0;
                min-height: 100vh;
                overflow-x: hidden;
            }
    
            #particle-canvas {
                position: fixed;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                z-index: 0;
                pointer-events: none;
            }
    
            .container {
                position: relative;
                z-index: 1;
                max-width: 1600px;
                margin: 0 auto;
                padding: 20px;
            }
    
            header {
                text-align: center;
                padding: 30px 0;
                border-bottom: 1px solid rgba(0, 200, 255, 0.2);
                margin-bottom: 30px;
            }
    
            h1 {
                font-size: 2.5rem;
                font-weight: 300;
                letter-spacing: 3px;
                background: linear-gradient(90deg, #00c8ff, #00ff88, #00c8ff);
                background-size: 200% 100%;
                -webkit-background-clip: text;
                -webkit-text-fill-color: transparent;
                background-clip: text;
                animation: gradientFlow 4s ease infinite;
            }
    
            @keyframes gradientFlow {
                0%, 100% { background-position: 0% 50%; }
                50% { background-position: 100% 50%; }
            }
    
            .subtitle {
                color: #888;
                margin-top: 10px;
                font-size: 0.95rem;
                letter-spacing: 1px;
            }
    
            .main-grid {
                display: grid;
                grid-template-columns: 320px 1fr;
                gap: 25px;
            }
    
            @media (max-width: 1100px) {
                .main-grid {
                    grid-template-columns: 1fr;
                }
            }
    
            .panel {
                background: linear-gradient(145deg, rgba(20, 25, 40, 0.9), rgba(10, 15, 25, 0.95));
                border: 1px solid rgba(0, 200, 255, 0.15);
                border-radius: 12px;
                padding: 20px;
                backdrop-filter: blur(10px);
            }
    
            .panel-title {
                font-size: 0.85rem;
                text-transform: uppercase;
                letter-spacing: 2px;
                color: #00c8ff;
                margin-bottom: 20px;
                padding-bottom: 10px;
                border-bottom: 1px solid rgba(0, 200, 255, 0.2);
            }
    
            .control-group {
                margin-bottom: 18px;
            }
    
            .control-label {
                display: flex;
                justify-content: space-between;
                font-size: 0.8rem;
                color: #aaa;
                margin-bottom: 8px;
            }
    
            .control-value {
                color: #00ff88;
                font-family: 'Consolas', monospace;
            }
    
            input[type="range"] {
                width: 100%;
                height: 6px;
                border-radius: 3px;
                background: linear-gradient(90deg, #1a1a2e, #2a2a4e);
                outline: none;
                -webkit-appearance: none;
            }
    
            input[type="range"]::-webkit-slider-thumb {
                -webkit-appearance: none;
                width: 18px;
                height: 18px;
                border-radius: 50%;
                background: linear-gradient(145deg, #00c8ff, #0088aa);
                cursor: pointer;
                box-shadow: 0 0 10px rgba(0, 200, 255, 0.5);
                transition: transform 0.2s, box-shadow 0.2s;
            }
    
            input[type="range"]::-webkit-slider-thumb:hover {
                transform: scale(1.15);
                box-shadow: 0 0 20px rgba(0, 200, 255, 0.8);
            }
    
            .waveform-selector {
                display: grid;
                grid-template-columns: 1fr 1fr;
                gap: 8px;
                margin-bottom: 20px;
            }
    
            .waveform-btn {
                padding: 12px 8px;
                background: rgba(30, 35, 50, 0.8);
                border: 1px solid rgba(0, 200, 255, 0.2);
                border-radius: 8px;
                color: #aaa;
                font-size: 0.75rem;
                cursor: pointer;
                transition: all 0.3s;
                text-transform: uppercase;
                letter-spacing: 1px;
            }
    
            .waveform-btn:hover {
                background: rgba(0, 200, 255, 0.1);
                border-color: rgba(0, 200, 255, 0.4);
            }
    
            .waveform-btn.active {
                background: linear-gradient(145deg, rgba(0, 200, 255, 0.2), rgba(0, 150, 200, 0.1));
                border-color: #00c8ff;
                color: #00c8ff;
                box-shadow: 0 0 15px rgba(0, 200, 255, 0.3);
            }
    
            .waveform-btn.full-width {
                grid-column: 1 / -1;
            }
    
            .chart-container {
                position: relative;
                height: 280px;
                margin-bottom: 20px;
            }
    
            .chart-canvas {
                width: 100%;
                height: 100%;
                border-radius: 8px;
                background: rgba(5, 10, 20, 0.8);
            }
    
            .chart-label {
                position: absolute;
                font-size: 0.7rem;
                color: #666;
                text-transform: uppercase;
                letter-spacing: 1px;
            }
    
            .chart-label.top-left { top: 8px; left: 10px; }
            .chart-label.top-right { top: 8px; right: 10px; }
    
            .stats-grid {
                display: grid;
                grid-template-columns: repeat(3, 1fr);
                gap: 10px;
                margin-top: 20px;
            }
    
            .stat-box {
                background: rgba(0, 0, 0, 0.3);
                padding: 15px 10px;
                border-radius: 8px;
                text-align: center;
                border: 1px solid rgba(0, 200, 255, 0.1);
                transition: all 0.3s;
            }
    
            .stat-box:hover {
                border-color: rgba(0, 200, 255, 0.3);
                transform: translateY(-2px);
            }
    
            .stat-value {
                font-size: 1.3rem;
                font-weight: 600;
                color: #00ff88;
                font-family: 'Consolas', monospace;
            }
    
            .stat-label {
                font-size: 0.65rem;
                color: #777;
                text-transform: uppercase;
                letter-spacing: 1px;
                margin-top: 5px;
            }
    
            .comparison-section {
                margin-top: 20px;
            }
    
            .comparison-header {
                display: flex;
                justify-content: space-between;
                align-items: center;
                margin-bottom: 15px;
            }
    
            .toggle-btn {
                padding: 8px 16px;
                background: rgba(0, 200, 255, 0.1);
                border: 1px solid rgba(0, 200, 255, 0.3);
                border-radius: 20px;
                color: #00c8ff;
                font-size: 0.75rem;
                cursor: pointer;
                transition: all 0.3s;
            }
    
            .toggle-btn:hover {
                background: rgba(0, 200, 255, 0.2);
            }
    
            .toggle-btn.active {
                background: rgba(0, 200, 255, 0.3);
            }
    
            .legend {
                display: flex;
                gap: 20px;
                justify-content: center;
                margin-top: 10px;
                flex-wrap: wrap;
            }
    
            .legend-item {
                display: flex;
                align-items: center;
                gap: 8px;
                font-size: 0.75rem;
                color: #aaa;
            }
    
            .legend-color {
                width: 20px;
                height: 3px;
                border-radius: 2px;
            }
    
            .param-estimation {
                margin-top: 25px;
            }
    
            .estimation-bar {
                margin-bottom: 15px;
            }
    
            .est-header {
                display: flex;
                justify-content: space-between;
                margin-bottom: 6px;
            }
    
            .est-name {
                font-size: 0.75rem;
                color: #aaa;
            }
    
            .est-value {
                font-size: 0.75rem;
                color: #00c8ff;
                font-family: 'Consolas', monospace;
            }
    
            .bar-track {
                height: 8px;
                background: rgba(30, 35, 50, 0.8);
                border-radius: 4px;
                overflow: hidden;
                position: relative;
            }
    
            .bar-fill {
                height: 100%;
                border-radius: 4px;
                transition: width 0.5s ease;
                position: relative;
            }
    
            .bar-fill::after {
                content: '';
                position: absolute;
                right: 0;
                top: 0;
                height: 100%;
                width: 20px;
                background: linear-gradient(90deg, transparent, rgba(255,255,255,0.3));
            }
    
            .mismatch-indicator {
                margin-top: 20px;
                padding: 15px;
                background: rgba(0, 0, 0, 0.3);
                border-radius: 8px;
                border-left: 3px solid #ff6b6b;
            }
    
            .mismatch-title {
                font-size: 0.8rem;
                color: #ff6b6b;
                margin-bottom: 8px;
            }
    
            .mismatch-value {
                font-size: 1.5rem;
                font-family: 'Consolas', monospace;
                color: #fff;
            }
    
            .mismatch-desc {
                font-size: 0.7rem;
                color: #666;
                margin-top: 5px;
            }
    
            footer {
                text-align: center;
                padding: 30px;
                color: #444;
                font-size: 0.75rem;
                margin-top: 30px;
                border-top: 1px solid rgba(0, 200, 255, 0.1);
            }
    
            .glow-effect {
                animation: glow 2s ease-in-out infinite alternate;
            }
    
            @keyframes glow {
                from { filter: drop-shadow(0 0 2px rgba(0, 200, 255, 0.5)); }
                to { filter: drop-shadow(0 0 8px rgba(0, 200, 255, 0.8)); }
            }
    
            .pulse {
                animation: pulse 1.5s ease-in-out infinite;
            }
    
            @keyframes pulse {
                0%, 100% { opacity: 1; }
                50% { opacity: 0.7; }
            }
        </style>
    </head>
    <body>
        <canvas id="particle-canvas"></canvas>
        
        <div class="container">
            <header>
                <h1>Gravitational Wave Parameter Estimation</h1>
                <p class="subtitle">Compact Binary Coalescence Waveform Analysis</p>
            </header>
    
            <div class="main-grid">
                <div class="left-column">
                    <div class="panel">
                        <div class="panel-title">Waveform Family</div>
                        <div class="waveform-selector">
                            <button class="waveform-btn active" data-model="IMRPhenomD">IMRPhenomD</button>
                            <button class="waveform-btn" data-model="EOBNR">SEOBNRv4</button>
                            <button class="waveform-btn" data-model="TaylorF2">TaylorF2</button>
                            <button class="waveform-btn" data-model="NRSur">NRSur7dq4</button>
                        </div>
                    </div>
    
                    <div class="panel" style="margin-top: 20px;">
                        <div class="panel-title">Binary Parameters</div>
                        
                        <div class="control-group">
                            <div class="control-label">
                                <span>Primary Mass (m1)</span>
                                <span class="control-value" id="m1-val">36 M</span>
                            </div>
                            <input type="range" id="m1" min="5" max="100" value="36">
                        </div>
    
                        <div class="control-group">
                            <div class="control-label">
                                <span>Secondary Mass (m2)</span>
                                <span class="control-value" id="m2-val">29 M</span>
                            </div>
                            <input type="range" id="m2" min="5" max="100" value="29">
                        </div>
    
                        <div class="control-group">
                            <div class="control-label">
                                <span>Spin 1 (chi1z)</span>
                                <span class="control-value" id="chi1-val">0.25</span>
                            </div>
                            <input type="range" id="chi1" min="-99" max="99" value="25">
                        </div>
    
                        <div class="control-group">
                            <div class="control-label">
                                <span>Spin 2 (chi2z)</span>
                                <span class="control-value" id="chi2-val">-0.10</span>
                            </div>
                            <input type="range" id="chi2" min="-99" max="99" value="-10">
                        </div>
    
                        <div class="control-group">
                            <div class="control-label">
                                <span>Distance</span>
                                <span class="control-value" id="dist-val">410 Mpc</span>
                            </div>
                            <input type="range" id="dist" min="50" max="2000" value="410">
                        </div>
    
                        <div class="control-group">
                            <div class="control-label">
                                <span>Inclination</span>
                                <span class="control-value" id="inc-val">45 deg</span>
                            </div>
                            <input type="range" id="inc" min="0" max="180" value="45">
                        </div>
    
                        <div class="control-group">
                            <div class="control-label">
                                <span>Reference Phase</span>
                                <span class="control-value" id="phase-val">0.0 rad</span>
                            </div>
                            <input type="range" id="phase" min="0" max="628" value="0">
                        </div>
                    </div>
                </div>
    
                <div class="right-column">
                    <div class="panel">
                        <div class="chart-container">
                            <span class="chart-label top-left">Strain h(t)</span>
                            <span class="chart-label top-right" id="waveform-label">IMRPhenomD</span>
                            <canvas id="strain-chart" class="chart-canvas"></canvas>
                        </div>
    
                        <div class="legend" id="main-legend">
                            <div class="legend-item">
                                <div class="legend-color" style="background: #00c8ff;"></div>
                                <span>Plus Polarization</span>
                            </div>
                            <div class="legend-item">
                                <div class="legend-color" style="background: #00ff88;"></div>
                                <span>Cross Polarization</span>
                            </div>
                        </div>
    
                        <div class="stats-grid">
                            <div class="stat-box">
                                <div class="stat-value" id="chirp-mass">28.6</div>
                                <div class="stat-label">Chirp Mass (M)</div>
                            </div>
                            <div class="stat-box">
                                <div class="stat-value" id="total-mass">65</div>
                                <div class="stat-label">Total Mass (M)</div>
                            </div>
                            <div class="stat-box">
                                <div class="stat-value" id="mass-ratio">0.81</div>
                                <div class="stat-label">Mass Ratio</div>
                            </div>
                            <div class="stat-box">
                                <div class="stat-value" id="peak-freq">180</div>
                                <div class="stat-label">Peak Freq (Hz)</div>
                            </div>
                            <div class="stat-box">
                                <div class="stat-value" id="snr-value">23.4</div>
                                <div class="stat-label">SNR</div>
                            </div>
                            <div class="stat-box">
                                <div class="stat-value" id="duration">0.42</div>
                                <div class="stat-label">Duration (s)</div>
                            </div>
                        </div>
                    </div>
    
                    <div class="panel comparison-section">
                        <div class="comparison-header">
                            <div class="panel-title" style="margin: 0; border: none; padding: 0;">Frequency Domain</div>
                            <button class="toggle-btn" id="compare-toggle">Compare Models</button>
                        </div>
                        <div class="chart-container">
                            <span class="chart-label top-left">Strain h(f)</span>
                            <span class="chart-label top-right">Frequency (Hz)</span>
                            <canvas id="freq-chart" class="chart-canvas"></canvas>
                        </div>
                        <div class="legend" id="freq-legend"></div>
                    </div>
    
                    <div class="panel param-estimation">
                        <div class="panel-title">Parameter Estimation Confidence</div>
                        
                        <div class="estimation-bar">
                            <div class="est-header">
                                <span class="est-name">Chirp Mass</span>
                                <span class="est-value" id="est-mc">28.6 +/- 0.8 M</span>
                            </div>
                            <div class="bar-track">
                                <div class="bar-fill" id="bar-mc" style="width: 92%; background: linear-gradient(90deg, #00c8ff, #00ff88);"></div>
                            </div>
                        </div>
    
                        <div class="estimation-bar">
                            <div class="est-header">
                                <span class="est-name">Mass Ratio</span>
                                <span class="est-value" id="est-q">0.81 +/- 0.05</span>
                            </div>
                            <div class="bar-track">
                                <div class="bar-fill" id="bar-q" style="width: 85%; background: linear-gradient(90deg, #00c8ff, #0088ff);"></div>
                            </div>
                        </div>
    
                        <div class="estimation-bar">
                            <div class="est-header">
                                <span class="est-name">Effective Spin</span>
                                <span class="est-value" id="est-chi">0.12 +/- 0.03</span>
                            </div>
                            <div class="bar-track">
                                <div class="bar-fill" id="bar-chi" style="width: 78%; background: linear-gradient(90deg, #ff8844, #ffcc00);"></div>
                            </div>
                        </div>
    
                        <div class="estimation-bar">
                            <div class="est-header">
                                <span class="est-name">Luminosity Distance</span>
                                <span class="est-value" id="est-dl">410 +/- 80 Mpc</span>
                            </div>
                            <div class="bar-track">
                                <div class="bar-fill" id="bar-dl" style="width: 65%; background: linear-gradient(90deg, #ff6b6b, #ff8844);"></div>
                            </div>
                        </div>
    
                        <div class="mismatch-indicator">
                            <div class="mismatch-title">Waveform Systematic Uncertainty</div>
                            <div class="mismatch-value" id="mismatch-val">0.0034</div>
                            <div class="mismatch-desc">Mismatch between IMRPhenomD and SEOBNRv4 (lower is better)</div>
                        </div>
                    </div>
                </div>
            </div>
    
            <footer>
                Gravitational Wave Parameter Estimation Simulator | Waveform Models: IMRPhenomD, SEOBNRv4, TaylorF2, NRSur7dq4
            </footer>
        </div>
    
        <script>
            // Particle Background
            const particleCanvas = document.getElementById('particle-canvas');
            const pCtx = particleCanvas.getContext('2d');
            
            function resizeParticleCanvas() {
                particleCanvas.width = window.innerWidth;
                particleCanvas.height = window.innerHeight;
            }
            resizeParticleCanvas();
            window.addEventListener('resize', resizeParticleCanvas);
    
            const particles = [];
            const numParticles = 80;
    
            for (let i = 0; i < numParticles; i++) {
                particles.push({
                    x: Math.random() * particleCanvas.width,
                    y: Math.random() * particleCanvas.height,
                    vx: (Math.random() - 0.5) * 0.3,
                    vy: (Math.random() - 0.5) * 0.3,
                    size: Math.random() * 2 + 0.5,
                    alpha: Math.random() * 0.4 + 0.1
                });
            }
    
            function animateParticles() {
                pCtx.clearRect(0, 0, particleCanvas.width, particleCanvas.height);
                
                particles.forEach(p => {
                    p.x += p.vx;
                    p.y += p.vy;
                    
                    if (p.x < 0) p.x = particleCanvas.width;
                    if (p.x > particleCanvas.width) p.x = 0;
                    if (p.y < 0) p.y = particleCanvas.height;
                    if (p.y > particleCanvas.height) p.y = 0;
                    
                    pCtx.beginPath();
                    pCtx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
                    pCtx.fillStyle = `rgba(0, 200, 255, ${p.alpha})`;
                    pCtx.fill();
                });
                
                // Draw connections
                particles.forEach((p1, i) => {
                    particles.slice(i + 1).forEach(p2 => {
                        const dx = p1.x - p2.x;
                        const dy = p1.y - p2.y;
                        const dist = Math.sqrt(dx * dx + dy * dy);
                        
                        if (dist < 120) {
                            pCtx.beginPath();
                            pCtx.moveTo(p1.x, p1.y);
                            pCtx.lineTo(p2.x, p2.y);
                            pCtx.strokeStyle = `rgba(0, 200, 255, ${0.08 * (1 - dist / 120)})`;
                            pCtx.stroke();
                        }
                    });
                });
                
                requestAnimationFrame(animateParticles);
            }
            animateParticles();
    
            // Waveform Generation
            const G = 6.674e-11;
            const c = 3e8;
            const M_sun = 1.989e30;
            const Mpc = 3.086e22;
    
            let currentModel = 'IMRPhenomD';
            let compareMode = false;
    
            const modelColors = {
                'IMRPhenomD': '#00c8ff',
                'EOBNR': '#00ff88',
                'TaylorF2': '#ff8844',
                'NRSur': '#ff6b6b'
            };
    
            // Parameters
            let params = {
                m1: 36,
                m2: 29,
                chi1: 0.25,
                chi2: -0.10,
                distance: 410,
                inclination: 45,
                phase: 0
            };
    
            function getChirpMass(m1, m2) {
                return Math.pow(m1 * m2, 3/5) / Math.pow(m1 + m2, 1/5);
            }
    
            function getEta(m1, m2) {
                return (m1 * m2) / Math.pow(m1 + m2, 2);
            }
    
            function getEffectiveSpin(m1, m2, chi1, chi2) {
                return (m1 * chi1 + m2 * chi2) / (m1 + m2);
            }
    
            // Simplified waveform models
            function generateTaylorF2(params, nPoints = 500) {
                const { m1, m2, chi1, chi2, distance, inclination, phase } = params;
                const Mc = getChirpMass(m1, m2) * M_sun;
                const eta = getEta(m1, m2);
                const DL = distance * Mpc;
                const inc = inclination * Math.PI / 180;
                
                const data = [];
                const f_low = 20;
                const f_high = 500;
                
                for (let i = 0; i < nPoints; i++) {
                    const f = f_low + (f_high - f_low) * i / nPoints;
                    const v = Math.pow(Math.PI * Mc * f / c**3, 1/3);
                    
                    // Post-Newtonian phase
                    const phi = -2 * Math.PI * f * 0.1 + phase + 3/(128 * eta) * Math.pow(v, -5);
                    const A = (1/DL) * Math.sqrt(5*np.pi/24) * (Mc**2) * (np.pi*f)**(2/3) / (c**4);
                    
                    const amp = Math.pow(f / 100, 2/3) * 1e-21 * (100 / distance);
                    
                    data.push({
                        freq: f,
                        amplitude: amp * (1 + Math.cos(inc)**2)**2,
                        phase: phi
                    });
                }
                return data;
            }
    
            function generateIMRPhenomD(params, nPoints = 1000) {
                const { m1, m2, chi1, chi2, distance, inclination, phase } = params;
                const M = m1 + m2;
                const Mc = getChirpMass(m1, m2);
                const eta = getEta(m1, m2);
                const chi_eff = getEffectiveSpin(m1, m2, chi1, chi2);
                
                const data = [];
                const duration = 2.0;
                const dt = duration / nPoints;
                
                // Key frequencies
                const f_merger = 0.02 * c**3 / (M * M_sun * G);
                const f_ring = 0.03 * c**3 / (M * M_sun * G);
                
                for (let i = 0; i < nPoints; i++) {
                    const t = (i / nPoints - 0.8) * duration;
                    
                    let amp = 0;
                    let phi = 0;
                    
                    if (t < 0) {
                        // Inspiral
                        const tau = -t;
                        const f = 30 * Math.pow(tau + 0.01, -3/8) * Math.pow(Mc, -5/8);
                        amp = 1e-21 * (100 / distance) * Math.pow(Math.max(0.1, tau), -1/4);
                        phi = 2 * Math.PI * 100 * (Math.pow(tau + 0.01, 5/8) - 0.1);
                        
                        // Spin correction
                        amp *= (1 + 0.3 * chi_eff);
                    } else if (t < 0.02) {
                        // Merger
                        amp = 2e-21 * (100 / distance) * Math.exp(-t * 20);
                        phi = 2 * Math.PI * 200 * t;
                    } else {
                        // Ringdown
                        const tau_ring = 0.005 * M;
                        amp = 1e-21 * (100 / distance) * Math.exp(-(t - 0.02) * 100) * 0.5;
                        phi = 2 * Math.PI * 250 * t;
                    }
                    
                    // Inclination effect
                    const inc = inclination * Math.PI / 180;
                    const h_plus = amp * (1 + Math.cos(inc)**2) / 2;
                    const h_cross = amp * Math.cos(inc);
                    
                    data.push({
                        time: t,
                        h_plus: h_plus * Math.cos(phi + phase),
                        h_cross: h_cross * Math.sin(phi + phase),
                        freq: 30 * Math.pow(Math.abs(t) + 0.01, -3/8)
                    });
                }
                return data;
            }
    
            function generateEOBNR(params, nPoints = 1000) {
                const { m1, m2, chi1, chi2, distance, inclination, phase } = params;
                const M = m1 + m2;
                const Mc = getChirpMass(m1, m2);
                const eta = getEta(m1, m2);
                
                const data = [];
                const duration = 2.0;
                
                // EOB has slightly different dynamics
                const chi_eff = getEffectiveSpin(m1, m2, chi1, chi2);
                
                for (let i = 0; i < nPoints; i++) {
                    const t = (i / nPoints - 0.8) * duration;
                    
                    let amp = 0;
                    let phi = 0;
                    
                    if (t < 0) {
                        const tau = -t;
                        // EOB-inspired amplitude
                        amp = 1e-21 * (100 / distance) * Math.pow(Math.max(0.1, tau), -1/4) * (1 + 0.1 * eta);
                        phi = 2 * Math.PI * 100 * (Math.pow(tau + 0.01, 5/8) - 0.1);
                        amp *= (1 + 0.25 * chi_eff);
                    } else if (t < 0.025) {
                        amp = 2.1e-21 * (100 / distance) * Math.exp(-t * 15);
                        phi = 2 * Math.PI * 180 * t;
                    } else {
                        amp = 1.1e-21 * (100 / distance) * Math.exp(-(t - 0.025) * 80) * 0.4;
                        phi = 2 * Math.PI * 240 * t;
                    }
                    
                    const inc = inclination * Math.PI / 180;
                    const h_plus = amp * (1 + Math.cos(inc)**2) / 2;
                    const h_cross = amp * Math.cos(inc);
                    
                    data.push({
                        time: t,
                        h_plus: h_plus * Math.cos(phi + phase),
                        h_cross: h_cross * Math.sin(phi + phase),
                        freq: 30 * Math.pow(Math.abs(t) + 0.01, -3/8)
                    });
                }
                return data;
            }
    
            function generateNRSur(params, nPoints = 1000) {
                const { m1, m2, chi1, chi2, distance, inclination, phase } = params;
                const M = m1 + m2;
                const Mc = getChirpMass(m1, m2);
                const eta = getEta(m1, m2);
                
                const data = [];
                const duration = 1.5;
                
                // NRSur includes higher-order modes
                const chi_eff = getEffectiveSpin(m1, m2, chi1, chi2);
                
                for (let i = 0; i < nPoints; i++) {
                    const t = (i / nPoints - 0.7) * duration;
                    
                    let amp = 0;
                    let phi = 0;
                    
                    if (t < 0) {
                        const tau = -t;
                        amp = 1e-21 * (100 / distance) * Math.pow(Math.max(0.05, tau), -1/4);
                        phi = 2 * Math.PI * 120 * (Math.pow(tau + 0.01, 5/8) - 0.08);
                        
                        // Add mode structure
                        amp *= (1 + 0.15 * Math.sin(phi * 2));
                    } else if (t < 0.02) {
                        amp = 2.2e-21 * (100 / distance) * Math.exp(-t * 18);
                        phi = 2 * Math.PI * 200 * t;
                    } else {
                        amp = 1.2e-21 * (100 / distance) * Math.exp(-(t - 0.02) * 90) * 0.45;
                        phi = 2 * Math.PI * 260 * t;
                    }
                    
                    const inc = inclination * Math.PI / 180;
                    const h_plus = amp * (1 + Math.cos(inc)**2) / 2;
                    const h_cross = amp * Math.cos(inc);
                    
                    data.push({
                        time: t,
                        h_plus: h_plus * Math.cos(phi + phase),
                        h_cross: h_cross * Math.sin(phi + phase),
                        freq: 30 * Math.pow(Math.abs(t) + 0.01, -3/8)
                    });
                }
                return data;
            }
    
            // Canvas drawing
            const strainCanvas = document.getElementById('strain-chart');
            const strainCtx = strainCanvas.getContext('2d');
            const freqCanvas = document.getElementById('freq-chart');
            const freqCtx = freqCanvas.getContext('2d');
    
            function setupCanvas(canvas, ctx) {
                const rect = canvas.getBoundingClientRect();
                canvas.width = rect.width * 2;
                canvas.height = rect.height * 2;
                ctx.scale(2, 2);
                return { width: rect.width, height: rect.height };
            }
    
            function drawGrid(ctx, width, height) {
                ctx.strokeStyle = 'rgba(0, 200, 255, 0.1)';
                ctx.lineWidth = 0.5;
                
                const gridX = 10;
                const gridY = 8;
                
                for (let i = 0; i <= gridX; i++) {
                    const x = (i / gridX) * width;
                    ctx.beginPath();
                    ctx.moveTo(x, 0);
                    ctx.lineTo(x, height);
                    ctx.stroke();
                }
                
                for (let i = 0; i <= gridY; i++) {
                    const y = (i / gridY) * height;
                    ctx.beginPath();
                    ctx.moveTo(0, y);
                    ctx.lineTo(width, y);
                    ctx.stroke();
                }
            }
    
            function drawWaveform(ctx, data, width, height, color, isPlus = true) {
                const padding = 40;
                const plotWidth = width - padding * 2;
                const plotHeight = height - padding * 2;
                
                const key = isPlus ? 'h_plus' : 'h_cross';
                const maxAmp = Math.max(...data.map(d => Math.abs(d[key]))) * 1.2;
                
                ctx.beginPath();
                ctx.strokeStyle = color;
                ctx.lineWidth = 1.5;
                
                // Glow effect
                ctx.shadowColor = color;
                ctx.shadowBlur = 8;
                
                data.forEach((d, i) => {
                    const x = padding + (i / data.length) * plotWidth;
                    const y = height / 2 - (d[key] / maxAmp) * (plotHeight / 2);
                    
                    if (i === 0) ctx.moveTo(x, y);
                    else ctx.lineTo(x, y);
                });
                
                ctx.stroke();
                ctx.shadowBlur = 0;
            }
    
            function drawFreqDomain(ctx, data, width, height, color) {
                const padding = 40;
                const plotWidth = width - padding * 2;
                const plotHeight = height - padding * 2;
                
                const maxAmp = Math.max(...data.map(d => d.amplitude)) * 1.2;
                
                ctx.beginPath();
                ctx.strokeStyle = color;
                ctx.lineWidth = 1.5;
                
                ctx.shadowColor = color;
                ctx.shadowBlur = 8;
                
                data.forEach((d, i) => {
                    const x = padding + (i / data.length) * plotWidth;
                    const y = height - padding - (d.amplitude / maxAmp) * plotHeight;
                    
                    if (i === 0) ctx.moveTo(x, y);
                    else ctx.lineTo(x, y);
                });
                
                ctx.stroke();
                ctx.shadowBlur = 0;
            }
    
            function updatePlots() {
                // Generate waveforms
                let timeData, freqData;
                
                const generators = {
                    'IMRPhenomD': generateIMRPhenomD,
                    'EOBNR': generateEOBNR,
                    'TaylorF2': generateTaylorF2,
                    'NRSur': generateNRSur
                };
                
                timeData = generators[currentModel](params);
                
                // Setup strain canvas
                const strainSize = setupCanvas(strainCanvas, strainCtx);
                strainCtx.fillStyle = 'rgba(5, 10, 20, 0.95)';
                strainCtx.fillRect(0, 0, strainSize.width, strainSize.height);
                drawGrid(strainCtx, strainSize.width, strainSize.height);
                
                // Draw waveforms
                drawWaveform(strainCtx, timeData, strainSize.width, strainSize.height, '#00c8ff', true);
                drawWaveform(strainCtx, timeData, strainSize.width, strainSize.height, '#00ff88', false);
                
                // Draw axis labels
                strainCtx.fillStyle = '#666';
                strainCtx.font = '10px sans-serif';
                strainCtx.fillText('Time (s)', strainSize.width / 2, strainSize.height - 5);
                
                // Setup frequency canvas
                const freqSize = setupCanvas(freqCanvas, freqCtx);
                freqCtx.fillStyle = 'rgba(5, 10, 20, 0.95)';
                freqCtx.fillRect(0, 0, freqSize.width, freqSize.height);
                drawGrid(freqCtx, freqSize.width, freqSize.height);
                
                if (compareMode) {
                    // Draw all models
                    Object.keys(generators).forEach(model => {
                        const fd = generateTaylorF2(params);
                        drawFreqDomain(freqCtx, fd, freqSize.width, freqSize.height, modelColors[model]);
                    });
                } else {
                    const fd = generateTaylorF2(params);
                    drawFreqDomain(freqCtx, fd, freqSize.width, freqSize.height, modelColors[currentModel]);
                }
                
                // Frequency axis
                freqCtx.fillStyle = '#666';
                freqCtx.font = '10px sans-serif';
                freqCtx.fillText('20 Hz', 45, freqSize.height - 5);
                freqCtx.fillText('500 Hz', freqSize.width - 60, freqSize.height - 5);
                
                // Update frequency legend
                const freqLegend = document.getElementById('freq-legend');
                if (compareMode) {
                    freqLegend.innerHTML = Object.keys(modelColors).map(model => `
                        <div class="legend-item">
                            <div class="legend-color" style="background: ${modelColors[model]};"></div>
                            <span>${model}</span>
                        </div>
                    `).join('');
                } else {
                    freqLegend.innerHTML = `
                        <div class="legend-item">
                            <div class="legend-color" style="background: ${modelColors[currentModel]};"></div>
                            <span>${currentModel}</span>
                        </div>
                    `;
                }
                
                // Update stats
                const Mc = getChirpMass(params.m1, params.m2);
                const M = params.m1 + params.m2;
                const q = Math.min(params.m1, params.m2) / Math.max(params.m1, params.m2);
                const chi_eff = getEffectiveSpin(params.m1, params.m2, params.chi1, params.chi2);
                
                document.getElementById('chirp-mass').textContent = Mc.toFixed(1);
                document.getElementById('total-mass').textContent = M.toFixed(0);
                document.getElementById('mass-ratio').textContent = q.toFixed(2);
                
                const peakFreq = Math.round(220 * (65 / M));
                document.getElementById('peak-freq').textContent = peakFreq;
                
                const snr = (25 * Math.sqrt(100 / params.distance) * (Mc / 28.6)).toFixed(1);
                document.getElementById('snr-value').textContent = snr;
                
                const duration = (0.4 * (M / 65) ** (-5/3)).toFixed(2);
                document.getElementById('duration').textContent = duration;
                
                // Update estimation bars
                const snrNum = parseFloat(snr);
                const confidence = Math.min(95, 50 + snrNum * 2);
                
                document.getElementById('est-mc').textContent = `${Mc.toFixed(1)} +/- ${(0.5 * 100 / snrNum).toFixed(1)} M☉`;
                document.getElementById('bar-mc').style.width = `${confidence}%`;
                
                document.getElementById('est-q').textContent = `${q.toFixed(2)} +/- ${(0.02 * 100 / snrNum).toFixed(3)}`;
                document.getElementById('bar-q').style.width = `${confidence - 7}%`;
                
                document.getElementById('est-chi').textContent = `${chi_eff.toFixed(2)} +/- ${(0.05 * 100 / snrNum).toFixed(3)}`;
                document.getElementById('bar-chi').style.width = `${confidence - 14}%`;
                
                document.getElementById('est-dl').textContent = `${params.distance} +/- ${Math.round(params.distance * 0.2)} Mpc`;
                document.getElementById('bar-dl').style.width = `${confidence - 27}%`;
                
                // Update mismatch
                const mismatch = (0.001 + 0.01 * Math.abs(params.chi1 - params.chi2) + 0.005 * (1 - q)).toFixed(4);
                document.getElementById('mismatch-val').textContent = mismatch;
            }
    
            // Event handlers
            document.querySelectorAll('.waveform-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    document.querySelectorAll('.waveform-btn').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    currentModel = btn.dataset.model;
                    document.getElementById('waveform-label').textContent = currentModel;
                    updatePlots();
                });
            });
    
            document.getElementById('compare-toggle').addEventListener('click', function() {
                compareMode = !compareMode;
                this.classList.toggle('active');
                this.textContent = compareMode ? 'Hide Comparison' : 'Compare Models';
                updatePlots();
            });
    
            // Parameter controls
            const controls = ['m1', 'm2', 'chi1', 'chi2', 'dist', 'inc', 'phase'];
    
            controls.forEach(ctrl => {
                const slider = document.getElementById(ctrl);
                slider.addEventListener('input', () => {
                    const val = parseFloat(slider.value);
                    
                    switch(ctrl) {
                        case 'm1':
                            params.m1 = val;
                            document.getElementById('m1-val').textContent = `${val} M☉`;
                            break;
                        case 'm2':
                            params.m2 = val;
                            document.getElementById('m2-val').textContent = `${val} M☉`;
                            break;
                        case 'chi1':
                            params.chi1 = val / 100;
                            document.getElementById('chi1-val').textContent = (val / 100).toFixed(2);
                            break;
                        case 'chi2':
                            params.chi2 = val / 100;
                            document.getElementById('chi2-val').textContent = (val / 100).toFixed(2);
                            break;
                        case 'dist':
                            params.distance = val;
                            document.getElementById('dist-val').textContent = `${val} Mpc`;
                            break;
                        case 'inc':
                            params.inclination = val;
                            document.getElementById('inc-val').textContent = `${val}°`;
                            break;
                        case 'phase':
                            params.phase = val / 100;
                            document.getElementById('phase-val').textContent = `${(val / 100).toFixed(2)} rad`;
                            break;
                    }
                    
                    updatePlots();
                });
            });
    
            // Initial render
            updatePlots();
    
            // Responsive
            window.addEventListener('resize', () => {
                updatePlots();
            });
    
            // Animation loop for subtle waveform animation
            let animPhase = 0;
            function animateWaveform() {
                animPhase += 0.02;
                
                // Subtle phase animation on the strain plot
                const strainSize = { 
                    width: strainCanvas.getBoundingClientRect().width, 
                    height: strainCanvas.getBoundingClientRect().height 
                };
                
                requestAnimationFrame(animateWaveform);
            }
            animateWaveform();
        </script>
    </body>
    </html>
    

    Features

    Waveform Families

    1. IMRPhenomD: Phenomenological inspiral-merger-ringdown model, widely used in LIGO analysis
    2. SEOBNRv4: Effective-One-Body Numerical Relativity model with calibrated dynamics
    3. TaylorF2: Post-Newtonian frequency-domain inspiral-only approximation
    4. NRSur7dq4: Numerical Relativity Surrogate with higher-order modes

    Interactive Parameters

    • Masses: Primary and secondary black hole masses (5-100 M☉)
    • Spins: Aligned spins for both components (-1 to +1)
    • Distance: Luminosity distance (50-2000 Mpc)
    • Inclination: Orbital inclination angle (0-180°)
    • Reference Phase: Initial phase offset

    Visualizations

    • Time-domain strain: Shows h+ and h× polarizations with glow effects
    • Frequency-domain: Amplitude spectral density with model comparison
    • Parameter confidence bars: Shows estimation uncertainty based on SNR
    • Waveform mismatch: Systematic uncertainty between models

    Dynamic Elements

    • Animated particle background with connection lines
    • Glowing waveform traces
    • Real-time parameter updates
    • Gradient animations on title
    • Interactive hover effects on all elements