Stardis The MonteCarlo framework for coupled thermal problems
Stardis 0.14.0 is available
 Build from sources: git
Stardis is a thermal simulation framework for complex 2D and 3D environments, based on new MonteCarlo algorithms built from reformulations of the main heat transfer phenomena: conduction, convection and radiation. A set of crossrecursive 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 crossrecursion of the various MonteCarlo algorithms.
Refer to the Stardis consortium's service offer for longterm 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

Caliot et al.
(IJHMT 2024) 
Penazzi et al.
(Computer Physics Communications 2024) 
Bati et al.
(SIGGRAPH 2023) 
Tregan et al.
(PLOS ONE 2023) 
Villefranque et al.
(Science Advances 2022)
 Probe computation: Stardis will not compute the full temperature field of a system; instead, it can be used to focus on a specific spatial/temporal zone of the system.
 Reference method: the numerical uncertainty is a unique feature of stochastic methods. It can be reduced using a reformulation of the underlying integral for specific problems, and possibly using better suited sampling techniques. Ultimately, the numerical uncertainty can also be reduced by increasing the number of statistical samples. Any value of temperature (or flux) computed by Stardis must agree with the values computed by other tools, within the uncertainty range (and also within the limits of validity of the various assumptions used to derive the MonteCarlo algorithms used in Stardis). This can prove very useful in order to validate any result obtained by any thermal solver in a case when no analytic solution is available or when a physical intuition is impossible to achieve due to the complexity of the problem.
 Educational purposes: since the various probability sets used by the underlying MonteCarlo algorithms solely rely on the physics, thermal paths naturally explore the spatial and temporal zones of interest in the system. This can be a drawback in some situations (the paths will have a hard time exiting a highly conductive solid surrounded by nonconductive media) but is a major asset for the direct visualization of what contributes to a given result: the main sources of heat, what transfer modes are dominant, what are the main paths of heat transfer, etc.
 Sensitivity analysis: the Green functions of the system (estimated and stored during an initial MonteCarlo computation) can be reused for subsequent (very fast) postprocessing computations. This makes possible to explore the sensitivity of any given result to the variations of a boundary or initial condition, or internal power source. This technique is only a small part of a family of socalled "symbolic" MonteCarlo algorithms that extend the scope of sensitivity analysis to any thermal parameter (for instance: the conductivity of a given solid, a convective exchange coefficient or the emissivity of a solid).
The Stardis framework is structured around two main components. The first one, StardisSolver, is the core library that implements the MonteCarlo 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 StardisSolver, from input data describing the system to simulate (geometry, thermal properties, limit conditions, etc.) to heat transfer simulation and results postprocessing. See below for more information on each of these components.
StardisSolver
StardisSolver 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 StardisSolver library is currently used in the two following projects:
 Stardis application is the reference implementation of a complete workflow using StardisSolver.
 SYRTHES is the general thermal software developed by Électricité de France R&D.
The coupled MonteCarlo algorithms implemented into StardisSolver are based on the following hypothesis:
 Conduction: the discretization of thermal heat transfer in solids introduces the notion of a conductive path length within the MonteCarlo algorithm. Solutions obtained using this algorithm are formally exact at the limit of a null path length. In practice, this path length has to be adapted, at the individual solid level, so that its value is small compared to the typical length of the solid.
 Convection: fluid media are supposed to be isothermal, even if their temperature may vary with time. This hypothesis relies on the assumption of perfectly agitated fluids.
 Radiation: local radiative transfer is solved by an iterative numerical method (Picard algorithm) that requires the knowledge of a reference temperature field. At the basic level (one level of recursion), and using a uniform reference temperature field, this algorithm translates into the hypothesis of a linearized radiative transfer. Using a higher order or recursion makes possible to converge the result closer to the solution of a rigorous spectrallyintegrated radiative transfer (a difference of temperatures to the power 4 when integrated over the whole spectrum). The higher the recursion order, the better will be the convergence of the algorithm.
The remaining of this section describes the main functionalities provided by StardisSolver upon the aforementioned hypothesis.
Probe computation
StardisSolver 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 MonteCarlo method makes it possible to compute a numerical uncertainty (standard deviation of the weight distribution) over each result.
Flux computation
StardisSolver 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 MonteCarlo 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 MonteCarlo simulation. This information, known as the Green function, can then be used in a (very fast) postprocessing 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 nonstationary case).
Temporal dynamics analysis
StardisSolver can output the end of each path sampled during a MonteCarlo 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
StardisSolver 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 StardisSolver. 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 frontend 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 MonteCarlo 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 postprocess binary greenfunction 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 postprocess instead of a new MonteCarlo simulation is the tremendous improvement on computation time. Refer to its manual page page for more informations.
Installation
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 StarEngine
project: it provides CMake scripts that automate the download, the compilation
and deployment of the Stardis framework. This build procedure assumes the
following prerequisites:
 git source control.
 GNU Compiler Collection in version 7 or higher.
 CMake in version 3.1 or higher.
 OpenMPI 2 or higher if
distributed memory parallelism is enabled via the
ENABLE_MPI
variable of the build system.  Optionally, the AsciiDoc tool suite to generate the man pages of the reference documentation.
Build
Assuming that the aforementioned prerequisites are available, the build procedure is summed up to:
~ $ git clone b Stardis0.14.0 \ https://gitlab.com/mesostar/starengine.git Stardis0.14.0 ~ $ mkdir Stardis0.14.0/build; cd Stardis0.14.0/build ~/Stardis0.14.0/build $ cmake ../cmake DDEPLOY_STARDIS_CLI=ON DENABLE_MPI=ON ~/Stardis0.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
Stardis0.14.0
.
Run
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.
~ $ . ~/Stardis0.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 commandline to consult them. For example:
~ $ man stardis ~ $ man stardisinput ~ $ man stardisoutput ~ $ man sgreen ~ $ man sgreeninput ~ $ man sgreenoutput
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.
Package
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.
~/Stardis0.14.0/build $ make pkg ~/Stardis0.14.0/build $ ls package/Stardis0.14.0* # list packages
License
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.