/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 898 by gross, Sun Nov 12 23:56:26 2006 UTC revision 5939 by caltinay, Thu Feb 18 10:04:32 2016 UTC
# Line 1  Line 1 
1  #          Copyright 2006 by ACcESS MNRF  ##############################################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2016 by The 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/template/")
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'),  #Note that scons construction vars the the following purposes:
60    ('cxx_flags_MPI', 'C++ compiler flags to use (Release MPI build)', '-ansi -wd1563 -wd161'),  #  CPPFLAGS -> to the preprocessor
61    ('cxx_flags_debug_MPI', 'C++ compiler flags to use (Debug MPI build)', '-ansi -DDOASSERT -DDOPROF -wd1563 -wd161'),  #  CCFLAGS  -> flags for _both_ C and C++
62    ('ar_flags', 'Static library archiver flags to use', None),  #  CXXFLAGS -> flags for c++ _only_
63    ('sys_libs', 'System libraries to link with', None),  #  CFLAGS   -> flags for c only
64    ('tar_flags','flags for zip files','-c -z'),  
65  # MKL  vars = Variables(options_file, ARGUMENTS)
66    PathOption('mkl_path', 'Path to MKL includes', None),  vars.AddVariables(
67    PathOption('mkl_lib_path', 'Path to MKL libs', None),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
68    ('mkl_libs', 'MKL libraries to link with', None),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
69  # SCSL    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
70    PathOption('scsl_path', 'Path to SCSL includes', None),    BoolVariable('verbose', 'Output full compile/link lines', False),
71    PathOption('scsl_lib_path', 'Path to SCSL libs', None),  # Compiler/Linker options
72    ('scsl_libs', 'SCSL libraries to link with', None),    ('cxx', 'Path to C++ compiler', 'default'),
73    ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),    ('cc_flags', 'Base (C and C++) compiler flags', 'default'),
74  # UMFPACK    ('cc_optim', 'Additional (C and C++) flags for a non-debug build', 'default'),
75    PathOption('ufc_path', 'Path to UFconfig includes', ufc_path_default),    ('cc_debug', 'Additional (C and C++) flags for a debug build', 'default'),
76    PathOption('umf_path', 'Path to UMFPACK includes', umf_path_default),    ('cxx_extra', 'Extra C++ compiler flags', ''),
77    PathOption('umf_lib_path', 'Path to UMFPACK libs', umf_lib_path_default),    ('cpp_flags', 'C Pre-processor flags', ''),
78    ('umf_libs', 'UMFPACK libraries to link with', umf_libs_default),    ('cpp_extra', 'Extra C Pre-processor flags', ''),
79  # AMD (used by UMFPACK)    ('ld_extra', 'Extra linker flags', ''),
80    PathOption('amd_path', 'Path to AMD includes', amd_path_default),    ('nvcc', 'Path to CUDA compiler', 'default'),
81    PathOption('amd_lib_path', 'Path to AMD libs', amd_lib_path_default),    ('nvccflags', 'Base CUDA compiler flags', 'default'),
82    ('amd_libs', 'AMD libraries to link with', amd_libs_default),    BoolVariable('werror','Treat compiler warnings as errors', True),
83  # BLAS    BoolVariable('debug', 'Compile with debug flags', False),
84    PathOption('blas_path', 'Path to BLAS includes', None),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
85    PathOption('blas_lib_path', 'Path to BLAS libs', None),    ('omp_flags', 'OpenMP compiler flags', 'default'),
86    ('blas_libs', 'BLAS libraries to link with', None),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
87  # Python  # Mandatory libraries
88  # locations of include files for python    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
89    PathOption('python_path', 'Path to Python includes', '/usr/include/python%s.%s'%(sys.version_info[0],sys.version_info[1])),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
90    PathOption('python_lib_path', 'Path to Python libs', '/usr/lib'),  # Mandatory for tests
91    ('python_lib', 'Python libraries to link with', ["python%s.%s"%(sys.version_info[0],sys.version_info[1]),]),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
92  # Boost    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
93    PathOption('boost_path', 'Path to Boost includes', '/usr/include'),  # Optional libraries and options
94    PathOption('boost_lib_path', 'Path to Boost libs', '/usr/lib'),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
95    ('boost_lib', 'Boost libraries to link with', ['boost_python',]),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
96  # Doc building    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
97  #  PathOption('doxygen_path', 'Path to Doxygen executable', None),    BoolVariable('cuda', 'Enable GPU code with CUDA (requires thrust)', False),
98  #  PathOption('epydoc_path', 'Path to Epydoc executable', None),    ('cuda_prefix', 'Prefix/Paths to NVidia CUDA installation', default_prefix),
99  # PAPI    BoolVariable('netcdf', 'Enable netCDF file support', False),
100    PathOption('papi_path', 'Path to PAPI includes', None),    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
101    PathOption('papi_lib_path', 'Path to PAPI libs', None),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
102    ('papi_libs', 'PAPI libraries to link with', None),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
103  # MPI    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
104    BoolOption('useMPI', 'Compile parallel version using MPI', 'no'),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
105      BoolVariable('mkl', 'Enable the Math Kernel Library', False),
106      ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
107      ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
108      BoolVariable('umfpack', 'Enable UMFPACK', False),
109      ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
110      ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
111      BoolVariable('boomeramg', 'Enable BoomerAMG', False),
112      ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
113      ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
114      EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
115      ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
116      ('lapack_libs', 'LAPACK libraries to link with', []),
117      BoolVariable('silo', 'Enable the Silo file format in weipa', False),
118      ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
119      ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
120      BoolVariable('visit', 'Enable the VisIt simulation interface', False),
121      ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
122      ('visit_libs', 'VisIt libraries to link with', ['simV2']),
123      ListVariable('domains', 'Which domains to build', 'all',\
124                   ['dudley','finley','ripley','speckley']),
125    # Advanced settings
126      ('launcher', 'Launcher command (e.g. mpirun)', 'default'),
127      ('prelaunch', 'Command to execute before launcher (e.g. mpdboot)', 'default'),
128      ('postlaunch', 'Command to execute after launcher (e.g. mpdexit)', 'default'),
129      #dudley_assemble_flags = -funroll-loops      to actually do something
130      ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
131      # To enable passing function pointers through python
132      BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
133      # An option for specifying the compiler tools
134      ('tools_names', 'Compiler tools to use', ['default']),
135      ('env_export', 'Environment variables to be passed to tools',[]),
136      EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
137      EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
138      ('build_shared', 'Build dynamic libraries only', True),
139      ('sys_libs', 'Extra libraries to link with', []),
140      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
141      ('SVN_VERSION', 'Do not use from options file', -2),
142      ('pythoncmd', 'which python to compile with','python'),
143      ('usepython3', 'Is this a python3 build?', False),
144      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
145      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
146      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
147      BoolVariable('longindices', 'use long indices (for very large matrices)', False),
148      BoolVariable('compressed_files','Enables reading from compressed binary files', True),
149      ('compression_libs', 'Compression libraries to link with', ['boost_iostreams']),
150      BoolVariable('papi', 'Enable PAPI', False),
151      ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
152      ('papi_libs', 'PAPI libraries to link with', ['papi']),
153      BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
154      BoolVariable('osx_dependency_fix', 'Fix dependencies for libraries to have absolute paths (OSX)',
155    False)
156  )  )
157    
158  # 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))  
159    
160  # Add some customer builders  # Intel's compiler uses regular expressions improperly and emits a warning
161  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});  
162    
163  if env['PLATFORM'] == "win32":  # PATH is needed so the compiler, linker and tools are found if they are not
164     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  # in default locations.
165    env = Environment(tools = ['default'], options = vars,
166                      ENV = {'PATH': os.environ['PATH']})
167    
168    # set the vars for clang
169    def mkclang(env):
170        env['CXX']='clang++'
171    
172    if env['tools_names'] != ['default']:
173        zz=env['tools_names']
174        if 'clang' in zz:
175            zz.remove('clang')
176            zz.insert(0, mkclang)
177        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
178                          ENV = {'PATH' : os.environ['PATH']})
179    
180    if options_file:
181        opts_valid=False
182        if 'escript_opts_version' in env.Dictionary() and \
183            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
184                opts_valid=True
185        if opts_valid:
186            print("Using options in %s." % options_file)
187        else:
188            print("\nOptions file %s" % options_file)
189            print("is outdated! Please update the file by examining one of the TEMPLATE")
190            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
191            Exit(1)
192    
193    # Generate help text (scons -h)
194    Help(vars.GenerateHelpText(env))
195    
196    # Check for superfluous options
197    if len(vars.UnknownVariables())>0:
198        for k in vars.UnknownVariables():
199            print("Unknown option '%s'" % k)
200        Exit(1)
201    
202    if env['cuda']:
203        if env['nvcc'] != 'default':
204            env['NVCC'] = env['nvcc']
205        env.Tool('nvcc')
206    
207    if 'dudley' in env['domains']:
208        env['domains'].append('finley')
209    
210    # create dictionary which will be populated with info for buildvars file
211    env['buildvars']={}
212    # create list which will be populated with warnings if there are any
213    env['warnings']=[]
214    
215    #################### Make sure install directories exist #####################
216    
217    env['BUILD_DIR']=Dir(env['build_dir']).abspath
218    prefix=Dir(env['prefix']).abspath
219    env['buildvars']['prefix']=prefix
220    env['incinstall'] = os.path.join(prefix, 'include')
221    env['bininstall'] = os.path.join(prefix, 'bin')
222    env['libinstall'] = os.path.join(prefix, 'lib')
223    env['pyinstall']  = os.path.join(prefix, 'esys')
224    if not os.path.isdir(env['bininstall']):
225        os.makedirs(env['bininstall'])
226    if not os.path.isdir(env['libinstall']):
227        os.makedirs(env['libinstall'])
228    if not os.path.isdir(env['pyinstall']):
229        os.makedirs(env['pyinstall'])
230    
231    env.Append(CPPPATH = [env['incinstall']])
232    env.Append(LIBPATH = [env['libinstall']])
233    
234    ################# Fill in compiler options if not set above ##################
235    
236    if env['cxx'] != 'default': env['CXX']=env['cxx']
237    
238    # version >=9 of intel C++ compiler requires use of icpc to link in C++
239    # runtimes (icc does not)
240    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
241        env['LINK'] = env['CXX']
242    
243    # default compiler/linker options
244    cc_flags = ''
245    cc_optim = ''
246    cc_debug = ''
247    omp_flags = ''
248    omp_ldflags = ''
249    fatalwarning = '' # switch to turn warnings into errors
250    sysheaderopt = '' # how to indicate that a header is a system header
251    
252    # env['CC'] might be a full path
253    cc_name=os.path.basename(env['CXX'])
254    
255    if cc_name == 'icpc':
256        # Intel compiler
257        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
258        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
259        cc_flags    = "-std=c++11 -fPIC -w2 -wd1875 -Wno-unknown-pragmas"
260        cc_optim    = "-O3 -ftz -fno-alias -inline-level=2 -ipo -xHost"
261        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
262        omp_flags   = "-openmp"
263        omp_ldflags = "-openmp -openmp_report=1"
264        fatalwarning = "-Werror"
265    elif cc_name[:3] == 'g++':
266        # GNU C++ on any system
267        # note that -ffast-math is not used because it breaks isnan(),
268        # see mantis #691
269        cc_flags     = "-std=c++11 -pedantic -Wall -fPIC -Wno-unknown-pragmas -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
270        cc_optim     = "-O3"
271        #max-vartrack-size: avoid vartrack limit being exceeded with escriptcpp.cpp
272        cc_debug     = "-g3 -O0 -D_GLIBCXX_DEBUG -DDOASSERT -DDOPROF -DBOUNDS_CHECK --param=max-vartrack-size=100000000"
273        omp_flags    = "-fopenmp"
274        omp_ldflags  = "-fopenmp"
275        fatalwarning = "-Werror"
276        sysheaderopt = "-isystem"
277    elif cc_name == 'cl':
278        # Microsoft Visual C on Windows
279        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
280        cc_optim     = "/O2 /Op /W3"
281        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
282        fatalwarning = "/WX"
283    elif cc_name == 'icl':
284        # Intel C on Windows
285        cc_flags     = '/EHsc /GR /MD'
286        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
287        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
288        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
289        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
290    
291    env['sysheaderopt']=sysheaderopt
292    
293    # set defaults if not otherwise specified
294    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
295    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
296    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
297    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
298    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
299    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
300    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
301    if env['cpp_flags'] != '': env.Append(CPPFLAGS = env['cpp_flags'])
302    if env['cpp_extra'] != '': env.Append(CPPFLAGS = " "+env['cpp_extra'])
303    
304    if env['nvccflags'] != 'default':
305        env['NVCCFLAGS'] = env['nvccflags']
306        env['SHNVCCFLAGS'] = env['nvccflags'] + ' -shared'
307    
308    if env['longindices']:
309        env.Append(CPPDEFINES = ['ESYS_INDEXTYPE_LONG'])
310    
311    if env['usepython3']:
312        env.Append(CPPDEFINES=['ESPYTHON3'])
313    
314    # set up the autolazy values
315    if env['forcelazy'] == 'on':
316        env.Append(CPPDEFINES=['FAUTOLAZYON'])
317    elif env['forcelazy'] == 'off':
318        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
319    
320    # set up the collective resolve values
321    if env['forcecollres'] == 'on':
322        env.Append(CPPDEFINES=['FRESCOLLECTON'])
323    elif env['forcecollres'] == 'off':
324        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
325    
326    # allow non-standard C if requested
327    if env['iknowwhatimdoing']:
328        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
329    
330    # Disable OpenMP if no flags provided
331    if env['openmp'] and env['omp_flags'] == '':
332       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
333       env['openmp'] = False
334    
335    if env['openmp']:
336        env.Append(CCFLAGS = env['omp_flags'])
337        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
338    else:
339        env['omp_flags']=''
340        env['omp_ldflags']=''
341    
342    env['buildvars']['openmp']=int(env['openmp'])
343    
344    # add debug/non-debug compiler flags
345    env['buildvars']['debug']=int(env['debug'])
346    if env['debug']:
347        env.Append(CCFLAGS = env['cc_debug'])
348    else:
349        env.Append(CCFLAGS = env['cc_optim'])
350    
351    # always add cc_flags
352    env.Append(CCFLAGS = env['cc_flags'])
353    
354    # add system libraries
355    env.AppendUnique(LIBS = env['sys_libs'])
356    
357    # set defaults for launchers if not otherwise specified
358    if env['prelaunch'] == 'default':
359        if env['mpi'] == 'INTELMPI' and env['openmp']:
360            env['prelaunch'] = "export I_MPI_PIN_DOMAIN=omp"
361        elif env['mpi'] == 'OPENMPI':
362            # transform comma-separated list to '-x a -x b -x c ...'
363            env['prelaunch'] = "EE=$(echo -x %e|sed -e 's/,/ -x /g')"
364        elif env['mpi'] == 'MPT':
365            env['prelaunch'] = "export MPI_NUM_MEMORY_REGIONS=0"
366        elif env['mpi'] == 'MPICH2':
367            env['prelaunch'] = "mpdboot -n %n -r ssh -f %f"
368        else:
369            env['prelaunch'] = ""
370    
371    if env['launcher'] == 'default':
372        if env['mpi'] == 'INTELMPI':
373            env['launcher'] = "mpirun -hostfile %f -n %N -ppn %p %b"
374        elif env['mpi'] == 'OPENMPI':
375            env['launcher'] = "mpirun ${AGENTOVERRIDE} --gmca mpi_warn_on_fork 0 ${EE} --host %h -bynode -bind-to-core --cpus-per-rank %t -np %N %b"
376        elif env['mpi'] == 'MPT':
377            env['launcher'] = "mpirun %h -np %p %b"
378        elif env['mpi'] == 'MPICH':
379            env['launcher'] = "mpirun -machinefile %f -np %N %b"
380        elif env['mpi'] == 'MPICH2':
381            env['launcher'] = "mpiexec -genvlist %e -np %N %b"
382        else:
383            env['launcher'] = "%b"
384    
385    if env['postlaunch'] == 'default':
386        if env['mpi'] == 'MPICH2':
387            env['postlaunch'] = "mpdallexit"
388        else:
389            env['postlaunch'] = ""
390    
391    # determine svn revision
392    global_revision=ARGUMENTS.get('SVN_VERSION', None)
393    if global_revision:
394        global_revision = re.sub(':.*', '', global_revision)
395        global_revision = re.sub('[^0-9]', '', global_revision)
396        if global_revision == '': global_revision='-2'
397  else:  else:
398     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', single_source=True)    # Get the global Subversion revision number for the getVersion() method
399  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});    try:
400        global_revision = os.popen('svnversion -n .').read()
401  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)      global_revision = re.sub(':.*', '', global_revision)
402  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});      global_revision = re.sub('[^0-9]', '', global_revision)
403        if global_revision == '': global_revision='-2'
404      except:
405        global_revision = '-1'
406    env['svn_revision']=global_revision
407    env['buildvars']['svn_revision']=global_revision
408    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
409    
410    if IS_WINDOWS:
411        if not env['build_shared']:
412            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
413            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
414    
415    env['IS_WINDOWS']=IS_WINDOWS
416    env['IS_OSX']=IS_OSX
417    
418    ###################### Copy required environment vars ########################
419    
420    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
421    if IS_WINDOWS:
422        LD_LIBRARY_PATH_KEY='PATH'
423        env['ENV']['LD_LIBRARY_PATH']=''
424    else:
425        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
426    
427  # 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  
428    
429  if 'shake71' == socket.gethostname().split('.')[0]:  # the following env variables are exported for the unit tests
   if useMPI:  
     env['CC'] = 'mpicc'  
     env['CXX'] = 'mpiCC'  
