30-EFT.WP.Propagation.TensionPotential v1.0 | Chapter 9 — Modeling Methods & Numerical Implementation

Home ／ Docs-Technical WhitePaper ／ 30-EFT.WP.Propagation.TensionPotential v1.0

Chapter 9 — Modeling Methods & Numerical Implementation

• I. One-Sentence Aim
  Provide an executable route from T_fil(x,t) to Phi_T(x,t), then to n_eff(x,t,f) and T_arr. Cover both grid-first and path-first solvers, define step-size control and error estimation, establish convergence criteria and benchmark tasks, and ensure performance and reproducibility.
• II. Scope & Non-Goals
• Covered: model representation and discretization strategies; solver design with pseudocode; step-size control and error estimation; convergence and stability; benchmark tasks and validation sets; performance and reproducibility; interface and logging conventions.
• Non-goals: no restatement of Chapter 4’s theory for constructing Phi_T or Chapter 5’s details for constructing n_eff; no device-level mechanical or electrical parameters.
• III. Minimal Terms & Symbols
• Fields & potentials: T_fil(x,t), Phi_T(x,t), grad_Phi_T(x,t).
• Index & speeds: n_eff(x,t,f), c_ref, c_loc(x,t,f) = c_ref / n_eff(x,t,f).
• Path & measure: gamma(ell), d ell, segmented paths gamma_i, interface set Sigma.
• Arrival-time gauges: T_arr = ( 1 / c_ref ) * ( ∫ n_eff d ell ), or T_arr = ( ∫ ( n_eff / c_ref ) d ell ).
• Bands & decomposition: n_eff = n_common(x,t) + n_path(x,t,f).
• Errors & thresholds: u_stat, u_sys, u_c, convergence threshold eps_T.
• IV. Model Representation & Discretization Strategies
• Field representation
• Grid field: store Phi_T[j] at nodes x_j; approximate grad_Phi_T[j] via finite differences or finite volumes; optionally smooth with a convolution kernel K_epsilon.
• Trajectory field: evaluate Phi_T( gamma(ell) ) and grad_Phi_T( gamma(ell) ) only along the path; obtain gradients from local samples or analytic forms.
• Effective-index construction
• In-place mapping: at grid or path samples, evaluate n_eff = F( Phi_T, grad_Phi_T, rho, f ) and clamp n_eff ∈ [1, n_max].
• Decomposition cache: pre-estimate n_common(x,t); for each frequency, compute only n_path(x,t,f) and reuse the common term.
• Path & interfaces
• Generate path discretization { gamma[k], Δell[k] } and detect crossings { ell_i } consistently; integrate segment by segment at interfaces and log segment endpoints.
• For anisotropic models, also emit t_hat[k] to evaluate dot( grad_Phi_T , t_hat ).
• V. Solver Designs & Pseudocode
• Grid-first (Field-first)
• Build or load T_fil.
• Compute Phi_T = G( T_fil ), apply gauge and boundaries.
• Compute grad_Phi_T, smooth if needed.
• On the grid, assemble n_common and band-dependent n_path.
• For any path, sample n_eff( gamma[k] ) by interpolation and integrate.
• Pseudocode
• Phi_T = build_phi_t(T_fil, params_G)
• Phi_T = fix_gauge(Phi_T, x_ref, t_ref)
• grad_Phi_T = gradient(Phi_T)
• n_eff = assemble_neff(Phi_T, grad_Phi_T, rho, f_grid)
• T_arr = arrival_time(mode, n_eff, gamma, c_ref)
• Path-first (Trajectory-first)
• Capture { gamma[k], Δell[k] }.
• Along the path, evaluate T_fil( gamma[k] ), then obtain Phi_T( gamma[k] ) and grad_Phi_T( gamma[k] ).
• Pointwise compute n_eff( gamma[k], f ), apply segmented integration and interface corrections.
• Pseudocode
• path = capture_path(raw_track, coord_spec)
• for k: phi[k], gphi[k] = eval_phi_and_grad(gamma[k])
• for f in f_grid: T_arr[f] = integrate(mode, phi, gphi, rho, gamma, Δell, c_ref)
• Hybrid strategy
• Precompute slowly varying terms on a grid; locally refine around the path and fit interfaces in small windows to reduce interpolation error and cost.
• VI. Step-Size Control & Error Estimation
• Adaptive step size
• Criterion 1: geometry curvature norm( d^2 gamma / d ell^2 ) ≥ tau_geom.
• Criterion 2: medium variation norm( d n_eff / d ell ) ≥ tau_medium.
• Reduce step size when either triggers so the integrand is well approximated by a low-order polynomial on each segment.
• Quadrature & error
• Prefer composite Gauss or adaptive Simpson; for a segment, use the difference between 2nd- and 4th-order estimates as local error.
• Aggregate global error via root-sum-of-squares of segment errors; target | T_arr^{(fine)} − T_arr^{(coarse)} | ≤ eps_T.
• Band differencing
• For ΔT_arr(f1,f2), enforce identical { gamma[k], Δell[k] } and the same step-size strategy to prevent numerical artifacts from contaminating the path term.
• VII. Convergence & Stability
• Refinement trials
• Use grid refinement ratio r and path-step ratio r_ell; require monotone error reduction with refinement; estimate empirical order p.
• If non-monotone, revisit smoothing scale epsilon, interface segmentation, and the clamping interval for n_eff.
• Checks
• Gauge consistency: | T_arr^{const} − T_arr^{gen} | ≤ eta_T.
• Lower bound: T_arr ≥ L_path / c_ref.
• Gauge invariance: for Phi_T → Phi_T + C, observables depending only on grad_Phi_T remain unchanged.
• VIII. Benchmark Tasks & Validation Set
• Benchmark 1 — Uniform medium
• Set n_eff ≡ 1; any path must yield T_arr = L_path / c_ref. Validates end-to-end dimensions and implementation.
• Benchmark 2 — Linear potential gradient
• Use Phi_T = Phi_0 + a · x; compare analytic approximations with numerics to test step-size control.
• Benchmark 3 — Two-layer interface
• Two constant n_eff layers plus interface correction; verify segmented integration and interface handling.
• Benchmark 4 — Anisotropic channel
• Include dot( grad_Phi_T , t_hat ); test directionality with path ensembles of different incidence.
• Benchmark 5 — Band dispersion
• Fit polynomial coefficients of n_path across multiple frequency points; check linear region of ΔT_arr and out-of-band suppression.
• Acceptance highlights
• Lower bound, dual-gauge consistency, reparameterization invariance, additive path splicing, stable differencing.
• IX. Performance Optimization & Reproducibility
• Performance
• Vectorize batched integrations; parallelize over bands and over paths.
• Cache local neighborhoods of Phi_T and grad_Phi_T near the path to accelerate repeated evaluations.
• For grid-first, employ multiresolution levels and read-only texture-like interpolation to reduce memory jitter.
• Reproducibility
• Fix RNG seeds; fix coordinate and unit mappings; persist hash(n_eff), hash(gamma), hash(Phi_T), hash(code).
• Logs must include quadrature method, step-size policy, threshold parameters, interface markers, and trigger statistics.
• X. Error Handling & Guardbands
• Error composition
• Cross-check u_c(T_arr) via both GUM and MC; report mean ± k·u_c.
• Guardband
• Set GB = k_guard · u_c as the admissible deviation in acceptance criteria; route edge samples to a review queue.
• Exceptions
• If n_eff < 1 or persistent dual-gauge inconsistency appears, trigger rollback and falsification recording; freeze the implicated configuration.
• XI. Interfaces & Implementation Bindings (I20-29 … I20-40)
• I20-29 build_solver_config(params) -> SolverCfg
  Aggregate step-size, thresholds, quadrature, and parallel policies.
