/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 863 by matt, Wed Oct 4 01:01:15 2006 UTC revision 5148 by caltinay, Mon Sep 15 01:25:23 2014 UTC
# Line 1  Line 1 
1  #          Copyright 2006 by ACcESS MNRF  ##############################################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2014 by University of Queensland
4  #       Primary Business: Queensland, Australia  # http://www.uq.edu.au
 #  Licensed under the Open Software License version 3.0  
 #     http://www.opensource.org/licenses/osl-3.0.php  
5  #  #
6    # Primary Business: Queensland, Australia
7    # Licensed under the Open Software License version 3.0
8    # http://www.opensource.org/licenses/osl-3.0.php
9  #  #
10    # Development until 2012 by Earth Systems Science Computational Center (ESSCC)
11    # Development 2012-2013 by School of Earth Sciences
12    # Development from 2014 by Centre for Geoscience Computing (GeoComp)
13  #  #
14    ##############################################################################
15    
16  # top-level Scons configuration file for all esys13 modules  EnsureSConsVersion(0,98,1)
17  # Begin initialisation Section  EnsurePythonVersion(2,5)
 # all of this section just intialises default environments and helper  
 # scripts. You shouldn't need to modify this section.  
 EnsureSConsVersion(0,96,91)  
 EnsurePythonVersion(2,3)  
   
 # import tools:  
 import glob  
 import sys, os  
 import socket  
 # Add our extensions  
 if sys.path.count('scons')==0: sys.path.append('scons')  
 import scons_extensions  
   
 # check if UMFPACK is installed on the system:  
 if os.path.isdir('/opt/UMFPACK/Include') and os.path.isdir('/opt/UMFPACK/Lib'):  
    umf_path_default='/opt/UMFPACK/Include'  
    umf_lib_path_default='/opt/UMFPACK/Lib'  
    umf_libs_default=['umfpack']  
 else:  
    umf_path_default=None  
    umf_lib_path_default=None  
    umf_libs_default=None  
   
 if os.path.isdir('/opt/AMD/Include') and os.path.isdir('/opt/AMD/Lib'):  
    amd_path_default='/opt/AMD/Include'  
    amd_lib_path_default='/opt/AMD/Lib'  
    amd_libs_default=['amd']  
 else:  
    amd_path_default=None  
    amd_lib_path_default=None  
    amd_libs_default=None  
   
 if os.path.isdir('/opt/UFconfig'):  
    ufc_path_default='/opt/UFconfig'  
 else:  
    ufc_path_default=None  
