/[escript]/branches/diaplayground/SConstruct
ViewVC logotype

Diff of /branches/diaplayground/SConstruct

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

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

  ViewVC Help
Powered by ViewVC 1.1.26