Output Format

Directory Structure

Each simulation run creates a timestamped output directory:

outputs/
  YYYY-MM-DD/
    HH/
      RUN_N/
        frames.npy                      # Full simulation output (full runner)
        frames_chunk_000.npy            # Chunk files (chunked runner)
        frames_chunk_001.npy
        frames_chunk_manifest.json      # Chunk index (chunked runner)
        turbulence_animation.gif        # Animation (when generated)
        config.json                     # Copy of config used
        atmospheric_layers_data.log     # Geometry and layer info
        monitoring/
          system_info.json              # Hardware info
          metrics/                      # Performance metrics
          tensorboard/                  # TensorBoard logs

When dataset generation is enabled (create_data_set.flag = true):

outputs/YYYY-MM-DD/HH/dataset/DATA_N/

Frames Array

Shape

(steps, 2, nx_size, nx_size)

Dimension	Meaning
steps	Number of time steps
2	Channels: phase and amplitude
nx_size	Spatial grid size (from phase_screen_size config)

Channels

Index	Content	Units	Typical Range
0	Phase	Radians	Varies with turbulence strength
1	Amplitude	Unitless	~1.0 (normalized)

Loading

import numpy as np

frames = np.load("outputs/2024-01-15/14/RUN_1/frames.npy")

# Single time step
phase_t0 = frames[0, 0, :, :]
amplitude_t0 = frames[0, 1, :, :]

# Time series at a single pixel
phase_series = frames[:, 0, 128, 128]

# Intensity (amplitude squared)
intensity = frames[:, 1, :, :] ** 2

Chunk Manifest (Streaming Mode)

When using --runner chunked, frames are saved in chunks with a manifest file:

{
  "chunks": [
    "frames_chunk_000.npy",
    "frames_chunk_001.npy",
    "frames_chunk_002.npy"
  ],
  "total_steps": 300,
  "chunk_size": 100,
  "shape_per_chunk": [100, 2, 2048, 2048],
  "timing": {
    "total_time": 45.2,
    "compute_time": 40.1,
    "io_time": 5.1
  },
  "memory": {
    "peak_memory_mb": 4200
  }
}

Loading Chunks

import numpy as np
import json

# Load manifest
with open("frames_chunk_manifest.json") as f:
    manifest = json.load(f)

# Load all chunks
chunks = [np.load(f) for f in manifest["chunks"]]
frames = np.concatenate(chunks, axis=0)
print(frames.shape)  # (total_steps, 2, nx_size, nx_size)

Loading a Single Chunk

# Load only the first 100 frames
chunk_0 = np.load("frames_chunk_000.npy")
print(chunk_0.shape)  # (100, 2, 2048, 2048)

Log Files

atmospheric_layers_data.log

Contains geometry and layer configuration details logged during initialization:

• Layer heights and their distribution
• Per-layer r0 values
• Per-layer wind speeds
• Extrusion rates (pixels per tick)

monitoring/system_info.json

Hardware information captured at simulation start:

{
  "cpu_count": 16,
  "cpu_freq_mhz": 3400,
  "ram_total_gb": 32.0,
  "gpu_name": "NVIDIA GeForce RTX 4080",
  "gpu_memory_total_mb": 13424,
  "gpu_temperature": 45
}