18    
19  # Default options and options help text  import atexit, sys, os, platform, re
20  # These are defaults and can be overridden using command line arguments or an options file.  from distutils import sysconfig
21  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used  from dependencies import *
22  # DO NOT CHANGE THEM HERE  from site_init import *
23  if ARGUMENTS.get('options_file',0):  
24     options_file = ARGUMENTS.get('options_file',0)  # Version number to check for in options file. Increment when new features are
25  else:  # added or existing options changed.
26     from string import ascii_letters,digits  REQUIRED_OPTS_VERSION=202
27     hostname=""  
28     for s in socket.gethostname().split('.')[0]:  # MS Windows support, many thanks to PH
29        if s in ascii_letters+digits:  IS_WINDOWS = (os.name == 'nt')
30           hostname+=s  
31        else:  IS_OSX = (os.uname()[0] == 'Darwin')
32           hostname+="_"  
33     options_file = "scons/"+hostname+"_options.py"  ########################## Determine options file ############################
34    # 1. command line
35  opts = Options(options_file, ARGUMENTS)  # 2. scons/<hostname>_options.py
36  opts.AddOptions(  # 3. name as part of a cluster
37  # Where to install esys stuff  options_file=ARGUMENTS.get('options_file', None)
38    ('incinstall', 'where the esys headers will be installed', Dir('#.').abspath+'/include'),  if not options_file:
39    ('libinstall', 'where the esys libraries will be installed', Dir('#.').abspath+'/lib'),      ext_dir = os.path.join(os.getcwd(), 'scons')
40    ('pyinstall', 'where the esys python modules will be installed', Dir('#.').abspath),      hostname = platform.node().split('.')[0]
41    ('src_zipfile', 'the source zip file will be installed.', Dir('#.').abspath+"/release/escript_src.zip"),      for name in hostname, effectiveName(hostname):
42    ('test_zipfile', 'the test zip file will be installed.', Dir('#.').abspath+"/release/escript_tests.zip"),          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
43    ('src_tarfile', 'the source tar file will be installed.', Dir('#.').abspath+"/release/escript_src.tar.gz"),          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
44    ('test_tarfile', 'the test tar file will be installed.', Dir('#.').abspath+"/release/escript_tests.tar.gz"),          if os.path.isfile(options_file): break
45    ('examples_tarfile', 'the examples tar file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.tar.gz"),  
46    ('examples_zipfile', 'the examples zip file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.zip"),  if not os.path.isfile(options_file):
47    ('guide_pdf', 'name of the user guide in pdf format', Dir('#.').abspath+"/release/doc/user/guide.pdf"),      print("\nWARNING:\nOptions file %s" % options_file)
48    ('api_epydoc', 'name of the epydoc api docs directory',Dir('#.').abspath+"/release/doc/epydoc"),      print("not found! Default options will be used which is most likely suboptimal.")
49    ('guide_html', 'name of the directory for user guide in html format', Dir('#.').abspath+"/release/doc/user/html"),      print("We recommend that you copy the most relavent options file in the scons/os/")
50  # Compilation options      print("subdirectory and customize it to your needs.\n")
51    BoolOption('dodebug', 'Do you want a debug build?', 'no'),      options_file = None
52    ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/hostname_options.py)", options_file),  
53    ('cc_defines','C/C++ defines to use', None),  ############################### Build options ################################
54    ('cc_flags','C compiler flags to use (Release build)', '-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas'),  
55    ('cc_flags_debug', 'C compiler flags to use (Debug build)', '-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas'),  default_prefix='/usr'
56    ('cxx_flags', 'C++ compiler flags to use (Release build)', '--no-warn -ansi'),  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
57    ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', '--no-warn -ansi -DDOASSERT -DDOPROF'),  lapack_flavours=('none', 'clapack', 'mkl')
58    ('cc_flags_MPI','C compiler flags to use (Release MPI build)', '-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias -fno-alias -c99 -w1 -fpic -wd161'),  
59    ('cc_flags_debug_MPI', 'C compiler flags to use (Debug MPI build)', '-g -O0 -c99 -w1 -fpic -wd161'),  vars = Variables(options_file, ARGUMENTS)
60    ('cxx_flags_MPI', 'C++ compiler flags to use (Release MPI build)', '-ansi -wd1563 -wd161'),  vars.AddVariables(
61    ('cxx_flags_debug_MPI', 'C++ compiler flags to use (Debug MPI build)', '-ansi -DDOASSERT -DDOPROF -wd1563 -wd161'),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
62    ('ar_flags', 'Static library archiver flags to use', None),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
63    ('sys_libs', 'System libraries to link with', None),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
64    ('tar_flags','flags for zip files','-c -z'),    BoolVariable('verbose', 'Output full compile/link lines', False),
65  # MKL  # Compiler/Linker options
66    PathOption('mkl_path', 'Path to MKL includes', None),    ('cxx', 'Path to C++ compiler', 'default'),
67    PathOption('mkl_lib_path', 'Path to MKL libs', None),    ('cc_flags', 'Base C++ compiler flags', 'default'),
68    ('mkl_libs', 'MKL libraries to link with', None),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
69  # SCSL    ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
70    PathOption('scsl_path', 'Path to SCSL includes', None),    ('cxx_extra', 'Extra C++ compiler flags', ''),
71    PathOption('scsl_lib_path', 'Path to SCSL libs', None),    ('ld_extra', 'Extra linker flags', ''),
72    ('scsl_libs', 'SCSL libraries to link with', None),    ('nvcc', 'Path to CUDA compiler', 'default'),
73    ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),    ('nvccflags', 'Base CUDA compiler flags', 'default'),
74  # UMFPACK    BoolVariable('werror','Treat compiler warnings as errors', True),
75    PathOption('ufc_path', 'Path to UFconfig includes', ufc_path_default),    BoolVariable('debug', 'Compile with debug flags', False),
76    PathOption('umf_path', 'Path to UMFPACK includes', umf_path_default),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
77    PathOption('umf_lib_path', 'Path to UMFPACK libs', umf_lib_path_default),    ('omp_flags', 'OpenMP compiler flags', 'default'),
78    ('umf_libs', 'UMFPACK libraries to link with', umf_libs_default),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
79  # AMD (used by UMFPACK)  # Mandatory libraries
80    PathOption('amd_path', 'Path to AMD includes', amd_path_default),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
81    PathOption('amd_lib_path', 'Path to AMD libs', amd_lib_path_default),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
82    ('amd_libs', 'AMD libraries to link with', amd_libs_default),  # Mandatory for tests
83  # BLAS    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
84    PathOption('blas_path', 'Path to BLAS includes', None),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
85    PathOption('blas_lib_path', 'Path to BLAS libs', None),  # Optional libraries and options
86    ('blas_libs', 'BLAS libraries to link with', None),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
87  # Python    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
88  # locations of include files for python    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
89    PathOption('python_path', 'Path to Python includes', '/usr/include/python%s.%s'%(sys.version_info[0],sys.version_info[1])),    BoolVariable('netcdf', 'Enable netCDF file support', False),
90    PathOption('python_lib_path', 'Path to Python libs', '/usr/lib'),    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
91    ('python_lib', 'Python libraries to link with', ["python%s.%s"%(sys.version_info[0],sys.version_info[1]),]),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
92  # Boost    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
93    PathOption('boost_path', 'Path to Boost includes', '/usr/include'),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
94    PathOption('boost_lib_path', 'Path to Boost libs', '/usr/lib'),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
95    ('boost_lib', 'Boost libraries to link with', ['boost_python',]),    BoolVariable('papi', 'Enable PAPI', False),
96  # Doc building    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
97  #  PathOption('doxygen_path', 'Path to Doxygen executable', None),    ('papi_libs', 'PAPI libraries to link with', ['papi']),
98  #  PathOption('epydoc_path', 'Path to Epydoc executable', None),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
99  # PAPI    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
100    PathOption('papi_path', 'Path to PAPI includes', None),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
101    PathOption('papi_lib_path', 'Path to PAPI libs', None),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
102    ('papi_libs', 'PAPI libraries to link with', None),    BoolVariable('umfpack', 'Enable UMFPACK', False),
103  # MPI    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
104    BoolOption('useMPI', 'Compile parallel version using MPI', 'no'),    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
105      BoolVariable('boomeramg', 'Enable BoomerAMG', False),
106      ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
107      ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
108      EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
109      ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
110      ('lapack_libs', 'LAPACK libraries to link with', []),
111      BoolVariable('silo', 'Enable the Silo file format in weipa', False),
112      ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
113      ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
114      BoolVariable('visit', 'Enable the VisIt simulation interface', False),
115      ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
116      ('visit_libs', 'VisIt libraries to link with', ['simV2']),
117      BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
118      BoolVariable('cuda', 'Enable GPU code with CUDA (requires thrust)', False),
119      ('thrust_prefix', 'Prefix/Paths to NVidia thrust installation', default_prefix),
120    # Advanced settings
121      #dudley_assemble_flags = -funroll-loops      to actually do something
122      ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
123      # To enable passing function pointers through python
124      BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
125      # An option for specifying the compiler tools (see windows branch)
126      ('tools_names', 'Compiler tools to use', ['default']),
127      ('env_export', 'Environment variables to be passed to tools',[]),
128      EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
129      EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
130      # finer control over library building, intel aggressive global optimisation
131      # works with dynamic libraries on windows.
132      ('build_shared', 'Build dynamic libraries only', False),
133      ('sys_libs', 'Extra libraries to link with', []),
134      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
135      ('SVN_VERSION', 'Do not use from options file', -2),
136      ('pythoncmd', 'which python to compile with','python'),
137      ('usepython3', 'Is this a python3 build? (experimental)', False),
138      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
139      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
140      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
141      BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
142      BoolVariable('compressed_files','Enables reading from compressed binary files', True),
143      ('compression_libs', 'Compression libraries to link with', ['boost_iostreams'])
144  )  )
145    
146  # Initialise Scons Build Environment  ##################### Create environment and help text #######################
 # check for user environment variables we are interested in  
 try:  
    python_path = os.environ['PYTHONPATH']  
 except KeyError:  
    python_path = ''  
 try:  
    path = os.environ['PATH']  
 except KeyError:  
    path = ''  
 try:  
    ld_library_path = os.environ['LD_LIBRARY_PATH']  
 except KeyError:  
    ld_library_path = ''  
   
 # 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 os.name != "nt" and os.uname()[4]=='ia64':  
    env = Environment(ENV = {'PATH':path}, tools = ['default', 'intelc'], options = opts)  
    env['ENV']['PATH'] = path  
    env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
    env['ENV']['PYTHONPATH'] = python_path  
    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  
 elif os.name == "nt":  
    env = Environment(tools = ['default', 'intelc'], options = opts)  
    env['ENV']['PYTHONPATH'] = python_path  
 else:  
    env = Environment(tools = ['default'], options = opts)  
    env['ENV']['PATH'] = path  
    env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
    env['ENV']['PYTHONPATH'] = python_path  
   
 # Setup help for options  
 Help(opts.GenerateHelpText(env))  
