🔭 astrophysics

CARMApy: An Open-Source Python Framework for Simulating Microphysical Clouds in Planetary Atmospheres

This paper introduces CARMApy, a new open-source Python framework that wraps the legacy ExoCARMA Fortran code to simulate microphysical cloud processes in planetary atmospheres with enhanced speed and flexibility while maintaining consistency with previous results.

Original authors: Wolf Cukier, Diana Powell, Xi Zhang, Peter Gao, Dominic Samra, Vighnesh Nagpal

Published 2026-06-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Wolf Cukier, Diana Powell, Xi Zhang, Peter Gao, Dominic Samra, Vighnesh Nagpal

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the atmosphere of a distant planet as a giant, swirling kitchen where invisible ingredients (gases) are constantly trying to turn into solid clouds. Sometimes these clouds are made of rock, sometimes of metal, and sometimes of ice. Understanding exactly how these clouds form, how big the particles get, and where they float is crucial for figuring out what these alien worlds are actually like.

This paper introduces CARMApy, a new, free computer program designed to simulate this "cloud kitchen" for planets outside our solar system.

Here is a breakdown of what the paper says, using simple analogies:

1. The Problem: The "Old Recipe Book"

For nearly 50 years, scientists have used a powerful tool called CARMA to model these clouds. Think of the original CARMA as a legendary, complex recipe book written in a very old, difficult language (Fortran).

The Issue: Only a handful of expert chefs (scientists) know how to read this old book. It takes years of training just to figure out how to turn the pages and follow the instructions.
The Limitation: Because it's so hard to use, many researchers can't study these clouds, even though clouds change how we see planets.

2. The Solution: CARMApy (The "User-Friendly App")

The authors have built CARMApy, which is essentially a modern, easy-to-use "app" or "wrapper" that sits on top of that old, powerful recipe book.

How it works: It takes the heavy lifting of the old code and translates it into Python, a language that is much easier for modern scientists to read and write.
The Benefit: Now, researchers don't need to be master chefs in the old language to use the best recipes. They can just click buttons and run simulations to see how clouds form on alien worlds.

3. What Does the Program Actually Do?

CARMApy simulates the life cycle of cloud particles from the very beginning. It tracks them through five main "stages of life," much like tracking a drop of water in a storm:

Birth (Nucleation): It calculates how gas molecules randomly bump into each other and stick together to form the very first tiny specks of a cloud. It does this for two types: spontaneous birth (homogeneous) and birth on top of an existing "seed" particle (heterogeneous).
Growing Up (Condensation): It tracks how these specks grow larger as more gas sticks to them, or how they shrink (evaporate) if the air gets too hot.
Socializing (Coagulation): It simulates particles bumping into each other. Sometimes they stick together to form bigger clumps; sometimes they bounce off.
Moving Around (Transport): It calculates how gravity pulls these clouds down (sedimentation) and how wind or turbulence pushes them up (diffusion).
The Result: The program outputs a detailed map showing exactly how many cloud particles there are at every height, how big they are, and what they are made of.

4. The "Speed Upgrade"

One of the biggest claims in the paper is that this new version is faster.

The authors tested CARMApy against the old version (ExoCARMA 1.0).
The Result: The new code runs about 2 times faster on a single processor and nearly 4 times faster when using multiple processors at once.
Why it matters: It's like upgrading from a bicycle to a sports car. Scientists can run their simulations in minutes instead of hours, allowing them to test more ideas.

5. Does It Work? (The Benchmark)

The authors didn't just build the car; they drove it to make sure it goes the same direction as the old one.

They ran a test case involving a "Brown Dwarf" (a type of failed star) with specific cloud conditions.
The Verdict: The results from the new Python code were virtually identical to the old Fortran code. The differences were so tiny (like a fraction of a degree in temperature) that they are likely just due to the computer's math rounding errors, not actual mistakes.
Conclusion: The new tool is just as accurate as the old one but much easier to use and faster.

6. What Can You See?

The paper shows examples of what the program produces:

Cloud Maps: Visualizations showing the size of cloud particles at different heights in the atmosphere.
Spectra: Simulated light signatures. Since clouds change how a planet reflects or emits light, this helps astronomers know what to look for when they point telescopes (like the James Webb Space Telescope) at these planets.
2D Models: The code can even simulate clouds moving around a planet's equator, showing how clouds might look different on the "morning" side versus the "evening" side of a planet.

Summary

CARMApy is a new, open-source tool that makes it easy for scientists to simulate how clouds form on alien planets. It takes a powerful but difficult 50-year-old code, wraps it in modern, easy-to-use software, speeds it up significantly, and proves it gives the same accurate results as the original. It allows researchers to better understand the "weather" of worlds we have never visited.

Technical Summary of CARMApy: An Open-Source Python Framework for Simulating Microphysical Clouds in Planetary Atmospheres

