STARDIS(1) | General Commands Manual | STARDIS(1) |

# NAME

`stardis`

—
statistical solving of coupled thermal systems

# SYNOPSIS

`stardis` |
[`-eghiv` ] [`-a`
diff_algo] [`-D`
path_type,files_name_prefix]
[`-d` file_base_name]
[`-F`
surface[,time[,time]]]
[`-G`
green_bin[,green_ascii]]
[`-I` initial_time]
[`-L` interface_probes]
[`-m`
medium_name[,time[,time]]]
[`-n` samples_count]
[`-o` picard_order]
[`-P`
x,y,z[,time[,time]][:side_indicator]]
[`-p`
x,y,z[,time[,time]]]
[`-R`
rendering_opt[:rendering_opt
...]] [`-S`
surface[,time[,time]]]
[`-s`
surface[,time[,time]]]
[`-t` threads_count]
[`-V` verbosity_level]
[`-X` output_rng]
[`-x` input_rng]
`-M` system |

# DESCRIPTION

`stardis`

solves coupled thermal systems:
conductive, convective and radiative transfers are solved together. The
physical model used for conduction is the local unstationary heat conduction
equation. Convection fluxes are assumed to be linear with temperature, and
radiation is assumed to be integrated over the whole thermal spectral range,
therefore radiative heat fluxes are proportionnal to a difference of
temperatures to the power 4. `stardis`

can deal with
complex geometries as well as high-frequency external solicitations over a
very long period of time, relative to the characteristic time of the system.
The provided system description should comply with the
stardis-input(5)
format.

`stardis`

can compute a thermal observable,
like temperature or flux, at a probe point and date or the mean value of an
observable over a given surface, volume, or time range. When a time range
`t1`,`t2` is provided, the computed
value is the mean value over the time range. To compute the value at a given
time, simply provide a single value `t`. In addition,
`stardis`

gives access to the evaluation of the
propagator (a.k.a the Green function). The propagator is of great value for
thermicist engineers as it gives some crucial information to analyse heat
transfers in the system. It helps engineers answer questions like
“Where from does the heat come at this location?”. Propagators
seamlessly aggregate all the provided geometrical and physical information
on the system in an unbiased and very-fast statistical model.

`stardis`

also provides two additional
functionalities: converting the
stardis-input(5)
geometry into a VTK file and rendering an infrared image of the submitted
system.

`stardis`

' algorithms are based on
state-of-the-art Monte Carlo method applied to radiative transfer physics
(Delatorre et al. 2014) combined with conduction's statistical formulation
(Kac 1949 and Muller 1956). Monte Carlo algorithms associated with
convective and conductive processes consist in sampling heat paths: this can
be seen as an extension of Monte Carlo algorithms that solve monochromatic
radiative transfer. The radiative transfer algorithm, based on the Picard
method, is also based on sampling radiative paths. However, since
`stardis`

solves the spectrally integrated radiative
transfer, the process can be recursive: secondary heat paths (convective,
conductive and radiative) may be necessary along the sampling of an initial
radiative path. The solution may not be sufficiently converged with a Picard
order equal to 1 in the presence of high temperature gradients. Increasing
the Picard order may be necessary in this case, until the required
convergence is reached.

One of the key features of `stardis`

is that
its algorithms are not based on a volumetric mesh of the system: only the
representation of its interfaces is required. And these are used only as a
description of the system, not as a basis for calculation, whose
discretization would have an impact on the accuracy of estimates.

`stardis`

implements mixed parallelism. On a
single computer (that is, a node), it uses shared memory parallelism while
it relies on Message Passing Interface (MPI) to parallelize calculations
between multiple nodes. `stardis`

can therefore be
launched either directly or via a process launcher such as
mpirun(1) to distribute the
calculation on several computers.

The options are as follows:

`-a`

`diff_algo`- Define the diffusion algorithm to be used when sampling a conductive path.
The default diffusion algorithm is
`dsphere`

.The diffusion algorithms are as follows:

`dsphere`

- Use the delta sphere algorithm, in which Brownian motion is
approximated by a random walk of random delta steps. The algorithm is
consistent with respect to the
`delta`parameter, i.e. Brownian motion is estimated exactly with`delta`tending towards 0. This numerical parameter`delta`is defined by solid and can be varied in time and space to handle the spatio-temporal temperature gradient without prohibitively increasing computation time (see stardis-input(1)). `wos`

