/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 1375 by gross, Wed Jan 9 00:15:05 2008 UTC revision 3947 by caltinay, Wed Aug 22 23:19:10 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',''),
 #  
 #    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)  
135  )  )
 #=================================================================================================  
 #  
 #   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)  
136    
137  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  ##################### Create environment and help text #######################
138    
139  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
140  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  # about failing to find the compilers. This warning can be safely ignored.
141    
142  # 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
143  try:  # in default locations.
144     incinstall = env['incinstall']  env = Environment(tools = ['default'], options = vars,
145     env.Append(CPPPATH = [incinstall,])                    ENV = {'PATH': os.environ['PATH']})
146  except KeyError:  if env['tools_names'] != 'default':
147     incinstall = None      env = Environment(tools = ['default'] + env['tools_names'], options = vars,
148  try:                        ENV = {'PATH' : os.environ['PATH']})
149     libinstall = env['libinstall']  
150     env.Append(LIBPATH = [libinstall,]) # Adds -L for building of libescript.so libfinley.so escriptcpp.so finleycpp.so  if options_file:
151     env.PrependENVPath('LD_LIBRARY_PATH', libinstall)      opts_valid=False
152     if IS_WINDOWS_PLATFORM :      if 'escript_opts_version' in env.Dictionary() and \
153        env.PrependENVPath('PATH', libinstall)          int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
154        env.PrependENVPath('PATH', env['boost_lib_path'])              opts_valid=True
155  except KeyError:      if opts_valid:
156     libinstall = None          print("Using options in %s." % options_file)
157  try:      else:
158     pyinstall = env['pyinstall'] # all targets will install into pyinstall/esys but PYTHONPATH points at straight pyinstall so you go import esys.escript etc          print("\nOptions file %s" % options_file)
159  except KeyError:          print("is outdated! Please update the file by examining one of the TEMPLATE")
160     pyinstall = None          print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
161            Exit(1)
162  try:  
163     cc_defines = env['cc_defines']  # Generate help text (scons -h)
164     env.Append(CPPDEFINES = cc_defines)  Help(vars.GenerateHelpText(env))
165  except KeyError:  
166     pass  # Check for superfluous options
167  try:  if len(vars.UnknownVariables())>0:
168     flags = env['ar_flags']      for k in vars.UnknownVariables():
169     env.Append(ARFLAGS = flags)          print("Unknown option '%s'" % k)
170  except KeyError:      Exit(1)
171     ar_flags = None  
172  try:  #################### Make sure install directories exist #####################
173     sys_libs = env['sys_libs']  
174  except KeyError:  env['BUILD_DIR']=env['build_dir']
175     sys_libs = []  prefix=Dir(env['prefix']).abspath
176    env['incinstall'] = os.path.join(prefix, 'include')
177  try:  env['bininstall'] = os.path.join(prefix, 'bin')
178     tar_flags = env['tar_flags']  env['libinstall'] = os.path.join(prefix, 'lib')
179     env.Replace(TARFLAGS = tar_flags)  env['pyinstall']  = os.path.join(prefix, 'esys')
180  except KeyError:  if not os.path.isdir(env['bininstall']):
181     pass      os.makedirs(env['bininstall'])
182    if not os.path.isdir(env['libinstall']):
183  try:      os.makedirs(env['libinstall'])
184     exinstall = env['exinstall']  if not os.path.isdir(env['pyinstall']):
185  except KeyError:      os.makedirs(env['pyinstall'])
186     exinstall = None  
187  try:  env.Append(CPPPATH = [env['incinstall']])
188     sys_libinstall = env['sys_libinstall']  env.Append(LIBPATH = [env['libinstall']])
189  except KeyError:  
190     sys_libinstall = None  ################# Fill in compiler options if not set above ##################
191  try:  
192     sys_pyinstall = env['sys_pyinstall']  if env['cc'] != 'default': env['CC']=env['cc']
193  except KeyError:  if env['cxx'] != 'default': env['CXX']=env['cxx']
194     sys_pyinstall = None  
195  try:  # version >=9 of intel C++ compiler requires use of icpc to link in C++
196     sys_exinstall = env['sys_exinstall']  # runtimes (icc does not)
197  except KeyError:  if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
198     sys_exinstall = None      env['LINK'] = env['CXX']
199    
200  # ====================== debugging ===================================  # default compiler/linker options
201  try:  cc_flags = ''
202     dodebug = env['dodebug']  cc_optim = ''
203  except KeyError:  cc_debug = ''
204     dodebug = None  omp_flags = ''
205    omp_ldflags = ''
206  # === switch on omp ===================================================  fatalwarning = '' # switch to turn warnings into errors
207  try:  sysheaderopt = '' # how to indicate that a header is a system header
208    omp_flags = env['omp_flags']  
209  except KeyError:  # env['CC'] might be a full path
210    omp_flags = ''  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:
326        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
327    
328  try:  # the following env variables are exported for the unit tests
   omp_flags_debug = env['omp_flags_debug']  
 except KeyError:  
   omp_flags_debug = ''  