147    
148  # Add some customer builders  # Intel's compiler uses regular expressions improperly and emits a warning
149  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  # about failing to find the compilers. This warning can be safely ignored.
 env.Append(BUILDERS = {'PyCompile' : py_builder});  
150    
151  if env['PLATFORM'] == "win32":  # PATH is needed so the compiler, linker and tools are found if they are not
152     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  # in default locations.
153    env = Environment(tools = ['default'], options = vars,
154                      ENV = {'PATH': os.environ['PATH']})
155    
156    # set the vars for clang
157    def mkclang(env):
158        env['CXX']='clang++'
159    
160    if env['tools_names'] != ['default']:
161        zz=env['tools_names']
162        if 'clang' in zz:
163            zz.remove('clang')
164            zz.insert(0, mkclang)
165        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
166                          ENV = {'PATH' : os.environ['PATH']})
167    
168    if options_file:
169        opts_valid=False
170        if 'escript_opts_version' in env.Dictionary() and \
171            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
172                opts_valid=True
173        if opts_valid:
174            print("Using options in %s." % options_file)
175        else:
176            print("\nOptions file %s" % options_file)
177            print("is outdated! Please update the file by examining one of the TEMPLATE")
178            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
179            Exit(1)
180    
181    # Generate help text (scons -h)
182    Help(vars.GenerateHelpText(env))
183    
184    # Check for superfluous options
185    if len(vars.UnknownVariables())>0:
186        for k in vars.UnknownVariables():
187            print("Unknown option '%s'" % k)
188        Exit(1)
189    
190    if env['cuda']:
191        if env['nvcc'] != 'default':
192            env['NVCC'] = env['nvcc']
193        env.Tool('nvcc')
194    
195    # create dictionary which will be populated with info for buildvars file
196    env['buildvars']={}
197    # create list which will be populated with warnings if there are any
198    env['warnings']=[]
199    
200    #################### Make sure install directories exist #####################
201    
202    env['BUILD_DIR']=Dir(env['build_dir']).abspath
203    prefix=Dir(env['prefix']).abspath
204    env['buildvars']['prefix']=prefix
205    env['incinstall'] = os.path.join(prefix, 'include')
206    env['bininstall'] = os.path.join(prefix, 'bin')
207    env['libinstall'] = os.path.join(prefix, 'lib')
208    env['pyinstall']  = os.path.join(prefix, 'esys')
209    if not os.path.isdir(env['bininstall']):
210        os.makedirs(env['bininstall'])
211    if not os.path.isdir(env['libinstall']):
212        os.makedirs(env['libinstall'])
213    if not os.path.isdir(env['pyinstall']):
214        os.makedirs(env['pyinstall'])
215    
216    env.Append(CPPPATH = [env['incinstall']])
217    env.Append(LIBPATH = [env['libinstall']])
218    
219    ################# Fill in compiler options if not set above ##################
220    
221    if env['cxx'] != 'default': env['CXX']=env['cxx']
222    
223    # version >=9 of intel C++ compiler requires use of icpc to link in C++
224    # runtimes (icc does not)
225    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
226        env['LINK'] = env['CXX']
227    
228    # default compiler/linker options
229    cc_flags = ''
230    cc_optim = ''
231    cc_debug = ''
232    omp_flags = ''
233    omp_ldflags = ''
234    fatalwarning = '' # switch to turn warnings into errors
235    sysheaderopt = '' # how to indicate that a header is a system header
236    
237    # env['CC'] might be a full path
238    cc_name=os.path.basename(env['CXX'])
239    
240    if cc_name == 'icpc':
241        # Intel compiler
242        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
243        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
244        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas"
245        cc_optim    = "-O3 -ftz -fno-alias -inline-level=2 -ipo -xHost"
246        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
247        omp_flags   = "-openmp"
248        omp_ldflags = "-openmp -openmp_report=1"
249        fatalwarning = "-Werror"
250    elif cc_name[:3] == 'g++':
251        # GNU C on any system
252        # note that -ffast-math is not used because it breaks isnan(),
253        # see mantis #691
254        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
255        cc_optim     = "-O3"
256        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK --param=max-vartrack-size=90000000" #avoids vartrack limit being exceeded with escriptcpp.cpp
257        omp_flags    = "-fopenmp"
258        omp_ldflags  = "-fopenmp"
259        fatalwarning = "-Werror"
260        sysheaderopt = "-isystem"
261    elif cc_name == 'cl':
262        # Microsoft Visual C on Windows
263        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
264        cc_optim     = "/O2 /Op /W3"
265        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
266        fatalwarning = "/WX"
267    elif cc_name == 'icl':
268        # Intel C on Windows
269        cc_flags     = '/EHsc /GR /MD'
270        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
271        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
272        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
273        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
274    
275    env['sysheaderopt']=sysheaderopt
276    
277    # set defaults if not otherwise specified
278    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
279    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
280    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
281    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
282    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
283    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
284    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
285    
286    if env['nvccflags'] != 'default':
287        env['NVCCFLAGS'] = env['nvccflags']
288        env['SHNVCCFLAGS'] = env['nvccflags'] + ' -shared'
289    
290    if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
291    
292    if env['usepython3']:
293        env.Append(CPPDEFINES=['ESPYTHON3'])
294    
295    # set up the autolazy values
296    if env['forcelazy'] == 'on':
297        env.Append(CPPDEFINES=['FAUTOLAZYON'])
298    elif env['forcelazy'] == 'off':
299        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
300    
301    # set up the collective resolve values
302    if env['forcecollres'] == 'on':
303        env.Append(CPPDEFINES=['FRESCOLLECTON'])
304    elif env['forcecollres'] == 'off':
305        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
306    
307    # allow non-standard C if requested
308    if env['iknowwhatimdoing']:
309        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
310    
311    # Disable OpenMP if no flags provided
312    if env['openmp'] and env['omp_flags'] == '':
313       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
314       env['openmp'] = False
315    
316    if env['openmp']:
317        env.Append(CCFLAGS = env['omp_flags'])
318        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
319    else:
320        env['omp_flags']=''
321        env['omp_ldflags']=''
322    
323    env['buildvars']['openmp']=int(env['openmp'])
324    
325    # add debug/non-debug compiler flags
326    env['buildvars']['debug']=int(env['debug'])
327    if env['debug']:
328        env.Append(CCFLAGS = env['cc_debug'])
329    else:
330        env.Append(CCFLAGS = env['cc_optim'])
331    
332    # always add cc_flags
333    env.Append(CCFLAGS = env['cc_flags'])
334    
335    # add system libraries
336    env.AppendUnique(LIBS = env['sys_libs'])
337    
338    # determine svn revision
339    global_revision=ARGUMENTS.get('SVN_VERSION', None)
340    if global_revision:
341        global_revision = re.sub(':.*', '', global_revision)
342        global_revision = re.sub('[^0-9]', '', global_revision)
343        if global_revision == '': global_revision='-2'
344  else:  else:
345     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', single_source=True)    # Get the global Subversion revision number for the getVersion() method
346  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});    try:
347        global_revision = os.popen('svnversion -n .').read()
348  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)      global_revision = re.sub(':.*', '', global_revision)
349  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});      global_revision = re.sub('[^0-9]', '', global_revision)
350        if global_revision == '': global_revision='-2'
351      except:
352        global_revision = '-1'
353    env['svn_revision']=global_revision
354    env['buildvars']['svn_revision']=global_revision
355    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
356    
357    if IS_WINDOWS:
358        if not env['build_shared']:
359            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
360            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
361    
362    # VSL random numbers
363    env['buildvars']['vsl_random']=int(env['vsl_random'])
364    if env['vsl_random']:
365        env.Append(CPPDEFINES = ['MKLRANDOM'])
366    
367    env['IS_WINDOWS']=IS_WINDOWS
368    
369    ###################### Copy required environment vars ########################
370    
371    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
372    if IS_WINDOWS:
373        LD_LIBRARY_PATH_KEY='PATH'
374        env['ENV']['LD_LIBRARY_PATH']=''
375    else:
376        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
377    
378  # Convert the options which are held in environment variable into python variables for ease of handling and configure compilation options  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
 try:  
    incinstall = env['incinstall']  
    env.Append(CPPPATH = [incinstall,])  
 except KeyError:  
    incinstall = None  
 try:  
    libinstall = env['libinstall']  
    env.Append(LIBPATH = [libinstall,])  
    env.PrependENVPath('LD_LIBRARY_PATH', libinstall)  
    if env['PLATFORM'] == "win32":  
       env.PrependENVPath('PATH', libinstall)  
       env.PrependENVPath('PATH', env['boost_lib_path'])  
 except KeyError:  
    libinstall = None  
 try:  
    pyinstall = env['pyinstall']+'/esys' # all targets will install into pyinstall/esys but PYTHONPATH points at straight pyinstall so you go import esys.escript etc  
    env.PrependENVPath('PYTHONPATH', env['pyinstall'])  
 except KeyError:  
    pyinstall = None  
 try:  
    dodebug = env['dodebug']  
 except KeyError:  
    dodebug = None  
 try:  
    useMPI = env['useMPI']  
 except KeyError:  
    useMPI = None  
 try:  
    cc_defines = env['cc_defines']  
    env.Append(CPPDEFINES = cc_defines)  
 except KeyError:  
    pass  
