README

   1 #
   2 # =================================================================
   3 # Installation instructions, up to date for 2.2.0 version
   4 # =================================================================
   5 #
   6
   7 You'll find here generic instructions for installing the SALOME2 platform.
   8
   9
  10 1. Quick Overview
  11    --------------
  12
  13 First of all, you have to check (or install if needed) the dependant
  14 software programs on your system. These programs are:
  15
  16 - common development tools as gcc, automake, autoconf and libtools.
  17 - third party softwares used in SALOME building or runtime process
  18   (python, OCC, VTK, ...)
  19
  20 Further details can be found in sections [2] and [3].
  21
  22 If the dependencies are installed on your system, then you have to set
  23 your shell environment to get access to the software components
  24 (cf. [4]. "Preparing the shell environment").
  25
  26 The next step is to install the KERNEL (cf. [5] "Installing KERNEL"):
  27 $ mkdir <kernel_build>
  28 $ mkdir <kernel_install>
  29 $ cd <kernel_src>
  30 $ ./build_configure
  31 $ cd <kernel_build>
  32 $ <kernel_src>/configure --prefix=<kernel_install>
  33 $ make
  34 $ make install
  35
  36 Then, the SALOME components GEOM, MED, VISU, ... can be installed
  37 with a similar procedure (cf. [6]).
  38
  39 Eventually, the platform can be run by executing the shell script
  40 runSalome (cf. [7]). Here, somme additionnal variables have to be set
  41 to describe the SALOME runtime configuration (<COMPONENT>_ROOT_DIR,
  42 OMNIORB_CONFIG)
  43
  44 The following provides you with specific instructions for each step.
  45
  46
  47 2. System configuration
  48    --------------------
  49
  50 We suggest the following configuration for building process:
  51 - gcc-3.2 (3.2.3 if gcc3-2 is not the native compiler of your distribution)
  52 - automake-1.9 (only aclocal is used)
  53 - autoconf-2.59
  54 - libtool-1.5.6
  55
  56 remarks :
  57 - This is the minimum level of automake,autoconf & libtool, if you need
  58   to compile all the third party softwares (included OpenCascade 5.2).
  59 - SALOME2 is compiled and tested on a RedHat 8.0 version, with
  60   - gcc-3.2
  61   and
  62   - automake-1.6.3
  63   - autoconf-2.53
  64   - libtool-1.4.2
  65   This level of automake,autoconf & libtool is OK if you do not need to
  66   recompile OpenCascade 5.2.
  67
  68 3. Third-party dependencies
  69    ------------------------
  70
  71 The SALOME platform relies on a set of third-party softwares. The
  72 current version depends on:
  73
  74  CAS-5.2                OpenCascade (try binaries,a source patch is needed)
  75  PyQt-3.3.2             Python-Qt Wrapper
  76  Python-2.2.2           Python interpreter
  77  SWIG-1.3.17            SWIG library
  78  VTK-4.2.2              VTK 3D-viewer
  79  boost-1_31_0           C++ library (only include templates are used)
  80  hdf5-1.4.4             Files Database library
  81  med-2.1.6              MED Data Format support for file records
  82  omniORB-3.0.5          ORB used in SALOME
  83  qt-x11-free-3.0.5      Qt library
  84  qwt-0.4.1              Graph components for Qt
  85  sip-3.3.2              langage binding software
  86  tcl8.3                 Tcl interpreter
  87  tk8.3                  Tk widgets
  88
  89 And, in order to build the documentation:
  90
  91  doxygen-1.3-rc2
  92  graphviz-1.9
  93
  94 Additionnal software may be installed for optional features:
  95
  96  netgen4.3_calibre3_gcc3.2.3.tgz
  97  tix8.1.4_calibre3_gcc3.2.3.tgz
  98  openpbs-2.3.16
  99  lsf-???
 100
 101 ######
 102 ###### To Do -------------------------
 103 ######
 104 - Instructions for installing these software programs can be found in a
 105   special note doc/configuration_examples/install-prerequis.
 106 - Installation shell scripts are also provided.
 107   These scripts have to be adapted to your own configuration.
 108
 109 - See doc/configuration_examples/*
 110 ######
 111 ###### To Do -------------------------
 112 ######
 113
 114 In the following, we assume that all the third-party softwares are
 115 installed in the same root directory, named <salomeroot>/prerequis.
 116 Then, your file system should probably look like:
 117
 118 <salomeroot>/prerequis/Python-2.2.2
 119 <salomeroot>/prerequis/omniORB-3.0.5
 120 <salomeroot>/prerequis/qt-x11-free-3.0.5
 121 ...
 122
 123
 124 4. Preparing the shell environment
 125    -------------------------------
 126
 127 Some variables have to be set to get acces to third-party software
 128 components (include files, executable, library, ...) during building
 129 process and runtime.
 130
 131 The shell file prerequis.sh, embedded in the KERNEL source package,
 132 provides a template for setting those variables. In this example, all the
 133 softwares are supposed to be installed in the same root directory,
 134 named here INSTALLROOT.
 135
 136 Copy the prerequis.sh in a working directory and adjust the settings
 137 to your own configuration. To get the shell prepared, just
 138 execute the following command in the building shell:
 139
 140 $ source prerequis.sh
 141
 142 (we assume here a ksh or bash mode)
 143
 144
 145 5. Installing the KERNEL component
 146    -------------------------------
 147
 148 We use here the notation <kernel_src> to specify the source directory
 149 of the KERNEL component. The shell environment is supposed to have
 150 been set (cf. 4).
 151
 152 Installing the KERNEL from a source package needs three directories:
 153
 154 - the source directory, denoted here by <kernel_src>.
 155
 156 - the build directory, denoted by <kernel_build> in the following. This
 157   directory can't be the same directory as <kernel_src>.
 158
 159 - the install directory, denoted by <kernel_install> in the following. This
 160   directory can't be the same directory as <kernel_src> or
 161   <kernel_build>.
 162
 163 The installing process is:
 164
 165 STEP 1: preparing directories
 166 create the <kernel_build> and the <kernel_install> directories.
 167 $ mkdir <kernel_build>
 168 $ mkdir <kernel_install>
 169
 170 STEP 2: build configure script
 171 go to <kernel_src> directory and generate the "configure" script.
 172 $ cd <kernel_src>
 173 $ ./build_configure
 174
 175 If it doesn't work, check your system automake tools as specified in
 176 section [2].
 177
 178 STEP 3: configure the building process
 179 go to the build directory and execute the configuration process:
 180 $ cd <kernel_build>
 181 $ <kernel_src>/configure --prefix=<kernel_install>
 182
 183 Note that <kernel_install> must be an absolute path.
 184
 185 When the configure process is complete, check the status of
 186 third-party softwares detection. You should have a status like:
 187
 188 ---------------------------------------------
 189 Summary
 190 ---------------------------------------------
 191
 192 Configure
 193            cc : yes
 194         boost : yes
 195      lex_yacc : yes
 196        python : yes
 197          swig : yes
 198       threads : yes
 199        OpenGL : yes
 200            qt : yes
 201           vtk : yes
 202          hdf5 : yes
 203          med2 : yes
 204       omniORB : yes
 205           occ : yes
 206           sip : yes
 207          pyqt : yes
 208           qwt : yes
 209       doxygen : yes
 210      graphviz : no
 211       openpbs : no
 212           lsf : no
 213
 214 Default ORB   : omniORB
 215
 216 ---------------------------------------------
 217
 218 If a software get a status "no", then it's not "seen" in the system:
 219 - the software is not installed, or
 220 - the shell environment is not set correctly.
 221
 222 In this example, the software programs graphviz, openpbs and lsf are not
 223 installed (optional for most usages).
 224
 225
 226 STEP 4 : Building the binary files
 227 Execute make in the <kernel_build> directory:
 228 $ make
 229
 230
 231 STEP 5: Installing binary files, scripts and documentation
 232 Execute install target in the <kernel_build> directory:
 233 $ make install
 234
 235
 236 6. Installing the SALOME components
 237    --------------------------------
 238
 239 Installing a component <COMPONENT> is done by following the same
 240 instructions as given for the KERNEL, replacing KERNEL by
 241 <COMPONENT> (build_configure, configure, make, make install).
 242
 243 You just have to be aware of the dependencies between components:
 244
 245 - MED    depends on KERNEL
 246 - GEOM   depends on KERNEL
 247 - SMESH  depends on KERNEL, MED, GEOM
 248 - VISU   depends on KERNEL, MED
 249 - SUPERV depends on KERNEL
 250
 251 For example, installing the component SMESH needs the previous
 252 installation of the KERNEL component, and then the GEOM and MED components.
 253
 254 The building process uses the variables <COMPONENT>_ROOT_DIR to
 255 localize the dependant components. The variables must be set to the
 256 install path directory of the components <COMPONENT> (ex:
 257 KERNEL_ROOT_DIR=<kernel_install>).
 258
 259 In the above example, the three variables KERNEL_ROOT_DIR,
 260 GEOM_ROOT_DIR and MED_ROOT_DIR have to be set before configuring the
 261 building process of the SMESH component (STEP 3).
 262
 263
 264 7. Runtime
 265    -------
 266
 267 To run the SALOME platform, the procedure is:
 268 - set the shell environment to get acces to third-party softwares
 269
 270 $ source prerequis.sh
 271
 272 - define the SALOME configuration by setting the whole set of
 273   variables <COMPONENT>_ROOT_DIR. Here, you just have to set the
 274   kernel and the components you need.
 275
 276 $ export KERNEL_ROOT_DIR=<kernel_install>
 277 $ export MED_ROOT_DIR=<med_install>
 278 $ ...
 279
 280 - define the CORBA configuration file by setting the variable
 281   OMNIORB_CONFIG. This variable must be set to a writable file
 282   path. The file may be arbitrary chosen and doesn't need to exist
 283   before running. We suggest:
 284
 285 $ export OMNIORB_CONFIG=$HOME/.omniORB.cfg
 286
 287 - run the SALOME platform by executing the script runSalome
 288 $ $KERNEL_ROOT_DIR/bin/salome/runSalome
 289
 290
 291 8. Suggestions and advices
 292    ----------------------
 293
 294 For convenience or customization, we suggest the following organisation:
 295
 296 - chose and create a root directory for the SALOME platform, say
 297   <salomeroot>.
 298
 299 - install the third-party softwares in a sub-directory "prerequis"
 300
 301 - install the SALOME components in a sub-directory "SALOME2"
 302
 303 - make personnal copies of the files prerequis.sh and runSalome in
 304   <salomeroot>.
 305
 306 $ cp <kernel_src>/prerequis.sh <rundir>/.
 307 $ cp <kernel_install>/bin/salome/runSalome <rundir>/.
 308
 309 Edit the file prerequis.sh and adjust it to your own configuration.
 310
 311 - define the SALOME2 configuration
 312 This step consists in setting the KERNEL_ROOT_DIR, the whole set of
 313 variables <COMPONENT>_ROOT_DIR you need, and the OMNIORB_CONFIG
 314 variable.
 315 We suggest to create a shell file envSalome.sh containing those
 316 settings. Then the configuration consists in loading envSalome.sh in
 317 the runtime shell:
 318
 319 $ source envSalome.sh
 320
 321 - When installed with this file organisation, running SALOME is done
 322   with the following shell commands:
 323
 324 $ source <salomeroot>/prerequis.sh
 325 $ source <salomeroot>/envSalome.sh
 326 $ ./runSalome
 327
 328
 329 # =================================================================
 330 # End of file