329    
330  # ========= use mpi? =====================================================  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
331  try:      try:
332     useMPI = env['useMPI']          env['ENV'][key] = os.environ[key]
333  except KeyError:      except KeyError:
334     useMPI = None          env['ENV'][key] = 1
 # ========= set compiler flags ===========================================  
335    
336  # Can't use MPI and OpenMP simultaneously at this time  env_export=env['env_export']
337  if useMPI:  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','TMPDIR','TEMP','TMP'])
     omp_flags=''  
     omp_flags_debug=''  
338    
339  if dodebug:  for key in set(env_export):
340      try:      try:
341        flags = env['cc_flags_debug'] + ' ' + omp_flags_debug          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
342      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:  
343          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 = []  
344    
 # ============= set blas =====================================  
345  try:  try:
346     includes = env['blas_path']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Append(CPPPATH = [includes,])  
347  except KeyError:  except KeyError:
348     pass      pass
349    
350  try:  # these shouldn't be needed
351     lib_path = env['blas_lib_path']  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
352     env.Append(LIBPATH = [lib_path,])  #    try:
353  except KeyError:  #        env['ENV'][key] = os.environ[key]
354     pass  #    except KeyError:
355    #        pass
356    
357  try:  try:
358     blas_libs = env['blas_libs']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
359  except KeyError:  except KeyError:
360     blas_libs = [ ]      pass
361    
362  # ========== netcdf ====================================  ######################## Add some custom builders ############################
363  try:  
364     useNetCDF = env['useNetCDF']  if env['pythoncmd']=='python':
365  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  
366  else:  else:
367     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)
368     netCDF_libs=[ ]  env.Append(BUILDERS = {'PyCompile' : py_builder});
369    
370  # ====================== boost ======================================  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
371  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  
372    
373    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
374    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
375    
376  # ============= and some helpers =====================================  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
377  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  
378    
379  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  
380    
381  try:  # Create a Configure() environment to check for compilers and python
382     guide_pdf = env.File(env['guide_pdf'])  conf = Configure(env.Clone())
 except KeyError:  
    guide_pdf = None  
383    
384  try:  ######## Test that the compilers work
385     guide_html_index = env.File('index.htm',env['guide_html'])  
386  except KeyError:  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
387     guide_html_index = None      if not conf.CheckCC():
388            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     api_epydoc = env.Dir(env['api_epydoc'])      # 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     api_epydoc = None      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  try:  ######## numpy (required)
    api_doxygen = env.Dir(env['api_doxygen'])  
 except KeyError:  
    api_doxygen = None  
525    
526  try:  if env['pythoncmd']=='python':
527     svn_pipe = os.popen("svnversion -n .")      try:
528     global_revision = svn_pipe.readlines()        from numpy import identity
529     svn_pipe.close()      except ImportError:
530     global_revision = re.sub(":.*", "", global_revision[0])        print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
531     global_revision = re.sub("[^0-9]", "", global_revision)        Exit(1)
532    else:
533        p=subprocess.call([env['pythoncmd'],'-c','import numpy'])
534        if p!=0:
535          print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
536          Exit(1)
537    
538    ######## CppUnit (required for tests)
539    
540    try:
541        cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
542        env.AppendUnique(CPPPATH = [cppunit_inc_path])
543        env.AppendUnique(LIBPATH = [cppunit_lib_path])
544        env.PrependENVPath(LD_LIBRARY_PATH_KEY, cppunit_lib_path)
545        env['cppunit']=True
546  except:  except:
547     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'))  
548    
549  # FIXME: exinstall and friends related to examples are not working.  ######## netCDF (optional)
 build_target = env.Alias('build',[libinstall,incinstall,pyinstall,init_target])  