379    
380  if 'shake71' == socket.gethostname().split('.')[0]:  # the following env variables are exported for the unit tests
   if useMPI:  
     env['CC'] = 'mpicc'  
     env['CXX'] = 'mpiCC'  
381    
382  if dodebug:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
   if useMPI:  
383      try:      try:
384        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
385      except KeyError:      except KeyError:
386        pass          env['ENV'][key] = '1'
387    else:  
388    env_export=env['env_export']
389    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP','LD_PRELOAD'])
390    
391    for key in set(env_export):
392      try:      try:
393        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
394      except KeyError:      except KeyError:
       pass  
 else:  
   if useMPI:  
    try:  
      flags = env['cc_flags_MPI']  
      env.Append(CCFLAGS = flags)  
    except KeyError:  
       pass  
   else:  
    try:  
       flags = env['cc_flags']  
       env.Append(CCFLAGS = flags)  
    except KeyError:  
       pass  
 if dodebug:  
    if useMPI:  
      try:  
         flags = env['cxx_flags_debug_MPI']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
    else:  
      try:  
         flags = env['cxx_flags_debug']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
 else:  
    if useMPI:  
      try:  
         flags = env['cxx_flags_MPI']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
    else:  
      try:  
         flags = env['cxx_flags']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
395          pass          pass
 try:  
    flags = env['ar_flags']  
    env.Append(ARFLAGS = flags)  
 except KeyError:  
    ar_flags = None  
 try:  
    sys_libs = env['sys_libs']  
 except KeyError:  
    sys_libs = ''  
