Wobei $\mathbf{A}_{ij}$ die lokale Adjazenzmatrix des Raum-Gitters darstellt und $\ell_P$ die Planck-Länge ist.

Der Term $\mathbf{L}_G$ bezeichnet den diskreten Graph-Laplace-Operator. Der Großteil der Energie entweicht als primäre Gitter-Taktung $\omega_{\text{lattice}}$, während die Kernfusion $\varepsilon_{\text{Fusion}}^{(\text{Abfall})}$ nur den sekundären Oberflächeneffekt bildet.

/**
 * DTIM-ZEC MODULAR PHYSICS FRAMEWORK (DAMTP ACADEMIC STANDARD)
 * DTIM_MainSequence_Dwarf_Equilibrium.pde - Main Sequence Dwarf Equilibrium Engine
 * Target: Processing 4.5.6 / Astronomical Compendium Module
 * License: CC0 1.0 Universal / MIT
 * Copyright (c) 2026 Jan Bühring
 */

final int GRID_POINTS = 120;
float[] coreAdjacencyDensity = new float[GRID_POINTS];
float latticeFrequency = 15.625f; // kHz Base Clock Rate
float criticalThreshold = 0.85f;

void setup() {
  size(800, 380);
  println("[DTIM-ASTROPHYSICS] Initializing Main Sequence Dwarf Equilibrium Matrix...");
  
  // Seed initial Hydro-Information Gradient
  for (int i = 0; i < GRID_POINTS; i++) {
    float r = map(i, 0, GRID_POINTS, 0.0f, 1.0f);
    coreAdjacencyDensity[i] = exp(-r * 3.5f);
  }
}

void draw() {
  background(11, 15, 25);
  
  // Calculate Singularity-Avoidance Inversion Loop
  float pulse = sin(frameCount * 0.05f) * 0.02f;
  
  // Draw Graph-Laplace Density Curve
  strokeWeight(2);
  stroke(251, 191, 36); // Solar Amber Color
  noFill();
  beginShape();
  for (int x = 0; x < GRID_POINTS; x++) {
    float px = map(x, 0, GRID_POINTS, 50, width - 50);
    float val = coreAdjacencyDensity[x] + pulse;
    
    // Inversion Trigger Cutoff at Critical Limit
    if (val > criticalThreshold) {
      val = criticalThreshold - (val - criticalThreshold) * 0.5f; // Automatic Reset
    }
    float py = map(val, 0.0f, 1.0f, height - 60, 60);
    vertex(px, py);
  }
  endShape();
  
  // Draw Threshold Boundary Line
  stroke(239, 68, 68, 180); // Red Critical Cutoff
  line(50, map(criticalThreshold, 0, 1, height - 60, 60), width - 50, map(criticalThreshold, 0, 1, height - 60, 60));
  
  drawCompendiumOverlay();
}

void drawCompendiumOverlay() {
  fill(15, 23, 42, 220);
  stroke(51, 65, 85);
  rect(20, 20, width - 40, 85, 6);
  
  fill(56, 189, 248);
  textSize(13);
  text("DTIM-ZEC ASTROPHYSICAL HANDBOOK // LEHRMEINUNG: HAUPTREIHEN-ZWERGE", 35, 42);
  
  fill(226, 232, 240);
  textSize(11);
  text("MODELL: Gelber Zwerg (Sol-Typ G2V) | INVERSIONS-TAKTUNGEN: 15.625 kHz Nominal", 35, 62);
  
  fill(52, 211, 153);
  text("SINGULARITÄTS-STATUS: STABIL (Inversion aktiv // Kernel Panic verhindert)", 35, 82);
}

Aufgrund der reduzierten Masse $M_*$ sinkt die Taktfrequenz $\omega_{\text{M-Zwerg}}$ drastisch. Das Raum-Gitter altert praktisch nicht.

Staut sich die Phasen-Information $\Phi_{\text{phase}}$ im trägen Konvektions-Gitter an, schießt der Stern die überschüssige Energie in einem abrupten Garbage-Collection-Puls über den Extended Void Bus ins All.