• I20-30 solve_phi_grid(T_fil, params_G, boundary) -> Phi_T, grad_Phi_T
  Grid-first potential and gradient generation.
• I20-31 eval_phi_traj(gamma, T_fil, params_G) -> { Phi_T[k], grad_Phi_T[k] }
  Path-first evaluation of potential and gradient.
• I20-32 assemble_neff(Phi_T, grad_Phi_T, rho, f_grid, params) -> n_eff_field
  Construct and clamp n_eff; support caching of the common term.
• I20-33 integrate_path_constant(n_eff, gamma, Δell, c_ref) -> T_arr
  Path integration for the constant-factored gauge.
• I20-34 integrate_path_general(n_eff, gamma, Δell, c_ref_field) -> T_arr
  Path integration for the general gauge.
• I20-35 segment_and_integrate(n_eff, gamma, Sigma, mode) -> { T_arr_i }, T_arr
  Interface segmentation and composition.
• I20-36 convergence_scan(problem, cfg_list) -> Report
  Multi-level refinements and error-slope estimates.
• I20-37 benchmark_suite(runlist) -> Summary
  Execute Section VIII benchmarks and emit pass/fail conclusions.
• I20-38 cache_neighborhood(field, gamma, radius) -> Handle
  Build path-neighborhood caches to accelerate evaluation.
• I20-39 log_artifacts(meta, hashes, metrics) -> Log
  Record contracts, parameters, thresholds, and metrics.
• I20-40 check_invariants(results) -> Verdict
  Verify lower bound, dual-gauge consistency, splicing additivity, and reparameterization invariance.
• XII. Minimal Log & Artifact Set
• Runtime environment: timestamps; device/library versions; coordinate and unit contracts.
• Solver configuration: SolverCfg, step-size policy, quadrature method, threshold parameters.
• Data hashes: hash(n_eff), hash(gamma), hash(Phi_T), hash(code).
• Result metrics: T_arr, ΔT_arr, eps_T, eta_T, u_c, GB, benchmark pass status, and the list of falsification samples.
• XIII. Cross-References
• EFT.WP.Propagation.TensionPotential v1.0 Chapters 4, 5, 6, 7, 8
• EFT.WP.Core.Equations v1.1 S06-*
• EFT.WP.Core.Metrology v1.0 M05-, M10-
• EFT.WP.Core.Errors v1.0 M20-*
• XIV. Deliverables
• Solver implementation checklist and pseudocode.
• Step-size and error-control templates; convergence-test script essentials.
• Benchmark suite and pass criteria; required log fields and artifact-hash manifest.