/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.1388  
changed lines
  Added in v.3967

  ViewVC Help
Powered by ViewVC 1.1.26