/**
 * DTIM-ZEC MODULAR PHYSICS FRAMEWORK (DAMTP ACADEMIC STANDARD)
 * DTIM_RedDwarf_Convective_Grid.pde - M-Dwarf Fully Convective Matrix Simulator
 * Target: Processing 4.5.6 / Astronomical Compendium Module 2
 * License: CC0 1.0 Universal / MIT
 * Copyright (c) 2026 Jan Bühring
 */

final int NUM_CELLS = 80;
float[] phaseAccumulation = new float[NUM_CELLS];
boolean flareActive = false;
float flareIntensity = 0.0f;

void setup() {
  size(800, 380);
  println("[DTIM-ASTROPHYSICS] Initializing M-Dwarf Convective Grid...");
  
  // Initialize fully convective homogeneous phase density
  for (int i = 0; i < NUM_CELLS; i++) {
    phaseAccumulation[i] = random(0.1f, 0.4f);
  }
}

void draw() {
  background(11, 15, 25);
  
  // Simulate slow phase accumulation in convective cells
  for (int i = 0; i < NUM_CELLS; i++) {
    phaseAccumulation[i] += random(0.001f, 0.003f);
    
    // Check Garbage Collection Threshold
    if (phaseAccumulation[i] > 0.95f) {
      triggerEVMGarbageCollection();
    }
  }
  
  // Render M-Dwarf Convective Waveform
  strokeWeight(3);
  if (flareActive) {
    stroke(248, 113, 113); // Red-Hot Flare Discharge
  } else {
    stroke(239, 68, 68);  // Stable M-Dwarf Crimson
  }
  
  noFill();
  beginShape();
  for (int x = 0; x < NUM_CELLS; x++) {
    float px = map(x, 0, NUM_CELLS, 50, width - 50);
    float val = phaseAccumulation[x] + (flareActive ? flareIntensity : 0.0f);
    float py = map(val, 0.0f, 1.2f, height - 60, 60);
    vertex(px, py);
  }
  endShape();
  
  // Decay Flare Activity
  if (flareActive) {
    flareIntensity *= 0.85f;
    if (flareIntensity < 0.01f) {
      flareActive = false;
    }
  }
  
  drawRedDwarfOverlay();
}

void triggerEVMGarbageCollection() {
  flareActive = true;
  flareIntensity = 0.35f;
  
  // EVM Reset across all convective cells
  for (int i = 0; i < NUM_CELLS; i++) {
    phaseAccumulation[i] *= 0.25f; // Phase purged to Extended Void Bus
  }
  println("[EVM-BUS] Garbage Collection Pulse Executed. System Reset Complete.");
}

void drawRedDwarfOverlay() {
  fill(15, 23, 42, 220);
  stroke(51, 65, 85);
  rect(20, 20, width - 40, 85, 6);
  
  fill(248, 113, 113);
  textSize(13);
  text("DTIM-ZEC ASTROPHYSICAL HANDBOOK // LEHRMEINUNG: ROTE ZWERGE (KLASSE M)", 35, 42);
  
  fill(226, 232, 240);
  textSize(11);
  text("SPEKTRALKLASSE: M-Dwarf (Ross 128 Typ) | CONVECTIVE MIXING: 100% Homogen", 35, 62);
  
  if (flareActive) {
    fill(248, 113, 113);
    text("STATUS: EVM GARBAGE COLLECTION ACTIVE (Phasen-Purge zur Entlastung)", 35, 82);
  } else {
    fill(52, 211, 153);
    text("STATUS: ULTRA-LONG-LIFE MODE (Taktfrequenz minimal // Alterung: Null)", 35, 82);
  }
}

Durch die extrem hohe Frequenz $\omega_{\text{Blue}}$ verschleißt die lokale Raum-Struktur in wenigen Millionen Jahren vollständig.

Sobald der Grenzwert $\rho_{\text{max}}$ erreicht ist, bricht der Rang der Adjazenzmatrix zusammen. Die freiwerdende Rekonfigurations-Energie entlädt sich als Schockwelle – die Supernova formatiert den lokalen Sektor neu.

/**
 * DTIM-ZEC MODULAR PHYSICS FRAMEWORK (DAMTP ACADEMIC STANDARD)
 * DTIM_BlueGiant_HyperClock_Matrix.pde - O/B Type Star Hyper-Clocking Simulator
 * Target: Processing 4.5.6 / Astronomical Compendium Module 3
 * License: CC0 1.0 Universal / MIT
 * Copyright (c) 2026 Jan Bühring
 */

