SALOME is free software that provides a generic platform for Pre and Post-Processing for numerical simulation. It is based on an open and flexible architecture made of reusable components available as free software.
It is open-source (LGPL), and you can download both the source code and the executables from the site www.salome-platform.org.
Salome Platform:
· Supports interoperability between CAD modeling and computation software (CAD-CAE link)
· Makes easier the integration of new components on heterogeneous systems for numerical computation
· Sets the priority to multi-physics coupling between computation software
· Provides a generic user interface, user-friendly and efficient, which helps to reduce the costs and delays of carrying out the studies
· Reduces training time to the specific time for learning the software solution which has been based on this platform
· All functionalities are accessible through the programmatic integrated Python console
SALOME platform is distributed under LGPL license (GNU Lesser General Public License). Please see http://www.gnu.org/licenses/lgpl.html
Possessing the source code of the platform, you can freely modify it for your internal purposes.
However, you can copy and distribute such modifications only provided that you meet the conditions stated in the LGPL license:
· The modified work must itself be a software library.
· You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.
· You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.
Yes, you can. However, you can charge the price only for your module, while SALOME itself is free.
You must give prominent notice with each copy of the distribution that Salome is used in it and that Salome and its use are covered by LGPL license.
All products required by SALOME are distributed under LGPL license (or similar) or “free for non commercial usage” licenses.
No, there is no solver which comes with SALOME platform, but there are some solvers which can be used with it transparently. For example Code_Aster (please visit http://www.code-aster.com/). Also there is a site http://www.caelinux.com which provides a special Linux distribution including SALOME, Code_Aster and other free solvers.
Currently there is no public Windows version of SALOME platform.
Release notes for SALOME provide a list of platforms where SALOME is qualified. Also there is some useful information about SALOME porting on other Linux systems on Salome forum (http://www.salome-platform.org/forum)
Please contact our support team through http://www.salome-platform.org/contact/ to have more information about available services.
Yes, SALOME platform is qualified on Mandriva 2006 64 bit Linux.
You can download the Installation Wizard with binary distribution from http://www.salome-platform.org/download section.
Install Wizard (see 2.1) includes the sources of SALOME platform.
There is runInstall script in the root folder of the Installation Wizard archive. This script runs GUI interface of the installation procedure or runs batch installation.
There is a README file with useful information on how SALOME is built, run, etc., in the root folder of the Installation Wizard archive. Another README file describing the Installation Wizard itself, the launching procedure and the meaning of optional parameters is located in /doc/ folder.
Successful compilation and execution of Salome platform requires quite a number of third party products, including, but not limited to: gcc, tcltk, Python, Qt&msg2qm, Sip, PyQt, Boost, Swig, Open CASCASDE Technology, Qwt, OmniORB, Hdf, Med, Vtk, Numeric, Graphviz, Doxygen, NETGEN and docutils.
All these products are free software and distributed together with Salome platform.
More information about the versions of the products required for a particular Salome version can be found in http://www.salome-platform.org/download/ section.
Naturally, all prerequisites are necessary and should be installed on your PC. You can easily install them using SALOME Install Wizard
Execution of Salome platform requires tcltk, Python, Qt, PyQt, Boost, Swig, Open CASCASDE Technology, Qwt, OmniORB, Hdf, Med, Vtk and NETGEN.
It is recommended to use NVIDIA GeForce card, better starting from GeForce 4. However SALOME works on Radeon cards as well. Gauss points presentations in Post-Pro module require that your video card could support Point Sprite OpenGL specification.
Salome Platform execution requires 512Mb RAM (1024Mb recommended) and at least 500Mb of swap space. Salome full installation requires ~ 600Mb of disk space, but during the installation you will need 1Gb of free disk space.
Salome is permanently tested on Mandriva 2006 32bit; Mandriva 2006 64bit; Debian Sarge 3.1 and Mandrake 10.1 platforms. Salome is not tested but is known to run successfully on RedHat Enterprise 4; RedHat Scientific 4.2 and RedHat Scientific 4.3 platforms.
The best way is to use “build.sh” script supplied with SALOME Installation Wizard. However you can build a custom SALOME module using the standard GNU rules (“build_configure, configure, make, make install)
Use “build.sh –h” to see all possible options to build custom module separately.
Such errors appear because the installation of some NVIDIA drivers creates wrong system files.
It means that you haven't installed some mandatory products during the installation procedure.
Some packages of SALOME needs FORTRAN compiler. Pre compiled binary distribution is linked with it, however on some systems this RPM package is absent. It is necessary to install it additionally.
If you compile SALOME from sources, it may use other FORTRAN compiler, native for your system, for example gfortran on Mandriva 2006 64 bit.
Study is a document within GUI, an abstraction layer between actual document data (probably, remote data available through CORBA) and data presentation (in the Object Browser). It contains a tree of Data Object instances.
SALOME is a distributed system, which means that all functionality of the application is exposed as objects and each object can use any of the services provided by other objects in the system, or even objects in other systems. The client components can also create objects that behave in server-like roles. Most of SALOME modules with the exception of Light modules are defined as CORBA servers and can be run on distributed computers.
SALOME supports two development languages: C++ and python. Developers can write custom modules using these two languages. Most of the standard SALOME modules are C++ modules. Some python modules can be found in the EXAMPLES (PY_HELLO or RANDOMIZER)
Module can publish their data in SALOME study to provide access to them for other components. Also publishing in the Study provides persistence of such data (not in all cases, persistence of complex data is provided by special methods).
When a developer develops a new module, it inherits some virtual methods (trough IDL interfaces) like PublishInStudy. This redefined method provides a general way of publishing of custom objects in the Study tree. Also to provide persistence module should inherit Driver interface (and should redefine some of its methods).
SALOME has embedded python console, where the user can lunch python scripts. Many SALOME functionalities are mapped to python and can be run using python. This is automation of SALOME functions. Some useful examples are placed in XXX_SRC/src/XXX_SWIG packages (where XX is name of module, for example GEOM) or in MODULE_NAME/bin/salome in binary distribution.
Text User Interface (TUI) – is a special API in python which provides access to the functionalities of SALOME modules. This API can be used for writing scripts for calculation in batch mode.
It is possible to use both GUI and TUI working with SALOME. TUI interface is most suitable for long calculations in batch mode. Then the calculation results can be controlled using GUI.
Most SALOME components are written based on CORBA middleware. Thus they have servers inside. Such servers can be run in special processes or inside the main process (collocated mode).
You can use the “light” SALOME configuration if you don’t need CORBA in the application. This configuration provides a GUI framework to write classical one-process GUI applications (SALOME light components). Such components can be run separately or can work together in the same session with classical full components.
The light configuration of SALOME does not depend on CORBA. There is an example of light component – “LIGHT_SRC” coming with SALOME Install Wizard.
If you develop a simple pre—post processor which does not need standard SALOME modules, like Geometry, Mesh, etc., but you have a GUI based on qt, you can organize it as a light SALOME module.
These modules provide some samples of how to write your own components based on SALOME. These are HELLO_SRC (C++ SALOME component), PYHELLO_SRC (Python SALOME component), LIGTH_SRC (light module of SALOME), SIERPINSKY_SRC and RANDOMIZER_SRC. The latter two are C++ and python components, which show interaction between modules.
After the SALOME installation, the procedure creates two environment files “salome.sh” or “salome.csh”. You have to source this environment in shell.
You have to call "runSalome' command after the definition of the environment”
Some SALOME modules can run in two different modes – embedded and standalone. In the first mode CORBA servers of this module are run inside the main GUI session process. In the second mode they are run as separate processes (Container). The container can be run on different hosts, which provides a distribution of servers.
There is xml configuration in $HOME, for example, .SalomeApprc.3.2.6. There are “embedded” and “standalone” xml tags, where the necessary servers are placed.
By default CORBA naming server starts in port 2810. However if this port is busy, the launh procedure finds the next free port.
It is necessary to call “killSalome.py” procedure to kill all running servers and services (like omniNames etc) after you exit from GUI session. “killSalomeWIthPort.py” should be used if you have several sessions running on different ports. You should input the name of the port as argument. In this case only the processes corresponding to the configuration of the port are shut down and other processes are still being executed.
To launch Salome without GUI, use “runSalome –t” command: only the necessary servers are launched (without GUI) and the python console is also active enabling to load TUI scripts.
To launch a group of chosen Salome modules, use the command “runSalome –modules=XXX, YYY”, where XXX and YYY are modules. You can use –h command to display help of runSalome script.
To activate any Salome module, click at the corresponding button in the toolbar.
There is no possibility to activate the GUI of a certain module from Salome TUI interface. However, it is possible to use the functions of the module in batch mode, for this:
To activate Geometry module run SALOME via "runSalome -t" command, then type in the terminal (start python interpreter):
import salome, GEOM; salome.salome_init()
geom = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
geom = geom._narrow(GEOM.GEOM_Gen)
To activate Mesh module run SALOME via "runSalome -t" command, then type in the terminal (start python interpreter):
import salome, SMESH; salome.salome_init()
mesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
mesh = mesh._narrow(SMESH.SMESH_Gen)
To activate Post-Pro module run SALOME via "runSalome --gui" command, then type in the terminal (start python interpreter):
import salome, VISU; salome.salome_init()
visu = salome.lcc.FindOrLoadComponent("FactoryServer", "VISU")
visu = visu._narrow(VISU.VISU_Gen)
To activate Supervisor module run SALOME via "runSalome -t" command, then type in the terminal (start python interpreter):
import salome, SUPERV; salome.salome_init()
superv = salome.lcc.FindOrLoadComponent("FactoryServer", "SUPERV")
It means that you have not set the environment for your module, or that this module does not have a GUI interface and can be used only in TUI mode.
The notion of shape is completely presented in OpenCASCADE technology documentation (http://www.opencascade.org)
Geometry module currently supports BREP (native OCCT format), STEP (API 214), IGS (up to 5.3 version) and STL formats. There is also a commercially available CATIAV5 plug-in.
The term point presents the lowest level of abstraction in geometry, an entity that has a location in space or a plane but no extent.
The term vertex means a corner of
· an angle: the point where two line segments join or meet, where two lines cross (intersect), or any appropriate combination of rays, segments and lines that result in two straight "sides" meeting at one place.
· a polygon: any point on the polygon where two sides (line segments) meet and connect.
· a polyhedron: any point where three or more edges meet and connect to each other. The edges are the connections (line segments as shared sides) of two or more faces (polygons).
· for curves a vertex is a point on the curve with a local minimum or maximum of curvature.
In Salome most 2D and 3D objects can be defined through a number of vertices.
This function serves for testing purposes; it loads «GEOM_usinggeom.py” script which builds different shapes.
To import a STEP file using TUI use commands geompy.ImportSTEP(full_path_to_file) or geompy.Import(full_path_to_file, "STEP").
To export to IGES a shape from Geometry use commands
geompy.ExportIGES(geometry, full_path_to_file_to_export) - exports to "iges-5.1" format, or
geompy.Export(geometry, full_path_to_file_to_export, "IGES") - exports to "iges-5.1" format, or
geompy.Export(geometry, full_path_to_file_to_export, "IGES_5_3") - exports to "iges-5.3" format
It is possible to build a solid shape from a 2D geometry using the Extrusion operation. Select this operation from the toolbar or the menu and define the Base Shape and the direction by a vertex or two points.
Multi-translation is a duplication of a selected object in the chosen direction. It is possible to indicate the Vector of translation the Step, i.e. the distance between the copies and the Number of copies. Double Multi-translation is a duplication of a selected object in two chosen directions, which creates a square field of copies. It is possible to define the Vector, the Step and the Number of copies for both directions.
Multi-rotation creates several geometrical objects rotated in one or two dimensions basing on the initial geometrical object. It is possible to define the Shape to be rotated, the Axis of rotation and the Number of Times the shape must be rotated. Rotation Angle will be 2*PI/NbTimes.
Double Multi-rotation rotates the given Object around the given Axis on the given Angle the given Number of Times and multi-translates each rotation result.
To define a Working Plane select in the Main Menu New Entity - > Basic - > Working Plane or click the corresponding button in the toolbar. There are several algorithms of working plane creation. Firstly, it is possible to design a Plane, a Planar Face or a Local Coordinate System as a Working Plane. Secondly, a Working Plane can be defined by two vectors. Finally, you can select one of three basic projections of XYZ coordinate system as a Working Plane.
Partition algorithm builds a shape by intersection of two shapes or a shape and a plane. Use partition by plains to split your complex geometry into a number of simple geometries, wish are much easier to be meshed by the algorithms.
To orient all normals of a 2D/3D mesh in one direction, use Modification/Orientation operation. Unfortunately it does not provide a one-click option to orient all normals in one direction. So, if you select the whole mesh, it will simply redirect all normals. For 3D elements, "Bad oriented volume" filter criterion helps to find the volumes that should be reoriented. For 2D elements, you have to select the elements to be reoriented manually.
It is possible to use alternative 1D and 2D hypotheses assigned to subshapes of the main shape or to groups of subshapes, but it is impossible to mesh a part of a solid with an alternative 3D hypothesis without splitting.
No, it is only possible to find volumic elements oriented differently from MED convention using "Bad oriented volume" filter criterion.
Currently it is not possible.
Use local 1D hypotheses on different edges.
