3D Simulation Technical Guide

This guide explains the concepts behind the Interactive 3D Solar System Simulation: the geocentric frame it renders in, the input constants that drive it, and how it computes positions. It is written for developers, researchers, and anyone curious about the technical implementation; basic familiarity with JavaScript and trigonometry is helpful but not required.

This page establishes:

• The geocentric frame the scene renders in, and the start-date alignment — The Geocentric Frame, Start Date Alignment.
• Where the source code and data live, and what each input parameter is — Source Code & Data, Input Parameter Reference.
• How right ascension and declination are computed from world positions — Right Ascension & Declination Calculations.
• How the other planets and the Moon are placed — How Other Planets Work, Moon.

The Geocentric Frame

The simulation places Earth at the center of the scene — a geocentric reference frame. The Sun orbits Earth (not the other way around), and all planets revolve around the Sun, which itself revolves around Earth. This is a natural choice because the model describes precession cycles as seen from Earth’s reference frame.

How it works in the 3D scene:

The Sun has speed: 2π — exactly one revolution per year around barycenterEarthAndSun. Since barycenterEarthAndSun is nested inside Earth’s precession hierarchy, the Sun inherits all of Earth’s precession rotations while orbiting at 1 AU.

For other planets, a yearly revolution sandwich converts heliocentric orbits into the geocentric frame:

PerihelionFromEarth         (speed: +2π/yr, perihelion offset position)
  └── ...
      └── RealPerihelionAtSun  (speed: −2π/yr, orbit size, inclination tilt)
            └── Planet          (own orbital speed)

The +2π layer makes the planet’s orbit center revolve at the same rate as the Sun — keeping the planet centered on the Sun as seen from Earth. The −2π layer cancels this revolution for the orbit inside, so the planet orbits at its own heliocentric rate. The net effect: the planet orbits the Sun, which orbits Earth, producing the correct apparent geocentric motion (annual retrograde loops, elongations, and zodiac transit).

The two base units of the scene are 2π radians = one solar year and 100 units = 1 AU; every period and distance is expressed relative to those.

Start Date Alignment

The simulation’s start date is aligned to the June Solstice of 21 June 2000, 00:00 UTC.

At this moment, the Sun was at its highest declination (RA ~6h / ~18h), corresponding to maximum obliquity effect.

The June Solstice doesn’t occur at exactly the same time each year. The calendar uses 365.2425 days (accounting for leap years), which doesn’t perfectly match the actual solar year length. The simulation accounts for this offset.

Source Code & Data

• Simulation code: Available on GitHub  (see the simulation source files)
• Model documentation: The simulator’s own docs — architecture, constants, verification gates — are in the repository’s docs/
• Configuration: All values in the simulation match the Formulas and the theory described in this documentation

Input Parameter Reference

The simulation is driven by a set of input constants. All other values (day lengths, year lengths, precession rates, orbital positions) are derived from these inputs.

Core Cycle Parameters

Year & Day Length Parameters

Model Start Position Parameters

Physical Constants

Right Ascension & Declination Calculations

All celestial position values in the simulation are calculated entirely in the browser - no external API calls. The calculations are deterministic based on the current Julian Date.

Step 1: Get World Positions

Each frame, the simulation retrieves the 3D positions of celestial bodies:

earth.rotationAxis.getWorldPosition(EARTH_POS);   // Earth center
sun.planetObj.getWorldPosition(SUN_POS);          // Sun center
obj.planetObj.getWorldPosition(PLANET_POS);       // Current planet

Step 2: Transform to Earth-Equatorial Frame

The planet’s position is converted to Earth’s local coordinate system, which includes the axial tilt and the 90° rotation that starts the simulation at the June Solstice:

LOCAL.copy(PLANET_POS);
earth.rotationAxis.worldToLocal(LOCAL);           // World → Earth frame

The line earth.containerObj.rotation.y = (Math.PI/2) * whichSolsticeOrEquinox applies the 90° rotation so that 0h RA still points at the March Equinox even though the simulation begins at the June Solstice.

Step 3: Convert to Spherical Coordinates

SPHERICAL.setFromVector3(LOCAL);
obj.ra  = SPHERICAL.theta;                        // θ → Right Ascension (radians)
obj.dec = SPHERICAL.phi;                          // φ → Declination (radians)

Since LOCAL is already in the tilted equatorial frame, θ directly gives the RA and φ gives the Declination - no additional trigonometry needed.

Step 4: Format for Display

The raw radians are converted to sexagesimal notation:

obj.raDisplay  = radiansToRa(obj.ra);             // "12h34m56s"
obj.decDisplay = radiansToDec(obj.dec);           // "+12°34′56″"