550    
551  env.Default(build_target)  netcdf_inc_path=''
552    netcdf_lib_path=''
553  # Zipgets  if env['netcdf']:
554  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++')
555  env.Alias('release_tests',[ test_zipfile, test_tarfile])      env.AppendUnique(CPPPATH = [netcdf_inc_path])
556  env.Alias('release_examples',[ examples_zipfile, examples_tarfile])      env.AppendUnique(LIBPATH = [netcdf_lib_path])
557  env.Alias('examples_zipfile',examples_zipfile)      env.AppendUnique(LIBS = env['netcdf_libs'])
558  env.Alias('examples_tarfile',examples_tarfile)      env.PrependENVPath(LD_LIBRARY_PATH_KEY, netcdf_lib_path)
559  env.Alias('api_epydoc',api_epydoc)      env.Append(CPPDEFINES = ['USE_NETCDF'])
560  env.Alias('api_doxygen',api_doxygen)  
561  env.Alias('guide_html_index',guide_html_index)  ######## PAPI (optional)
562  env.Alias('guide_pdf', guide_pdf)  
563  env.Alias('docs',[ 'release_examples', 'guide_pdf', api_epydoc, api_doxygen, guide_html_index])  papi_inc_path=''
564  env.Alias('release', ['release_src', 'release_tests', 'docs'])  papi_lib_path=''
565    if env['papi']:
566  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')
567  env.Alias('build_py_tests',build_target) # target to build all python tests      env.AppendUnique(CPPPATH = [papi_inc_path])
568  env.Alias('build_all_tests', [ 'build_tests', 'build_py_tests' ] ) # target to build all python tests      env.AppendUnique(LIBPATH = [papi_lib_path])
569  env.Alias('run_tests', 'build_tests')   # target to run all C++ test      env.AppendUnique(LIBS = env['papi_libs'])
570  env.Alias('py_tests', 'build_py_tests') # taget to run all released python tests      env.PrependENVPath(LD_LIBRARY_PATH_KEY, papi_lib_path)
571  env.Alias('all_tests', ['run_tests', 'py_tests']) # target to run all C++ and released python tests      env.Append(CPPDEFINES = ['BLOCKPAPI'])
572    
573    ######## MKL (optional)
574  # Allow sconscripts to see the env  
575  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=''
576      "boost_lib", "python_lib", "doxygen_path", "epydoc_path", "papi_libs",  mkl_lib_path=''
577          "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "examples_tarfile", "examples_zipfile", "trilinos_libs", "mpi_libs", "papi_instrument_solver",  if env['mkl']:
578          "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')
579        env.AppendUnique(CPPPATH = [mkl_inc_path])
580  # End initialisation section      env.AppendUnique(LIBPATH = [mkl_lib_path])
581  # Begin configuration section      env.AppendUnique(LIBS = env['mkl_libs'])
582  # adds this file and the scons option directore to the source tar      env.PrependENVPath(LD_LIBRARY_PATH_KEY, mkl_lib_path)
583  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'])
584  release_testfiles=[env.File('README_TESTS'),]  
585  env.Zip(src_zipfile, release_srcfiles)  ######## UMFPACK (optional)
586  env.Zip(test_zipfile, release_testfiles)  
587  try:  umfpack_inc_path=''
588     env.Tar(src_tarfile, release_srcfiles)  umfpack_lib_path=''
589     env.Tar(test_tarfile, release_testfiles)  if env['umfpack']:
590  except AttributeError:      umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c')
591     pass      env.AppendUnique(CPPPATH = [umfpack_inc_path])
592  # Insert new components to be build here      env.AppendUnique(LIBPATH = [umfpack_lib_path])
593  # FIXME: might be nice to replace this verbosity with a list of targets and some      env.AppendUnique(LIBS = env['umfpack_libs'])
594  # FIXME: nifty python to create the lengthy but very similar env.Sconscript lines      env.PrependENVPath(LD_LIBRARY_PATH_KEY, umfpack_lib_path)
595  # Third Party libraries      env.Append(CPPDEFINES = ['UMFPACK'])
596  env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
597  # C/C++ Libraries  ######## LAPACK (optional)
598  env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
599  # bruce is removed for now as it doesn't really do anything  if env['lapack']=='mkl' and not env['mkl']:
600  # env.SConscript(dirs = ['bruce/src'], build_dir='build/$PLATFORM/bruce', duplicate=0)      print("mkl_lapack requires MKL!")
601  env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)      Exit(1)
602  env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
603  env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  env['uselapack'] = env['lapack']!='none'
604  env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  lapack_inc_path=''
605  env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  lapack_lib_path=''
606  env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  if env['uselapack']:
607  env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)      header='clapack.h'
608  env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)      if env['lapack']=='mkl':
609  #env.SConscript(dirs = ['../test'], build_dir='../test/build', duplicate=0)          env.AppendUnique(CPPDEFINES = ['MKL_LAPACK'])
610            header='mkl_lapack.h'
611        lapack_inc_path,lapack_lib_path=findLibWithHeader(env, env['lapack_libs'], header, env['lapack_prefix'], lang='c')
612        env.AppendUnique(CPPPATH = [lapack_inc_path])
613        env.AppendUnique(LIBPATH = [lapack_lib_path])
614        env.AppendUnique(LIBS = env['lapack_libs'])
615        env.Append(CPPDEFINES = ['USE_LAPACK'])
616    
617    ######## Silo (optional)
618    
619    silo_inc_path=''
620    silo_lib_path=''
621    if env['silo']:
622        silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c')
623        env.AppendUnique(CPPPATH = [silo_inc_path])
624        env.AppendUnique(LIBPATH = [silo_lib_path])
625        # Note that we do not add the libs since they are only needed for the
626        # weipa library and tools.
627        #env.AppendUnique(LIBS = [env['silo_libs']])
628    
629    ######## VSL random numbers (optional)
630    if env['vsl_random']:
631        env.Append(CPPDEFINES = ['MKLRANDOM'])
632    
633    ######## VisIt (optional)
634    
635    visit_inc_path=''
636    visit_lib_path=''
637    if env['visit']:
638        visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c')
639        env.AppendUnique(CPPPATH = [visit_inc_path])
640        env.AppendUnique(LIBPATH = [visit_lib_path])
641    
642    ######## MPI (optional)
643    
644    if env['mpi']=='no':
645        env['mpi']='none'
646    
647    env['usempi'] = env['mpi']!='none'
648    mpi_inc_path=''
649    mpi_lib_path=''
650    if env['usempi']:
651        mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c')
652        env.AppendUnique(CPPPATH = [mpi_inc_path])
653        env.AppendUnique(LIBPATH = [mpi_lib_path])
654        env.AppendUnique(LIBS = env['mpi_libs'])
655        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mpi_lib_path)
656        env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
657        # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
658        # On the other hand MPT and OpenMPI don't define the latter so we have to
659        # do that here
660        if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
661            env.Append(CPPDEFINES = ['MPI_INCLUDED'])
662    
663    ######## BOOMERAMG (optional)
664    
665    if env['mpi'] == 'none': env['boomeramg'] = False
666    
667    boomeramg_inc_path=''
668    boomeramg_lib_path=''
669    if env['boomeramg']:
670        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        env.AppendUnique(LIBPATH = [boomeramg_lib_path])
673        env.AppendUnique(LIBS = env['boomeramg_libs'])
674        env.PrependENVPath(LD_LIBRARY_PATH_KEY, boomeramg_lib_path)
675        env.Append(CPPDEFINES = ['BOOMERAMG'])
676    
677    ######## ParMETIS (optional)
678    
679    if not env['usempi']: env['parmetis'] = False
680    
681    parmetis_inc_path=''
682    parmetis_lib_path=''
683    if env['parmetis']:
684        parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c')
685        env.AppendUnique(CPPPATH = [parmetis_inc_path])
686        env.AppendUnique(LIBPATH = [parmetis_lib_path])
687        env.AppendUnique(LIBS = env['parmetis_libs'])
688        env.PrependENVPath(LD_LIBRARY_PATH_KEY, parmetis_lib_path)
689        env.Append(CPPDEFINES = ['USE_PARMETIS'])
690    
691    ######## gmsh (optional, for tests)
692    
693    try:
694        import subprocess
695        p=subprocess.Popen(['gmsh', '-info'], stderr=subprocess.PIPE)
696        _,e=p.communicate()
697        if e.split().count("MPI"):
698            env['gmsh']='m'
699        else:
700            env['gmsh']='s'
701    except OSError:
702        env['gmsh']=False
703    
704    ######## PDFLaTeX (for documentation)
705    if 'PDF' in dir(env) and '.tex' in env.PDF.builder.src_suffixes(env):
706        env['pdflatex']=True
707    else:
708        env['pdflatex']=False
709    
710    ######################## Summarize our environment ###########################
711    
712    # keep some of our install paths first in the list for the unit tests
713    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
714    env.PrependENVPath('PYTHONPATH', prefix)
715    env['ENV']['ESCRIPT_ROOT'] = prefix
716    
717    if not env['verbose']:
718        env['CCCOMSTR'] = "Compiling $TARGET"
719        env['CXXCOMSTR'] = "Compiling $TARGET"
720        env['SHCCCOMSTR'] = "Compiling $TARGET"
721        env['SHCXXCOMSTR'] = "Compiling $TARGET"
722        env['ARCOMSTR'] = "Linking $TARGET"
723        env['LINKCOMSTR'] = "Linking $TARGET"
724        env['SHLINKCOMSTR'] = "Linking $TARGET"
725        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
726        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
727        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
728        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
729        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
730    
731    print("")
732    print("*** Config Summary (see config.log and lib/buildvars for details) ***")
733    print("Escript/Finley revision %s"%global_revision)
734    print("  Install prefix:  %s"%env['prefix'])
735    print("          Python:  %s"%sysconfig.PREFIX)
736    print("           boost:  %s"%env['boost_prefix'])
737    print("           numpy:  YES")
738    if env['usempi']:
739        print("             MPI:  YES (flavour: %s)"%env['mpi'])
740    else:
741        print("             MPI:  DISABLED")
742    if env['uselapack']:
743        print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
744    else:
745        print("          LAPACK:  DISABLED")
746    d_list=[]
747    e_list=[]
748    for i in 'debug','openmp','netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit','vsl_random':
749        if env[i]: e_list.append(i)
750        else: d_list.append(i)
751    for i in e_list:
752        print("%16s:  YES"%i)
753    for i in d_list:
754        print("%16s:  DISABLED"%i)
755    if env['cppunit']:
756        print("         CppUnit:  FOUND")
757    else:
758        print("         CppUnit:  NOT FOUND")
759    if env['gmsh']=='m':
760        print("            gmsh:  FOUND, MPI-ENABLED")
761    elif env['gmsh']=='s':
762        print("            gmsh:  FOUND")
763    else:
764        print("            gmsh:  NOT FOUND")
765    if env['numpy_h']:
766        print("   numpy headers:  FOUND")
767    else:
768        print("   numpy headers:  NOT FOUND")
769    print("   vsl_random:  %s"%env['vsl_random'])
770        
771    if ((fatalwarning != '') and (env['werror'])):
772        print("  Treating warnings as errors")
773    else:
774        print("  NOT treating warnings as errors")
775    print("")
776    
777    ####################### Configure the subdirectories #########################
778    
779    from grouptest import *
780    
781    TestGroups=[]
782    
783    # keep an environment without warnings-as-errors
784    dodgy_env=env.Clone()
785    
786    # now add warnings-as-errors flags. This needs to be done after configuration
787    # because the scons test files have warnings in them
788    if ((fatalwarning != '') and (env['werror'])):
789        env.Append(CCFLAGS = fatalwarning)
790    
791    Export(
792      ['env',
793       'dodgy_env',
794       'IS_WINDOWS',
795       'TestGroups'
796      ]
797    )
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 = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
809    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', 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 = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
813    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
814    
815    
816    ######################## Populate the buildvars file #########################
817    
818    # remove obsolete file
819    if not env['usempi']:
820        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
821        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
822    
823    # Try to extract the boost version from version.hpp
824    boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
825    boostversion='unknown'
826    try:
827        for line in boosthpp:
828            ver=re.match(r'#define BOOST_VERSION (\d+)',line)
829            if ver:
830                boostversion=ver.group(1)
831    except StopIteration:
832        pass
833    boosthpp.close()
834    
835    
836    buildvars=open(os.path.join(env['libinstall'], 'buildvars'), 'w')
837    buildvars.write("svn_revision="+str(global_revision)+"\n")
838    buildvars.write("prefix="+prefix+"\n")
839    buildvars.write("cc="+env['CC']+"\n")
840    buildvars.write("cxx="+env['CXX']+"\n")
841    if env['pythoncmd']=='python':
842        buildvars.write("python="+sys.executable+"\n")
843        buildvars.write("python_version="+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+"\n")
844    else:
845        buildvars.write("python="+env['pythoncmd']+"\n")
846        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)
847        verstring=p.stdout.readline().strip()
848        p.wait()
849        buildvars.write("python_version="+verstring+"\n")
850    buildvars.write("boost_inc_path="+boost_inc_path+"\n")
851    buildvars.write("boost_lib_path="+boost_lib_path+"\n")
852    buildvars.write("boost_version="+boostversion+"\n")
853    buildvars.write("debug=%d\n"%int(env['debug']))
854    buildvars.write("openmp=%d\n"%int(env['openmp']))
855    buildvars.write("mpi=%s\n"%env['mpi'])
856    buildvars.write("mpi_inc_path=%s\n"%mpi_inc_path)
857    buildvars.write("mpi_lib_path=%s\n"%mpi_lib_path)
858    buildvars.write("lapack=%s\n"%env['lapack'])
859    buildvars.write("vsl_random=%d\n"%int(env['vsl_random']))
860    for i in 'netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit':
861        buildvars.write("%s=%d\n"%(i, int(env[i])))
862        if env[i]:
863            buildvars.write("%s_inc_path=%s\n"%(i, eval(i+'_inc_path')))
864            buildvars.write("%s_lib_path=%s\n"%(i, eval(i+'_lib_path')))
865    buildvars.close()
866    
867    ################### Targets to build and install libraries ###################
868    
869    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
870    env.Alias('target_init', [target_init])
871    # delete buildvars upon cleanup
872    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
873    
874    # The headers have to be installed prior to build in order to satisfy
875    # #include <paso/Common.h>
876    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
877    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
878    
879    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
880    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
881    
882    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
883    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escript_py'])
884    
885    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
886    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
887    
888    env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
889    env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
890    
891    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
892    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
893    
894    env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
895    env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
896    
897    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
898    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
899    
900    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
901    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
902    
903    # Now gather all the above into some easy targets: build_all and install_all
904    build_all_list = []
905    build_all_list += ['build_esysUtils']
906    build_all_list += ['build_paso']
907    build_all_list += ['build_escript']
908    build_all_list += ['build_pasowrap']
909    build_all_list += ['build_dudley']
910    build_all_list += ['build_finley']
911    build_all_list += ['build_ripley']
912    build_all_list += ['build_weipa']
913    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
914    if env['usempi']:   build_all_list += ['build_pythonMPI']
915    build_all_list += ['build_escriptconvert']
916    env.Alias('build_all', build_all_list)
917    
918    install_all_list = []
919    install_all_list += ['target_init']
920    install_all_list += ['install_esysUtils']
921    install_all_list += ['install_paso']
922    install_all_list += ['install_escript']
923    install_all_list += ['install_pasowrap']
924    install_all_list += ['install_dudley']
925    install_all_list += ['install_finley']
926    install_all_list += ['install_ripley']
927    install_all_list += ['install_weipa']
928    if not IS_WINDOWS: install_all_list += ['install_escriptreader']
929    install_all_list += ['install_downunder_py']
930    install_all_list += ['install_modellib_py']
931    install_all_list += ['install_pycad_py']
932    if env['usempi']:   install_all_list += ['install_pythonMPI']
933    install_all_list += ['install_escriptconvert']
934    env.Alias('install_all', install_all_list)
935    
936    # Default target is install
937    env.Default('install_all')
938    
939    ################## Targets to build and run the test suite ###################
940    
941    if not env['cppunit']:
942        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C/C++ unit tests, CppUnit not found!";exit 1')
943        env.Alias('run_tests', test_msg)
944    env.Alias('run_tests', ['install_all'])
945    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
946    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
947    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
948    
949    ##################### Targets to build the documentation #####################
950    
951    env.Alias('api_epydoc','install_all')
952    env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'user_pdf', 'install_pdf', 'cookbook_pdf'])
953    env.Alias('release_prep', ['docs', 'install_all'])
954    
955  syslib_install_target = env.installDirectory(sys_libinstall,libinstall)  if not IS_WINDOWS:
956  syspy_install_target = env.installDirectory(sys_pyinstall,pyinstall,recursive=True)      try:
957            utest=open('utest.sh','w')
958            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix))
959            for tests in TestGroups:
960                utest.write(tests.makeString())
961            utest.close()
962            Execute(Chmod('utest.sh', 0o755))
963            print("Generated utest.sh.")
964        except IOError:
965            print("Error attempting to write unittests file.")
966            Exit(1)
967    
968        # delete utest.sh upon cleanup
969        env.Clean('target_init', 'utest.sh')
970    
971        # Make sure that the escript wrapper is in place
972        if not os.path.isfile(os.path.join(env['bininstall'], 'run-escript')):
973            print("Copying escript wrapper.")
974            Execute(Copy(os.path.join(env['bininstall'],'run-escript'), 'bin/run-escript'))
975    
 install_target = env.Alias("install", env.Flatten([syslib_install_target, syspy_install_target]) )  

Legend:
Removed from v.1375  
changed lines
  Added in v.3947

  ViewVC Help
Powered by ViewVC 1.1.26