FAQ

The SALOME platform is an open source software framework for pre- and post-processing and integration of numerical solvers from various scientific fields. CEA and EDF use SALOME to perform a large number of simulations, typically related to power plant equipment and alternative energy. To address these challenges, SALOME includes a CAD/CAE modelling tool, mesh generators, an advanced 3D visualization tool,  etc.

The SALOME platform is distributed under the GNU Lesser General Public License (LGPL) version 2.1. All products required by SALOME are distributed under the LGPL (or equivalent) or “free for non-commercial use” licence

SALOME provides SolverLab, which allows to solve partial differential equations. Other solvers dedicated to a specific domain are available in dedicated applications:

• salome_meca integrates the code_aster solver dedicated to structures and thermomechanics analyses
• salome_cfd integrates the code_saturne and neptune_cfd solvers dedicated to computational fluid dynamics (monophasic and multiphasic)

Other applications with non open-source codes are developed but not distributed on internet.

SALOME is developed and qualified on Linux and Windows. SALOME is built and tested on different Linux platforms: Red Hat, CentOS 7 and 8, Debian 9 and 10, Ubuntu 18 and 20, Fedora. If specific binaries are not distributed for your Linux platforms, you can use the generic “universal” binaries. These binaries are built on the CentOS 7 platform. The libraries needed to make the binaries work on other, newer platforms are included in the archive.

SALOME is a French acronym which stands for  “Simulation numérique par Architecture Logicielle en Open source et à Méthodologie d’Évolution”. In English this translates to    “numerical simulation with evolving methodologies over open source computing architectures”.

SAT is a tool used for maintenance and packaging of the SALOME platform. It facilitates the building on various Linux and Windows platforms of large software packages that rely on many prerequisites. The following features are supported:

• definition of the application content: which products (prerequisites, codes, modules) are needed and which versions are required.
• application configuration: how to get the source of the products, how to compile them, which options to use.
• preparation of the complete software: all necessary sources with the right versions are retrieved from git/svn/cvs repositories, or from already prepared tarballs.
• management of patches if some are needed to compile on specific platforms.
• management of the environment to be set up at compile time and at run time.
• automatic compilation of the complete application (the application with all its products).
• production of a launcher that sets up the environment and starts the application.
• packaging: creating binary and/or source packages to distribute the application on various platforms.

SAT is a Command Line Interface (CLI) based on the Python language. It is a suite of commands, which are detailed later in this documentation. These commands are used to perform operations on the application. SAT allows you to complete the commands using the provided complete_sat.sh script.

The SALOME platform relies on a large number of third party products, including Python, Qt, sip, PyQt, boost, swig, Open CASCASDE Technology, qwt, omniORB, Hdf5, Paraview. Depending on the platform, some third party products are embedded in the SALOME tarball, others are directly provided by the system (native products installed with yum or apt).

Before using or compiling SALOME for the first time, it is advisable to check if all the system requirements are installed. To do this, it is convenient to use the following SAT command, which will list the missing system dependencies:

./sat config SALOME-9.8.0 --check_system

For 3D visualization, it is recommended to use a dedicatied graphics card (NVIDIA or AMD RADEON), and to install the corresponding proprietary driver.

First, download SALOME for your specific operating system version. If your OS is not supported, you can use the “universal version”.

Extract the archive.

Then, check that the dependancies are installed on your OS:

./sat config SALOME-9.8.0 --check_system

Check that your graphic card is well configured for 3D rendering.

Then launch SALOME with:

./salome

More information is  available in the README file.

SALOME is built on Windows 10 with the Visual Studio 2017 compiler. It is important to choose a very short name for the installation directory, to avoid exceeding the PATH size limit (for example C:\SAL).

SALOME can be installed through an .exe install wizard or a .zip archive.

To launch the install wizard, double-click on it and follow the instructions. At the end of the installation, click on the launcher run_salome.exe to start SALOME.

If your company’s IT security policy forbid to install softwares with .exe files, we also provide SALOME in a .zip archive. To install it:

• Create a directory of maximum 4 letters at the root of your disk (for example C:\SAL)
• Go inside it and unzip SALOME;
• Go to the directory created by the previous action;
• Run SALOME by double-clicking on run_salome.bat or run_salome.exe or with command line.

 

The SALOME source code is included in the SALOME packages as tarballs in the ARCHIVES directory. To install the source code in the SOURCE directory, use the command:

./sat prepare SALOME-9.8.0

The SALOME source code can also be retrieved directly from the git repositories. More information on the gitweb page.

The SALOME source code is included in the SALOME packages and can be compiled, either partially (one or more products) or completely. For more information, follow the instructions in the README file contained in the package.

SALOME is a distributed system, which means that all the functionality of the application is exposed as objects and that each object can use any of the services provided by other objects in the system, or even by objects in other systems. The SALOME platform uses the CORBA middleware to allow the distribution of components over remote resources. Therefore, most SALOME components are defined as CORBA servers and implement a CORBA interface. They can be launched either in a dedicated server, or integrated in the main SALOME process. This possibility is exploited by the YACS module to couple computational codes. SALOME components that do not need CORBA are written with the SALOME “light” configuration. This configuration provides a GUI framework to write classical one-process GUI applications (SALOME light components). These components can be run separately or run in the same session as the full classic components.

With increasingly powerful computers, CORBA is becoming less useful in SALOME, apart from YACS and the code coupling use cases. When CORBA is not needed, an optimised mode has been developed to avoid launching CORBA session server. This mode, called SSL, will be the default mode from SALOME 9.9. With this mode, all code is executed within the main SALOME process. The user does not need to “kill” the servers after using SALOME. Debugging and testing is also easier.

