atmorad-py 0.1.1__tar.gz

atmorad_py-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,47 @@
+name: CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  test-and-lint:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        resolution: ["locked", "lowest-direct"]
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.1.0
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Install Dependencies
+        run: |
+          if [ "${{ matrix.resolution }}" = "lowest-direct" ]; then
+            uv venv
+            uv pip install -e ".[dev]" --resolution lowest-direct
+          else
+            uv sync --all-extras --dev
+          fi
+
+      - name: Ruff
+        if: matrix.resolution == 'locked'
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
+
+      - name: Pytests
+        run: uv run pytest tests/

atmorad_py-0.1.1/.gitignore

@@ -0,0 +1,12 @@
+.venv
+env/
+.ruff_cache
+.provenance
+__pycache__/
+fig/*
+*egg-info
+build/
+dist/
+results*/
+*.png
+*.npz   

atmorad_py-0.1.1/.python-version

@@ -0,0 +1 @@
+3.12

atmorad_py-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Karol Dąbrowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

atmorad_py-0.1.1/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: atmorad-py
+Version: 0.1.1
+Summary: A 3D monte carlo simulation of Atmospheric Radiative Transfer
+Author-email: Karol Dąbrowski <atmorad@kdabr.com>
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Requires-Dist: cmocean>=2.0.0
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: tqdm>=4.60.0
+Description-Content-Type: text/markdown
+
+# AtmoRad
+## A vectorized Monte Carlo simulation of atmospheric radiative transfer.
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+| **2D Surface absorption map** | **Sample photon paths** |
+| :--- | :--- |
+| ![map](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/surface_absorption_map.png) | ![paths](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/3d_photon_paths.png) |
+| **Vertical flux profile** | **Vertical absorption profile** |
+| ![profile](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/vertical_flux_profile.png)| ![hist](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/heating_profile.png) |
+
+## Overview:
+
+This project simulates the propagation of light through a plane-parallel atmosphere over a horizontally mixed surface and its interactions with the ground boundary. Developed as a student project, created to learn computational physics and software development.
+
+### Physical model
+- **Analog Monte Carlo Approach**: Light is simulated using discrete photon packets. Final flux is calculated as a fraction of the total detected packets.
+- **Plane-parallel approximation**: The atmosphere consists of horizontally uniform layers.
+- **Multi-material atmospheric layers**: Layers can consist of multiple atmospheric materials simultaneously. A photon is assigned a material randomly when it is initialized and again when it crosses into a new layer. Each material has its own extinction coefficient, SSA and phase function.
+- **Custom Phase Functions**: Henyey-Greenstein and Rayleigh phase functions are already implemented in the simulation, but any custom user-defined function can be constructed using the `Scattering` class.
+- **Surface Reflections**: The surface consists of materials, each with its own albedo, a predefined BRDF reflection model (`Lambertian`, `Mirror`), and a `ProceduralMap` that outputs material ID based on spatial coordinates.
+- **Photon Properties**: Light is treated as monochromatic, non-polarized particles. During the simulation they can be scattered, reflected, or absorbed. 
+- **Incident Irradiance & Adjacency Effect**: Custom detectors allow measuring downward/upward incident flux at any arbitrary altitude - helpful for visualizing the adjacency effect.
+
+
+## Technical implementation:
+- The simulation uses `numpy` to simulate photons simultaneously in large batches.
+- The results are plotted using `matplotlib` and `seaborn` (e.g., photon paths, flux profile, 2D ground flux maps)
+- The code uses multiprocessing to run batches in parallel.
+  
+## Installation:
+- Using `uv` ([install uv](https://docs.astral.sh/uv/getting-started/installation/)):
+```bash
+uv tool install atmorad-py
+```
+- Using `pip`:
+```bash
+pip install atmorad-py
+```
+- Run the simulation:
+```bash
+atmorad --init
+atmorad simulation.toml
+```
+- Check `results/` directory for simulation artifacts.
+
+## Project Structure
+- `engine/`: Divides photons into batches and runs the simulation.
+- `physics/`: Contains a rotation function, scattering phase functions, reflection functions.
+- `environment/`: Keeps track of the environment. Contains `Scene`, `Atmosphere` and `Surface` classes.
+- `detectors/`: Provides functionality for tracking photons during the simulation and generates results.
+- `output/`: Handles results and figure generation.
+- `config/` and `builder.py`: Parses `.toml` configuration file and generates simulation context.
+- `cli.py`: Provides CLI for `atmorad`.
+
+## Customization
+You can define your own surface reflection algorithms and scattering phase functions using decorators as shown below:
+
+```python
+import numpy as np
+from atmorad import build_context, MCRadiationRunner, DataIO, ResultAnalyzer
+from atmorad import SurfaceReflection, register_reflection, orientation
+from atmorad import Scattering, register_scattering
+
+# 1. Register a custom surface reflection
+@register_reflection("custom-reflection")
+class CustomReflection(SurfaceReflection):
+    # Specify arbitrary custom parameters
+    def __init__(self, param_1, param_2):
+        self.param_1 = param_1
+        self.param_2 = param_2
+    def reflect(self, direction, rand_1, rand_2):
+        # Your custom reflection physics here
+        cos_theta = np.sqrt(rand_1)
+        sin_theta = np.sqrt(1.0 - rand_1)
+
+        # you can also use specified parameters
+        # self.param_1, self.param_2
+
+        phi = rand_2 * 2 * np.pi
+        cos_phi, sin_phi = np.cos(phi), np.sin(phi)
+        
+        return orientation(cos_theta, sin_theta, cos_phi, sin_phi)
+    
+# 2. Register a custom scattering phase function
+@register_scattering("custom-scattering")
+class CustomScattering(Scattering):
+    # Specify arbitrary custom parameters
+    def __init__(self, g, resolution=1000):
+        # Define a pdf array
+        self.g = g
+        cos_grid = np.linspace(-1, 1, resolution)
+
+        pdf = (1 - g**2) / (2 * (1 + g**2 - 2 * g * cos_grid) ** 1.5)
+
+        super().__init__(pdf_array=pdf, resolution=resolution)
+
+# 3. Run the simulation using custom names in your config
+if __name__ == "__main__":
+    context = build_context("simulation.toml")
+    runner = MCRadiationRunner(context)
+    runner.run()
+
+    # 4. Save and analyze results
+    results = runner.get_results()
+    outputs = DataIO(context.config)
+    analyzer = ResultAnalyzer(results, context.config)
+    
+    outputs.save_all_artifacts(analyzer, results)
+    outputs.save_metadata(context.config, results)
+    outputs.save_results(results)
+```
+In `simulation.toml` you can specify your defined scatterings and reflections:
+```toml
+[atmosphere_materials.custom-atm-material]
+ssa = 0.9
+scattering = {type = "custom-scattering", g=0.8} 
+
+[surface_materials.custom-surf-material]
+albedo = 0.5
+reflection = {type = "custom-reflection", param_1=2, param_2=1.3} # match param names defined in python
+```
+Then you can use your defined materials for atmospheric layers and surface maps:
+```toml
+[[layer]]
+z_range_km = [0, 2]
+materials = [{type = "custom-atm-material", weight = 1.0}]
+
+# ...
+
+[surface]
+name = "uniform"
+material = "custom-surf-material"
+```
+
+## References and Literature
+- (in Polish) Script for Lecture about [Radiative Processes in the Atmosphere](https://www.igf.fuw.edu.pl/~kmark/stacja/wyklady/ProcesyRadiacyjne/2013/WykladRadiacjaKlimat.pdf), Prof. K. Markowicz, Faculty of Physics, University of Warsaw, 2013.
+
+## Acknowledgments
+- This project was inspired by the lectures on *Radiative Processes in the Atmosphere* by Prof. K. Markowicz, Faculty of Physics, University of Warsaw.
+- Large Language Models were used for code debugging and learning best Python practices (e.g. `dataclasses`, `__init__.py` import interfaces, class responsibilities, config parsing).
+
+## Contributing
+Feel free to open an [Issue](https://github.com/dabrokarol/atmorad-py/issues) or submit a Pull Request if you'd like to contribute or report a bug.
+

atmorad_py-0.1.1/README.md

@@ -0,0 +1,146 @@
+# AtmoRad
+## A vectorized Monte Carlo simulation of atmospheric radiative transfer.
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+| **2D Surface absorption map** | **Sample photon paths** |
+| :--- | :--- |
+| ![map](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/surface_absorption_map.png) | ![paths](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/3d_photon_paths.png) |
+| **Vertical flux profile** | **Vertical absorption profile** |
+| ![profile](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/vertical_flux_profile.png)| ![hist](https://raw.githubusercontent.com/dabrokarol/atmorad-py/main/docs/img/heating_profile.png) |
+
+## Overview:
+
+This project simulates the propagation of light through a plane-parallel atmosphere over a horizontally mixed surface and its interactions with the ground boundary. Developed as a student project, created to learn computational physics and software development.
+
+### Physical model
+- **Analog Monte Carlo Approach**: Light is simulated using discrete photon packets. Final flux is calculated as a fraction of the total detected packets.
+- **Plane-parallel approximation**: The atmosphere consists of horizontally uniform layers.
+- **Multi-material atmospheric layers**: Layers can consist of multiple atmospheric materials simultaneously. A photon is assigned a material randomly when it is initialized and again when it crosses into a new layer. Each material has its own extinction coefficient, SSA and phase function.
+- **Custom Phase Functions**: Henyey-Greenstein and Rayleigh phase functions are already implemented in the simulation, but any custom user-defined function can be constructed using the `Scattering` class.
+- **Surface Reflections**: The surface consists of materials, each with its own albedo, a predefined BRDF reflection model (`Lambertian`, `Mirror`), and a `ProceduralMap` that outputs material ID based on spatial coordinates.
+- **Photon Properties**: Light is treated as monochromatic, non-polarized particles. During the simulation they can be scattered, reflected, or absorbed. 
+- **Incident Irradiance & Adjacency Effect**: Custom detectors allow measuring downward/upward incident flux at any arbitrary altitude - helpful for visualizing the adjacency effect.
+
+
+## Technical implementation:
+- The simulation uses `numpy` to simulate photons simultaneously in large batches.
+- The results are plotted using `matplotlib` and `seaborn` (e.g., photon paths, flux profile, 2D ground flux maps)
+- The code uses multiprocessing to run batches in parallel.
+  
+## Installation:
+- Using `uv` ([install uv](https://docs.astral.sh/uv/getting-started/installation/)):
+```bash
+uv tool install atmorad-py
+```
+- Using `pip`:
+```bash
+pip install atmorad-py
+```
+- Run the simulation:
+```bash
+atmorad --init
+atmorad simulation.toml
+```
+- Check `results/` directory for simulation artifacts.
+
+## Project Structure
+- `engine/`: Divides photons into batches and runs the simulation.
+- `physics/`: Contains a rotation function, scattering phase functions, reflection functions.
+- `environment/`: Keeps track of the environment. Contains `Scene`, `Atmosphere` and `Surface` classes.
+- `detectors/`: Provides functionality for tracking photons during the simulation and generates results.
+- `output/`: Handles results and figure generation.
+- `config/` and `builder.py`: Parses `.toml` configuration file and generates simulation context.
+- `cli.py`: Provides CLI for `atmorad`.
+
+## Customization
+You can define your own surface reflection algorithms and scattering phase functions using decorators as shown below:
+
+```python
+import numpy as np
+from atmorad import build_context, MCRadiationRunner, DataIO, ResultAnalyzer
+from atmorad import SurfaceReflection, register_reflection, orientation
+from atmorad import Scattering, register_scattering
+
+# 1. Register a custom surface reflection
+@register_reflection("custom-reflection")
+class CustomReflection(SurfaceReflection):
+    # Specify arbitrary custom parameters
+    def __init__(self, param_1, param_2):
+        self.param_1 = param_1
+        self.param_2 = param_2
+    def reflect(self, direction, rand_1, rand_2):
+        # Your custom reflection physics here
+        cos_theta = np.sqrt(rand_1)
+        sin_theta = np.sqrt(1.0 - rand_1)
+
+        # you can also use specified parameters
+        # self.param_1, self.param_2
+
+        phi = rand_2 * 2 * np.pi
+        cos_phi, sin_phi = np.cos(phi), np.sin(phi)
+        
+        return orientation(cos_theta, sin_theta, cos_phi, sin_phi)
+    
+# 2. Register a custom scattering phase function
+@register_scattering("custom-scattering")
+class CustomScattering(Scattering):
+    # Specify arbitrary custom parameters
+    def __init__(self, g, resolution=1000):
+        # Define a pdf array
+        self.g = g
+        cos_grid = np.linspace(-1, 1, resolution)
+
+        pdf = (1 - g**2) / (2 * (1 + g**2 - 2 * g * cos_grid) ** 1.5)
+
+        super().__init__(pdf_array=pdf, resolution=resolution)
+
+# 3. Run the simulation using custom names in your config
+if __name__ == "__main__":
+    context = build_context("simulation.toml")
+    runner = MCRadiationRunner(context)
+    runner.run()
+
+    # 4. Save and analyze results
+    results = runner.get_results()
+    outputs = DataIO(context.config)
+    analyzer = ResultAnalyzer(results, context.config)
+    
+    outputs.save_all_artifacts(analyzer, results)
+    outputs.save_metadata(context.config, results)
+    outputs.save_results(results)
+```
+In `simulation.toml` you can specify your defined scatterings and reflections:
+```toml
+[atmosphere_materials.custom-atm-material]
+ssa = 0.9
+scattering = {type = "custom-scattering", g=0.8} 
+
+[surface_materials.custom-surf-material]
+albedo = 0.5
+reflection = {type = "custom-reflection", param_1=2, param_2=1.3} # match param names defined in python
+```
+Then you can use your defined materials for atmospheric layers and surface maps:
+```toml
+[[layer]]
+z_range_km = [0, 2]
+materials = [{type = "custom-atm-material", weight = 1.0}]
+
+# ...
+
+[surface]
+name = "uniform"
+material = "custom-surf-material"
+```
+
+## References and Literature
+- (in Polish) Script for Lecture about [Radiative Processes in the Atmosphere](https://www.igf.fuw.edu.pl/~kmark/stacja/wyklady/ProcesyRadiacyjne/2013/WykladRadiacjaKlimat.pdf), Prof. K. Markowicz, Faculty of Physics, University of Warsaw, 2013.
+
+## Acknowledgments
+- This project was inspired by the lectures on *Radiative Processes in the Atmosphere* by Prof. K. Markowicz, Faculty of Physics, University of Warsaw.
+- Large Language Models were used for code debugging and learning best Python practices (e.g. `dataclasses`, `__init__.py` import interfaces, class responsibilities, config parsing).
+
+## Contributing
+Feel free to open an [Issue](https://github.com/dabrokarol/atmorad-py/issues) or submit a Pull Request if you'd like to contribute or report a bug.
+

atmorad_py-0.1.1/TODO.md

@@ -0,0 +1,34 @@
+<!-- Robię teraz parsofanie configa. -->
+<!-- Trzeba zrobić konstruktory stosownych klas i stworzyć rejestry mapujące -->
+<!-- Gdy będą gotowe, trzeba zrobić parser configa -->
+
+<!-- Drugie zadanie: Results: tworzenie results/data-nazwa/ dla każdego eksperymentu
+w folderze będzie config, matadane, wyniki, fig/{wykresy} -->
+
+<!-- Trzecie zadanie: argparse
+- --help-config - wypluwa informacje o tym co trzeba do configa
+- --config=path - ścieżka do configa żeby łatwo wywoływać program -->
+
+Czwarte zadanie:
+dodanie modeli odbicia i rozpraszania
+- RoughSpecularReflection
+
+Piąte zadanie:
+<!-- - zwróć uwagę na dzielenie przez zero w scene.py (żeby było np.inf, a nie NaN) -->
+- zaimplementuj wskaźnik ile fotonów przetwarza się na sekundę (może nawet do wykresów)
+
+<!-- Szóste zadanie:  -->
+<!-- - detektory klasa basedetector -->
+<!-- - w scenie (lub symulacji) znajdują się eventy -->
+<!-- - każdy detektor dostaje pozycje i kierunki fotonów, które biorą udział w evencie -->
+
+<!-- BUG:
+energia się nie dodaje -->
+
+Zadanie:
+Napisać mega basic testy
+
+Zadanie:
+Pobawić się
+
+Zadanie:

atmorad_py-0.1.1/example.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+from atmorad import build_context, MCRadiationRunner, register_reflection, SurfaceReflection, orientation, Scattering, register_scattering, DataIO, ResultAnalyzer, rotate
+
+@register_reflection("my-example-reflection")
+class ExampleReflection(SurfaceReflection):
+    def reflect(self, direction, rand_1, rand_2):
+        # your reflection code
+    
+        return orientation(cos_theta, sin_theta, cos_phi, sin_phi)
+        
+@register_reflection("lambertian")
+class LambertianReflection(SurfaceReflection):
+    def reflect(self, direction, rand_1, rand_2):
+        phi = rand_2 * 2 * np.pi
+
+        cos_theta = np.sqrt(rand_1)
+        sin_theta = np.sqrt(1.0 - rand_1)
+
+        cos_phi = np.cos(phi)
+        sin_phi = np.sin(phi)
+        return (rotate())
+        return orientation(cos_theta, sin_theta, cos_phi, sin_phi)
+    
+@register_scattering("my-example-scattering")
+class ExampleScattering(Scattering):
+    def __init__(self, example-param, )
+    
+@register_scattering("hg")
+class HenyeyGreensteinScattering(Scattering):
+    def __init__(self, g: float, resolution=1000):
+        self.g = g
+        cos_grid = np.linspace(-1, 1, resolution)
+
+        if np.isclose(g, 1.0, atol=1e-9):
+            pdf = np.isclose(cos_grid, 1.0, atol=1e-9).astype(float)
+        elif np.isclose(g, -1.0, atol=1e-9):
+            pdf = np.isclose(cos_grid, -1.0, atol=1e-9).astype(float)
+        else:
+            pdf = (1 - g**2) / (2 * (1 + g**2 - 2 * g * cos_grid) ** 1.5)
+
+        super().__init__(pdf_array=pdf, resolution=resolution)
+        
+context = build_context("simulation.toml")
+runner = MCRadiationRunner(context)
+runner.run()
+
+results = runner.get_results()
+
+outputs = DataIO(context.config)
+analyzer = ResultAnalyzer(results, context.config)
+outputs.save_all_artifacts(analyzer, results)
+outputs.save_metadata(context.config, results)
+outputs.save_results(results)

atmorad_py-0.1.1/examples/adjacency_effect.toml

@@ -0,0 +1,36 @@
+[metadata]
+experiment_name = "adjacency001"
+description = "Demo showcasing adjacency effect"
+
+[engine]
+num_photons = 1_000_000
+batch_size = 100_000
+cpu_cores = 4
+
+[source]
+theta_sun_deg = 30
+
+[geometry]
+domain_size_x_km = 100
+domain_size_y_km = 100
+
+[detectors]
+num_full_paths = 0
+incident_flux_heights_km = [1e-5, 4.0]
+
+[output]
+save_incident_flux_maps = true
+overwrite = true
+save_plots = true
+
+
+[[layer]]
+z_range_km = [0, 4]
+materials = [
+    {type = "dark-clouds", weight = 1.0}
+]
+
+[surface]
+name = "split-half-x"
+material_left = "snow"
+material_right = "ocean"

atmorad_py-0.1.1/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "atmorad-py"
+dynamic = ["version"]
+description = "A 3D monte carlo simulation of Atmospheric Radiative Transfer"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+  { name = "Karol Dąbrowski", email = "atmorad@kdabr.com" }
+]
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+    "numpy>=1.26.0",
+    "matplotlib>=3.5.0",
+    "seaborn>=0.11.0",
+    "cmocean>=2.0.0",
+    "tqdm>=4.60.0",
+]
+
+[project.scripts]
+atmorad = "atmorad.cli:main"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/atmorad"]
+include-package-data = true
+
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+    "ruff>=0.15.13",
+]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = ["E501"]

atmorad_py-0.1.1/simulation.toml

@@ -0,0 +1,98 @@
+[metadata]
+experiment_name = "demo001"
+description = "A demo simulation."
+
+[engine]
+num_photons = 100_000
+batch_size = 100_000
+random_seed = 42
+cpu_cores = 4
+
+[source]
+theta_sun_deg = 30
+phi_sun_deg = 0 
+wavelength_nm = 530
+
+[geometry]
+domain_size_x_km = 100
+domain_size_y_km = 100
+boundary_condition = "periodic"
+
+[detectors]
+vertical_flux_resolution_km = 1.0
+map2d_resolution_km = 1.0
+num_full_paths = 200
+incident_flux_heights_km = [1e-5, 4.0]
+
+[output]
+save_absorption_maps = true
+save_incident_flux_maps = true
+save_vertical_profile = true
+save_photon_paths = true 
+save_heating_rates = true
+save_plots = true
+overwrite = true
+path = 'results'
+
+[surface_materials]
+[surface_materials.snow]
+albedo = 0.85
+reflection = {type = "lambertian"}
+[surface_materials.ocean]
+albedo = 0.01
+reflection = {type = "mirror", roughness = 0.0}
+
+
+[atmosphere_materials]
+[atmosphere_materials.air]
+extinction_coeff_per_km = 0.01
+ssa = 0.9
+scattering = {type = "rayleigh"} # rayleigh, hg, isotropic
+[atmosphere_materials.light-clouds]
+extinction_coeff_per_km = 1
+ssa = 0.999999
+scattering = {type = "hg", g = 0.85}
+[atmosphere_materials.dark-clouds]
+extinction_coeff_per_km = 5
+ssa = 0.999999
+scattering = {type = "hg", g = 0.85}
+
+# Define atmospheric structure from bottom to top
+[[layer]]
+z_range_km = [0, 2]
+materials = [{type = "air", weight = 1.0}]
+
+[[layer]]
+z_range_km = [2, 6]
+materials = [
+    {type = "air", weight = 0.1},
+    {type = "dark-clouds", weight = 0.9}
+]
+
+[[layer]]
+z_range_km = [6, 10]
+materials = [{type = "air", weight = 1.0}]
+
+# --- Surface Map Configuration ---
+# Choose one surface map by commenting out the others
+
+# [surface]
+# name = "uniform"
+# material = "snow"
+
+# [surface]
+# name = "split-half-x"
+# material_left = "snow"
+# material_right = "ocean"
+
+# [surface]
+# name = "checkerboard"
+# tile_size_km = 10
+# material_a = "snow"
+# material_b = "ocean"
+
+[surface]
+name = "circle"
+radius_km = 20
+material_in = "snow"
+material_out = "ocean"