/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1428 by trankine, Wed Feb 27 08:07:11 2008 UTC revision 3961 by jfenwick, Tue Sep 11 07:21:41 2012 UTC
# Line 1  Line 1 
1  #         Copyright 2006 by ACcESS MNRF  ########################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2012 by University of Queensland
4  #       Primary Business: Queensland, Australia  # Earth Systems Science Computational Center (ESSCC)
5  #  Licensed under the Open Software License version 3.0  # http://www.uq.edu.au/esscc
6  #     http://www.opensource.org/licenses/osl-3.0.php  #
7    # Primary Business: Queensland, Australia
8  # top-level Scons configuration file for all esys13 modules  # Licensed under the Open Software License version 3.0
9  # Begin initialisation Section  # http://www.opensource.org/licenses/osl-3.0.php
10  # all of this section just intialises default environments and helper  #
11  # scripts. You shouldn't need to modify this section.  ########################################################
12  EnsureSConsVersion(0,96,91)  
13  EnsurePythonVersion(2,3)  EnsureSConsVersion(0,98,1)
14    EnsurePythonVersion(2,5)
15  #===============================================================  
16  #   import tools:  import sys, os, platform, re
17  import glob  from distutils import sysconfig
18  import sys, os, re  from site_init import *
19  # Add our extensions  import subprocess
20  if sys.path.count('scons')==0: sys.path.append('scons')  from subprocess import PIPE, Popen
21  import scons_extensions  
22    # Version number to check for in options file. Increment when new features are
23  # We may also need to know where python's site-packages subdirectory lives  # added or existing options changed.
24  python_version = 'python%s.%s'%(sys.version_info[0],sys.version_info[1])  REQUIRED_OPTS_VERSION=201
25    
26  #===============================================================  # MS Windows support, many thanks to PH
27    IS_WINDOWS = (os.name == 'nt')
28  tools_prefix="/usr"  
29    ########################## Determine options file ############################
30  #==============================================================================================      # 1. command line
31  #      # 2. scons/<hostname>_options.py
32  #    get the installation prefix  # 3. name as part of a cluster
33  #  options_file=ARGUMENTS.get('options_file', None)
34  prefix = ARGUMENTS.get('prefix', sys.prefix )  if not options_file:
35        ext_dir = os.path.join(os.getcwd(), 'scons')
36  # We may also need to know where python's site-packages subdirectory lives      hostname = platform.node().split('.')[0]
37  python_version = 'python%s.%s'%(sys.version_info[0],sys.version_info[1])      for name in hostname, effectiveName(hostname):
38  # Install as a standard python package in /usr/lib64 if available, else in /usr/lib          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
39  if os.path.isdir(  prefix+"/lib64/"+python_version+"/site-packages"):          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
40     sys_dir_packages =  prefix+"/lib64/"+python_version+"/site-packages/esys"          if os.path.isfile(options_file): break
41     sys_dir_libraries = prefix+"/lib64"  
42  else:  if not os.path.isfile(options_file):
43     sys_dir_packages =  prefix+"/lib/"+python_version+"/site-packages/esys"      print("\nWARNING:\nOptions file %s" % options_file)
44     sys_dir_libraries = prefix+"/lib"      print("not found! Default options will be used which is most likely suboptimal.")
45        print("It is recommended that you copy one of the TEMPLATE files in the scons/")
46  sys_dir_examples = prefix+"/share/doc/esys"      print("subdirectory and customize it to your needs.\n")
47        options_file = None
48  source_root = Dir('#.').abspath  
49    ############################### Build options ################################
50  dir_packages = os.path.join(source_root,"esys")  
51  dir_examples = os.path.join(source_root,"examples")  default_prefix='/usr'
52  dir_libraries = os.path.join(source_root,"lib")  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
53    lapack_flavours=('none', 'clapack', 'mkl')
54  print "Source root is : ",source_root  
55  print " Default packages local installation:    ", dir_packages  vars = Variables(options_file, ARGUMENTS)
56  print " Default library local installation  ", dir_libraries  vars.AddVariables(
57  print " Default example local  installation:    ", dir_examples    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
58  print "Install prefix is: ", prefix    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
59  print " Default packages system installation:   ", sys_dir_packages    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
60  print " Default library system installation     ", sys_dir_libraries    BoolVariable('verbose', 'Output full compile/link lines', False),
61  print " Default example system installation:    ", sys_dir_examples  # Compiler/Linker options
62      ('cc', 'Path to C compiler', 'default'),
63  #==============================================================================================        ('cxx', 'Path to C++ compiler', 'default'),
64      ('cc_flags', 'Base C/C++ compiler flags', 'default'),
65  # Default options and options help text    ('cc_optim', 'Additional C/C++ flags for a non-debug build', 'default'),
66  # These are defaults and can be overridden using command line arguments or an options file.    ('cc_debug', 'Additional C/C++ flags for a debug build', 'default'),
67  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used    ('cc_extra', 'Extra C compiler flags', ''),
68  # DO NOT CHANGE THEM HERE    ('cxx_extra', 'Extra C++ compiler flags', ''),
69  # Where to install?    ('ld_extra', 'Extra linker flags', ''),
70  #==============================================================================================        BoolVariable('werror','Treat compiler warnings as errors', True),
71  #        BoolVariable('debug', 'Compile with debug flags', False),
72  #    get the options file if present:    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
73  #    ('omp_flags', 'OpenMP compiler flags', 'default'),
74  options_file = ARGUMENTS.get('options_file','')    ('omp_ldflags', 'OpenMP linker flags', 'default'),
75    # Mandatory libraries
76  if not os.path.isfile(options_file) :    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
77      options_file = False    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
78    # Mandatory for tests
79  if not options_file :    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
80     import socket    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
81     hostname = re.sub("[^0-9a-zA-Z]", "_", socket.gethostname().split('.')[0])  # Optional libraries and options
82     tmp = os.path.join("scons",hostname+"_options.py")    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
83      ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
84     if os.path.isfile(tmp) :    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
85        options_file = tmp    BoolVariable('netcdf', 'Enable netCDF file support', False),
86      ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
87  IS_WINDOWS_PLATFORM = (os.name== "nt")    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
88      BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
89  # If you're not going to tell me then......    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
90  # FIXME: add one for the altix too.    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
91  if not options_file :    BoolVariable('papi', 'Enable PAPI', False),
92     if IS_WINDOWS_PLATFORM :    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
93        options_file = "scons/windows_mscv71_options.py"    ('papi_libs', 'PAPI libraries to link with', ['papi']),
94     else:    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
95        options_file = "scons/linux_gcc_eg_options.py"    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
96      ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
97  # and load it    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
98  opts = Options(options_file, ARGUMENTS)    BoolVariable('umfpack', 'Enable UMFPACK', False),
99  #================================================================    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
100  #    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
101  #   check if UMFPACK is installed on the system:    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
102  #    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
103  uf_root=None    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
104  for i in [ 'UMFPACK', 'umfpack', 'ufsparse', 'UFSPARSE']:    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
105     if os.path.isdir(os.path.join(tools_prefix,'include',i)):    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
106         uf_root=i    ('lapack_libs', 'LAPACK libraries to link with', []),
107         print i," is used form ",tools_prefix    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
108         break    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
109  if not uf_root==None:    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
110     umf_path_default=os.path.join(tools_prefix,'include',uf_root)    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
111     umf_lib_path_default=os.path.join(tools_prefix,'lib')    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
112     umf_libs_default=['umfpack']    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
113     amd_path_default=os.path.join(tools_prefix,'include',uf_root)    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
114     amd_lib_path_default=os.path.join(tools_prefix,'lib')  # Advanced settings
115     amd_libs_default=['amd']    #dudley_assemble_flags = -funroll-loops      to actually do something
116     ufc_path_default=os.path.join(tools_prefix,'include',uf_root)    ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
117  else:    # To enable passing function pointers through python
118     umf_path_default=None    BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
119     umf_lib_path_default=None    # An option for specifying the compiler tools (see windows branch)
120     umf_libs_default=None    ('tools_names', 'Compiler tools to use', ['default']),
121     amd_path_default=None    ('env_export', 'Environment variables to be passed to tools',[]),
122     amd_lib_path_default=None    EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
123     amd_libs_default=None    EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
124     ufc_path_default=None    # finer control over library building, intel aggressive global optimisation
125  #    # works with dynamic libraries on windows.
126  #==========================================================================    ('build_shared', 'Build dynamic libraries only', False),
127  #    ('sys_libs', 'Extra libraries to link with', []),
128  #    python installation:    ('escript_opts_version', 'Version of options file (do not specify on command line)'),
129  #    ('SVN_VERSION', 'Do not use from options file', -2),
130  python_path_default=os.path.join(tools_prefix,'include','python%s.%s'%(sys.version_info[0],sys.version_info[1]))    ('pythoncmd', 'which python to compile with','python'),
131  python_lib_path_default=os.path.join(tools_prefix,'lib')    ('usepython3', 'Is this a python3 build? (experimental)', False),
132  python_lib_default="python%s.%s"%(sys.version_info[0],sys.version_info[1])    ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
133      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
134  #==========================================================================    ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
135  #    BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
136  #    boost installation:  )
 #  
 boost_path_default=os.path.join(tools_prefix,'include')  
 boost_lib_path_default=os.path.join(tools_prefix,'lib')  
 boost_lib_default=['boost_python']  
   
 #==========================================================================  
 #  
 #    check if netCDF is installed on the system:  
 #  
 netCDF_path_default=os.path.join(tools_prefix,'include','netcdf-3')  
 netCDF_lib_path_default=os.path.join(tools_prefix,'lib')  
137    
138  if os.path.isdir(netCDF_path_default) and os.path.isdir(netCDF_lib_path_default):  ##################### Create environment and help text #######################
      useNetCDF_default='yes'  
      netCDF_libs_default=[ 'netcdf_c++', 'netcdf' ]  
 else:  
      useNetCDF_default='no'  
      netCDF_path_default=None  
      netCDF_lib_path_default=None  
      netCDF_libs_default=None  
139    
140  #==========================================================================  # Intel's compiler uses regular expressions improperly and emits a warning
141  #  # about failing to find the compilers. This warning can be safely ignored.
 #  MPI:  
 #  
 if IS_WINDOWS_PLATFORM:  
    useMPI_default='no'  
    mpi_path_default=None  
    mpi_lib_path_default=None  
    mpi_libs_default=[]  
    mpi_run_default=None  
 else:  
    useMPI_default='no'  
    mpi_root='/usr/local'  
    mpi_path_default=os.path.join(mpi_root,'include')  
    mpi_lib_path_default=os.path.join(mpi_root,'lib')  
    mpi_libs_default=[ 'mpich' , 'pthread', 'rt' ]  
    mpi_run_default='mpiexec -np 1'  
 #  
 #==========================================================================  
 #  
 #    compile:  
 #  
 cc_flags_default='-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas -ansi'  
 cc_flags_debug_default='-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas -ansi'  
 cxx_flags_default='--no-warn -ansi'  
 cxx_flags_debug_default='--no-warn -ansi -DDOASSERT'  
   
 #==============================================================================================      
 # Default options and options help text  
 # These are defaults and can be overridden using command line arguments or an options file.  
 # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used  
 # DO NOT CHANGE THEM HERE  
 opts.AddOptions(  
 # Where to install esys stuff  
   ('incinstall', 'where the esys headers will be installed',             Dir('#.').abspath+'/include'),  
   ('libinstall', 'where the esys libraries will be installed',           dir_libraries),  
   ('pyinstall', 'where the esys python modules will be installed',       dir_packages),  
   ('exinstall', 'where the esys examples will be installed',             dir_examples),  
   ('sys_libinstall', 'where the system esys libraries will be installed',       sys_dir_libraries),  
   ('sys_pyinstall', 'where the system esys python modules will be installed',   sys_dir_packages),  
   ('sys_exinstall', 'where the system esys examples will be installed',         sys_dir_examples),  
   ('src_zipfile', 'the source zip file will be installed.',              Dir('#.').abspath+"/release/escript_src.zip"),  
   ('test_zipfile', 'the test zip file will be installed.',               Dir('#.').abspath+"/release/escript_tests.zip"),  
   ('src_tarfile', 'the source tar file will be installed.',              Dir('#.').abspath+"/release/escript_src.tar.gz"),  
   ('test_tarfile', 'the test tar file will be installed.',               Dir('#.').abspath+"/release/escript_tests.tar.gz"),  
   ('examples_tarfile', 'the examples tar file will be installed.',       Dir('#.').abspath+"/release/doc/escript_examples.tar.gz"),  
   ('examples_zipfile', 'the examples zip file will be installed.',       Dir('#.').abspath+"/release/doc/escript_examples.zip"),  
   ('guide_pdf', 'name of the user guide in pdf format',                  Dir('#.').abspath+"/release/doc/user/guide.pdf"),  
   ('api_epydoc', 'name of the epydoc api docs directory',                Dir('#.').abspath+"/release/doc/epydoc"),  
   ('guide_html', 'name of the directory for user guide in html format',  Dir('#.').abspath+"/release/doc/user/html"),  
   ('api_doxygen', 'name of the doxygen api docs directory',prefix+"/release/doc/doxygen"),  
 # Compilation options  
   BoolOption('dodebug', 'Do you want a debug build?', 'no'),  
   BoolOption('bounds_check', 'Do you want extra array bounds checking?', 'no'),  
   ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/<hostname>_options.py)", options_file),  
   ('cc_defines','C/C++ defines to use', None),  
   ('cc_flags','C compiler flags to use (Release build)', cc_flags_default),  
   ('cc_flags_debug', 'C compiler flags to use (Debug build)', cc_flags_debug_default),  
   ('cxx_flags', 'C++ compiler flags to use (Release build)', cxx_flags_default),  
   ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', cxx_flags_debug_default),  
   ('omp_flags', 'OpenMP compiler flags to use (Release build)', ''),  
   ('omp_flags_debug', 'OpenMP compiler flags to use (Debug build)', ''),  
   ('ar_flags', 'Static library archiver flags to use', None),  
   ('sys_libs', 'System libraries to link with', None),  
   ('tar_flags','flags for zip files','-c -z'),  
 # MKL  
   PathOption('mkl_path', 'Path to MKL includes', None),  
   PathOption('mkl_lib_path', 'Path to MKL libs', None),  
   ('mkl_libs', 'MKL libraries to link with', None),  
 # SCSL  
   PathOption('scsl_path', 'Path to SCSL includes', None),  
   PathOption('scsl_lib_path', 'Path to SCSL libs', None),  
   ('scsl_libs', 'SCSL libraries to link with', None),  
   ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),  
 # UMFPACK  
   PathOption('ufc_path', 'Path to UFconfig includes', ufc_path_default),  
   PathOption('umf_path', 'Path to UMFPACK includes', umf_path_default),  
   PathOption('umf_lib_path', 'Path to UMFPACK libs', umf_lib_path_default),  
   ('umf_libs', 'UMFPACK libraries to link with', umf_libs_default),  
 # AMD (used by UMFPACK)  
   PathOption('amd_path', 'Path to AMD includes', amd_path_default),  
   PathOption('amd_lib_path', 'Path to AMD libs', amd_lib_path_default),  
   ('amd_libs', 'AMD libraries to link with', amd_libs_default),  
 # TRILINOS  
   PathOption('trilinos_path', 'Path to TRILINOS includes', None),  
   PathOption('trilinos_lib_path', 'Path to TRILINOS libs', None),  
   ('trilinos_libs', 'TRILINOS libraries to link with', None),  
 # BLAS  
   PathOption('blas_path', 'Path to BLAS includes', None),  
   PathOption('blas_lib_path', 'Path to BLAS libs', None),  
   ('blas_libs', 'BLAS libraries to link with', None),  
 # netCDF  
   ('useNetCDF', 'switch on/off the usage of netCDF', useNetCDF_default),  
   PathOption('netCDF_path', 'Path to netCDF includes', netCDF_path_default),  
   PathOption('netCDF_lib_path', 'Path to netCDF libs', netCDF_lib_path_default),  
   ('netCDF_libs', 'netCDF C++ libraries to link with', netCDF_libs_default),  
 # Python  
 # locations of include files for python  
 # FIXME: python_path should be python_inc_path and the same for boost etc.  
   PathOption('python_path', 'Path to Python includes', python_path_default),  
   PathOption('python_lib_path', 'Path to Python libs', python_lib_path_default),  
   ('python_lib', 'Python libraries to link with', python_lib_default),  
   ('python_cmd', 'Python command', 'python'),  
 # Boost  
   PathOption('boost_path', 'Path to Boost includes', boost_path_default),  
   PathOption('boost_lib_path', 'Path to Boost libs', boost_lib_path_default),  
   ('boost_lib', 'Boost libraries to link with', boost_lib_default),  
 # Doc building  
 #  PathOption('doxygen_path', 'Path to Doxygen executable', None),  
 #  PathOption('epydoc_path', 'Path to Epydoc executable', None),  
 # PAPI  
   PathOption('papi_path', 'Path to PAPI includes', None),  
   PathOption('papi_lib_path', 'Path to PAPI libs', None),  
   ('papi_libs', 'PAPI libraries to link with', None),  
   ('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', None),  
 # MPI  
   BoolOption('useMPI', 'Compile parallel version using MPI', useMPI_default),  
   ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),  
   PathOption('mpi_path', 'Path to MPI includes', mpi_path_default),  
   ('mpi_run', 'mpirun name' , mpi_run_default),  
   PathOption('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)',mpi_lib_path_default),  
   ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', mpi_libs_default)  
 )  
 #=================================================================================================  
 #  
 #   Note: On the Altix the intel compilers are not automatically  
 #   detected by scons intelc.py script. The Altix has a different directory  
 #   path and in some locations the "modules" facility is used to support  
 #   multiple compiler versions. This forces the need to import the users PATH  
 #   environment which isn't the "scons way"  
 #   This doesn't impact linux and windows which will use the default compiler (g++ or msvc, or the intel compiler if it is installed on both platforms)  
 #   FIXME: Perhaps a modification to intelc.py will allow better support for ia64 on altix  
 #  