Problem Statement
Clouds exert first-order influences on planetary atmospheric properties, affecting inferences regarding composition (e.g., C/O and Mg/Si ratios), thermal structure, and dynamics. However, uncertainties in cloud formation processes propagate significantly into these inferences. Existing cloud models often rely on simplifying assumptions that limit their physical fidelity. "Gray cloud" models prioritize efficiency over physical complexity, while Equilibrium Cloud Condensation (ECC) models assume instantaneous saturation and require prescribed particle size distributions with fitted parameters (e.g., $f_{sed}$ ) of unclear physical meaning. Even Moment-Method Kinetic Cloud (MMKC) models, which include more physics, still rely on prescribed functional forms for particle size distributions. These limitations hinder the ability to reproduce observed spectral features, particularly with the advent of high-resolution JWST data.

While the Community Aerosol and Radiation Model for Atmospheres (CARMA) is a well-validated bin-scheme model capable of resolving arbitrary particle size distributions from first principles, its legacy Fortran implementation presents a barrier to entry. The code requires significant expertise to operate, limiting its use to a small subset of researchers. There is a need for a user-friendly, accessible interface that retains the physical rigor of CARMA while enabling broader application across the exoplanet community.

Methodology
The authors present CARMApy, an open-source Python wrapper for ExoCARMA 2.0, a modernized version of the CARMA 3.0 Fortran code. CARMApy is designed to be user-friendly, well-documented, and capable of running on standard hardware with multithreading support via OpenMP.

The core of the framework is a time-stepping, bin-scheme microphysical model that solves for particle size distributions across a user-defined grid of pressure levels and particle masses. The model simulates the following microphysical processes from first principles:

Nucleation: Both homogeneous (gas-to-particle) and heterogeneous (condensation on seed particles/CCN) nucleation are modeled using classical nucleation theory, including Zeldovich factors and shape factors for heterogeneous cases.
Growth and Evaporation: Modeled via diffusion of vapor molecules, corrected for non-continuum effects (Knudsen number), the Kelvin effect (curvature), and ventilation factors for moving particles.
Coagulation: Collision kernels account for Brownian motion, convective diffusion enhancement, and gravitational coalescence (differential settling). The model assumes particles stick or bounce based on empirical efficiencies but does not currently include fragmentation.
Transport: Vertical transport includes sedimentation (calculated across laminar, transitional, and turbulent regimes) and eddy diffusion.

Numerically, the code employs an operator-splitting method. Within each timestep, processes are applied sequentially: vertical transport, coagulation, nucleation/growth/evaporation, and finally gas depletion. Transport and diffusion are solved using the Piecewise Parabolic Method (PPM) to advect particles between bins. Coagulation and growth/evaporation are solved using semi-implicit schemes to ensure mass conservation and non-negative particle concentrations.

CARMApy includes built-in interfaces for:

Initialization: Setting chemical equilibrium abundances at the cloud base using pyFastChem and extending atmospheric profiles adiabatically.
Condensates: Supporting up to 10 default condensates (e.g., TiO $_2$ , Mg $_2$ SiO $_4$ ) with user-specified material properties (density, surface tension, saturation vapor pressure).
Post-processing: Generating spectra by calculating extinction, scattering, and asymmetry parameters via PyMieScatt and interfacing with PICASO for radiative transfer.
2D Simulations: A mode for modeling longitudinally varying cloud profiles (e.g., for Hot Jupiters) by advecting cloud columns around the equator.

Key Results
The authors benchmarked CARMApy against the legacy ExoCARMA 1.0 code using a 2000 K brown dwarf test case with TiO $_2$ and Mg $_2$ SiO $_4$ condensates.

Accuracy: The results were found to be consistent with previous versions. The total cloud and gas mass for each species agreed within relative differences of $\sim 3 \times 10^{-4}$ and $\sim 3 \times 10^{-5}$ , respectively. Emission spectra showed maximum absolute errors in brightness temperature of $\sim 0.3$ K (relative error $\sim 10^{-4}$ ), attributed to floating-point error propagation over tens of thousands of timesteps.
Performance: The Python wrapper, leveraging OpenMP multithreading, executed approximately 1.9 times faster in single-threaded mode and 3.8 times faster in multithreaded mode compared to the legacy ExoCARMA 1.0 code.
Outputs: The paper demonstrates the generation of various data products, including particle size distribution profiles, microphysical rate maps (nucleation, growth, evaporation), depleted gas abundance profiles, and limb-asymmetric transmission and emission spectra for 2D simulations.

Significance and Claims
The paper claims that CARMApy successfully democratizes access to high-fidelity microphysical cloud modeling. By wrapping a robust, half-century-old Fortran code in a modern Python interface, the authors enable researchers with minimal prior cloud modeling or Fortran expertise to simulate complex cloud physics. The framework is presented as a tool to better interpret high-resolution observations (such as those from JWST) by resolving arbitrary particle size distributions and capturing non-equilibrium effects that simpler models miss. The authors emphasize that while the code is a significant step forward, future work is needed to constrain material properties of cloud particles in exoplanet regimes and to incorporate additional physics such as fractal aggregates and radiatively active clouds. The code is released as open-source software with tutorials and documentation to facilitate community adoption.