Earth’s own frame is placed from the engine each frame, so any change to its tilt, precession rate or date is reflected in the next projection.

How Other Planets Work

Every planet (Mercury through Neptune) uses the same counter-rotation sandwich as the geocentric frame conversion. The hierarchy, using Jupiter as an example:

barycenterEarthAndSun
└── jupiterPerihelionDurationEcliptic1  (prograde, one turn per planets.jupiter.perihelionEclipticYears)
    └── PERIHELION JUPITER              (speed: +2π/yr, perihelion offset)
        └── jupiterPerihelionDurationEcliptic2  (retrograde at the same rate, cancels #1)
            ├── Jupiter Real Perihelion At Sun  (orbit size, inclination tilt, -2π/yr)
            │   └── Jupiter                     (orbital speed, axial tilt, mesh)
            └── Fixed Perihelion At Sun         (fixed perihelion reference, sibling)

The same sandwich principle applies: Ecliptic1 carries the perihelion marker at the precession rate; Ecliptic2 cancels the precession for the orbit inside. The planet orbits the Sun in the correct heliocentric frame, while its perihelion direction precesses independently.

The +2π/yr and −2π/yr layers are the geocentric frame conversion — they make the orbit center revolve with the Sun while letting the planet orbit at its own rate inside.

Orbital inclination is encoded as a static tilt on the RealPerihelionAtSun container, decomposed into two components based on the J2000 ascending node (Ω) and inclination (i):

orbitTilta = i × sin(Ω)     // rotation.x component
orbitTiltb = i × cos(Ω)     // rotation.z component

This orients the orbital plane at the correct angle to the ecliptic. The tilt is fixed at J2000 values — it does not precess in the 3D scene.

Dynamic inclination is computed analytically for the bodies with no element chain:

i(t) = mean + amplitude × cos(ω̃_ICRF(t) - cycleAnchor)

where ω̃_ICRF(t) is the ICRF perihelion longitude (ecliptic rate minus the device’s axial-line rate), and cycleAnchor is the per-planet ICRF perihelion longitude where MAX inclination occurs, evaluated at the bases’ phase origin t₀. Saturn’s cosine sign is flipped. Since the chain flip these law values are no longer what the panels display for the seven planets — the displayed inclinations (ecliptic and invariable-plane) come from the N-body element chain of date; the oscillation law remains for the no-chain bodies.

Key Differences from Earth

Moon

The Moon uses Earth as its center (not the Sun). It has six nested precession layers, following the same containerObj/orbitObj/pivotObj pattern. The signed layer rates sum exactly to the tropical month, and all layer phases are anchored to the J2000 lunar orbital elements:

earth.pivotObj
└── moonApsidalPrecession              — apsidal precession (+8.84765 yr of-date, prograde), carries eccentricity offset
    └── moonApsidalNodalPrecession1    — apsidal-nodal meeting cycle (−5.99701 yr, retrograde)
        └── moonApsidalNodalPrecession2  — counter-rotation (+5.99701 yr): the pair is inert (net zero)
            └── moonLunarLevelingCyclePrecession  — apsidal canceller (−8.84765 yr, of-date pair): mirrors the apsidal layer in rate and phase
                └── moonNodalPrecession          — nodal precession (−18.6132112 yr of-date, retrograde), pure rotation
                    └── moon                     — draconitic-month orbital speed (27.2122209 d), carries the ecliptic inclination tilt

The apsidal precession layer carries the orbital eccentricity offset (orbitRadius). The moon container carries the ecliptic inclination tilt (orbitTilta/orbitTiltb) — placed below the nodal rotation so the nodal layer’s own spin regresses the tilted orbit plane (measured −19.35°/yr, matching the observed nodal plane motion). All intermediate layers are pure rotation layers with zero radius and zero tilt.

The detailed settings for each body are browsable in the simulation’s Planet Orbit Analysis (Tools menu) and in the published @essrt/model-values registry.

Summary

The published periods are the model’s dynamical values (Earth’s Clock); the seven planets render from the N-body element chain.

Key Takeaways

1. Two base units - 2π for time (1 year), 100 for distance (1 AU)
2. Counter-rotating motions - Negative speeds (clockwise) vs positive speeds (counter-clockwise)
3. Browser-based calculations - All RA/Dec values computed locally, no external APIs
4. Geocentric frame — The Sun orbits Earth at 2π/year; planets use +2π/−2π layers for the heliocentric-to-geocentric conversion
5. Cross-surface parity - All simulation values match the Orbital Calculator and the published model-values registry

Return to the Interactive 3D Simulation or explore the Formulas for the complete analytical formulas.