142    
143  if IS_WINDOWS_PLATFORM:  # PATH is needed so the compiler, linker and tools are found if they are not
144        env = Environment(tools = ['default', 'msvc'], options = opts)  # in default locations.
145        #env = Environment(tools = ['default', 'intelc'], options = opts)  env = Environment(tools = ['default'], options = vars,
146  else:                    ENV = {'PATH': os.environ['PATH']})
147     if os.uname()[4]=='ia64':  if env['tools_names'] != 'default':
148        env = Environment(tools = ['default', 'intelc'], options = opts)      env = Environment(tools = ['default'] + env['tools_names'], options = vars,
149        if env['CXX'] == 'icpc':                        ENV = {'PATH' : os.environ['PATH']})
150           env['LINK'] = env['CXX'] # version >=9 of intel c++ compiler requires use of icpc to link in C++ runtimes (icc does not). FIXME: this behaviour could be directly incorporated into scons intelc.py  
151     else:  if options_file:
152        env = Environment(tools = ['default'], options = opts)      opts_valid=False
153  Help(opts.GenerateHelpText(env))      if 'escript_opts_version' in env.Dictionary() and \
154            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
155  if env['bounds_check']:              opts_valid=True
156     env.Append(CPPDEFINES = [ 'BOUNDS_CHECK' ])      if opts_valid:
157     env.Append(CXXDEFINES = [ 'BOUNDS_CHECK' ])          print("Using options in %s." % options_file)
158     bounds_check = env['bounds_check']      else:
159            print("\nOptions file %s" % options_file)
160            print("is outdated! Please update the file by examining one of the TEMPLATE")
161            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
162            Exit(1)
163    
164    # Generate help text (scons -h)
165    Help(vars.GenerateHelpText(env))
166    
167    # Check for superfluous options
168    if len(vars.UnknownVariables())>0:
169        for k in vars.UnknownVariables():
170            print("Unknown option '%s'" % k)
171        Exit(1)
172    
173    #################### Make sure install directories exist #####################
174    
175    env['BUILD_DIR']=env['build_dir']
176    prefix=Dir(env['prefix']).abspath
177    env['incinstall'] = os.path.join(prefix, 'include')
178    env['bininstall'] = os.path.join(prefix, 'bin')
179    env['libinstall'] = os.path.join(prefix, 'lib')
180    env['pyinstall']  = os.path.join(prefix, 'esys')
181    if not os.path.isdir(env['bininstall']):
182        os.makedirs(env['bininstall'])
183    if not os.path.isdir(env['libinstall']):
184        os.makedirs(env['libinstall'])
185    if not os.path.isdir(env['pyinstall']):
186        os.makedirs(env['pyinstall'])
187    
188    env.Append(CPPPATH = [env['incinstall']])
189    env.Append(LIBPATH = [env['libinstall']])
190    
191    ################# Fill in compiler options if not set above ##################
192    
193    if env['cc'] != 'default': env['CC']=env['cc']
194    if env['cxx'] != 'default': env['CXX']=env['cxx']
195    
196    # version >=9 of intel C++ compiler requires use of icpc to link in C++
197    # runtimes (icc does not)
198    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
199        env['LINK'] = env['CXX']
200    
201    # default compiler/linker options
202    cc_flags = ''
203    cc_optim = ''
204    cc_debug = ''
205    omp_flags = ''
206    omp_ldflags = ''
207    fatalwarning = '' # switch to turn warnings into errors
208    sysheaderopt = '' # how to indicate that a header is a system header
209    
210    # env['CC'] might be a full path
211    cc_name=os.path.basename(env['CC'])
212    
213    if cc_name == 'icc':
214        # Intel compiler
215        cc_flags    = "-std=c99 -fPIC -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"
216        cc_optim    = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias -ip"
217        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
218        omp_flags   = "-openmp -openmp_report0"
219        omp_ldflags = "-openmp -openmp_report0 -lpthread"
220        fatalwarning = "-Werror"
221    elif cc_name[:3] == 'gcc':
222        # GNU C on any system
223        cc_flags     = "-pedantic -Wall -fPIC -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
224        cc_optim     = "-O3"
225        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
226        omp_flags    = "-fopenmp"
227        omp_ldflags  = "-fopenmp"
228        fatalwarning = "-Werror"
229        sysheaderopt = "-isystem"
230    elif cc_name == 'cl':
231        # Microsoft Visual C on Windows
232        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
233        cc_optim     = "/O2 /Op /W3"
234        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
235        fatalwarning = "/WX"
236    elif cc_name == 'icl':
237        # Intel C on Windows
238        cc_flags     = '/EHsc /GR /MD'
239        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
240        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
241        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
242        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
243    
244    # set defaults if not otherwise specified
245    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
246    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
247    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
248    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
249    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
250    if env['cc_extra']  != '': env.Append(CFLAGS = env['cc_extra'])
251    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
252    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
253    
254    if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
255    
256    if env['usepython3']:
257        env.Append(CPPDEFINES=['ESPYTHON3'])
258    
259    # set up the autolazy values
260    if env['forcelazy'] == 'on':
261        env.Append(CPPDEFINES=['FAUTOLAZYON'])
262    elif env['forcelazy'] == 'off':
263        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
264    
265    # set up the collective resolve values
266    if env['forcecollres'] == 'on':
267        env.Append(CPPDEFINES=['FRESCOLLECTON'])
268    elif env['forcecollres'] == 'off':
269        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
270    
271    # allow non-standard C if requested
272    if env['iknowwhatimdoing']:
273        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
274    
275    # Disable OpenMP if no flags provided
276    if env['openmp'] and env['omp_flags'] == '':
277       print("OpenMP requested but no flags provided - disabling OpenMP!")
278       env['openmp'] = False
279    
280    if env['openmp']:
281        env.Append(CCFLAGS = env['omp_flags'])
282        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
283    else:
284        env['omp_flags']=''
285        env['omp_ldflags']=''
286    
287    # add debug/non-debug compiler flags
288    if env['debug']:
289        env.Append(CCFLAGS = env['cc_debug'])
290    else:
291        env.Append(CCFLAGS = env['cc_optim'])
292    
293    # always add cc_flags
294    env.Append(CCFLAGS = env['cc_flags'])
295    
296    # add system libraries
297    env.AppendUnique(LIBS = env['sys_libs'])
298    
299    
300    global_revision=ARGUMENTS.get('SVN_VERSION', None)
301    if global_revision:
302        global_revision = re.sub(':.*', '', global_revision)
303        global_revision = re.sub('[^0-9]', '', global_revision)
304        if global_revision == '': global_revision='-2'
305    else:
306      # Get the global Subversion revision number for the getVersion() method
307      try:
308        global_revision = os.popen('svnversion -n .').read()
309        global_revision = re.sub(':.*', '', global_revision)
310        global_revision = re.sub('[^0-9]', '', global_revision)
311        if global_revision == '': global_revision='-2'
312      except:
313        global_revision = '-1'
314    env['svn_revision']=global_revision
315    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
316    
317    if IS_WINDOWS:
318        if not env['build_shared']:
319            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
320            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
321    
322    ###################### Copy required environment vars ########################
323    
324    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
325    if IS_WINDOWS:
326        LD_LIBRARY_PATH_KEY='PATH'
327        env['ENV']['LD_LIBRARY_PATH']=''
328  else:  else:
329     bounds_check = 0      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
330    
331  #=================================================================================================  # the following env variables are exported for the unit tests
 #  
 #     Initialise Scons Build Environment  
 #     check for user environment variables we are interested in  
 try:  
    tmp = os.environ['PYTHONPATH']  
    env['ENV']['PYTHONPATH'] = tmp  
 except KeyError:  
    pass  