final int MATRIX_NODES = 150;
float[] nodeLoad = new float[MATRIX_NODES];
float hyperClockRate = 142.8f; // High frequency multiplier
boolean systemResetWarning = false;

void setup() {
  size(800, 380);
  println("[DTIM-ASTROPHYSICS] Initializing Blue Giant Hyper-Clocking Engine...");
  
  // Seed high initial matrix load
  for (int i = 0; i < MATRIX_NODES; i++) {
    nodeLoad[i] = random(0.6f, 0.92f);
  }
}

void draw() {
  background(11, 15, 25);
  
  // Simulate high-frequency lattice stress
  float evmVentRate = 0.015f;
  
  for (int i = 0; i < MATRIX_NODES; i++) {
    nodeLoad[i] += sin(frameCount * 0.2f + i) * 0.008f;
    nodeLoad[i] -= evmVentRate; // Continuous EVM Stellar Wind Dump
    
    if (nodeLoad[i] < 0.3f) nodeLoad[i] = 0.3f;
    if (nodeLoad[i] > 0.98f) systemResetWarning = true;
  }
  
  // Render Hyper-Clocking Waveform
  strokeWeight(2);
  if (systemResetWarning) {
    stroke(239, 68, 68); // Red Alert: Impending Supernova Reset
  } else {
    stroke(96, 165, 250); // Electric Blue Giant Color
  }
  
  noFill();
  beginShape();
  for (int x = 0; x < MATRIX_NODES; x++) {
    float px = map(x, 0, MATRIX_NODES, 50, width - 50);
    float val = nodeLoad[x] + sin(x * 0.4f + frameCount * 0.3f) * 0.05f;
    float py = map(val, 0.0f, 1.1f, height - 60, 60);
    vertex(px, py);
  }
  endShape();
  
  drawBlueGiantOverlay();
}

void drawBlueGiantOverlay() {
  fill(15, 23, 42, 220);
  stroke(51, 65, 85);
  rect(20, 20, width - 40, 85, 6);
  
  fill(96, 165, 250);
  textSize(13);
  text("DTIM-ZEC ASTROPHYSICAL HANDBOOK // LEHRMEINUNG: BLAUE RIESEN (O/B)", 35, 42);
  
  fill(226, 232, 240);
  textSize(11);
  text("SPEKTRALKLASSE: O/B-Type (Rigel/Spica) | CLOCK MULTIPLIER: " + hyperClockRate + "x SOL", 35, 62);
  
  if (systemResetWarning) {
    fill(239, 68, 68);
    text("WARNING: MATRIX SATURATION NEAR CRITICAL (Supernova Reset Imminent)", 35, 82);
  } else {
    fill(52, 211, 153);
    text("STATUS: HYPER-CLOCK ACTIVE // EVM STELLAR WIND VENTING: NOMINAL", 35, 82);
  }
}

Wenn $\rho_{\text{core}} > \rho_{\text{crit}}$, sinkt die Determinante der Kern-Adjazenzmatrix $\operatorname{Det}(\mathbf{A}_{ij})$ ab. Das erzwingt eine exponentielle Ausdehnung der äußeren Gitter-Punkte.

Die Abkühlung der Oberfläche ist kein rein energetischer Effekt, sondern eine direkte Folge des gestreckten Phasen-Abstands der Gitter-Knoten an der Sternperipherie.

/**
 * DTIM-ZEC MODULAR PHYSICS FRAMEWORK (DAMTP ACADEMIC STANDARD)
 * DTIM_RedGiant_EnvelopeExpansion.pde - Red Giant Matrix Displacement Simulator
 * Target: Processing 4.5.6 / Astronomical Compendium Module 4
 * License: CC0 1.0 Universal / MIT
 * Copyright (c) 2026 Jan Bühring
 */

final int RADIAL_STEPS = 100;
float coreSaturation = 0.4f;
float envelopeRadius = 120.0f;
boolean heliumFlashActive = false;

void setup() {
  size(800, 380);
  println("[DTIM-ASTROPHYSICS] Initializing Red Giant Matrix Displacement Simulator...");
}

