Stardis The Monte-Carlo framework for coupled thermal problems

Stardis 0.14.0 is available

Stardis is a thermal simulation framework for complex 2D and 3D environments, based on new Monte-Carlo algorithms built from reformulations of the main heat transfer phenomena: conduction, convection and radiation. A set of cross-recursive algorithms have then been derived, and result in the simulation of "thermal paths" that explore space and time until a boundary condition or an initial condition is found. The key concept here is that heat transfer phenomena are not considered separately but are naturally coupled via the cross-recursion of the various Monte-Carlo algorithms.

Refer to the Stardis consortium's service offer for long-term advices on its use, contribute to orientation choices and interact with its developers and other users.

Beyond its use as a regular thermal simulation tool, the Stardis framework explicitly targets engineers, researcher, teachers or students wishing to fully appropriate the statistical formulation of heat transfer, from theoretical concepts to practical implementation. The complete Stardis framework is thus released under free licenses that guarantee the users the ability to freely use, study, modify or extend the complete source code according to their needs.

Despite its specific advantages, Stardis is not meant to fully replace already well established and highly validated thermal simulation tools. Instead, it can be seen as an additional tool that can be useful for various purposes:

Related articles

The Stardis framework is structured around two main components. The first one, Stardis-Solver, is the core library that implements the Monte-Carlo algorithms. The second one is the Stardis application, a command line tool that can be seen as a reference implementation of a complete workflow relying on Stardis-Solver, from input data describing the system to simulate (geometry, thermal properties, limit conditions, etc.) to heat transfer simulation and results post-processing. See below for more information on each of these components.


Infrared timelapse animation of a chip and its heatsink covering a 14-second period of time. Computed using the stardis infrared rendering feature, one image per simulated second. Acknowledgment to Léa Penazzi and Anne Castelan for the scene geometry (also available in Stardis: Starter Pack) actually used in an upcoming research article, and to Simon Eibner who computed the animation.

Stardis-Solver is the core library of Stardis: it simulates coupled convecto - conducto - radiative heat transfers by sampling thermal paths that explore space and time until a boundary condition or an initial condition is met. Note that this path formulation does not require any volumetric mesh: in addition of the thermal properties and the limit/boundary conditions, only the geometry defining the contours of the objects is necessary.

The Stardis-Solver library is currently used in the two following projects:

The coupled Monte-Carlo algorithms implemented into Stardis-Solver are based on the following hypothesis:

Stardis computation time as function of geometrical refinement. Both the standard Monte-Carlo computation and the Green function construction and usage are insensitive. In this example, once constructed, using the Green function with any new set of sources is 103 times faster than Monte-Carlo.

The remaining of this section describes the main functionalities provided by Stardis-Solver upon the aforementioned hypothesis.

step sin pulse
Temporal dynamics analysis of a solid cube which has temperatures imposed on its left and right sides, and has adiabatic boundaries elsewhere. The center temperature is the result of a simple postprocess of a single Monte-Carlo computation.

Probe computation

Stardis-Solver computes the temperature at any given position (spatial and temporal). The main idea is that thermal paths start from this probe position, and scatter in space while going back in time, until a (spatial) boundary condition or a (temporal) initial condition is met. In addition to the value of temperature, using a Monte-Carlo method makes it possible to compute a numerical uncertainty (standard deviation of the weight distribution) over each result.

Flux computation

Stardis-Solver can compute the flux over any surface (or group of surfaces) at any time. Alternatively, it can also compute the total energy output from a solid element where an internal source of power must be taken into account.

Green function

The value of temperature computed at a probe position is no more than the mean of the Monte-Carlo weights of a set of thermal paths. In practice: when no internal power source has to be considered, the weight of any given thermal path is the temperature of the boundary or initial condition that has been reached; when internal power sources or imposed fluxes are taken into account, additional contributions to the weight must be continuously evaluated by the thermal conduction algorithm, but these contributions are proportional to the local dissipated power and imposed flux.