- Use the Walk on Sphere algorithm to estimate Brownian motion. Although a numerical parameter is required to define the distance at which the random walk is considered to have reached the boundary, it can be assumed that this algorithm estimates Brownian motion without any bias with respect to numerical uncertainty. Indeed, the aforementioned distance can be set to the computer's numerical accuracy without any significant impact on performance.

`-D`

`path_type`,`files_name_prefix`- Write sampled heat paths of the given
`path_type`to files in VTK format, one file per path. Possible values for`path_type`are`error`

(write paths ending in error),`success`

(write successful paths), and`all`

(write all paths). Actual file names are produced by appending`files_name_prefix`and the path rank starting at index ‘`00000000`

’, and possibly followed by ‘`_err`

’ for failure paths (e.g. prefix00000000.vtk, prefix00000001_err.vtk) `-d`

`file_base_name`- Write the geometry to a file in VTK format along with various properties,
including possible errors. Also possibly write some problematic parts of
the geometry (if any) in OBJ format. Possible parts are overlapping
triangles, riangles with property conflicts, and triangles with merge
errors. The various file are all named after the provided base name. If
this option is used, no computation occurs.
Using this option in conjunction with an option that specifies a compute region (i.e.

`-F`

,`-S`

,`-s`

) has the effect to include the region in the VTK output. `-e`

- Use extended format to output Monte Carlo results. Can only be used in
conjunction with options that compute a single Monte-Carlo
(
`-F`

,`-m`

,`-P`

,`-p`

or`-s`

without options`-g`

or`-G`

). `-F`

surface[,`time`[,`time`]]- Compute the mean flux on a given 2D surface at a given time, the surface being defined as the front sides of the triangles in the provided STL file. These triangles are not added to the geometry, but must be part of it. Flux is accounted positive when going from the front side to the back side, at a single-triangle level. By default the compute time is INF. The surface does not need to be connex.
`-G`

green_bin[,green_ascii]- Compute the Green function at the specified time and write it to a binary
file. If a green_ascii file name is provided,
information on heat paths' ends is also written in this second file in
ascii csv format.
This option can only be used in conjunction with one these options:

`-p`

,`-P`

,`-m`

,`-s`

and cannot be used in conjunction with option`-D`

.The resulting file can be further used through the sgreen(1) command to apply different temperature, flux or volumic power values.

`-g`

- Compute the Green function at the specified time and write it in ASCII to
standard output. This option can only be used in conjunction with one
these options:
`-p`

,`-P`

,`-m`

,`-s`

and cannot be used in conjunction with option`-D`

. `-h`

- Output short help and exit.
`-I`

`initial_time`- Define initial time in seconds. It can take any value between +/- infinity. The default initial time is 0.
`-i`

- Disable internal radiative exchanges. External radiative exchanges are still processed, i.e. the external source.
`-L`

interface_probes- Defines a set of interface probes for which
`stardis`

calculates the temperature. The argument file lists the interface probe points. Each line of this file describes a probe point using the same grammar as that used to describe a single interface probe (see`-P`

option). In addition to this syntax, characters behind the hash mark (‘`#`

’) are considered comments and are therefore ignored, as are empty lines, i.e. lines with no characters at all or composed solely of spaces and tabs.Note that this option parallelizes the calculation of the probe list, and not the calculation of each individual probe. Its use is therefore more advantageous in terms of load distribution when the number of probes to be evaluated is large, compared with the cost of calculating a single probe point.

`-M`

system- Read a text file containing a possibly partial description of the system. Can include programs, media enclosures and boundary conditions. Media and boundaries can appear in any order, but programs must be defined before their first reference. Refer to stardis-input(5) for a full description of the file format. Can be used more than once if the description is split across different files.
`-m`

`medium_name`[,`time`[,`time`]]- Compute the mean temperature in a given medium at a given time. The medium name must be part of the system description. By default the compute time is INF. The medium region does not need to be connex.
`-n`

`samples_count`- Number of Monte Carlo realisations. By default, the number of realisations is 10000.
`-o`

