/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

  ViewVC Help
Powered by ViewVC 1.1.26