/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.1416  
changed lines
  Added in v.3942

  ViewVC Help
Powered by ViewVC 1.1.26