`picard_order`- Determine the iteration level used with the Picard method to deal with
non-linear radiative transfer accross the model. By default
`picard_order`is set to 1. Note that a Picard order greater than 1 is incompatible both with Green computations and systems including volumic power sources or non zero flux at a boundary. `-P`

`x`,`y`,`z`[,`time`[,`time`]][:`side_indicator`]- Compute the temperature at the given probe on an interface at a given
time. If the probe is on an interface where a thermal contact resistance
is defined, it is mandatory to provide a side indicator (either
`FRONT`

,`BACK`

, or a medium name), as the temperature differs between the two sides. By default the compute time is INF. The probe is supposed to be on an interface and is moved to the closest point of the closest interface before the computation starts. The probe coordinates must be in the same system as the geometry. `-p`

`x`,`y`,`z`[,`time`[,`time`]]- Compute the temperature at the given probe at a given time. By default the compute time is INF. The probe must be in a medium. The probe coordinates must be in the same system as the geometry.
`-R`

`rendering_opt`[:`rendering_opt`...]- Render an infrared image of the system through a pinhole camera. One can
use all-default sub-options by simply providing the colon character
(‘
`:`

’) alone as an argument. Please note that the camera position must be outside the geometry or in a fluid.The rendering options are as follows:

`file=`

output_file- File name to use to write the infrared image to. If no file name is provided, the result is written to standard output.
`fmt=`

`image_file_format`- Format of the image file in output. Can be
`VTK`

, or`HT`

(see htrdr-image(5) and htpp(1)). Default`image_file_format`is HT. `fov=`

`angle`- Vertical field of view of the camera in [30,120] degrees. The default field of view is 70 degrees.
`img=`

`width`x`height`- Image definition. Default is 640x480.
`pos=`

`x`,`y`,`z`- Camera position. Default is 1,1,1 unless
`tgt`

is not defined, in which case the position is automatically calculated to ensure that the entire scene is visible. `spp=`

`samples_per_pixel`- Number of samples to solve the Monte Carlo estimation of each pixel. Default is 4.
`t=`

`time`,[`time`]- Rendering time. Default is INF,INF.
`tgt=`

`x`,`y`,`z`- Targeted position. Default is 0,0,0 unless
`pos`

is not defined, in which case the targeted position is automatically calculated to ensure that the entire scene is visible. `up=`

`x`,`y`,`z`- Upward vector that the top of the camera is pointing towards. Default is 0,0,1.

`-S`

surface[,`time`[,`time`]]- Compute the by-triangle mean temperature on a given 2D surface at a given time, the surface defined as the front sides of the triangles in the provided STL file. These triangles are not added to the geometry, but must be part of it. By default the compute time is INF. The surface does not need to be connex.
`-s`

surface[,`time`[,`time`]]- Compute the mean temperature on a given 2D surface at a given time, the surface being defined as the front sides of the triangles in the provided STL file. By default the compute time is INF. These triangles are not added to the geometry, but must be part of it. The surface does not need to be connex.
`-t`

`threads_count`- Advice on the number of threads to use. By default,
`stardis`

uses many threads as processor cores. `-V`

`verbosity_level`- Set the verbosity level. Possible values are
‘
`0`

’ (no message), ‘`1`

’ (error messages only), ‘`2`

’ (error and warning messages), and ‘`3`

’ (error, warning and informative messages). All the messages are written to standard error. Default is 1. `-v`

- Output version information and exit.
`-X`

output_rng- Write the random generator's internal state, as it is at the end of the computation, to the provided file.
`-x`

input_rng- Read the provided file and use its content to initialize the random
generator's internal state. Used in conjunction with the
`-X`

option, this can be used to ensure statistical independence between subsequent computations.

# EXIT STATUS

The `stardis`

utility exits 0 on
success, and >0 if an error occurs.

# EXAMPLES

Preprocess the system as described in scene
5.txt when intending to compute the mean flux on the triangles from
the file edge.stl, and write its geometry in the
file scene.vtk. Verbosity level is set to
`3`:

stardis -M "scene 5.txt" -F edge.stl -d -V 3 > scene.vtk

Compute the temperature at the probe point
`0`,`0.5`,`0` at
steady state. The system is read from the file
model.txt and the number of samples is set to
`1000000`:

stardis -M model.txt -p 0,0.5,0 -n 1000000