To use this session-less mode for launching python scripts:

• either set the environment variable SALOME_EMB_SERVANT to 1. On Linux:

export SALOME_EMB_SERVANT=1

or on Windows:

SET SALOME_EMB_SERVANT=1

• or add in your python script:

salome.standalone()
salome.salome_init()

To test this session-less mode in the graphic user interface (only for some module in SALOME 9.8), launch SALOME with:

./salome sessionless

The study is a document in the GUI, an abstraction layer between the actual data in the document (probably remote data available via CORBA) and the presentation of the data (in the Object Browser). It contains a tree of data object instances.

Each module can publish its data in SALOME study to allow other components to access it. Publishing in the Study also allows the persistence of this data through the “Save Study” menu. Note that the persistence of complex data can also be ensured by special methods, such as the “Save graph” of the YACS module.

All features developed in C++ are mapped to the Python API and can be executed with Python. SALOME uses python for its power and simplicity. This feature is the strengh of the SALOME platform and allows the creation of scripts and the automation of complex use cases. Writing SALOME’s Python scripts is made easier by the “Python dump feature”: the user experiments with complex actions in GUI mode and then dumps them into a Python script. He can then extend and parameterise then. This mode of working is very efficient.

The user has several possibilities. It is possible to :

• run a script when launching the GUI:

  ./salome myscript.py

• execute a script when launching SALOME in TUI mode:

  ./salome -t -w1 myscript.py

-t means text mode,

-w1 means kill CORBA servers at the end of the script.

• load a python script inside the GUI, from the File menu.
• execute Python commands in the GUI’s built-in Python window.

It is possible to use both GUI and TUI while working with SALOME. The TUI interface is best suited for long calculations in batch mode. The results of the calculations can be checked using the GUI. The Python dump feature allows to experiment with actions with the GUI and to save these actions in a Python script, which can be replayed later. Advanced modules such as SHAPER are more suited to the GUI (especially the sketcher), but their actions can still be saved in Python scripts.

MEDCoupling is the SALOME library for processing meshes and numerical fields (input and output data for field physics oriented simulation codes). It provides several powerful features, which can be divided into four categories:

• Data movement: read/write from/to file, reduce, extract, duplicate, aggregate, compare, exchange data memory to memory across process.
• Data analysis: extract/gather information in data to transform it into a condensed workable data (not necessarily field linked) for further use.
• Data conversion: interpolate, project, repair, decimate, format conversion to couple multiple simulation codes.
• Data optimization for simulation code : renumbering, partitioning for multiprocessor codes.

Data persistence is based on the .med format which is part of the medfile product. medfile specifies the field and mesh standard. The files are written with the hdf5 library and support parallelism.

The med file documentation is provided by the FIELDS module: menu Help/User’s Guide/FIELDS module/MedFile This documentation is written in French and presents in particular the connectivity reference within the “Guides d’utilisation” (User’s guide).

The FIELDS module of SALOME provides the MEDCoupling library (a C++ library dedicated to the manipulation of meshes and fields consistent with the MED model) as well as a Graphical User Interface to access some common operations. It simplifies MED manipulations and also gives access to simplified MED Visualizations linked to the PARAVIS module. The module FIELDS provides the documentation of MEDCoupling and medfile libraries.

Just run the command:

./salome context   # create a bash session with the SALOME environment

It is possible to use some standalone modules of SALOME independently of the others. For example, you can run SALOME paraview :

paraview   # run paraview provided by SALOME

 

Since version 9.4, SALOME uses pip to manage the Python modules included in SALOME. SALOME users can therefore customize their Python with the module of their choice. Start by setting the necessary environment variables for SALOME, run the following command:

./salome context # create a bash session with the SALOME environment 

Then one can use pip as intended. For example, to add a module h5py to SALOME via pip:

python -m pip install h5py==2.10.0 --no-dependencies

Similarly, to remove a module via pip  that is no longer needed

python -m pip uninstall h5py

When SALOME is started, it launches a CORBA server at the beginning which sometimes is not killed at the end. If you see old SALOME processes, it is possible to clean them up with the following command:

./salome killall

Under Windows, you must execute the command:

call kill_salome.bat

 

Depending on your desktop environment, strings in SALOME can be too small or too large. This also affects the height of the icons. It is possible to adjust the font scale using the QT_FONT_DPI parameter. For example, to increase the size by 10%:

export QT_FONT_DPI=110

 

For a good display of the 3D views, it is recommended to have a dedicated graphics card (Nvidia or AMD) and to install the proprietary driver from the package manager of your Linux platform.

For those who wish to use SALOME remotely (via ssh, virtual machine, etc), we recommend using the command ./mesa_salome rather than ./salome to launch SALOME.  The generic SALOME (./salome) uses OpenGL for 3D view rendering, however OpenGL  is not fully supported by the X11 transfer needed during remote sessions. To solve this problem, ./mesa_salome uses Mesa which is an alternative OpenGL implementation that enables you to use SALOME while not using your GPU driver. The performance of ./mesa_salome is downgraded, but this command is fully compatible with the generic SALOME (./salome).

If you need to work on a remote computer frequently, and do not want to sacrifice performance, we recommend using TurboVNC to launch a remote desktop and VirtualGL to use the remote graphic card: vglrun ./salome.

SALOME 9 has been enhanced to be able to handle large data sets. All modules (SMESH, PARAVIS, MEDCoupling) now support 64-bit integer arithmetics (int64), which makes it possible to manage large meshes. The SMESH module  has been optimized to display such meshes (multi-threading) and now includes very efficient meshing algorithms (such as Gmsh Hextreme).