void draw() {
  background(11, 15, 25);
  
  // Simulate continuous core saturation increase
  if (!heliumFlashActive) {
    coreSaturation += 0.0015f;
    envelopeRadius = map(coreSaturation, 0.4f, 1.0f, 120.0f, 260.0f);
  } else {
    // Post-Flash Core Reset
    coreSaturation *= 0.92f;
    envelopeRadius *= 0.96f;
    if (coreSaturation < 0.45f) {
      heliumFlashActive = false;
    }
  }
  
  // Trigger Helium Flash / Matrix Reset at Saturated Limit
  if (coreSaturation >= 0.98f) {
    heliumFlashActive = true;
    println("[DTIM-ZEC] Core Saturated! Helium Flash / Matrix Reset Executed.");
  }
  
  // Draw Red Giant Star System Visualization
  translate(width/2, height/2 + 10);
  
  // Outer Expanded Envelope (Red/Orange Glow)
  noFill();
  strokeWeight(2);
  float pulse = sin(frameCount * 0.08f) * 6.0f;
  
  if (heliumFlashActive) {
    stroke(255, 255, 255, 200); // Flash Burst
  } else {
    stroke(249, 115, 22, 180); // Red Giant Orange
  }
  ellipse(0, 0, (envelopeRadius + pulse) * 2, (envelopeRadius + pulse) * 2);
  
  // Saturated Compressed Core
  fill(251, 191, 36);
  noStroke();
  ellipse(0, 0, 24, 24);
  
  resetMatrix();
  drawRedGiantOverlay();
}

void drawRedGiantOverlay() {
  fill(15, 23, 42, 220);
  stroke(51, 65, 85);
  rect(20, 20, width - 40, 85, 6);
  
  fill(249, 115, 22);
  textSize(13);
  text("DTIM-ZEC ASTROPHYSICAL HANDBOOK // LEHRMEINUNG: ROTE RIESEN (GIANT BRANCH)", 35, 42);
  
  fill(226, 232, 240);
  textSize(11);
  text("KERN-SÄTTIGUNG: " + nf(coreSaturation * 100, 0, 1) + "% | ENVELOPE RADIUS: " + nf(envelopeRadius, 0, 1) + " R_sol", 35, 62);
  
  if (heliumFlashActive) {
    fill(239, 68, 68);
    text("STATUS: HELIUM FLASH ACTIVE (Topologischer Matrix-Reset im Kern)", 35, 82);
  } else {
    fill(52, 211, 153);
    text("STATUS: MATRIX DISPLACEMENT NOMINAL (Verdrängungs-Expansion aktiv)", 35, 82);
  }
}

Wenn der Eigenwert $\lambda_{\text{max}}(\Delta_G)$ der Gitter-Matrix gegen die fundamentale Taktfrequenz $\omega_{\text{lattice}}^2$ strebt, wird das System instabil: Die Hülle wird abgetrennt.

Der Massenverlust $\dot{M}_{\text{EVM}}$ erfolgt in gigantischen, unregelmäßigen Schüben, bei denen bis zu mehreren Sonnenmassen pro Jahrzehnt direkt an den Void-Bus abgegeben werden.

/**
 * DTIM-ZEC MODULAR PHYSICS FRAMEWORK (DAMTP ACADEMIC STANDARD)
 * DTIM_Hypergiant_MatrixInstability.pde - Hypergiant Bandwidth Limit Simulator
 * Target: Processing 4.5.6 / Astronomical Compendium Module 5
 * License: CC0 1.0 Universal / MIT
 * Copyright (c) 2026 Jan Bühring
 */

final int SHELL_NODES = 120;
float[] matrixStrain = new float[SHELL_NODES];
float hyperRadius = 210.0f;
boolean evmPurgeActive = false;
float purgeEjecta = 0.0f;

void setup() {
  size(800, 380);
  println("[DTIM-ASTROPHYSICS] Initializing Hypergiant Matrix Instability Simulator...");
  
  for (int i = 0; i < SHELL_NODES; i++) {
    matrixStrain[i] = random(0.7f, 0.95f);
  }
}

