/[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 5184 by caltinay, Wed Oct 1 04:19:22 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      ListVariable('domains', 'Which domains to build', 'all',\
120                   ['dudley','finley','ripley','speckley']),
121      ('thrust_prefix', 'Prefix/Paths to NVidia thrust installation', default_prefix),
122    # Advanced settings
123      #dudley_assemble_flags = -funroll-loops      to actually do something
124      ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
125      # To enable passing function pointers through python
126      BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
127      # An option for specifying the compiler tools (see windows branch)
128      ('tools_names', 'Compiler tools to use', ['default']),
129      ('env_export', 'Environment variables to be passed to tools',[]),
130      EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
131      EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
132      # finer control over library building, intel aggressive global optimisation
133      # works with dynamic libraries on windows.
134      ('build_shared', 'Build dynamic libraries only', False),
135      ('sys_libs', 'Extra libraries to link with', []),
136      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
137      ('SVN_VERSION', 'Do not use from options file', -2),
138      ('pythoncmd', 'which python to compile with','python'),
139      ('usepython3', 'Is this a python3 build? (experimental)', False),
140      ('longindices', 'use long indices (for very large matrices)', False),
141      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
142      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
143      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
144      BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
145      BoolVariable('compressed_files','Enables reading from compressed binary files', True),
146      ('compression_libs', 'Compression libraries to link with', ['boost_iostreams'])
147  )  )
148    
149  # 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  
150    
151  # Setup help for options  # Intel's compiler uses regular expressions improperly and emits a warning
152  Help(opts.GenerateHelpText(env))  # about failing to find the compilers. This warning can be safely ignored.
153    
154  # Add some customer builders  # PATH is needed so the compiler, linker and tools are found if they are not
155  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  # in default locations.
156  env.Append(BUILDERS = {'PyCompile' : py_builder});  env = Environment(tools = ['default'], options = vars,
157                      ENV = {'PATH': os.environ['PATH']})
158  if env['PLATFORM'] == "win32":  
159     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  # set the vars for clang
160    def mkclang(env):
161        env['CXX']='clang++'
162    
163    if env['tools_names'] != ['default']:
164        zz=env['tools_names']
165        if 'clang' in zz:
166            zz.remove('clang')
167            zz.insert(0, mkclang)
168        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
169                          ENV = {'PATH' : os.environ['PATH']})
170    
171    if options_file:
172        opts_valid=False
173        if 'escript_opts_version' in env.Dictionary() and \
174            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
175                opts_valid=True
176        if opts_valid:
177            print("Using options in %s." % options_file)
178        else:
179            print("\nOptions file %s" % options_file)
180            print("is outdated! Please update the file by examining one of the TEMPLATE")
181            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
182            Exit(1)
183    
184    # Generate help text (scons -h)
185    Help(vars.GenerateHelpText(env))
186    
187    # Check for superfluous options
188    if len(vars.UnknownVariables())>0:
189        for k in vars.UnknownVariables():
190            print("Unknown option '%s'" % k)
191        Exit(1)
192    
193    if env['cuda']:
194        if env['nvcc'] != 'default':
195            env['NVCC'] = env['nvcc']
196        env.Tool('nvcc')
197    
198    # create dictionary which will be populated with info for buildvars file
199    env['buildvars']={}
200    # create list which will be populated with warnings if there are any
201    env['warnings']=[]
202    
203    #################### Make sure install directories exist #####################
204    
205    env['BUILD_DIR']=Dir(env['build_dir']).abspath
206    prefix=Dir(env['prefix']).abspath
207    env['buildvars']['prefix']=prefix
208    env['incinstall'] = os.path.join(prefix, 'include')
209    env['bininstall'] = os.path.join(prefix, 'bin')
210    env['libinstall'] = os.path.join(prefix, 'lib')
211    env['pyinstall']  = os.path.join(prefix, 'esys')
212    if not os.path.isdir(env['bininstall']):
213        os.makedirs(env['bininstall'])
214    if not os.path.isdir(env['libinstall']):
215        os.makedirs(env['libinstall'])
216    if not os.path.isdir(env['pyinstall']):
217        os.makedirs(env['pyinstall'])
218    
219    env.Append(CPPPATH = [env['incinstall']])
220    env.Append(LIBPATH = [env['libinstall']])
221    
222    ################# Fill in compiler options if not set above ##################
223    
224    if env['cxx'] != 'default': env['CXX']=env['cxx']
225    
226    # version >=9 of intel C++ compiler requires use of icpc to link in C++
227    # runtimes (icc does not)
228    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
229        env['LINK'] = env['CXX']
230    
231    # default compiler/linker options
232    cc_flags = ''
233    cc_optim = ''
234    cc_debug = ''
235    omp_flags = ''
236    omp_ldflags = ''
237    fatalwarning = '' # switch to turn warnings into errors
238    sysheaderopt = '' # how to indicate that a header is a system header
239    
240    # env['CC'] might be a full path
241    cc_name=os.path.basename(env['CXX'])
242    
243    if cc_name == 'icpc':
244        # Intel compiler
245        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
246        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
247        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas"
248        cc_optim    = "-O3 -ftz -fno-alias -inline-level=2 -ipo -xHost"
249        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
250        omp_flags   = "-openmp"
251        omp_ldflags = "-openmp -openmp_report=1"
252        fatalwarning = "-Werror"
253    elif cc_name[:3] == 'g++':
254        # GNU C on any system
255        # note that -ffast-math is not used because it breaks isnan(),
256        # see mantis #691
257        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
258        cc_optim     = "-O3"
259        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK --param=max-vartrack-size=90000000" #avoids vartrack limit being exceeded with escriptcpp.cpp
260        omp_flags    = "-fopenmp"
261        omp_ldflags  = "-fopenmp"
262        fatalwarning = "-Werror"
263        sysheaderopt = "-isystem"
264    elif cc_name == 'cl':
265        # Microsoft Visual C on Windows
266        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
267        cc_optim     = "/O2 /Op /W3"
268        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
269        fatalwarning = "/WX"
270    elif cc_name == 'icl':
271        # Intel C on Windows
272        cc_flags     = '/EHsc /GR /MD'
273        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
274        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
275        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
276        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
277    
278    env['sysheaderopt']=sysheaderopt
279    
280    # set defaults if not otherwise specified
281    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
282    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
283    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
284    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
285    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
286    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
287    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
288    
289    if env['nvccflags'] != 'default':
290        env['NVCCFLAGS'] = env['nvccflags']
291        env['SHNVCCFLAGS'] = env['nvccflags'] + ' -shared'
292    
293    if env['BADPYTHONMACROS']:
294        env.Append(CPPDEFINES = ['BADPYTHONMACROS'])
295    
296    if env['longindices']:
297        env.Append(CPPDEFINES = ['ESYS_INDEXTYPE_LONG'])
298    
299    if env['usepython3']:
300        env.Append(CPPDEFINES=['ESPYTHON3'])
301    
302    # set up the autolazy values
303    if env['forcelazy'] == 'on':
304        env.Append(CPPDEFINES=['FAUTOLAZYON'])
305    elif env['forcelazy'] == 'off':
306        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
307    
308    # set up the collective resolve values
309    if env['forcecollres'] == 'on':
310        env.Append(CPPDEFINES=['FRESCOLLECTON'])
311    elif env['forcecollres'] == 'off':
312        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
313    
314    # allow non-standard C if requested
315    if env['iknowwhatimdoing']:
316        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
317    
318    # Disable OpenMP if no flags provided
319    if env['openmp'] and env['omp_flags'] == '':
320       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
321       env['openmp'] = False
322    
323    if env['openmp']:
324        env.Append(CCFLAGS = env['omp_flags'])
325        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
326    else:
327        env['omp_flags']=''
328        env['omp_ldflags']=''
329    
330    env['buildvars']['openmp']=int(env['openmp'])
331    
332    # add debug/non-debug compiler flags
333    env['buildvars']['debug']=int(env['debug'])
334    if env['debug']:
335        env.Append(CCFLAGS = env['cc_debug'])
336    else:
337        env.Append(CCFLAGS = env['cc_optim'])
338    
339    # always add cc_flags
340    env.Append(CCFLAGS = env['cc_flags'])
341    
342    # add system libraries
343    env.AppendUnique(LIBS = env['sys_libs'])
344    
345    # determine svn revision
346    global_revision=ARGUMENTS.get('SVN_VERSION', None)
347    if global_revision:
348        global_revision = re.sub(':.*', '', global_revision)
349        global_revision = re.sub('[^0-9]', '', global_revision)
350        if global_revision == '': global_revision='-2'
351  else:  else:
352     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', single_source=True)    # Get the global Subversion revision number for the getVersion() method
353  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});    try:
354        global_revision = os.popen('svnversion -n .').read()
355  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)      global_revision = re.sub(':.*', '', global_revision)
356  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});      global_revision = re.sub('[^0-9]', '', global_revision)
357        if global_revision == '': global_revision='-2'
358      except:
359        global_revision = '-1'
360    env['svn_revision']=global_revision
361    env['buildvars']['svn_revision']=global_revision
362    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
363    
364    if IS_WINDOWS:
365        if not env['build_shared']:
366            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
367            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
368    
369    # VSL random numbers
370    env['buildvars']['vsl_random']=int(env['vsl_random'])
371    if env['vsl_random']:
372        env.Append(CPPDEFINES = ['MKLRANDOM'])
373    
374    env['IS_WINDOWS']=IS_WINDOWS
375    
376    ###################### Copy required environment vars ########################
377    
378    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
379    if IS_WINDOWS:
380        LD_LIBRARY_PATH_KEY='PATH'
381        env['ENV']['LD_LIBRARY_PATH']=''
382    else:
383        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
384    
385  # 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  
386    
387  if 'shake71' == socket.gethostname().split('.')[0]:  # the following env variables are exported for the unit tests
   if useMPI:  
     env['CC'] = 'mpicc'  
     env['CXX'] = 'mpiCC'  