Compute the mean temperature in the medium
`med05` at
t=`100`s. The system is read
from the file model.txt and the result is output
with extended format (option `-e`

):

stardis -M model.txt -m med05,100 -e

Compute the temperature at the probe point
`0`,`0`,`0` at
t=`2500`. The system is read
from the 2 files media.txt and
bounds.txt, and the number of samples is set to
`1000000`:

stardis -M media.txt -M bounds.txt -p 0,0,0,2500 -n 1000000

Compute the mean temperature at the probe point
`1`,`2.5`,`0`
over the `50`,`5000` time range. The
system is read from the file model.txt:

stardis -M model.txt -p 1,2.5,0,50,5000

Compute 3 probe temperatures, ensuring statistical independence:

stardis -M model.txt -p 1,1.5,0,50,5000 -Xstate1 stardis -M model.txt -p 1,2.5,0,50,5000 -xstate1 -Xstate2 stardis -M model.txt -p 1,3.5,0,50,5000 -xstate2

Use mpirun(1) to
launch `stardis`

on several hosts defined in the
my_hosts file. Render the system as described in
scene.txt with default settings:

mpirun --hostfile my_hosts stardis -M scene.txt -R:

Render the system as described in scn.txt
at `100` seconds Using 2 samples per pixel for an image
of `800` by
`600` pixels saved in
htrdr-image(5) format
and all other settings set to their default values. The output is redirected
to the img.ht file. If the computation encounters
erroneous heat paths, they will be dumped to VTK files named
err_path_00000000.vtk,
err_path_00000001.vtk, etc. The image file is then
post-processed using htpp(1)
with default settings to obtain a png file:

stardis -M scn.txt \ -R t=100:spp=2:img=800x600:fmt=ht \ -D error,err_path_ \ > img.ht htpp -o img.pgn -v -m default img.ht

Compute the Green function that computes the temperature at the
probe point
`0`,`0`,`0` at
steady state. The system is read from the file
model.txt and the Green function is written to the
probe.green file and the heat paths' ends are
written to the probe_ends.csv file:

stardis -M model.txt -p 0,0,0 -G probe.green,probe_ends.csv

# SEE ALSO

htpp(1), mpirun(1), sgreen(1), htrdr-image(5), stardis-input(5), stardis-output(5)

Léa Penazzi et
al., Path integrals formulations leading to
propagator evaluation for coupled linear physics in large geometric
models, *Computer Physics Communications*,
294,
https://doi.org/10.1016/j.cpc.2023.108911,
2024.

Mégane Bati et
al., Coupling Conduction, Convection and Radiative
Transfer in a Single Path-Space: Application to Infrared Rendering,
*ACM Transactions on Graphics*, 4,
42,
https://doi.org/10.1145/3592121,
August 2023.

Jean Marc Tregan et al.,
Coupling radiative, conductive and convective
heat-transfers in a single Monte Carlo algorithm: A general theoretical
framework for linear situations, *PLOS ONE*,
4, 18,
https://doi.org/10.1371/journal.pone.0283681,
2023.

Jérémie Delatorre
et al., Monte Carlo advances and concentrated solar
applications, *Solar Energy*,
103,
https://doi.org/10.1016/j.solener.2013.02.035,
653--681, 2014.

Abdolhossein Haji-Sheikh
and Ephraim Maurice Sparrow, The
floating random walk and its applications to Monte-Carlo solutions of heat
equations, *SIAM Journal on Applied Mathematics*,
2, 14,
370--389, 1966.

Mervin E Muller,
Some continuous Monte Carlo methods for the Dirichlet
problem, *The Annals of Mathematical Statistics*,
569--589, 1956.

Mark Kac,
On distributions of certain Wiener functionals,
*Transactions of the American Mathematical Society*,
1, 65,
1--13, 1949.

# STANDARDS

*The VTK User's Guide*,
*Kitware, Inc*, 11,
470--482, 2010,
Simple Legacy Formats.

OpenMP Architecture Review Board, OpenMP C and C++ Application Interface, March 2002, version 2.0.

Message Passing Interface Forum, MPI-2: Extensions to The Message-Passing Interface, July 1997.

Marshall Burns, The StL Format: Standard Data Format for Fabbers, https://www.fabbers.com/tech/STL_Format, 1993.

July 18, 2024 | UNIX |