332    
333  env.PrependENVPath('PYTHONPATH', source_root)  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
334        try:
335            env['ENV'][key] = os.environ[key]
336        except KeyError:
337            env['ENV'][key] = 1
338    
339  try:  env_export=env['env_export']
340     omp_num_threads = os.environ['OMP_NUM_THREADS']  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','TMPDIR','TEMP','TMP'])
341  except KeyError:  
342     omp_num_threads = 1  for key in set(env_export):
343  env['ENV']['OMP_NUM_THREADS'] = omp_num_threads      try:
344            env['ENV'][key] = os.environ[key]
345        except KeyError:
346            pass
347    
348  try:  try:
349     path = os.environ['PATH']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env['ENV']['PATH'] = path  
350  except KeyError:  except KeyError:
351     omp_num_threads = 1      pass
   
 env['ENV']['OMP_NUM_THREADS'] = omp_num_threads  
352    
353    # these shouldn't be needed
354    #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
355    #    try:
356    #        env['ENV'][key] = os.environ[key]
357    #    except KeyError:
358    #        pass
359    
 # Copy some variables from the system environment to the build environment  
360  try:  try:
361     env['ENV']['DISPLAY'] = os.environ['DISPLAY']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
    env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  
    home_temp = os.environ['HOME']   # MPICH2's mpd needs $HOME to find $HOME/.mpd.conf  
    env['ENV']['HOME'] = home_temp  