388    
389  if dodebug:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
   if useMPI:  
390      try:      try:
391        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
392      except KeyError:      except KeyError:
393        pass          env['ENV'][key] = '1'
394    else:  
395    env_export=env['env_export']
396    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP','LD_PRELOAD'])
397    
398    for key in set(env_export):
399      try:      try:
400        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
401      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:  
402          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  
403    
404  try:  try:
405     lib_path = env['mkl_lib_path']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Append(LIBPATH = [lib_path,])  
406  except KeyError:  except KeyError:
407     pass      pass
408    
409  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:  
410    try:    try:
411      scsl_libs = env['scsl_libs_MPI']      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
412    except KeyError:    except KeyError:
413      scsl_libs = ''      pass
 else:  
   try:  
     scsl_libs = env['scsl_libs']  
   except KeyError:  
     scsl_libs = ''  
414    
 try:  
    includes = env['umf_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
415    
416  try:  # these shouldn't be needed
417     lib_path = env['umf_lib_path']  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
418     env.Append(LIBPATH = [lib_path,])  #    try:
419  except KeyError:  #        env['ENV'][key] = os.environ[key]
420     pass  #    except KeyError:
421    #        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  
422    
423  try:  try:
424     blas_libs = env['blas_libs']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
425  except KeyError:  except KeyError:
426     blas_libs = ''      pass
427    
428  try:  ######################## Add some custom builders ############################
    useNetCDF = env['useNetCDF']  
 except KeyError:  
    useNetCDF = 'yes'  
    pass  
429    
430  if not useNetCDF == 'yes':  if env['pythoncmd']=='python':
431     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 = [ ]  
432  else:  else:
433     netCDF_libs_cxx=[ ]      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
434    env.Append(BUILDERS = {'PyCompile' : py_builder});
435    
436  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
437     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  
438    
439    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
440    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
441    
442  try:  runPyExample_builder = Builder(action = runPyExample, suffix = '.passed', src_suffic='.py', single_source=True)
443     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  
444    
445  try:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
446     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  
447    
448  try:  ############################ Dependency checks ###############################
    guide_pdf = env.File(env['guide_pdf'])  
 except KeyError:  
    guide_pdf = None  
449    
450  try:  ######## Compiler
451     guide_html_index = env.File('index.htm',env['guide_html'])  env=checkCompiler(env)
452  except KeyError:  
453     guide_html_index = None  ######## Python headers & library (required)
454    env=checkPython(env)
455    
456    ######## boost & boost-python (required)
457    env=checkBoost(env)
458    
459    ######## NVCC version (optional)
460    if env['cuda']:
461        env=checkCudaVersion(env)
462    
463    ######## numpy (required) and numpy headers (optional)
464    env=checkNumpy(env)
465    
466    ######## CppUnit (required for tests)
467    env=checkCppUnit(env)
468    
469    ######## optional python modules (sympy, pyproj)
470    env=checkOptionalModules(env)
471    
472    ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
473    env=checkOptionalLibraries(env)
474    
475    ######## PDFLaTeX (for documentation)
476    env=checkPDFLatex(env)
477    
478    # keep some of our install paths first in the list for the unit tests
479    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
480    env.PrependENVPath('PYTHONPATH', prefix)
481    env['ENV']['ESCRIPT_ROOT'] = prefix
482    
483    if not env['verbose']:
484        env['CXXCOMSTR'] = "Compiling $TARGET"
485        env['SHCXXCOMSTR'] = "Compiling $TARGET"
486        env['ARCOMSTR'] = "Linking $TARGET"
487        env['LINKCOMSTR'] = "Linking $TARGET"
488        env['SHLINKCOMSTR'] = "Linking $TARGET"
489        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
490        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
491        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
492        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
493        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
494    
495    ####################### Configure the subdirectories #########################
496    
497    # remove obsolete files
498    if not env['usempi']:
499        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
500        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
501    
502    from grouptest import *
503    TestGroups=[]
504    
505    # keep an environment without warnings-as-errors
506    dodgy_env=env.Clone()
507    
508    # now add warnings-as-errors flags. This needs to be done after configuration
509    # because the scons test files have warnings in them
510    if ((fatalwarning != '') and (env['werror'])):
511        env.Append(CCFLAGS = fatalwarning)
512    
513    Export(
514      ['env',
515       'dodgy_env',
516       'IS_WINDOWS',
517       'TestGroups'
518      ]
519    )
520    
521  try:  #do not auto build
522     api_epydoc = env.Dir(env['api_epydoc'])  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
523  except KeyError:  env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
524     api_epydoc = None  env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
525    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
526    
527    env.SConscript(dirs = ['cusplibrary'])
528    
529    #This will pull in the escriptcore/py_src and escriptcore/test
530    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
531    #env.SConscript(dirs = ['escript/test'], variant_dir='$BUILD_DIR/$PLATFORM/escript/test', duplicate=0)
532    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
533    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
534    if 'dudley' in env['domains']:
535        env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
536    if 'finley' in env['domains']:
537        env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
538    if 'ripley' in env['domains']:
539        env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
540    if 'speckley' in env['domains']:
541        env.SConscript(dirs = ['speckley/src'], variant_dir='$BUILD_DIR/$PLATFORM/speckley', duplicate=0)
542    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
543    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
544    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
545    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
546    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
547    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
548    
549    
550    ######################## Populate the buildvars file #########################
551    
552    write_buildvars(env)
553    
554    ################### Targets to build and install libraries ###################
555    
556    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
557    env.Alias('target_init', [target_init])
558    # delete buildvars upon cleanup
559    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
560    
561    # The headers have to be installed prior to build in order to satisfy
562    # #include <paso/Common.h>
563    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
564    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
565    
566    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
567    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
568    
569    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
570    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
571    
572    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
573    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
574    
575    if 'dudley' in env['domains']:
576        env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
577        env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
578    
579    if 'finley' in env['domains']:
580        env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
581        env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
582    
583    if 'ripley' in env['domains']:
584        env.Alias('build_ripley', ['install_cusp_headers', 'install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
585        env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
586    
587    if 'speckley' in env['domains']:
588        env.Alias('build_speckley', ['install_speckley_headers', 'build_speckley_lib', 'build_speckleycpp_lib'])
589        env.Alias('install_speckley', ['build_speckley', 'install_speckley_lib', 'install_speckleycpp_lib', 'install_speckley_py'])
590    
591    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
592    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
593    
594    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
595    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
596    
597    # Now gather all the above into some easy targets: build_all and install_all
598    build_all_list = []
599    build_all_list += ['build_esysUtils']
600    build_all_list += ['build_paso']
601    build_all_list += ['build_escript']
602    build_all_list += ['build_pasowrap']
603    if 'dudley' in env['domains']: build_all_list += ['build_dudley']
604    if 'finley' in env['domains']: build_all_list += ['build_finley']
605    if 'ripley' in env['domains']: build_all_list += ['build_ripley']
606    if 'speckley' in env['domains']: build_all_list += ['build_speckley']
607    build_all_list += ['build_weipa']
608    if not IS_WINDOWS and 'finley' in env['domains']:
609        build_all_list += ['build_escriptreader']
610    if env['usempi']:   build_all_list += ['build_pythonMPI']
611    env.Alias('build_all', build_all_list)
612    
613    install_all_list = []
614    install_all_list += ['target_init']
615    install_all_list += ['install_esysUtils']
616    install_all_list += ['install_paso']
617    install_all_list += ['install_escript']
618    install_all_list += ['install_pasowrap']
619    if 'dudley' in env['domains']: install_all_list += ['install_dudley']
620    if 'finley' in env['domains']: install_all_list += ['install_finley']
621    if 'ripley' in env['domains']: install_all_list += ['install_ripley']
622    if 'speckley' in env['domains']: install_all_list += ['install_speckley']
623    install_all_list += ['install_weipa']
624    if not IS_WINDOWS and 'finley' in env['domains']:
625        install_all_list += ['install_escriptreader']
626    install_all_list += ['install_downunder_py']
627    install_all_list += ['install_modellib_py']
628    install_all_list += ['install_pycad_py']
629    if env['usempi']:   install_all_list += ['install_pythonMPI']
630    env.Alias('install_all', install_all_list)
631    
632    # Default target is install
633    env.Default('install_all')
634    
635    ################## Targets to build and run the test suite ###################
636    
637    if not env['cppunit']:
638        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
639        env.Alias('run_tests', test_msg)
640        env.Alias('build_tests', '')
641    env.Alias('run_tests', ['install_all'])
642    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
643    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
644    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
645    
646    ##################### Targets to build the documentation #####################
647    
648    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
649    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
650    env.Alias('docs', ['basedocs', 'sphinxdoc'])
651    env.Alias('release_prep', ['docs', 'install_all'])
652    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
653    
654    # The test scripts are always generated, this target allows us to
655    # generate the testscripts without doing a full build
656    env.Alias('testscripts',[])
657    
658    if not IS_WINDOWS:
659        generateTestScripts(env, TestGroups)
660    
661    
662    
663    ######################## Summarize our environment ###########################
664    def print_summary():
665        print("")
666        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
667        print("Escript/Finley revision %s"%global_revision)
668        print("  Install prefix:  %s"%env['prefix'])
669        print("          Python:  %s"%sysconfig.PREFIX)
670        print("           boost:  %s"%env['boost_prefix'])
671        if env['numpy_h']:
672            print("           numpy:  YES (with headers)")
673        else:
674            print("           numpy:  YES (without headers)")
675        if env['usempi']:
676            print("             MPI:  YES (flavour: %s)"%env['mpi'])
677        else:
678            print("             MPI:  DISABLED")
679        if env['uselapack']:
680            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
681        else:
682            print("          LAPACK:  DISABLED")
683        if env['cuda']:
684            print("            CUDA:  YES (nvcc: %s)"%env['nvcc_version'])
685        else:
686            print("            CUDA:  DISABLED")
687        d_list=[]
688        e_list=[]
689        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit','vsl_random':
690            if env[i]: e_list.append(i)
691            else: d_list.append(i)
692        for i in e_list:
693            print("%16s:  YES"%i)
694        for i in d_list:
695            print("%16s:  DISABLED"%i)
696        if env['cppunit']:
697            print("         CppUnit:  FOUND")
698        else:
699            print("         CppUnit:  NOT FOUND")
700        if env['gmsh']=='m':
701            print("            gmsh:  FOUND, MPI-ENABLED")
702        elif env['gmsh']=='s':
703            print("            gmsh:  FOUND")
704        else:
705            print("            gmsh:  NOT FOUND")
706        print(    "            gzip:  " + ("YES" if env['compressed_files'] else "NO"))
707    
708        if ((fatalwarning != '') and (env['werror'])):
709            print("  Treating warnings as errors")
710        else:
711            print("  NOT treating warnings as errors")
712        print("")
713        for w in env['warnings']:
714            print("WARNING: %s"%w)
715        if len(GetBuildFailures()):
716            print("\nERROR: build stopped due to errors\n")
717        else:
718            print("\nSUCCESS: build complete\n")
719    
720  # Zipgets  atexit.register(print_summary)
721    
 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.5184

  ViewVC Help
Powered by ViewVC 1.1.26