void draw() {
  background(11, 15, 25);
  
  // Calculate Chaotic Adjacency Matrix Strain
  float peakStrain = 0.0f;
  for (int i = 0; i < SHELL_NODES; i++) {
    matrixStrain[i] += random(-0.02f, 0.025f);
    matrixStrain[i] = constrain(matrixStrain[i], 0.4f, 1.05f);
    if (matrixStrain[i] > peakStrain) {
      peakStrain = matrixStrain[i];
    }
  }
  
  // Humphreys-Davidson Limit Threshold Check
  if (peakStrain >= 1.02f && !evmPurgeActive) {
    evmPurgeActive = true;
    purgeEjecta = 1.0f;
    println("[HUMPHREYS-DAVIDSON] Bandwidth Limit Exceeded! Triggering EVM Cascade Purge...");
  }
  
  // Render Hypergiant Core and Chaotic Shell
  translate(width/2, height/2 + 10);
  
  // EVM Purge Discharge Particles / Waves
  if (evmPurgeActive) {
    stroke(244, 114, 182, 220); // Bright Magenta EVM Purge Wave
    strokeWeight(3);
    noFill();
    ellipse(0, 0, (hyperRadius + purgeEjecta * 80.0f) * 2, (hyperRadius + purgeEjecta * 80.0f) * 2);
    
    purgeEjecta *= 0.92f;
    if (purgeEjecta < 0.02f) {
      evmPurgeActive = false;
      // Relieve Matrix Strain after Purge
      for (int i = 0; i < SHELL_NODES; i++) {
        matrixStrain[i] *= 0.65f;
      }
    }
  }
  
  // Pulsing Hypergiant Envelope
  noFill();
  strokeWeight(2);
  stroke(236, 72, 153, 180); // Hypergiant Pink/Purple
  beginShape();
  for (int a = 0; a < SHELL_NODES; a++) {
    float angle = map(a, 0, SHELL_NODES, 0, TWO_PI);
    float strainOffset = matrixStrain[a] * 25.0f;
    float r = hyperRadius + strainOffset + sin(angle * 6.0f + frameCount * 0.1f) * 8.0f;
    float x = r * cos(angle);
    float y = r * sin(angle);
    vertex(x, y);
  }
  endShape(CLOSE);
  
  // Compressed Hyper-Dense Core
  fill(255, 255, 255);
  noStroke();
  ellipse(0, 0, 18, 18);
  
  resetMatrix();
  drawHypergiantOverlay(peakStrain);
}

void drawHypergiantOverlay(float currentPeak) {
  fill(15, 23, 42, 220);
  stroke(51, 65, 85);
  rect(20, 20, width - 40, 85, 6);
  
  fill(236, 72, 153);
  textSize(13);
  text("DTIM-ZEC ASTROPHYSICAL HANDBOOK // LEHRMEINUNG: ÜBERRIESEN & HYPERRIESEN", 35, 42);
  
  fill(226, 232, 240);
  textSize(11);
  text("SPEKTRUM: Hypergiant (Stephenson 2-18 / Eta Carinae) | PEAK MATRIX STRAIN: " + nf(currentPeak * 100, 0, 1) + "%", 35, 62);
  
  if (evmPurgeActive) {
    fill(244, 114, 182);
    text("STATUS: EVM CASCADE PURGE ACTIVE (Gewaltsamer Hüllen-Auswurf ins Void)", 35, 82);
  } else if (currentPeak > 0.90f) {
    fill(251, 191, 36);
    text("STATUS: HUMPHREYS-DAVIDSON LIMIT CRITICAL // MATRIX INSTABILITY HIGH", 35, 82);
  } else {
    fill(52, 211, 153);
    text("STATUS: BANDWIDTH BOUNDARY STABLE (Adjazenz-Matrix im Notfall-Takt)", 35, 82);
  }
}

Wobei $\mathbf{A}_{ij}^{(\text{frozen})}$ den starren Invarianz-Operator der Diamant-Gitterstruktur beschreibt und $m_p$ die Protonenmasse symbolisiert.

Je schwerer ein Weißer Zwerg wird, desto kleiner schrumpft sein Radius $R_{\text{WD}}$, da das erstarrte Gitter unter höherer Last dichter komprimiert wird.