362  except KeyError:  except KeyError:
363     pass      pass
364    
365  try:  ######################## Add some custom builders ############################
    tmp = os.environ['PATH']  
    env['ENV']['PATH'] = tmp  
 except KeyError:  
    pass  
366    
367  try:  if env['pythoncmd']=='python':
368     tmp = os.environ['LD_LIBRARY_PATH']      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
369     print tmp  else:
370     env['ENV']['LD_LIBRARY_PATH'] = tmp      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
 except KeyError:  
    pass  
 #==========================================================================  
 #  
 #    Add some customer builders  
 #  
 py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  
371  env.Append(BUILDERS = {'PyCompile' : py_builder});  env.Append(BUILDERS = {'PyCompile' : py_builder});
372    
373  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed',  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
                               src_suffix=env['PROGSUFFIX'], single_source=True)  
   
374  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
375    
376  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
377  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
378    
379  # Convert the options which are held in environment variable into python variables for ease of handling and configure compilation options  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
380  try:  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
    incinstall = env['incinstall']  
    env.Append(CPPPATH = [incinstall,])  
 except KeyError:  
    incinstall = None  
 try:  
    libinstall = env['libinstall']  
    env.Append(LIBPATH = [libinstall,]) # Adds -L for building of libescript.so libfinley.so escriptcpp.so finleycpp.so  
    env.PrependENVPath('LD_LIBRARY_PATH', libinstall)  
    if IS_WINDOWS_PLATFORM :  
       env.PrependENVPath('PATH', libinstall)  
       env.PrependENVPath('PATH', env['boost_lib_path'])  
 except KeyError:  
    libinstall = None  
 try:  
    pyinstall = env['pyinstall'] # all targets will install into pyinstall/esys but PYTHONPATH points at straight pyinstall so you go import esys.escript etc  
 except KeyError:  
    pyinstall = None  
381    
382  try:  ############################ Dependency checks ###############################
    cc_defines = env['cc_defines']  
    env.Append(CPPDEFINES = cc_defines)  
 except KeyError:  
    pass  
 try:  
    flags = env['ar_flags']  
    env.Append(ARFLAGS = flags)  
 except KeyError:  
    ar_flags = None  
 try:  
    sys_libs = env['sys_libs']  
 except KeyError:  
    sys_libs = []  
383    
384  try:  # Create a Configure() environment to check for compilers and python
385     tar_flags = env['tar_flags']  conf = Configure(env.Clone())
    env.Replace(TARFLAGS = tar_flags)  
 except KeyError:  
    pass  