430    
431  if dodebug:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
   if useMPI:  
432      try:      try:
433        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
434      except KeyError:      except KeyError:
435        pass          env['ENV'][key] = '1'
436    else:  
437    env_export=env['env_export']
438    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP','LD_PRELOAD'])
439    
440    for key in set(env_export):
441      try:      try:
442        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
443      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:  
444          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 = ''  
445    
446  try:  for key in os.environ.keys():
447     tar_flags = env['tar_flags']      if key.startswith("SLURM_"):
448     env.Replace(TARFLAGS = tar_flags)          env['ENV'][key] = os.environ[key]
 except KeyError:  
    pass  
449    
450  try:  try:
451     includes = env['mkl_path']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Append(CPPPATH = [includes,])  
452  except KeyError:  except KeyError:
453     pass      pass
454    
455  try:  if IS_OSX:
    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:  
   try:  
     scsl_libs = env['scsl_libs_MPI']  
   except KeyError:  
     scsl_libs = ''  
 else:  
456    try:    try:
457      scsl_libs = env['scsl_libs']      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
458    except KeyError:    except KeyError:
459      scsl_libs = ''      pass
460    
 try:  
    includes = env['umf_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
461    
462  try:  # these shouldn't be needed
463     lib_path = env['umf_lib_path']  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
464     env.Append(LIBPATH = [lib_path,])  #    try:
465  except KeyError:  #        env['ENV'][key] = os.environ[key]
466     pass  #    except KeyError:
467    #        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  
468    
469  try:  try:
470     includes = env['amd_path']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
    env.Append(CPPPATH = [includes,])  
471  except KeyError:  except KeyError:
472     pass      pass
473    
474  try:  ######################## Add some custom builders ############################
    lib_path = env['amd_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
475    
476  if useMPI:  if env['pythoncmd']=='python':
477      amd_libs = ''      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
478  else:  else:
479     try:      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
480        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 = ''  
481    
482  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
483     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  
484    
485    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
486    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
487    
488  try:  runPyExample_builder = Builder(action = runPyExample, suffix = '.passed', src_suffic='.py', single_source=True)
489     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  
490    
491  try:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
492     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  
493    
494  try:  ############################ Dependency checks ###############################
    guide_pdf = env.File(env['guide_pdf'])  
 except KeyError:  
    guide_pdf = None  
495    
496  try:  ######## Compiler
497     guide_html_index = env.File('index.htm',env['guide_html'])  env=checkCompiler(env)
498  except KeyError:  
499     guide_html_index = None  ######## Python headers & library (required)
500    env=checkPython(env)
501    
502    ######## boost & boost-python (required)
503    env=checkBoost(env)
504    
505    ######## NVCC version (optional)
506    if env['cuda']:
507        env=checkCudaVersion(env)
508        env=checkCUDA(env)
509    
510    ######## numpy (required) and numpy headers (optional)
511    env=checkNumpy(env)
512    
513    ######## CppUnit (required for tests)
514    env=checkCppUnit(env)
515    
516    ######## optional python modules (sympy, pyproj)
517    env=checkOptionalModules(env)
518    
519    ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
520    env=checkOptionalLibraries(env)
521    
522    #use gmsh info to set some defines
523    if env['gmsh'] == 's':
524        env.Append(CPPDEFINES=['GMSH'])
525    elif env['gmsh'] == 'm':
526        env.Append(CPPDEFINES=['GMSH','GMSH_MPI'])
527    
528    ######## PDFLaTeX (for documentation)
529    env=checkPDFLatex(env)
530    
531    # keep some of our install paths first in the list for the unit tests
532    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
533    env.PrependENVPath('PYTHONPATH', prefix)
534    env['ENV']['ESCRIPT_ROOT'] = prefix
535    
536    if not env['verbose']:
537        env['CXXCOMSTR'] = "Compiling $TARGET"
538        env['SHCXXCOMSTR'] = "Compiling $TARGET"
539        env['ARCOMSTR'] = "Linking $TARGET"
540        env['LINKCOMSTR'] = "Linking $TARGET"
541        env['SHLINKCOMSTR'] = "Linking $TARGET"
542        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
543        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
544        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
545        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
546        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
547    
548    ####################### Configure the subdirectories #########################
549    
550    # remove obsolete files
551    if not env['usempi']:
552        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
553        Execute(Delete(os.path.join(env['bininstall'], 'escript-overlord')))
554        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
555    
556    from grouptest import *
557    TestGroups=[]
558    
559    # keep an environment without warnings-as-errors
560    dodgy_env=env.Clone()
561    
562    # now add warnings-as-errors flags. This needs to be done after configuration
563    # because the scons test files have warnings in them
564    if ((fatalwarning != '') and (env['werror'])):
565        env.Append(CCFLAGS = fatalwarning)
566    
567    Export(
568      ['env',
569       'dodgy_env',
570       'IS_WINDOWS',
571       'TestGroups'
572      ]
573    )
574    
575  try:  #do not auto build
576     api_epydoc = env.Dir(env['api_epydoc'])  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
577  except KeyError:  env.SConscript(dirs = ['tools/overlord'], variant_dir='$BUILD_DIR/$PLATFORM/tools/overlord', duplicate=0)
578     api_epydoc = None  env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
579    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
580    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
581    
582    env.SConscript(dirs = ['cusplibrary'])
583    
584    #This will pull in the escriptcore/py_src and escriptcore/test
585    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
586    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
587    if 'dudley' in env['domains']:
588        env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
589    if 'finley' in env['domains']:
590        env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
591    if 'ripley' in env['domains']:
592        env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
593    if 'speckley' in env['domains']:
594        env.SConscript(dirs = ['speckley/src'], variant_dir='$BUILD_DIR/$PLATFORM/speckley', duplicate=0)
595    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
596    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
597    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
598    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
599    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
600    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
601    
602    
603    ######################## Populate the buildvars file #########################
604    
605    write_buildvars(env)
606    
607    write_launcher(env)
608    
609    ################### Targets to build and install libraries ###################
610    
611    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
612    env.Alias('target_init', [target_init])
613    # delete buildvars upon cleanup
614    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
615    
616    # The headers have to be installed prior to build in order to satisfy
617    # #include <paso/Common.h>
618    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
619    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
620    
621    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
622    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
623    
624    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
625    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
626    
627    if 'dudley' in env['domains']:
628        env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
629        env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
630    
631    if 'finley' in env['domains']:
632        env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
633        env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
634    
635    if 'ripley' in env['domains']:
636        env.Alias('build_ripley', ['install_cusp_headers', 'install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
637        env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
638    
639    if 'speckley' in env['domains']:
640        env.Alias('build_speckley', ['install_speckley_headers', 'build_speckley_lib', 'build_speckleycpp_lib'])
641        env.Alias('install_speckley', ['build_speckley', 'install_speckley_lib', 'install_speckleycpp_lib', 'install_speckley_py'])
642    
643    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
644    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
645    
646    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
647    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
648    
649    # Now gather all the above into some easy targets: build_all and install_all
650    build_all_list = []
651    build_all_list += ['build_esysUtils']
652    build_all_list += ['build_paso']
653    build_all_list += ['build_escript']
654    if 'dudley' in env['domains']: build_all_list += ['build_dudley']
655    if 'finley' in env['domains']: build_all_list += ['build_finley']
656    if 'ripley' in env['domains']: build_all_list += ['build_ripley']
657    if 'speckley' in env['domains']: build_all_list += ['build_speckley']
658    build_all_list += ['build_weipa']
659    if not IS_WINDOWS and 'finley' in env['domains']:
660        build_all_list += ['build_escriptreader']
661    if env['usempi']:
662        build_all_list += ['build_pythonMPI', 'build_overlord']
663    env.Alias('build_all', build_all_list)
664    
665    install_all_list = []
666    install_all_list += ['target_init']
667    install_all_list += ['install_esysUtils']
668    install_all_list += ['install_paso']
669    install_all_list += ['install_escript']
670    if 'dudley' in env['domains']: install_all_list += ['install_dudley']
671    if 'finley' in env['domains']: install_all_list += ['install_finley']
672    if 'ripley' in env['domains']: install_all_list += ['install_ripley']
673    if 'speckley' in env['domains']: install_all_list += ['install_speckley']
674    install_all_list += ['install_weipa']
675    if not IS_WINDOWS and 'finley' in env['domains']:
676        install_all_list += ['install_escriptreader']
677    install_all_list += ['install_downunder_py']
678    install_all_list += ['install_modellib_py']
679    install_all_list += ['install_pycad_py']
680    if env['usempi']:
681        install_all_list += ['install_pythonMPI', 'install_overlord']
682    install_all_list += ['install_weipa_py']    
683    install_all_list += [env.Install(os.path.join(env['build_dir'],'scripts'), os.path.join('scripts', 'release_sanity.py'))]
684    
685    
686    if env['osx_dependency_fix']:
687        print("Require dependency fix")
688        install_all=env.Command('install_all',install_all_list,'scripts/moveall.sh')
689    else:
690        install_all=env.Alias('install_all', install_all_list)
691    
692    
693    
694    
695    # Default target is install
696    #env.Default('install_all')
697    
698    
699    sanity=env.Alias('sanity', env.Command('dummy','',os.path.join(env['prefix'], 'bin', 'run-escript')+' '+os.path.join(env['build_dir'],'scripts', 'release_sanity.py')))
700    env.Depends('dummy', install_all)
701    if env['usempi']:
702       #env.Requires('dummy', ['build_pythonMPI', 'install_pythonMPI'])
703       #env.Requires('dummy', env['prefix']+"/lib/pythonMPI")
704       env.Depends('dummy', ['build_pythonMPI', 'install_pythonMPI'])
705       env.Depends('dummy', env['prefix']+"/lib/pythonMPI")  
706    
707    if 'install_dudley' in install_all_list and \
708       'install_finley' in install_all_list and \
709       'install_ripley' in install_all_list and \
710       'install_speckley' in install_all_list:
711           env.AlwaysBuild('sanity')
712           env.Default('sanity')
713    else:
714        env.Default('install_all')
715    
716    ################## Targets to build and run the test suite ###################
717    
718    if not env['cppunit']:
719        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
720        env.Alias('run_tests', test_msg)
721        env.Alias('build_tests', '')
722    env.Alias('run_tests', ['install_all'])
723    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
724    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
725    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
726    Requires('py_tests', 'install_all')
727    
728    ##################### Targets to build the documentation #####################
729    
730    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
731    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
732    env.Alias('docs', ['basedocs', 'sphinxdoc'])
733    env.Alias('release_prep', ['docs', 'install_all'])
734    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
735    
736    # The test scripts are always generated, this target allows us to
737    # generate the testscripts without doing a full build
738    env.Alias('testscripts',[])
739    
740    if not IS_WINDOWS:
741        generateTestScripts(env, TestGroups)
742    
743    
744    ######################## Summarize our environment ###########################
745    def print_summary():
746        print("")
747        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
748        print("Escript/Finley revision %s"%global_revision)
749        print("  Install prefix:  %s"%env['prefix'])
750        print("          Python:  %s"%sysconfig.PREFIX)
751        print("           boost:  %s (Version %s)"%(env['boost_prefix'],env['boost_version']))
752        if env['numpy_h']:
753            print("           numpy:  YES (with headers)")
754        else:
755            print("           numpy:  YES (without headers)")
756        if env['usempi']:
757            print("             MPI:  YES (flavour: %s)"%env['mpi'])
758        else:
759            print("             MPI:  NO")
760        if env['parmetis']:
761            print("        ParMETIS:  %s (Version %s)"%(env['parmetis_prefix'],env['parmetis_version']))
762        else:
763            print("        ParMETIS:  NO")
764        if env['uselapack']:
765            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
766        else:
767            print("          LAPACK:  NO")
768        if env['cuda']:
769            print("            CUDA:  YES (nvcc: %s)"%env['nvcc_version'])
770        else:
771            print("            CUDA:  NO")
772        d_list=[]
773        e_list=[]
774        for i in 'debug','openmp','boomeramg','cppunit','gdal','mkl','netcdf','papi','pyproj','scipy','silo','sympy','umfpack','visit':
775            if env[i]: e_list.append(i)
776            else: d_list.append(i)
777        for i in e_list:
778            print("%16s:  YES"%i)
779        for i in d_list:
780            print("%16s:  NO"%i)
781        if env['gmshpy']:
782            gmshpy=" + python module"
783        else:
784            gmshpy=""
785        if env['gmsh']=='m':
786            print("            gmsh:  YES, MPI-ENABLED"+gmshpy)
787        elif env['gmsh']=='s':
788            print("            gmsh:  YES"+gmshpy)
789        else:
790            if env['gmshpy']:
791                print("            gmsh:  python module only")
792            else:
793                print("            gmsh:  NO")
794        print(    "            gzip:  " + ("YES" if env['compressed_files'] else "NO"))
795    
796        if ((fatalwarning != '') and (env['werror'])):
797            print("  Treating warnings as errors")
798        else:
799            print("  NOT treating warnings as errors")
800        print("")
801        for w in env['warnings']:
802            print("WARNING: %s"%w)
803        if len(GetBuildFailures()):
804            print("\nERROR: build stopped due to errors\n")
805        else:
806            print("\nSUCCESS: build complete\n")
807    
808  # Zipgets  atexit.register(print_summary)
809    
 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)  
 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.898  
changed lines
  Added in v.5939

  ViewVC Help
Powered by ViewVC 1.1.26