/**
 * DTIM-ZEC MODULAR PHYSICS FRAMEWORK (DAMTP ACADEMIC STANDARD)
 * DTIM_WhiteDwarf_StaticLock_Matrix.pde - Degenerate White Dwarf Matrix Simulator
 * Target: Processing 4.5.6 / Astronomical Compendium Module 6
 * License: CC0 1.0 Universal / MIT
 * Copyright (c) 2026 Jan Bühring
 */

final int LATTICE_GRID = 16;
float currentMass = 1.02f; // In Solar Masses (Sirius B Baseline)
float chandrasekharLimit = 1.44f;
boolean supernovaIaType = false;
float gridDisruptionPulse = 0.0f;

void setup() {
  size(800, 380);
  println("[DTIM-ASTROPHYSICS] Initializing White Dwarf Static Lock Simulator...");
}

void draw() {
  background(11, 15, 25);
  
  // Interactive Mass Accretion Simulation
  if (!supernovaIaType) {
    currentMass += 0.0015f; // Simulated mass accretion from companion star
  } else {
    gridDisruptionPulse *= 0.88f;
    if (gridDisruptionPulse < 0.01f) {
      supernovaIaType = false;
      currentMass = 0.85f; // Post-explosion reset / remnant core
    }
  }
  
  // Check Chandrasekhar Shear Limit
  if (currentMass >= chandrasekharLimit && !supernovaIaType) {
    supernovaIaType = true;
    gridDisruptionPulse = 1.0f;
    println("[CHANDRASEKHAR-LIMIT] Matrix Shear Failure! Type Ia Supernova Event Dispatched.");
  }
  
  // Calculate Mass-Radius Inverse Compression
  float clampedMass = min(currentMass, chandrasekharLimit);
  float radiusPx = map(clampedMass, 0.5f, chandrasekharLimit, 110.0f, 25.0f);
  
  // Render Frozen Crystal Matrix Grid
  translate(width/2, height/2 + 10);
  
  if (supernovaIaType) {
    // Type Ia Supernova Matrix Shatter Effect
    stroke(255, 255, 255, 240);
    strokeWeight(3);
    noFill();
    ellipse(0, 0, gridDisruptionPulse * 380.0f, gridDisruptionPulse * 380.0f);
  } else {
    // Rigid Diamond Lattice Interconnections
    stroke(103, 232, 249, 180); // Cyan Crystal Glow
    strokeWeight(1.5f);
    
    float spacing = (radiusPx * 2.0f) / LATTICE_GRID;
    for (int x = -LATTICE_GRID/2; x <= LATTICE_GRID/2; x++) {
      for (int y = -LATTICE_GRID/2; y <= LATTICE_GRID/2; y++) {
        float px = x * spacing;
        float py = y * spacing;
        
        if (dist(0, 0, px, py) <= radiusPx) {
          fill(224, 242, 254);
          noStroke();
          ellipse(px, py, 3.5f, 3.5f);
          
          stroke(6, 182, 212, 120);
          if (x < LATTICE_GRID/2) line(px, py, px + spacing, py);
          if (y < LATTICE_GRID/2) line(px, py, px, py + spacing);
        }
      }
    }
  }
  
  resetMatrix();
  drawWhiteDwarfOverlay();
}

void drawWhiteDwarfOverlay() {
  fill(15, 23, 42, 220);
  stroke(51, 65, 85);
  rect(20, 20, width - 40, 85, 6);
  
  fill(103, 232, 249);
  textSize(13);
  text("DTIM-ZEC ASTROPHYSICAL HANDBOOK // LEHRMEINUNG: WEISSE ZWERGE (DEGENERATE)", 35, 42);
  
  fill(226, 232, 240);
  textSize(11);
  text("ACCUMULATED MASS: " + nf(currentMass, 0, 3) + " M_sol | CHANDRASEKHAR LIMIT: 1.440 M_sol", 35, 62);
  
  if (supernovaIaType) {
    fill(239, 68, 68);
    text("STATUS: TYPE Ia SUPERNOVA (Scherbruch der statisch arretierten Adjazenzmatrix)", 35, 82);
  } else if (currentMass > 1.35f) {
    fill(251, 191, 36);
    text("STATUS: MATRIX SHEAR STRAIN CRITICAL // APPROACHING CHANDRASEKHAR BOUNDARY", 35, 82);
  } else {
    fill(52, 211, 153);
    text("STATUS: STATIC LOCK ACTIVE (Kristalline Diamant-Gitter-Arretierung nominal)", 35, 82);
  }
}