386    
387  try:  ######## Test that the compilers work
388     exinstall = env['exinstall']  
389  except KeyError:  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
390     exinstall = None      if not conf.CheckCC():
391  try:          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
392     sys_libinstall = env['sys_libinstall']          Exit(1)
393  except KeyError:      if not conf.CheckCXX():
394     sys_libinstall = None          print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
395  try:          Exit(1)
396     sys_pyinstall = env['sys_pyinstall']  else:
397  except KeyError:      if not conf.CheckFunc('printf', language='c'):
398     sys_pyinstall = None          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
399  try:          Exit(1)
400     sys_exinstall = env['sys_exinstall']      if not conf.CheckFunc('printf', language='c++'):
401  except KeyError:          print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
402     sys_exinstall = None          Exit(1)
403    
404  # ====================== debugging ===================================  if conf.CheckFunc('gethostname'):
405  try:      conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])
406     dodebug = env['dodebug']  
407  except KeyError:  ######## Python headers & library (required)
408     dodebug = None  
409    #First we check to see if the config file has specified
410  # === switch on omp ===================================================  ##Where to find the filae. Ideally, this should be automatic
411  try:  #But we need to deal with the case where python is not in its INSTALL
412    omp_flags = env['omp_flags']  #Directory
413  except KeyError:  # Use the python scons is running
414    omp_flags = ''  if env['pythoncmd']=='python':
415        python_inc_path=sysconfig.get_python_inc()
416        if IS_WINDOWS:
417            python_lib_path=os.path.join(sysconfig.get_config_var('prefix'), 'libs')
418        elif env['PLATFORM']=='darwin':
419            python_lib_path=sysconfig.get_config_var('LIBPL')
420        else:
421            python_lib_path=sysconfig.get_config_var('LIBDIR')
422    
423        #python_libs=[sysconfig.get_config_var('LDLIBRARY')] # only on linux
424        if IS_WINDOWS:
425            python_libs=['python%s%s'%(sys.version_info[0], sys.version_info[1])]
426        else:
427            python_libs=['python'+sysconfig.get_python_version()]
428    
429    #if we want to use a python other than the one scons is running
430    else:
431        initstring='from __future__ import print_function;from distutils import sysconfig;'
432        if env['pythonlibname']!='':
433            python_libs=env['pythonlibname']
434        else:   # work it out by calling python    
435            if IS_WINDOWS:
436                cmd='print("python%s%s"%(sys.version_info[0], sys.version_info[1]))'
437            else:
438                cmd='print("python"+sysconfig.get_python_version())'
439            p=Popen([env['pythoncmd'], '-c', initstring+cmd], stdout=PIPE)
440            python_libs=p.stdout.readline()
441            if env['usepython3']:       # This is to convert unicode str into py2 string
442                python_libs=python_libs.encode() # If scons runs on py3 then this must be rethought
443            p.wait()
444            python_libs=python_libs.strip()
445    
446  try:    
447    omp_flags_debug = env['omp_flags_debug']      # Now we know whether we are using python3 or not
448  except KeyError:      p=Popen([env['pythoncmd'], '-c',  initstring+'print(sysconfig.get_python_inc())'], stdout=PIPE)
449    omp_flags_debug = ''      python_inc_path=p.stdout.readline()
450        if env['usepython3']:
451             python_inc_path=python_inc_path.encode()
452        p.wait()  
453        python_inc_path=python_inc_path.strip()
454        if IS_WINDOWS:
455            cmd="os.path.join(sysconfig.get_config_var('prefix'), 'libs')"
456        elif env['PLATFORM']=='darwin':
457            cmd="sysconfig.get_config_var(\"LIBPL\")"
458        else:
459            cmd="sysconfig.get_config_var(\"LIBDIR\")"
460    
461        p=Popen([env['pythoncmd'], '-c', initstring+'print('+cmd+')'], stdout=PIPE)
462        python_lib_path=p.stdout.readline()
463        if env['usepython3']:
464            python_lib_path=python_lib_path.decode()
465        p.wait()
466        python_lib_path=python_lib_path.strip()
467    
468    #Check for an override from the config file.
469    #Ideally, this should be automatic
470    #But we need to deal with the case where python is not in its INSTALL
471    #Directory
472    if env['pythonlibpath']!='':
473        python_lib_path=env['pythonlibpath']
474    
475    if env['pythonincpath']!='':
476        python_inc_path=env['pythonincpath']
477    
478    
479    if sysheaderopt == '':
480        conf.env.AppendUnique(CPPPATH = [python_inc_path])
481    else:
482        conf.env.Append(CCFLAGS = [sysheaderopt, python_inc_path])
483    
484    conf.env.AppendUnique(LIBPATH = [python_lib_path])
485    conf.env.AppendUnique(LIBS = python_libs)
486    # The wrapper script needs to find the libs
487    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, python_lib_path)
488    
489    if not conf.CheckCHeader('Python.h'):
490        print("Cannot find python include files (tried 'Python.h' in directory %s)" % (python_inc_path))
491        Exit(1)
492    if not conf.CheckFunc('Py_Exit'):
493        print("Cannot find python library method Py_Main (tried %s in directory %s)" % (python_libs, python_lib_path))
494        Exit(1)
495    
496    ## reuse conf to check for numpy header (optional)
497    if env['usepython3']:
498        # FIXME: This is until we can work out how to make the checks in python 3
499        conf.env['numpy_h']=False
500    else:
501        if conf.CheckCXXHeader(['Python.h','numpy/ndarrayobject.h']):
502            conf.env.Append(CPPDEFINES = ['HAVE_NUMPY_H'])
503            conf.env['numpy_h']=True
504        else:
505            conf.env['numpy_h']=False
506    
507    # Commit changes to environment
508    env = conf.Finish()
509    
510    ######## boost (required)
511    
512    boost_inc_path,boost_lib_path=findLibWithHeader(env, env['boost_libs'], 'boost/python.hpp', env['boost_prefix'], lang='c++')
513    if sysheaderopt == '':
514        env.AppendUnique(CPPPATH = [boost_inc_path])
515    else:
516        # This is required because we can't -isystem /usr/include since it breaks
517        # std includes
518        if os.path.normpath(boost_inc_path) == '/usr/include':
519            conf.env.Append(CCFLAGS=[sysheaderopt, os.path.join(boost_inc_path,'boost')])
520        else:
521            env.Append(CCFLAGS=[sysheaderopt, boost_inc_path])
522    
523    env.AppendUnique(LIBPATH = [boost_lib_path])
524    env.AppendUnique(LIBS = env['boost_libs'])
525    env.PrependENVPath(LD_LIBRARY_PATH_KEY, boost_lib_path)
526    
527  # ========= use mpi? =====================================================  ######## numpy (required)
 try:  
    useMPI = env['useMPI']  
 except KeyError:  
    useMPI = None  
 # ========= set compiler flags ===========================================  
528    
529  if dodebug:  if env['pythoncmd']=='python':
530      try:      try:
531        flags = env['cc_flags_debug'] + ' ' + omp_flags_debug        from numpy import identity
532        env.Append(CCFLAGS = flags)      except ImportError:
533      except KeyError:        print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
534        pass        Exit(1)
535  else:  else:
536     try:      p=subprocess.call([env['pythoncmd'],'-c','import numpy'])
537        flags = env['cc_flags'] + ' ' + omp_flags      if p!=0:
538        env.Append(CCFLAGS = flags)        print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
539     except KeyError:        Exit(1)
540        pass  
541  if dodebug:  ######## CppUnit (required for tests)
542       try:  
543          flags = env['cxx_flags_debug']  try:
544          env.Append(CXXFLAGS = flags)      cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
545       except KeyError:      env.AppendUnique(CPPPATH = [cppunit_inc_path])
546          pass      env.AppendUnique(LIBPATH = [cppunit_lib_path])
547  else:      env.PrependENVPath(LD_LIBRARY_PATH_KEY, cppunit_lib_path)
548       try:      env['cppunit']=True
         flags = env['cxx_flags']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
 try:  
      if env['CC'] == 'gcc': env.Append(CCFLAGS = "-pedantic-errors -Wno-long-long")  
