-f <xml-file>
The configuration file to be used by the Installation Wizard.
If this parameter is missed then the script tries to define
- the Red Hat version and uses corresponding xml file.
- For example, for the Red Hat 8.0 config_RedHat8_0.xml file
+ the Linux version and uses corresponding xml file.
+ For example, for the Mandrake 10.1 config_Mandrake10_1.xml file
is supposed to be used by default. If the appropriate file
- is not found, config.xml is used by default.
+ is not found, config.xml is used by default. This file usually
+ refers to the default target platform. For SALOME version 3.0.0
+ and higher default target platform is Linux Mandrake 10.1.
-t <target-dir>
The target directory SALOME products to be installed to.
If used, overloads target directory, given in the
- configuration xml file.
+ configuration xml file (usually /salome).
-tmp <tmp-dir>
The directory, which is used to contain temporary files.
If used, overloads temporary directory, given in the
- configuration xml file.
+ configuration xml file (usually /tmp).
-h
Prints help information.
necessary environment variables for all products you have installed.
These files are:
* salome.csh + salome.sh in the KERNEL module's sources/binaries
- root directories;
- * env_products.csh + env_products.sh in the target directory.
+ root directories; these files can be used for the launching of
+ SALOME.
+ * env_products.csh + env_products.sh in the target directory;
+ these files contain minimal environment settings necessary
+ to build SALOME packages from sources (see paragraph 4).
To set SALOME environment just type in the terminal window:
source salome.csh
where <KERNEL_ROOT_DIR> is KERNEL binaries directory, e.g.
- KERNEL_2.2.0 for the 2.2.0 version.
+ KERNEL_3.0.0 for the 3.0.0 version.
2.2. Launching of SALOME
After you set environment you can start SALOME. Go to the KERNEL
- module's binaries directory (KERNEL_2.2.0/bin/salome for the version
- 2.2.0) by using of cd command and then type:
+ module's binaries directory (KERNEL_3.0.0/bin/salome for the version
+ 3.0.0) by using of cd command and then type:
runSalome [<parameters>]
This will start SALOME according to the configuration parameters which
- are described into salome.launch file, located in your home directory
- ( $HOME/.salome_<version-number>/salome.launch ),
- where <version_number> is number of SALOME version.
-
- If this file does not exists, it is created on the first launch of
- SALOME from <KERNEL_ROOT_DIR>/bin/salome/salome.launch.
-
- You can modify SALOME launching options by editing
- salome_<version_number>.launch file:
-
- <Configuration-list>
- <launchoptions>
- <gui>yes</gui>
- <logger>no</logger>
- <xterm>no</xterm>
- <portkill>yes</portkill>
- <killall>no</killall>
- </launchoptions>
- <modules-list>
- <module name="...">
- <plugin name="..."/>
- </module>
- </modules-list>
- <embedded-list>
- <embeddedserver>...</embeddedserver>
- </embedded-list>
- <standalone-list>
- <standaloneserver>...</standaloneserver>
- </standalone-list>
- </Configuration-list>
-
- Each parameter described in salome.launch file can be overrided by
- using corresponding keys for runSalome script:
+ are described in the configuration files: SalomeApp.xml in the
+ <GUI_ROOT_DIR>/share/salome/resources folder and .SalomeApprc.<version_number>
+ file, located in your home directory (where <version_number> is number
+ of SALOME version). If the latest file does not exist, it is created during
+ the first launch of SALOME.
+
+ You can modify SALOME launching options by editing your
+ ~/.SalomeApprc.<version_number> file:
+
+ <section name="launch">
+ <parameter name="gui" value="yes"/>
+ <parameter name="splash" value="yes"/>
+ <parameter name="file" value="no"/>
+ <parameter name="key" value="no"/>
+ <parameter name="interp" value="no"/>
+ <parameter name="logger" value="no"/>
+ <parameter name="xterm" value="no"/>
+ <parameter name="portkill" value="no"/>
+ <parameter name="killall" value="no"/>
+ <parameter name="modules" value="GEOM,SMESH,VISU,SUPERV,MED,COMPONENT"/>
+ <parameter name="embedded" value="SalomeAppEngine"/>
+ <parameter name="standalone" value="study,pyContainer,cppContainer,registry,moduleCatalog"/>
+ </section>
+
+ Some parameters described in configuration file can be overrided by
+ using of corresponding command-line keys for runSalome script:
--gui
Launch GUI desktop
--killall
Kill SALOME, running on all ports
--modules=<module>,<module>,...,<module>
- Use module(s), possible values are GEOM,SMESH,VISU,MED,SUPERV
- --embedded=<container>,<container>,...<container>
- Start specified container(s) embedded in SALOME Session server
+ Use module(s), possible values are GEOM,SMESH,VISU,MED,SUPERV,etc.
+ --embedded=<server>,<server>,...<server>
+ Start specified server/container(s) embedded in SALOME Session server
(i.e. running in the same process), possible values are registry,
- study, moduleCatalog, cppContainer, pyContainer, supervContainer
- --standalone=<container>,<container>,...<container>
- Start standalone container(s), possible values are registry,
- study, moduleCatalog, cppContainer, pyContainer, supervContainer
+ study, moduleCatalog, cppContainer, registry
+ --standalone=<server>,<server>,...<server>
+ Start standalone server/container(s), possible values are registry,
+ study, registry, moduleCatalog, cppContainer, pyContainer, supervContainer.
- Note that there is no key which corresponds to the <plugin> tag.
- This tag can be used currently only for SMESH module to point external
- meshers plugins which should be loaded by SMESH dynamically.
- Refer <SMESH_ROOT_DIR>/doc/salome/tui/SMESH/PluginMeshers.html
- for more information om meshers plugins.
+ Additional launch settings are given in other sections, which refer to certain
+ modules. For example, SMESH plugins which should be used in the SALOME launch
+ session can be mentioned in the <SMESH> section, e.g.:
+
+ <section name="SMESH">
+ <parameter name="name" value="Mesh"/>
+ <parameter name="icon" value="ModuleMesh.png"/>
+ <parameter name="plugins" value="StdMeshers,NETGENPlugin"/>
+ </section>
================================================================================
patient.
The quickest way to install SALOME is installation from the binaries.
In this mode the Installation Wizard just extracts all precompiled
- products from the corresponding archives.
+ products from the corresponding archives (except those products
+ which can be installed only by compiling from sources).
The installation from sources requires much more time than from
binaries because in this case the Installation Wizard extracts and
- then builds each product using the product's own installation
+ then builds each product using the product's own compilation
procedure.
The installation time also depends on the computer and platform used.
- For example, to install SALOME on Pentium III-800, Linux Red Hat 8.0,
+ For example, to install SALOME on Pentium IV-2GHz, Linux Mandrake 10.1,
time of the installation is:
- from binaries: ~10 minutes;
successfully.
To test SALOME platform, run SALOME desktop (see section 2), then
create a new study window (menu command 'File/New') and then type
- in the study's python console window:
+ in the study's embedded python console window:
import salome_test
- When running, the script loads diferent modules (Geometry, Mesh, Med,
+ When running, the script loads different modules (Geometry, Mesh, Med,
Post-Pro and Supervisor) and tests different functionality of these
modules. You can watch script running progress in the python console
window.
4. How to build SALOME modules from sources
This section describes the way how to build SALOME modules manually from
- sources packages provided with Installation Wizard.
+ sources distribution provided with Installation Wizard.
+
4.1. General procedure
- If you want to build SALOME modules from sources, install all products
- necessary for the platform and SALOME modules sources.
+ If you want to build SALOME modules from sources, install all prerequisite
+ products, required for the platform and SALOME modules sources.
Then follow the scenario described below.
In the scenario below it is supposed that you have installed SALOME
modules sources in the /home/salome directory. The name of each module
sources directory depends on the version of the platform, for example,
- KERNEL_SRC_2.2.0 for KERNEL module of SALOME version 2.2.0.
+ KERNEL_SRC_3.0.0 for KERNEL module of SALOME version 3.0.0.
The order of compilation and installation should be performed according
to the dependancies between modules:
-
+
+ Main SALOME modules:
+
* KERNEL -> no dependancies
- * GEOM -> KERNEL
- * MED -> KERNEL
- * SMESH -> KERNEL, GEOM, MED
- * VISU -> KERNEL, MED
- * SUPERV -> KERNEL
+ * GUI -> KERNEL
+ * GEOM -> KERNEL, GUI
+ * MED -> KERNEL, GUI
+ * SMESH -> KERNEL, GUI, GEOM, MED
+ * VISU -> KERNEL, GUI, MED
+ * SUPERV -> KERNEL, GUI
+
+ SMESH plugins:
+
+ * NETGENPLUGIN -> KERNEL, GUI, SMESH
+ * GHS3DPLUGIN -> KERNEL, GUI, SMESH
+
+ Sample modules:
+
* COMPONENT -> KERNEL
- * PYCALCULATOR -> KERNEL
- * NETGENPLUGIN -> KERNEL, SMESH
- * GHS3DPLUGIN -> KERNEL, SMESH
+ * PYCALCULATOR -> KERNEL,
+ * HELLO -> KERNEL, GUI
+ * PYHELLO -> KERNEL, GUI
+ * LIGHT -> KERNEL, GUI
- Note: NETGENPLUGIN, GHS3DPLUGIN are optional components. You may skip
+ Note: SMESH plugins and sample modules are optional. You may skip
compiling them if you do not plan to use NETGEN and/or GHS3D mesher
- algorithms.
- In general, each module (except KERNEL, of course) is optional for
+ algorithms and do not want to build samples.
+
+ In general, each module (except KERNEL and GUI, of course) is optional for
SALOME. If you do not need any module, just do not compile or install
it. But remember that some modules require other ones to be built first
(see dependancies table above).
- - go to KERNEL module's sources directory:
+ To build KERNEL module:
- cd /home/salome/KERNEL_SRC_2.2.0
+ - go to installation root directory (/home/salome in this example):
- - set environment variables (use bash or csh script, depending on
- your shell):
+ cd /home/salome
- source salome.csh
+ - to set environment variables use bash or csh script, depending on
+ your shell:
+
+ source ../env_products.csh
or
- source salome.sh
+ source ../env_products.sh
- - create a configuration script by typing
+ - create build directory for the KERNEL module:
- ./build_configure
+ mkdir KERNEL_build
+ cd KERNEL_build
- - go to the parent directory and create build directory:
+ - create a configuration script by typing
- cd ..
- mkdir KERNEL_build
+ ../KERNEL_SRC_3.3.0/build_configure
- run configure script which will check the environment and create
Makefile files:
- cd KERNEL_build
- ../KERNEL_SRC_2.2.0/configure --prefix=/home/salome/KERNEL_install
+ ../KERNEL_SRC_3.3.0/configure --prefix=/home/salome/KERNEL_install
Note, that --prefix option defines the directory where you want to
- install KERNEL module after 'make install' procedure.
+ install KERNEL module after 'make install' procedure. configure script
+ accepts also a lot of other parameters (for example, to build the module
+ in the optimized mode use --disable-debug --enable-production keys).
More about certain module's configure options you can learn by using
--help (-h) parameter.
- - build and install KERNEL module:
+ - build and (optionally) install KERNEL module:
make
make install
After you have completed this scenario, KERNEL module is built and
installed into /home/salome/KERNEL_install directory.
- - set environment:
+ - modify your environment scripts:
* for bash:
Note: if the compilation fails it may be caused by bad environment.
In this case you should check that environment script you use
- (salome.csh or salome.sh) contains the following lines for each module:
+ (salome.csh or salome.sh) contains the following lines for each module MODULE:
* for bash:
- export PATH=${<module>_ROOT_DIR}/bin/salome:${PATH}
- export LD_LIBRARY_PATH=${<module>_ROOT_DIR}/lib/salome:${LD_LIBRARY_PATH}
- export PYTHONPATH=${<module>_ROOT_DIR}/bin/salome:${PYTHONPATH}
- export PYTHONPATH=${<module>_ROOT_DIR}/lib/salome:${PYTHONPATH}
- export PYTHONPATH=${<module>_ROOT_DIR}/lib/python2.2/site-packages/salome:${PYTHONPATH}
- export PYTHONPATH=${<module>_ROOT_DIR}/lib/python2.2/site-packages/salome/shared_modules:${PYTHONPATH}
+ export MODULE_ROOT_DIR=/home/salome/<MODULE_distribution>
* for csh:
- setenv PATH ${<module>_ROOT_DIR}/bin/salome:${PATH}
- setenv LD_LIBRARY_PATH ${<module>_ROOT_DIR}/lib/salome:${LD_LIBRARY_PATH}
- setenv PYTHONPATH ${<module>_ROOT_DIR}/bin/salome:${PYTHONPATH}
- setenv PYTHONPATH ${<module>_ROOT_DIR}/lib/salome:${PYTHONPATH}
- setenv PYTHONPATH ${<module>_ROOT_DIR}/lib/python2.2/site-packages/salome:${PYTHONPATH}
- setenv PYTHONPATH ${<module>_ROOT_DIR}/lib/python2.2/site-packages/salome/shared_modules:${PYTHONPATH}
+ setenv MODULE_ROOT_DIR /home/salome/<MODULE_distribution>
+
+ where <MODULE_distribution> is a MODULE_build or MODULE_install (see above).
4.2. Automatic build procedure: build.csh script
(the same directory where env_products.[c]sh files are generated.
To use this script just install SALOME sources packages with
- Installation Wizard, then cd to the SALOME isntallation directory
+ Installation Wizard, then cd to the SALOME installation directory
and type:
./build.csh
and that's all.
- By default, build.csh only compiles the modules but not installs them,
+ By default, build.csh only compiles the modules but does not install them,
i.e. does not perform 'make install' step.
To do this, use -i option or -p <prefix> where <prefix> is target
directory.
When you run build.csh at first time it is not necessary to pass
-b, -c parameters. The script detects if build procedure has not yet
been performed and runs build_configure, configure procedures
- in this case.
+ in this case automatically.
Note: for avoiding of collisions it is recommended not to install
SALOME binaries packages with Installation Wizard if you plan to build