Wobei $R_{\text{NS}} \approx 10\text{–}12\,\text{km}$ den physikalischen Kompressions-Radius und $\omega_{\text{pulsar}}$ die Taktfrequenz der Pulsar-Rotation angibt.

Der Vektor $\vec{n}_{\text{magnetic}}$ beschreibt die geneigte Achse der Phasen-Torsion. Bei jeder Rotation streicht die Energiekeule präzise durch die Raum-Matrix.

/**
 * DTIM-ZEC MODULAR PHYSICS FRAMEWORK (DAMTP ACADEMIC STANDARD)
 * DTIM_NeutronStar_Pulsar_Beam.pde - Pulsar Relativistic Clock Sweep Simulator
 * Target: Processing 4.5.6 / Astronomical Compendium Module 7
 * License: CC0 1.0 Universal / MIT
 * Copyright (c) 2026 Jan Bühring
 */

float rotationAngle = 0.0f;
float pulsarFreq = 0.12f; // Clock Sweep Speed
float nsMass = 2.08f;     // Solar Masses (PSR J0740+6620 Baseline)
float tovLimit = 2.17f;
boolean TovLimitExceeded = false;

void setup() {
  size(800, 380);
  println("[DTIM-ASTROPHYSICS] Initializing Neutron Star Relativistic Clock Sweep Simulator...");
}

void draw() {
  background(11, 15, 25);
  
  // Rotate Pulsar Magnetic Axis
  rotationAngle += pulsarFreq;
  if (rotationAngle > TWO_PI) rotationAngle -= TWO_PI;
  
  translate(width/2, height/2 + 10);
  
  // Draw Relativistic EVM Beacon Beams (Top and Bottom)
  pushMatrix();
  rotate(rotationAngle);
  
  // Energy Beams Cone Rendering
  noStroke();
  fill(168, 85, 247, 180); // Electric Purple Pulsar Beam
  quad(0, 0, -35, -280, 35, -280, 0, 0);
  quad(0, 0, -35, 280, 35, 280, 0, 0);
  
  fill(255, 255, 255, 230); // Core Beam Center
  quad(0, 0, -10, -280, 10, -280, 0, 0);
  quad(0, 0, -10, 280, 10, 280, 0, 0);
  
  popMatrix();
  
  // Ultradense Squeezed Neutron Core
  stroke(192, 132, 252);
  strokeWeight(2);
  fill(255, 255, 255);
  ellipse(0, 0, 28, 28);
  
  // Outer Relativistic Matrix Field Lines
  noFill();
  stroke(168, 85, 247, 90);
  strokeWeight(1);
  ellipse(0, 0, 90, 90);
  ellipse(0, 0, 160, 160);
  
  resetMatrix();
  drawPulsarOverlay();
}

void drawPulsarOverlay() {
  fill(15, 23, 42, 220);
  stroke(51, 65, 85);
  rect(20, 20, width - 40, 85, 6);
  
  fill(192, 132, 252);
  textSize(13);
  text("DTIM-ZEC ASTROPHYSICAL HANDBOOK // LEHRMEINUNG: NEUTRONENSTERNE & PULSARE", 35, 42);
  
  fill(226, 232, 240);
  textSize(11);
  text("CORE MASS: " + nf(nsMass, 0, 2) + " M_sol | DTIM-TOV LIMIT: " + tovLimit + " M_sol | ROTATION: " + nf(pulsarFreq * 250, 0, 0) + " Hz", 35, 62);
  
  if (nsMass >= tovLimit) {
    fill(239, 68, 68);
    text("STATUS: TOV LIMIT EXCEEDED (Relativistischer Kollaps zum Schwarzen Loch)", 35, 82);
  } else {
    fill(52, 211, 153);
    text("STATUS: RELATIVISTIC CLOCK SWEEP NOMINAL (Phasen-Leuchtfeuer aktiv)", 35, 82);
  }
}