In any case, the position and date at the end of each thermal path (and also accumulation coefficients) can be stored during a first complete Monte-Carlo simulation. This information, known as the Green function, can then be used in a (very fast) post-processing step to compute all required results for different boundary and initial conditions (and also different internal power sources and imposed flux).

Infrared rendering

Stardis can render a scene in infrared without prior knowledge of the temperature field. Thermal paths that start at the camera in radiative mode propagate through the model, possibly in conductive, convective or radiative mode until reaching a boundary condition (or an initial condition in a non-stationary case).

Temporal dynamics analysis

Stardis-Solver can output the end of each path sampled during a Monte-Carlo computation, including position, elapsed time, and boundary/medium ID. This not only allows to weight the contribution of each boundary or initial condition to the result, but also gives the temporal dynamics of these contributions.

Thermal path visualization

Stardis-Solver can output the complete history of a set of thermal paths for later visualization. In addition to positions and dates, physics data is stored along thermal paths, such as the type of heat transfer phenomenon involved at each step, the accumulated power and flux, etc.

Stardis CLI tools

The stardis framework includes Command Line Interface (CLI) software, namely stardis and sgreen, to use along with Stardis-Solver. They make it easy to exploit the features of the solver.

The stardis CLI

The main CLI tool of the Stardis framework is stardis. It is a barebone front-end to the stardis solver. Depending on the provided command line arguments, it simulates a thermal system described through a simple text file and geometry files and produces various types of output, from simple Monte-Carlo results to infrared images or Green functions. Refer to its manual page page for more informations.

The sgreen CLI

The only purpose of sgreen is to post-process binary green-function files produced by the stardis CLI. It allows to apply a set of values to the initial and boundary conditions as well as the power and flux sources of the model to produce the same result a new simulation would produce. The obvious benefit of using the sgreen post-process instead of a new Monte-Carlo simulation is the tremendous improvement on computation time. Refer to its manual page page for more informations.


The installation of Stardis consists of compiling the solver and the command line tools directly on the target machine. The easiest way is to use the stardis branch of the Star-Engine project: it provides CMake scripts that automate the download, the compilation and deployment of the Stardis framework. This build procedure assumes the following prerequisites:


Assuming that the aforementioned prerequisites are available, the build procedure is summed up to:

~ $ git clone -b Stardis-0.14.0 \ Stardis-0.14.0
~ $ mkdir Stardis-0.14.0/build; cd Stardis-0.14.0/build
~/Stardis-0.14.0/build $ cmake ../cmake -DDEPLOY_STARDIS_CLI=ON -DENABLE_MPI=ON
~/Stardis-0.14.0/build $ make

Note that on CMake configuration step, we define the variables DEPLOY_STARDIS_CLI and ENABLE_MPI to enable the installation of the Stardis CLI tools and support for distributed parallelism via MPI.

By default Stardis is installed in the local subdirectory of Stardis-0.14.0.


Before running stardis, you must first run the stardis.profile script once in the current POSIX shell to update its environment variables. Then you can run the stardis program and check out its reference documentation.

~ $ . ~/Stardis-0.14.0/local/etc/stardis.profile
~ $ stardis -h

We point out that the stardis.profile script must be run in each new POSIX shell in which you want to give access to the Stardis installation.

If the AsciiDoc tool suite was installed on make invocation, the reference documentation should be available through manual pages. Use the man command-line to consult them. For example:

~ $ man stardis
~ $ man stardis-input
~ $ man stardis-output
~ $ man sgreen
~ $ man sgreen-input
~ $ man sgreen-output

Refer to the Stardis: Starter Pack to quickly run a thermal simulation through the stardis CLI; this archive provides input data and scripts and is a good starting point to begin with the Stardis framework.


Once built, the Stardis installation can be packaged in an archive that can then be deployed on compatible systems, i.e. systems whose C library is compatible with the one available on the system used to build Stardis.

~/Stardis-0.14.0/build $ make pkg
~/Stardis-0.14.0/build $ ls package/Stardis-0.14.0* # list packages


Stardis is free software released under the GPLv3+ license: GNU GPL version 3 or later. You can freely study, modify or extend it. You are also welcome to redistribute it under certain conditions; refer to the license for details.