396    
397  try:  try:
398     tar_flags = env['tar_flags']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Replace(TARFLAGS = tar_flags)  
399  except KeyError:  except KeyError:
400     pass      pass
401    
402  try:  if IS_OSX:
    includes = env['mkl_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
   
 try:  
    lib_path = env['mkl_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
   
 if useMPI:  
    mkl_libs = ''  
 else:  
    try:  
       mkl_libs = env['mkl_libs']  
    except KeyError:  
       mkl_libs = ''  
   
 try:  
    includes = env['scsl_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
   
 try:  
    lib_path = env['scsl_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
   
 if useMPI:  
403    try:    try:
404      scsl_libs = env['scsl_libs_MPI']      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
405    except KeyError:    except KeyError:
406      scsl_libs = ''      pass
 else:  
   try:  
     scsl_libs = env['scsl_libs']  
   except KeyError:  
     scsl_libs = ''  
   
 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  
407    
 if useMPI:  
     umf_libs = ''  
 else:  
    try:  
       umf_libs = env['umf_libs']  
    except KeyError:  
       umf_libs = ''  
408    
409  try:  # these shouldn't be needed
410     includes = env['ufc_path']  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
411     env.Append(CPPPATH = [includes,])  #    try:
412  except KeyError:  #        env['ENV'][key] = os.environ[key]
413     pass  #    except KeyError:
414    #        pass
415    
416  try:  try:
417     includes = env['amd_path']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
    env.Append(CPPPATH = [includes,])  
418  except KeyError:  except KeyError:
419     pass      pass
420    
421  try:  ######################## Add some custom builders ############################
    lib_path = env['amd_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
422    
423  if useMPI:  if env['pythoncmd']=='python':
424      amd_libs = ''      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
425  else:  else:
426     try:      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
427        amd_libs = env['amd_libs']  env.Append(BUILDERS = {'PyCompile' : py_builder});
    except KeyError:  
       amd_libs = ''  
   
 try:  
    includes = env['blas_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
   
 try:  
    lib_path = env['blas_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
   
 try:  
    blas_libs = env['blas_libs']  
 except KeyError:  
    blas_libs = ''  
428    
429  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
430     includes = env['boost_path']  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['boost_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    boost_lib = env['boost_lib']  
 except KeyError:  
    boost_lib = None  
 try:  
    includes = env['python_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['python_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    python_lib = env['python_lib']  
 except KeyError:  
    python_lib = None  
 try:  
    doxygen_path = env['doxygen_path']  
 except KeyError:  
    doxygen_path = None  
 try:  
    epydoc_path = env['epydoc_path']  
 except KeyError:  
    epydoc_path = None  
 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  
431    
432    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
433    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
434    
435  try:  runPyExample_builder = Builder(action = runPyExample, suffix = '.passed', src_suffic='.py', single_source=True)
436     src_zipfile = env.File(env['src_zipfile'])  env.Append(BUILDERS = {'RunPyExample' : runPyExample_builder});
 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  
437    
438  try:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
439     src_tarfile = env.File(env['src_tarfile'])  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
 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  
440    
441  try:  ############################ Dependency checks ###############################
    guide_pdf = env.File(env['guide_pdf'])  
 except KeyError:  
    guide_pdf = None  
442    
443  try:  ######## Compiler
444     guide_html_index = env.File('index.htm',env['guide_html'])  env=checkCompiler(env)
445  except KeyError:  
446     guide_html_index = None  ######## Python headers & library (required)
447    env=checkPython(env)
448    
449    ######## boost & boost-python (required)
450    env=checkBoost(env)
451    
452    ######## NVCC version (optional)
453    if env['cuda']:
454        env=checkCudaVersion(env)
455    
456    ######## numpy (required) and numpy headers (optional)
457    env=checkNumpy(env)
458    
459    ######## CppUnit (required for tests)
460    env=checkCppUnit(env)
461    
462    ######## optional python modules (sympy, pyproj)
463    env=checkOptionalModules(env)
464    
465    ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
466    env=checkOptionalLibraries(env)
467    
468    ######## PDFLaTeX (for documentation)
469    env=checkPDFLatex(env)
470    
471    # keep some of our install paths first in the list for the unit tests
472    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
473    env.PrependENVPath('PYTHONPATH', prefix)
474    env['ENV']['ESCRIPT_ROOT'] = prefix
475    
476    if not env['verbose']:
477        env['CXXCOMSTR'] = "Compiling $TARGET"
478        env['SHCXXCOMSTR'] = "Compiling $TARGET"
479        env['ARCOMSTR'] = "Linking $TARGET"
480        env['LINKCOMSTR'] = "Linking $TARGET"
481        env['SHLINKCOMSTR'] = "Linking $TARGET"
482        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
483        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
484        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
485        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
486        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
487    
488    ####################### Configure the subdirectories #########################
489    
490    # remove obsolete files
491    if not env['usempi']:
492        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
493        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
494    
495    from grouptest import *
496    TestGroups=[]
497    
498    # keep an environment without warnings-as-errors
499    dodgy_env=env.Clone()
500    
501    # now add warnings-as-errors flags. This needs to be done after configuration
502    # because the scons test files have warnings in them
503    if ((fatalwarning != '') and (env['werror'])):
504        env.Append(CCFLAGS = fatalwarning)
505    
506    Export(
507      ['env',
508       'dodgy_env',
509       'IS_WINDOWS',
510       'TestGroups'
511      ]
512    )
513    
514  try:  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
515     api_epydoc = env.Dir(env['api_epydoc'])  env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
516  except KeyError:  env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
517     api_epydoc = None  env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
518    
519    env.SConscript(dirs = ['cusplibrary'])
520    
521    #This will pull in the escriptcore/py_src and escriptcore/test
522    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
523    #env.SConscript(dirs = ['escript/test'], variant_dir='$BUILD_DIR/$PLATFORM/escript/test', duplicate=0)
524    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
525    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
526    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
527    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
528    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
529    env.SConscript(dirs = ['speckley/src'], variant_dir='$BUILD_DIR/$PLATFORM/speckley', duplicate=0)
530    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
531    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
532    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
533    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
534    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
535    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
536    
537    
538    ######################## Populate the buildvars file #########################
539    
540    write_buildvars(env)
541    
542    ################### Targets to build and install libraries ###################
543    
544    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
545    env.Alias('target_init', [target_init])
546    # delete buildvars upon cleanup
547    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
548    
549    # The headers have to be installed prior to build in order to satisfy
550    # #include <paso/Common.h>
551    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
552    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
553    
554    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
555    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
556    
557    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
558    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
559    
560    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
561    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
562    
563    env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
564    env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
565    
566    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
567    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
568    
569    env.Alias('build_ripley', ['install_cusp_headers', 'install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
570    env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
571    
572    env.Alias('build_speckley', ['install_speckley_headers', 'build_speckley_lib', 'build_speckleycpp_lib'])
573    env.Alias('install_speckley', ['build_speckley', 'install_speckley_lib', 'install_speckleycpp_lib', 'install_speckley_py'])
574    
575    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
576    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
577    
578    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
579    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
580    
581    # Now gather all the above into some easy targets: build_all and install_all
582    build_all_list = []
583    build_all_list += ['build_esysUtils']
584    build_all_list += ['build_paso']
585    build_all_list += ['build_escript']
586    build_all_list += ['build_pasowrap']
587    build_all_list += ['build_dudley']
588    build_all_list += ['build_finley']
589    build_all_list += ['build_ripley']
590    build_all_list += ['build_speckley']
591    build_all_list += ['build_weipa']
592    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
593    if env['usempi']:   build_all_list += ['build_pythonMPI']
594    build_all_list += ['build_escriptconvert']
595    env.Alias('build_all', build_all_list)
596    
597    install_all_list = []
598    install_all_list += ['target_init']
599    install_all_list += ['install_esysUtils']
600    install_all_list += ['install_paso']
601    install_all_list += ['install_escript']
602    install_all_list += ['install_pasowrap']
603    install_all_list += ['install_dudley']
604    install_all_list += ['install_finley']
605    install_all_list += ['install_ripley']
606    install_all_list += ['install_speckley']
607    install_all_list += ['install_weipa']
608    if not IS_WINDOWS: install_all_list += ['install_escriptreader']
609    install_all_list += ['install_downunder_py']
610    install_all_list += ['install_modellib_py']
611    install_all_list += ['install_pycad_py']
612    if env['usempi']:   install_all_list += ['install_pythonMPI']
613    install_all_list += ['install_escriptconvert']
614    env.Alias('install_all', install_all_list)
615    
616    # Default target is install
617    env.Default('install_all')
618    
619    ################## Targets to build and run the test suite ###################
620    
621    if not env['cppunit']:
622        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
623        env.Alias('run_tests', test_msg)
624        env.Alias('build_tests', '')
625    env.Alias('run_tests', ['install_all'])
626    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
627    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
628    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
629    
630    ##################### Targets to build the documentation #####################
631    
632    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
633    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
634    env.Alias('docs', ['basedocs', 'sphinxdoc'])
635    env.Alias('release_prep', ['docs', 'install_all'])
636    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
637    
638    # The test scripts are always generated, this target allows us to
639    # generate the testscripts without doing a full build
640    env.Alias('testscripts',[])
641    
642    if not IS_WINDOWS:
643        generateTestScripts(env, TestGroups)
644    
645    
646    
647    ######################## Summarize our environment ###########################
648    def print_summary():
649        print("")
650        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
651        print("Escript/Finley revision %s"%global_revision)
652        print("  Install prefix:  %s"%env['prefix'])
653        print("          Python:  %s"%sysconfig.PREFIX)
654        print("           boost:  %s"%env['boost_prefix'])
655        if env['numpy_h']:
656            print("           numpy:  YES (with headers)")
657        else:
658            print("           numpy:  YES (without headers)")
659        if env['usempi']:
660            print("             MPI:  YES (flavour: %s)"%env['mpi'])
661        else:
662            print("             MPI:  DISABLED")
663        if env['uselapack']:
664            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
665        else:
666            print("          LAPACK:  DISABLED")
667        if env['cuda']:
668            print("            CUDA:  YES (nvcc: %s)"%env['nvcc_version'])
669        else:
670            print("            CUDA:  DISABLED")
671        d_list=[]
672        e_list=[]
673        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit','vsl_random':
674            if env[i]: e_list.append(i)
675            else: d_list.append(i)
676        for i in e_list:
677            print("%16s:  YES"%i)
678        for i in d_list:
679            print("%16s:  DISABLED"%i)
680        if env['cppunit']:
681            print("         CppUnit:  FOUND")
682        else:
683            print("         CppUnit:  NOT FOUND")
684        if env['gmsh']=='m':
685            print("            gmsh:  FOUND, MPI-ENABLED")
686        elif env['gmsh']=='s':
687            print("            gmsh:  FOUND")
688        else:
689            print("            gmsh:  NOT FOUND")
690        print(    "            gzip:  " + ("YES" if env['compressed_files'] else "NO"))
691    
692        if ((fatalwarning != '') and (env['werror'])):
693            print("  Treating warnings as errors")
694        else:
695            print("  NOT treating warnings as errors")
696        print("")
697        for w in env['warnings']:
698            print("WARNING: %s"%w)
699        if len(GetBuildFailures()):
700            print("\nERROR: build stopped due to errors\n")
701        else:
702            print("\nSUCCESS: build complete\n")
703    
704  # Zipgets  atexit.register(print_summary)
705    
 env.Default(libinstall)  
 env.Default(incinstall)  
 env.Default(pyinstall)  
 env.Alias('release_src',[ src_zipfile, src_tarfile ])  
 env.Alias('release_tests',[ test_zipfile, test_tarfile])  
 env.Alias('release_examples',[ examples_zipfile, examples_tarfile])  
 env.Alias('api_epydoc',api_epydoc)  
 env.Alias('guide_pdf', guide_pdf)  
 env.Alias('docs',[ 'release_examples', 'guide_pdf', guide_html_index, api_epydoc])  
 env.Alias('release', ['release_src', 'release_tests', 'docs'])  
 env.Alias('build_tests')    # target to build all C++ tests  
 env.Alias('build_py_tests') # target to build all python tests  
 env.Alias('build_all_tests', [ 'build_tests', 'build_py_tests' ] ) # target to build all python tests  
 env.Alias('run_tests', 'build_tests')   # target to run all C++ test  
 env.Alias('py_tests', 'build_py_tests') # taget to run all released python tests  
 env.Alias('all_tests', ['run_tests', 'py_tests']) # target to run all C++ and released python tests  
   
 # Python install - esys __init__.py  
 init_target = env.Command(pyinstall+'/__init__.py', None, Touch('$TARGET'))  
 env.Alias(init_target)  
   
 # Allow sconscripts to see the env  
 Export(["env", "incinstall", "libinstall", "pyinstall", "dodebug", "mkl_libs", "scsl_libs", "umf_libs", "amd_libs", "blas_libs",  
     "boost_lib", "python_lib", "doxygen_path", "epydoc_path", "papi_libs",  
         "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "examples_tarfile", "examples_zipfile",  
         "guide_pdf", "guide_html_index", "api_epydoc", "useMPI"])  
   
 # End initialisation section  
 # Begin configuration section  
 # adds this file and the scons option directore to the source tar  
 release_srcfiles=[env.File('SConstruct'),]+[ env.File(x) for x in glob.glob('scons/*.py') ]  
 release_testfiles=[env.File('README_TESTS'),]  
 env.Zip(src_zipfile, release_srcfiles)  
 env.Zip(test_zipfile, release_testfiles)  
 env.Tar(src_tarfile, release_srcfiles)  
 env.Tar(test_tarfile, release_testfiles)  
   
 # Insert new components to be build here  
 # FIXME: might be nice to replace this verbosity with a list of targets and some  
 # FIXME: nifty python to create the lengthy but very similar env.Sconscript lines  
 # Third Party libraries  
 env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
 # C/C++ Libraries  
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 env.SConscript(dirs = ['bruce/src'], build_dir='build/$PLATFORM/bruce', duplicate=0)  
 env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
 env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  
 env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  
 env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
   
 # added by Ben Cumming  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 #env.SConscript(dirs = ['../test'], build_dir='../test/build', duplicate=0)  

Legend:
Removed from v.863  
changed lines
  Added in v.5148

  ViewVC Help
Powered by ViewVC 1.1.26