549  except:  except:
550       pass      env['cppunit']=False
   
 # ============= Remember what options were used in the compile =====================================  
 if not IS_WINDOWS_PLATFORM:  
   env.Execute("/bin/rm -f " + libinstall + "/Compiled.with.*")  
   if dodebug:       env.Execute("touch " + libinstall + "/Compiled.with.debug")  
   if useMPI:        env.Execute("touch " + libinstall + "/Compiled.with.mpi")  
   if omp_flags != '':   env.Execute("touch " + libinstall + "/Compiled.with.OpenMP")  
   if bounds_check:  env.Execute("touch " + libinstall + "/Compiled.with.bounds_check")  
   
 # ============= set mkl (but only of no MPI) =====================================  
 if not useMPI:  
    try:  
       includes = env['mkl_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['mkl_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
       env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
    except KeyError:  
       pass  
   
    try:  
       mkl_libs = env['mkl_libs']  
    except KeyError:  
       mkl_libs = []  
 else:  
      mkl_libs = []  
   
 # ============= set scsl (but only of no MPI) =====================================  
 if not useMPI:  
    try:  
       includes = env['scsl_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['scsl_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
       env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
    except KeyError:  
       pass  
     
    try:  
       scsl_libs = env['scsl_libs']  
    except KeyError:  
       scsl_libs = [ ]  
   
 else:  
     scsl_libs =  []  
   
 # ============= set TRILINOS (but only with MPI) =====================================  
 if useMPI:  
    try:  
       includes = env['trilinos_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['trilinos_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
    except KeyError:  
       pass  
   
    try:  
       trilinos_libs = env['trilinos_libs']  
    except KeyError:  
       trilinos_libs = []  
 else:  
      trilinos_libs = []  
   
   
 # ============= set umfpack (but only without MPI) =====================================  
 umf_libs=[ ]  
 if not useMPI:  
    try:  
       includes = env['umf_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['umf_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
    except KeyError:  
       pass  
   
    try:  
       umf_libs = env['umf_libs']  
       umf_libs+=umf_libs  
    except KeyError:  
       pass  
   
    try:  
       includes = env['ufc_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       includes = env['amd_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['amd_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
    except KeyError:  
       pass  
   
    try:  
       amd_libs = env['amd_libs']  
       umf_libs+=amd_libs  
    except KeyError:  
       pass  
   
 # ============= set TRILINOS (but only with MPI) =====================================  
 if useMPI:  
    try:  
       includes = env['trilinos_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['trilinos_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
    except KeyError:  
       pass  
   
    try:  
       trilinos_libs = env['trilinos_libs']  
    except KeyError:  
       trilinos_libs = []  
 else:  
      trilinos_libs = []  
551    
552  # ============= set blas =====================================  ######## netCDF (optional)
 try:  
    includes = env['blas_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
553    
554  try:  netcdf_inc_path=''
555     lib_path = env['blas_lib_path']  netcdf_lib_path=''
556     env.Append(LIBPATH = [lib_path,])  if env['netcdf']:
557  except KeyError:      netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'netcdf.h', env['netcdf_prefix'], lang='c++')
558     pass      env.AppendUnique(CPPPATH = [netcdf_inc_path])
559        env.AppendUnique(LIBPATH = [netcdf_lib_path])
560  try:      env.AppendUnique(LIBS = env['netcdf_libs'])
561     blas_libs = env['blas_libs']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, netcdf_lib_path)
562  except KeyError:      env.Append(CPPDEFINES = ['USE_NETCDF'])
563     blas_libs = [ ]  
564    ######## PAPI (optional)
565  # ========== netcdf ====================================  
566  try:  papi_inc_path=''
567     useNetCDF = env['useNetCDF']  papi_lib_path=''
568  except KeyError:  if env['papi']:
569     useNetCDF = 'yes'      papi_inc_path,papi_lib_path=findLibWithHeader(env, env['papi_libs'], 'papi.h', env['papi_prefix'], lang='c')
570     pass      env.AppendUnique(CPPPATH = [papi_inc_path])
571            env.AppendUnique(LIBPATH = [papi_lib_path])
572  if useNetCDF == 'yes':      env.AppendUnique(LIBS = env['papi_libs'])
573     try:      env.PrependENVPath(LD_LIBRARY_PATH_KEY, papi_lib_path)
574        netCDF_libs = env['netCDF_libs']      env.Append(CPPDEFINES = ['BLOCKPAPI'])
575     except KeyError:  
576        pass  ######## MKL (optional)
577    
578     env.Append(LIBS = netCDF_libs)  mkl_inc_path=''
579     env.Append(CPPDEFINES = [ 'USE_NETCDF' ])  mkl_lib_path=''
580     try:  if env['mkl']:
581        includes = env['netCDF_path']      mkl_inc_path,mkl_lib_path=findLibWithHeader(env, env['mkl_libs'], 'mkl_solver.h', env['mkl_prefix'], lang='c')
582        env.Append(CPPPATH = [includes,])      env.AppendUnique(CPPPATH = [mkl_inc_path])
583     except KeyError:      env.AppendUnique(LIBPATH = [mkl_lib_path])
584        pass      env.AppendUnique(LIBS = env['mkl_libs'])
585        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mkl_lib_path)
586     try:      env.Append(CPPDEFINES = ['MKL'])
587        lib_path = env['netCDF_lib_path']  
588        env.Append(LIBPATH = [ lib_path, ])  ######## UMFPACK (optional)
589        env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
590        if IS_WINDOWS_PLATFORM :  umfpack_inc_path=''
591           env.PrependENVPath('PATH', lib_path)  umfpack_lib_path=''
592     except KeyError:  if env['umfpack']:
593        pass      umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c')
594  else:      env.AppendUnique(CPPPATH = [umfpack_inc_path])
595     print "Warning: Installation is not configured with netCDF. Some I/O function may not be available."      env.AppendUnique(LIBPATH = [umfpack_lib_path])
596     netCDF_libs=[ ]      env.AppendUnique(LIBS = env['umfpack_libs'])
597        env.PrependENVPath(LD_LIBRARY_PATH_KEY, umfpack_lib_path)
598  # ====================== boost ======================================      env.Append(CPPDEFINES = ['UMFPACK'])
599  try:  
600     includes = env['boost_path']  ######## LAPACK (optional)
601     env.Append(CPPPATH = [includes,])  
602  except KeyError:  if env['lapack']=='mkl' and not env['mkl']:
603     pass      print("mkl_lapack requires MKL!")
604  try:      Exit(1)
605     lib_path = env['boost_lib_path']  
606     env.Append(LIBPATH = [lib_path,])  env['uselapack'] = env['lapack']!='none'
607     env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  lapack_inc_path=''
608     if IS_WINDOWS_PLATFORM :  lapack_lib_path=''
609        env.PrependENVPath('PATH', lib_path)  if env['uselapack']:
610  except KeyError:      header='clapack.h'
611     pass      if env['lapack']=='mkl':
612  try:          env.AppendUnique(CPPDEFINES = ['MKL_LAPACK'])
613     boost_lib = env['boost_lib']          header='mkl_lapack.h'
614  except KeyError:      lapack_inc_path,lapack_lib_path=findLibWithHeader(env, env['lapack_libs'], header, env['lapack_prefix'], lang='c')
615     boost_lib = None      env.AppendUnique(CPPPATH = [lapack_inc_path])
616  # ====================== python ======================================      env.AppendUnique(LIBPATH = [lapack_lib_path])
617  try:      env.AppendUnique(LIBS = env['lapack_libs'])
618     includes = env['python_path']      env.Append(CPPDEFINES = ['USE_LAPACK'])
619     env.Append(CPPPATH = [includes,])  
620  except KeyError:  ######## Silo (optional)
621     pass  
622  try:  silo_inc_path=''
623     lib_path = env['python_lib_path']  silo_lib_path=''
624     env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  if env['silo']:
625     env.Append(LIBPATH = [lib_path,])      silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c')
626  except KeyError:      env.AppendUnique(CPPPATH = [silo_inc_path])
627     pass      env.AppendUnique(LIBPATH = [silo_lib_path])
628  try:      # Note that we do not add the libs since they are only needed for the
629     python_lib = env['python_lib']      # weipa library and tools.
630  except KeyError:      #env.AppendUnique(LIBS = [env['silo_libs']])
631     python_lib = None  
632  # =============== documentation =======================================  ######## VSL random numbers (optional)
633  try:  if env['vsl_random']:
634     doxygen_path = env['doxygen_path']      env.Append(CPPDEFINES = ['MKLRANDOM'])
635  except KeyError:  
636     doxygen_path = None  ######## VisIt (optional)
637  try:  
638     epydoc_path = env['epydoc_path']  visit_inc_path=''
639  except KeyError:  visit_lib_path=''
640     epydoc_path = None  if env['visit']:
641  # =============== PAPI =======================================      visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c')
642  try:      env.AppendUnique(CPPPATH = [visit_inc_path])
643     includes = env['papi_path']      env.AppendUnique(LIBPATH = [visit_lib_path])
644     env.Append(CPPPATH = [includes,])  
645  except KeyError:  ######## MPI (optional)
646     pass  
647  try:  if env['mpi']=='no':
648     lib_path = env['papi_lib_path']      env['mpi']='none'
649     env.Append(LIBPATH = [lib_path,])  
650  except KeyError:  env['usempi'] = env['mpi']!='none'
651     pass  mpi_inc_path=''
652  try:  mpi_lib_path=''
653     papi_libs = env['papi_libs']  if env['usempi']:
654  except KeyError:      mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c')
655     papi_libs = None      env.AppendUnique(CPPPATH = [mpi_inc_path])
656  # ============= set mpi =====================================      env.AppendUnique(LIBPATH = [mpi_lib_path])
657  if useMPI:      env.AppendUnique(LIBS = env['mpi_libs'])
658     env.Append(CPPDEFINES=['PASO_MPI',])      env.PrependENVPath(LD_LIBRARY_PATH_KEY, mpi_lib_path)
659     try:      env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
660        includes = env['mpi_path']      # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
661        env.Append(CPPPATH = [includes,])      # On the other hand MPT and OpenMPI don't define the latter so we have to
662     except KeyError:      # do that here
663        pass      if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
664     try:          env.Append(CPPDEFINES = ['MPI_INCLUDED'])
665        lib_path = env['mpi_lib_path']  
666        env.Append(LIBPATH = [lib_path,])  ######## BOOMERAMG (optional)
667        env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
668     except KeyError:  if env['mpi'] == 'none': env['boomeramg'] = False
669        pass  
670     try:  boomeramg_inc_path=''
671        mpi_libs = env['mpi_libs']  boomeramg_lib_path=''
672     except KeyError:  if env['boomeramg']:
673        mpi_libs = []      boomeramg_inc_path,boomeramg_lib_path=findLibWithHeader(env, env['boomeramg_libs'], 'HYPRE.h', env['boomeramg_prefix'], lang='c')
674        env.AppendUnique(CPPPATH = [boomeramg_inc_path])
675     try:      env.AppendUnique(LIBPATH = [boomeramg_lib_path])
676        mpi_run = env['mpi_run']      env.AppendUnique(LIBS = env['boomeramg_libs'])
677     except KeyError:      env.PrependENVPath(LD_LIBRARY_PATH_KEY, boomeramg_lib_path)
678        mpi_run = ''      env.Append(CPPDEFINES = ['BOOMERAMG'])
679    
680     try:  ######## ParMETIS (optional)
681         mpich_ignore_cxx_seek=env['MPICH_IGNORE_CXX_SEEK']  
682         env.Append(CPPDEFINES = [ mpich_ignore_cxx_seek ] )  if not env['usempi']: env['parmetis'] = False
683     except KeyError:  
684        pass  parmetis_inc_path=''
685  else:  parmetis_lib_path=''
686    mpi_libs=[]  if env['parmetis']:
687    mpi_run = mpi_run_default      parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c')
688  # =========== zip files ===========================================      env.AppendUnique(CPPPATH = [parmetis_inc_path])
689  try:      env.AppendUnique(LIBPATH = [parmetis_lib_path])
690     includes = env['papi_path']      env.AppendUnique(LIBS = env['parmetis_libs'])
691     env.Append(CPPPATH = [includes,])      env.PrependENVPath(LD_LIBRARY_PATH_KEY, parmetis_lib_path)
692  except KeyError:      env.Append(CPPDEFINES = ['USE_PARMETIS'])
693     pass  
694  try:  ######## gmsh (optional, for tests)
695     lib_path = env['papi_lib_path']  
696     env.Append(LIBPATH = [lib_path,])  try:
697  except KeyError:      import subprocess
698     pass      p=subprocess.Popen(['gmsh', '-info'], stderr=subprocess.PIPE)
699  try:      _,e=p.communicate()
700     papi_libs = env['papi_libs']      if e.split().count("MPI"):
701  except KeyError:          env['gmsh']='m'
702     papi_libs = None      else:
703  try:          env['gmsh']='s'
704     papi_instrument_solver = env['papi_instrument_solver']  except OSError:
705  except KeyError:      env['gmsh']=False
706     papi_instrument_solver = None  
707    ######## PDFLaTeX (for documentation)
708    if 'PDF' in dir(env) and '.tex' in env.PDF.builder.src_suffixes(env):
709  # ============= and some helpers =====================================      env['pdflatex']=True
710  try:  else:
711     doxygen_path = env['doxygen_path']      env['pdflatex']=False
712  except KeyError:  
713     doxygen_path = None  ######################## Summarize our environment ###########################
714  try:  
715     epydoc_path = env['epydoc_path']  # keep some of our install paths first in the list for the unit tests
716  except KeyError:  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
717     epydoc_path = None  env.PrependENVPath('PYTHONPATH', prefix)
718  try:  env['ENV']['ESCRIPT_ROOT'] = prefix
719     src_zipfile = env.File(env['src_zipfile'])  
720  except KeyError:  if not env['verbose']:
721     src_zipfile = None      env['CCCOMSTR'] = "Compiling $TARGET"
722  try:      env['CXXCOMSTR'] = "Compiling $TARGET"
723     test_zipfile = env.File(env['test_zipfile'])      env['SHCCCOMSTR'] = "Compiling $TARGET"
724  except KeyError:      env['SHCXXCOMSTR'] = "Compiling $TARGET"
725     test_zipfile = None      env['ARCOMSTR'] = "Linking $TARGET"
726  try:      env['LINKCOMSTR'] = "Linking $TARGET"
727     examples_zipfile = env.File(env['examples_zipfile'])      env['SHLINKCOMSTR'] = "Linking $TARGET"
728  except KeyError:      env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
729     examples_zipfile = None      env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
730        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
731  try:      env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
732     src_tarfile = env.File(env['src_tarfile'])      #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
733  except KeyError:  
734     src_tarfile = None  print("")
735  try:  print("*** Config Summary (see config.log and lib/buildvars for details) ***")
736     test_tarfile = env.File(env['test_tarfile'])  print("Escript/Finley revision %s"%global_revision)
737  except KeyError:  print("  Install prefix:  %s"%env['prefix'])
738     test_tarfile = None  print("          Python:  %s"%sysconfig.PREFIX)
739  try:  print("           boost:  %s"%env['boost_prefix'])
740     examples_tarfile = env.File(env['examples_tarfile'])  print("           numpy:  YES")
741  except KeyError:  if env['usempi']:
742     examples_tarfile = None      print("             MPI:  YES (flavour: %s)"%env['mpi'])
743    else:
744  try:      print("             MPI:  DISABLED")
745     guide_pdf = env.File(env['guide_pdf'])  if env['uselapack']:
746  except KeyError:      print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
747     guide_pdf = None  else:
748        print("          LAPACK:  DISABLED")
749  try:  d_list=[]
750     guide_html_index = env.File('index.htm',env['guide_html'])  e_list=[]
751  except KeyError:  for i in 'debug','openmp','netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit','vsl_random':
752     guide_html_index = None      if env[i]: e_list.append(i)
753        else: d_list.append(i)
754  try:  for i in e_list:
755     api_epydoc = env.Dir(env['api_epydoc'])      print("%16s:  YES"%i)
756  except KeyError:  for i in d_list:
757     api_epydoc = None      print("%16s:  DISABLED"%i)
758    if env['cppunit']:
759  try:      print("         CppUnit:  FOUND")
760     api_doxygen = env.Dir(env['api_doxygen'])  else:
761  except KeyError:      print("         CppUnit:  NOT FOUND")
762     api_doxygen = None  if env['gmsh']=='m':
763        print("            gmsh:  FOUND, MPI-ENABLED")
764  try:  elif env['gmsh']=='s':
765     svn_pipe = os.popen("svnversion -n .")      print("            gmsh:  FOUND")
766     global_revision = svn_pipe.readlines()  else:
767     svn_pipe.close()      print("            gmsh:  NOT FOUND")
768     global_revision = re.sub(":.*", "", global_revision[0])  if env['numpy_h']:
769     global_revision = re.sub("[^0-9]", "", global_revision)      print("   numpy headers:  FOUND")
770  except:  else:
771     global_revision="-1"      print("   numpy headers:  NOT FOUND")
772     print "Warning: unable to recover global revsion number."  print("   vsl_random:  %s"%env['vsl_random'])
773  if global_revision == "": global_revision="0"      
774  print "Revision number is %s."%global_revision  if ((fatalwarning != '') and (env['werror'])):
775  env.Append(CPPDEFINES = "SVN_VERSION="+global_revision)      print("  Treating warnings as errors")
776    else:
777  # Python install - esys __init__.py      print("  NOT treating warnings as errors")
778  init_target = env.Command(pyinstall+'/__init__.py', None, Touch('$TARGET'))  print("")
779    
780  # FIXME: exinstall and friends related to examples are not working.  ####################### Configure the subdirectories #########################
781  build_target = env.Alias('build',[libinstall,incinstall,pyinstall,init_target])  
782    from grouptest import *
783  env.Default(build_target)  
784    TestGroups=[]
785  # Zipgets  
786  env.Alias('release_src',[ src_zipfile, src_tarfile ])  # keep an environment without warnings-as-errors
787  env.Alias('release_tests',[ test_zipfile, test_tarfile])  dodgy_env=env.Clone()
788  env.Alias('release_examples',[ examples_zipfile, examples_tarfile])  
789  env.Alias('examples_zipfile',examples_zipfile)  # now add warnings-as-errors flags. This needs to be done after configuration
790  env.Alias('examples_tarfile',examples_tarfile)  # because the scons test files have warnings in them
791  env.Alias('api_epydoc',api_epydoc)  if ((fatalwarning != '') and (env['werror'])):
792  env.Alias('api_doxygen',api_doxygen)      env.Append(CCFLAGS = fatalwarning)
793  env.Alias('guide_html_index',guide_html_index)  
794  env.Alias('guide_pdf', guide_pdf)  Export(
795  env.Alias('docs',[ 'release_examples', 'guide_pdf', api_epydoc, api_doxygen, guide_html_index])    ['env',
796  env.Alias('release', ['release_src', 'release_tests', 'docs'])     'dodgy_env',
797       'IS_WINDOWS',
798  env.Alias('build_tests',build_target)    # target to build all C++ tests     'TestGroups'
799  env.Alias('build_py_tests',build_target) # target to build all python tests    ]
800  env.Alias('build_all_tests', [ 'build_tests', 'build_py_tests' ] ) # target to build all python tests  )
 env.Alias('run_tests', 'build_tests')   # target to run all C++ test  
 env.Alias('py_tests', 'build_py_tests') # taget to run all released python tests  
 env.Alias('all_tests', ['run_tests', 'py_tests']) # target to run all C++ and released python tests  
   
   
 # Allow sconscripts to see the env  
 Export(["IS_WINDOWS_PLATFORM", "env", "incinstall", "libinstall", "pyinstall", "dodebug", "mkl_libs", "scsl_libs", "umf_libs", "blas_libs", "netCDF_libs", "useNetCDF", "mpi_run",  
     "boost_lib", "python_lib", "doxygen_path", "epydoc_path", "papi_libs",  
         "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "examples_tarfile", "examples_zipfile", "trilinos_libs", "mpi_libs", "papi_instrument_solver",  
         "guide_pdf", "guide_html_index", "api_epydoc", "api_doxygen", "useMPI" ])  
   
 # End initialisation section  
 # Begin configuration section  
 # adds this file and the scons option directore to the source tar  
 release_srcfiles=[env.File('SConstruct'),env.Dir('lib'),env.Dir('include'),]+[ env.File(x) for x in glob.glob('scons/*.py') ]  
 release_testfiles=[env.File('README_TESTS'),]  
 env.Zip(src_zipfile, release_srcfiles)  
 env.Zip(test_zipfile, release_testfiles)  
 try:  
    env.Tar(src_tarfile, release_srcfiles)  
    env.Tar(test_tarfile, release_testfiles)  
 except AttributeError:  
    pass  
 # Insert new components to be build here  
 # FIXME: might be nice to replace this verbosity with a list of targets and some  
 # FIXME: nifty python to create the lengthy but very similar env.Sconscript lines  
 # Third Party libraries  
 env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
 # C/C++ Libraries  
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 # bruce is removed for now as it doesn't really do anything  
 # env.SConscript(dirs = ['bruce/src'], build_dir='build/$PLATFORM/bruce', duplicate=0)  
 env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
 env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  
 env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  
 env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 #env.SConscript(dirs = ['../test'], build_dir='../test/build', duplicate=0)  
801    
802    env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
803    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
804    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
805    env.SConscript(dirs = ['escript/src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
806    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
807    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
808    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
809    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
810    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
811    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
812    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
813    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
814    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
815    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
816    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
817    
818    
819    ######################## Populate the buildvars file #########################
820    
821    # remove obsolete file
822    if not env['usempi']:
823        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
824        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
825    
826    # Try to extract the boost version from version.hpp
827    boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
828    boostversion='unknown'
829    try:
830        for line in boosthpp:
831            ver=re.match(r'#define BOOST_VERSION (\d+)',line)
832            if ver:
833                boostversion=ver.group(1)
834    except StopIteration:
835        pass
836    boosthpp.close()
837    
838    
839    buildvars=open(os.path.join(env['libinstall'], 'buildvars'), 'w')
840    buildvars.write("svn_revision="+str(global_revision)+"\n")
841    buildvars.write("prefix="+prefix+"\n")
842    buildvars.write("cc="+env['CC']+"\n")
843    buildvars.write("cxx="+env['CXX']+"\n")
844    if env['pythoncmd']=='python':
845        buildvars.write("python="+sys.executable+"\n")
846        buildvars.write("python_version="+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+"\n")
847    else:
848        buildvars.write("python="+env['pythoncmd']+"\n")
849        p=Popen([env['pythoncmd'], '-c', 'from __future__ import print_function;import sys;print(str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2]))'], stdout=PIPE)
850        verstring=p.stdout.readline().strip()
851        p.wait()
852        buildvars.write("python_version="+verstring+"\n")
853    buildvars.write("boost_inc_path="+boost_inc_path+"\n")
854    buildvars.write("boost_lib_path="+boost_lib_path+"\n")
855    buildvars.write("boost_version="+boostversion+"\n")
856    buildvars.write("debug=%d\n"%int(env['debug']))
857    buildvars.write("openmp=%d\n"%int(env['openmp']))
858    buildvars.write("mpi=%s\n"%env['mpi'])
859    buildvars.write("mpi_inc_path=%s\n"%mpi_inc_path)
860    buildvars.write("mpi_lib_path=%s\n"%mpi_lib_path)
861    buildvars.write("lapack=%s\n"%env['lapack'])
862    buildvars.write("vsl_random=%d\n"%int(env['vsl_random']))
863    for i in 'netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit':
864        buildvars.write("%s=%d\n"%(i, int(env[i])))
865        if env[i]:
866            buildvars.write("%s_inc_path=%s\n"%(i, eval(i+'_inc_path')))
867            buildvars.write("%s_lib_path=%s\n"%(i, eval(i+'_lib_path')))
868    buildvars.close()
869    
870    ################### Targets to build and install libraries ###################
871    
872    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
873    env.Alias('target_init', [target_init])
874    # delete buildvars upon cleanup
875    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
876    
877    # The headers have to be installed prior to build in order to satisfy
878    # #include <paso/Common.h>
879    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
880    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
881    
882    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
883    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
884    
885    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
886    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escript_py'])
887    
888    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
889    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
890    
891    env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
892    env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
893    
894    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
895    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
896    
897    env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
898    env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
899    
900    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
901    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
902    
903    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
904    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
905    
906    # Now gather all the above into some easy targets: build_all and install_all
907    build_all_list = []
908    build_all_list += ['build_esysUtils']
909    build_all_list += ['build_paso']
910    build_all_list += ['build_escript']
911    build_all_list += ['build_pasowrap']
912    build_all_list += ['build_dudley']
913    build_all_list += ['build_finley']
914    build_all_list += ['build_ripley']
915    build_all_list += ['build_weipa']
916    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
917    if env['usempi']:   build_all_list += ['build_pythonMPI']
918    build_all_list += ['build_escriptconvert']
919    env.Alias('build_all', build_all_list)
920    
921    install_all_list = []
922    install_all_list += ['target_init']
923    install_all_list += ['install_esysUtils']
924    install_all_list += ['install_paso']
925    install_all_list += ['install_escript']
926    install_all_list += ['install_pasowrap']
927    install_all_list += ['install_dudley']
928    install_all_list += ['install_finley']
929    install_all_list += ['install_ripley']
930    install_all_list += ['install_weipa']
931    if not IS_WINDOWS: install_all_list += ['install_escriptreader']
932    install_all_list += ['install_downunder_py']
933    install_all_list += ['install_modellib_py']
934    install_all_list += ['install_pycad_py']
935    if env['usempi']:   install_all_list += ['install_pythonMPI']
936    install_all_list += ['install_escriptconvert']
937    env.Alias('install_all', install_all_list)
938    
939    # Default target is install
940    env.Default('install_all')
941    
942    ################## Targets to build and run the test suite ###################
943    
944    if not env['cppunit']:
945        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C/C++ unit tests, CppUnit not found!";exit 1')
946        env.Alias('run_tests', test_msg)
947    env.Alias('run_tests', ['install_all'])
948    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
949    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
950    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
951    
952    ##################### Targets to build the documentation #####################
953    
954    env.Alias('api_epydoc','install_all')
955    env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'user_pdf', 'install_pdf', 'cookbook_pdf'])
956    env.Alias('release_prep', ['docs', 'install_all'])
957    
958  syslib_install_target = env.installDirectory(sys_libinstall,libinstall)  if not IS_WINDOWS:
959  syspy_install_target = env.installDirectory(sys_pyinstall,pyinstall,recursive=True)      try:
960            utest=open('utest.sh','w')
961            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix))
962            for tests in TestGroups:
963                utest.write(tests.makeString())
964            utest.close()
965            Execute(Chmod('utest.sh', 0o755))
966            print("Generated utest.sh.")
967        except IOError:
968            print("Error attempting to write unittests file.")
969            Exit(1)
970    
971        # delete utest.sh upon cleanup
972        env.Clean('target_init', 'utest.sh')
973    
974        # Make sure that the escript wrapper is in place
975        if not os.path.isfile(os.path.join(env['bininstall'], 'run-escript')):
976            print("Copying escript wrapper.")
977            Execute(Copy(os.path.join(env['bininstall'],'run-escript'), 'bin/run-escript'))
978    
 install_target = env.Alias("install", env.Flatten([syslib_install_target, syspy_install_target]) )  

Legend:
Removed from v.1428  
changed lines
  Added in v.3961

  ViewVC Help
Powered by ViewVC 1.1.26