/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 2387 by jfenwick, Wed Apr 15 05:05:27 2009 UTC revision 5496 by sshaw, Thu Feb 26 00:36:29 2015 UTC
# Line 1  Line 1 
1    ##############################################################################
 ########################################################  
2  #  #
3  # Copyright (c) 2003-2008 by University of Queensland  # Copyright (c) 2003-2015 by University of Queensland
4  # Earth Systems Science Computational Center (ESSCC)  # http://www.uq.edu.au
 # http://www.uq.edu.au/esscc  
5  #  #
6  # Primary Business: Queensland, Australia  # Primary Business: Queensland, Australia
7  # Licensed under the Open Software License version 3.0  # Licensed under the Open Software License version 3.0
8  # http://www.opensource.org/licenses/osl-3.0.php  # 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  EnsureSConsVersion(0,96,91)  #
14  EnsurePythonVersion(2,3)  ##############################################################################
   
 import sys, os, re, socket, platform, stat  
   
 # Add our extensions  
 if os.path.isdir('scons'): sys.path.append('scons')  
 import scons_extensions  
15    
16  # Use /usr/lib64 if available, else /usr/lib  EnsureSConsVersion(0,98,1)
17  usr_lib = '/usr/lib'  EnsurePythonVersion(2,5)
 if os.path.isfile('/usr/lib64/libc.so'): usr_lib = '/usr/lib64'  
18    
19  # The string python2.4 or python2.5  import atexit, sys, os, platform, re
20  python_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])  from distutils import sysconfig
21    from dependencies import *
22    from site_init import *
23    
24    # Version number to check for in options file. Increment when new features are
25    # added or existing options changed.
26    REQUIRED_OPTS_VERSION=202
27    
28  # MS Windows support, many thanks to PH  # MS Windows support, many thanks to PH
29  IS_WINDOWS_PLATFORM = (os.name== "nt")  IS_WINDOWS = (os.name == 'nt')
30    
31  prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  IS_OSX = (os.uname()[0] == 'Darwin')
32    
33  # Read configuration options from file scons/<hostname>_options.py  ########################## Determine options file ############################
34  hostname = re.sub("[^0-9a-zA-Z]", "_", socket.gethostname().split('.')[0])  # 1. command line
35  tmp = os.path.join("scons",hostname+"_options.py")  # 2. scons/<hostname>_options.py
36  options_file = ARGUMENTS.get('options_file', tmp)  # 3. name as part of a cluster
37  if not os.path.isfile(options_file):  options_file=ARGUMENTS.get('options_file', None)
38    options_file = False  if not options_file:
39    print "Options file not found (expected '%s')" % tmp      ext_dir = os.path.join(os.getcwd(), 'scons')
40  else:      hostname = platform.node().split('.')[0]
41    print "Options file is", options_file      for name in hostname, effectiveName(hostname):
42            mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
43  # Load options file and command-line arguments          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
44  opts = Options(options_file, ARGUMENTS)          if os.path.isfile(options_file): break
45    
46  ############ Load build options ################################  if not os.path.isfile(options_file):
47        print("\nWARNING:\nOptions file %s" % options_file)
48  opts.AddOptions(      print("not found! Default options will be used which is most likely suboptimal.")
49  # Where to install esys stuff      print("We recommend that you copy the most relavent options file in the scons/os/")
50    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),      print("subdirectory and customize it to your needs.\n")
51    ('incinstall', 'where the esys headers will be installed',             os.path.join(Dir('#.').abspath,'include')),      options_file = None
52    ('bininstall', 'where the esys binaries will be installed',            os.path.join(prefix,'bin')),  
53    ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),  ############################### Build options ################################
54    ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),  
55  # Compilation options  default_prefix='/usr'
56    BoolOption('dodebug', 'For backwards compatibility', 'no'),  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
57    BoolOption('usedebug', 'Do you want a debug build?', 'no'),  lapack_flavours=('none', 'clapack', 'mkl')
58    BoolOption('usevtk', 'Do you want to use VTK?', 'yes'),  
59    ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  vars = Variables(options_file, ARGUMENTS)
60    ('win_cc_name', 'windows C compiler name if needed', 'msvc'),  vars.AddVariables(
61    # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
62    ('cc_flags', 'C compiler flags to use', '-DEFAULT_1'),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
63    ('cc_optim', 'C compiler optimization flags to use', '-DEFAULT_2'),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
64    ('cc_debug', 'C compiler debug flags to use', '-DEFAULT_3'),    BoolVariable('verbose', 'Output full compile/link lines', False),
65    ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),  # Compiler/Linker options
66    ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),    ('cxx', 'Path to C++ compiler', 'default'),
67    ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),    ('cc_flags', 'Base C++ compiler flags', 'default'),
68    ('cc_extra', 'Extra C/C++ flags', ''),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
69      ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
70      ('cxx_extra', 'Extra C++ compiler flags', ''),
71    ('ld_extra', 'Extra linker flags', ''),    ('ld_extra', 'Extra linker flags', ''),
72    ('sys_libs', 'System libraries to link with', []),    ('nvcc', 'Path to CUDA compiler', 'default'),
73    ('ar_flags', 'Static library archiver flags to use', ''),    ('nvccflags', 'Base CUDA compiler flags', 'default'),
74    BoolOption('useopenmp', 'Compile parallel version using OpenMP', 'no'),    BoolVariable('werror','Treat compiler warnings as errors', True),
75    BoolOption('usepedantic', 'Compile with -pedantic if using gcc', 'no'),    BoolVariable('debug', 'Compile with debug flags', False),
76    BoolOption('usewarnings','Compile with warnings as errors if using gcc','yes'),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
77    ('forcelazy','for testing use only - set the default value for autolazy','leave_alone'),    ('omp_flags', 'OpenMP compiler flags', 'default'),
78  # Python    ('omp_ldflags', 'OpenMP linker flags', 'default'),
79    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),  # Mandatory libraries
80    ('python_lib_path', 'Path to Python libs', usr_lib),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
81    ('python_libs', 'Python libraries to link with', [python_version]),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
82    ('python_cmd', 'Python command', 'python'),  # Mandatory for tests
83  # Boost    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
84    ('boost_path', 'Path to Boost includes', '/usr/include'),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
85    ('boost_lib_path', 'Path to Boost libs', usr_lib),  # Optional libraries and options
86    ('boost_libs', 'Boost libraries to link with', ['boost_python']),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
87  # NetCDF    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
88    BoolOption('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
89    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),    BoolVariable('cuda', 'Enable GPU code with CUDA (requires thrust)', False),
90    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    ('cuda_prefix', 'Prefix/Paths to NVidia CUDA installation', default_prefix),
91    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    BoolVariable('netcdf', 'Enable netCDF file support', False),
92  # MPI    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
93    BoolOption('useMPI', 'For backwards compatibility', 'no'),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
94    BoolOption('usempi', 'Compile parallel version using MPI', 'no'),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
95    ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
96    ('mpi_path', 'Path to MPI includes', '/usr/include'),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
97    ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
98    ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
99    ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', ['mpich' , 'pthread', 'rt']),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
100    ('mpi_flavour','Type of MPI execution environment','none'),    BoolVariable('umfpack', 'Enable UMFPACK', False),
101  # ParMETIS    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
102    BoolOption('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
103    ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
104    ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
105    ('parmetis_libs', 'ParMETIS library to link with', ['parmetis', 'metis']),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
106  # PAPI    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
107    BoolOption('usepapi', 'switch on/off the usage of PAPI', 'no'),    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
108    ('papi_path', 'Path to PAPI includes', '/usr/include'),    ('lapack_libs', 'LAPACK libraries to link with', []),
109    ('papi_lib_path', 'Path to PAPI libs', usr_lib),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
110    ('papi_libs', 'PAPI libraries to link with', ['papi']),    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
   BoolOption('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', False),  
 # MKL  
   BoolOption('usemkl', 'switch on/off the usage of MKL', 'no'),  
   ('mkl_path', 'Path to MKL includes', '/sw/sdev/cmkl/10.0.2.18/include'),  
   ('mkl_lib_path', 'Path to MKL libs', '/sw/sdev/cmkl/10.0.2.18/lib/em64t'),  
   ('mkl_libs', 'MKL libraries to link with', ['mkl_solver', 'mkl_em64t', 'guide', 'pthread']),  
 # UMFPACK  
   BoolOption('useumfpack', 'switch on/off the usage of UMFPACK', 'no'),  
   ('ufc_path', 'Path to UFconfig includes', '/usr/include/suitesparse'),  
   ('umf_path', 'Path to UMFPACK includes', '/usr/include/suitesparse'),  
   ('umf_lib_path', 'Path to UMFPACK libs', usr_lib),  
   ('umf_libs', 'UMFPACK libraries to link with', ['umfpack']),  
 # Silo  
   BoolOption('usesilo', 'switch on/off the usage of Silo', 'yes'),  
   ('silo_path', 'Path to Silo includes', '/usr/include'),  
   ('silo_lib_path', 'Path to Silo libs', usr_lib),  
111    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
112  # AMD (used by UMFPACK)    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
113    ('amd_path', 'Path to AMD includes', '/usr/include/suitesparse'),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
114    ('amd_lib_path', 'Path to AMD libs', usr_lib),    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
115    ('amd_libs', 'AMD libraries to link with', ['amd']),    ListVariable('domains', 'Which domains to build', 'all',\
116  # BLAS (used by UMFPACK)                 ['dudley','finley','ripley','speckley']),
117    ('blas_path', 'Path to BLAS includes', '/usr/include/suitesparse'),  # Advanced settings
118    ('blas_lib_path', 'Path to BLAS libs', usr_lib),    ('launcher', 'Launcher command (e.g. mpirun)', 'default'),
119    ('blas_libs', 'BLAS libraries to link with', ['blas']),    ('prelaunch', 'Command to execute before launcher (e.g. mpdboot)', 'default'),
120  # An option for specifying the compiler tools set (see windows branch).    ('postlaunch', 'Command to execute after launcher (e.g. mpdexit)', 'default'),
121    ('tools_names', 'allow control over the tools in the env setup', ['intelc']),    #dudley_assemble_flags = -funroll-loops      to actually do something
122  # finer control over library building, intel aggressive global optimisation    ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
123  # works with dynamic libraries on windows.    # To enable passing function pointers through python
124    ('share_esysUtils', 'control static or dynamic esysUtils lib', False),    BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
125    ('share_paso', 'control static or dynamic paso lib', False)    # An option for specifying the compiler tools
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      ('build_shared', 'Build dynamic libraries only', False),
131      ('sys_libs', 'Extra libraries to link with', []),
132      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
133      ('SVN_VERSION', 'Do not use from options file', -2),
134      ('pythoncmd', 'which python to compile with','python'),
135      ('usepython3', 'Is this a python3 build? (experimental)', False),
136      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
137      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
138      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
139      BoolVariable('longindices', 'use long indices (for very large matrices)', False),
140      BoolVariable('compressed_files','Enables reading from compressed binary files', True),
141      ('compression_libs', 'Compression libraries to link with', ['boost_iostreams']),
142      BoolVariable('papi', 'Enable PAPI', False),
143      ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
144      ('papi_libs', 'PAPI libraries to link with', ['papi']),
145      BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False)
146  )  )
147    
148  ############ Specify which compilers to use ####################  ##################### Create environment and help text #######################
149    
150  # intelc uses regular expressions improperly and emits a warning about  # Intel's compiler uses regular expressions improperly and emits a warning
151  # failing to find the compilers.  This warning can be safely ignored.  # about failing to find the compilers. This warning can be safely ignored.
152    
153  if IS_WINDOWS_PLATFORM:  # PATH is needed so the compiler, linker and tools are found if they are not
154        env = Environment(options = opts)  # in default locations.
155        env = Environment(tools = ['default'] + env['tools_names'],  env = Environment(tools = ['default'], options = vars,
156                          options = opts)                    ENV = {'PATH': os.environ['PATH']})
157    
158    # set the vars for clang
159    def mkclang(env):
160        env['CXX']='clang++'
161    
162    if env['tools_names'] != ['default']:
163        zz=env['tools_names']
164        if 'clang' in zz:
165            zz.remove('clang')
166            zz.insert(0, mkclang)
167        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
168                          ENV = {'PATH' : os.environ['PATH']})
169    
170    if options_file:
171        opts_valid=False
172        if 'escript_opts_version' in env.Dictionary() and \
173            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
174                opts_valid=True
175        if opts_valid:
176            print("Using options in %s." % options_file)
177        else:
178            print("\nOptions file %s" % options_file)
179            print("is outdated! Please update the file by examining one of the TEMPLATE")
180            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
181            Exit(1)
182    
183    # Generate help text (scons -h)
184    Help(vars.GenerateHelpText(env))
185    
186    # Check for superfluous options
187    if len(vars.UnknownVariables())>0:
188        for k in vars.UnknownVariables():
189            print("Unknown option '%s'" % k)
190        Exit(1)
191    
192    if env['cuda']:
193        if env['nvcc'] != 'default':
194            env['NVCC'] = env['nvcc']
195        env.Tool('nvcc')
196    
197    if 'dudley' in env['domains']:
198        env['domains'].append('finley')
199    
200    # create dictionary which will be populated with info for buildvars file
201    env['buildvars']={}
202    # create list which will be populated with warnings if there are any
203    env['warnings']=[]
204    
205    #################### Make sure install directories exist #####################
206    
207    env['BUILD_DIR']=Dir(env['build_dir']).abspath
208    prefix=Dir(env['prefix']).abspath
209    env['buildvars']['prefix']=prefix
210    env['incinstall'] = os.path.join(prefix, 'include')
211    env['bininstall'] = os.path.join(prefix, 'bin')
212    env['libinstall'] = os.path.join(prefix, 'lib')
213    env['pyinstall']  = os.path.join(prefix, 'esys')
214    if not os.path.isdir(env['bininstall']):
215        os.makedirs(env['bininstall'])
216    if not os.path.isdir(env['libinstall']):
217        os.makedirs(env['libinstall'])
218    if not os.path.isdir(env['pyinstall']):
219        os.makedirs(env['pyinstall'])
220    
221    env.Append(CPPPATH = [env['incinstall']])
222    env.Append(LIBPATH = [env['libinstall']])
223    
224    ################# Fill in compiler options if not set above ##################
225    
226    if env['cxx'] != 'default': env['CXX']=env['cxx']
227    
228    # version >=9 of intel C++ compiler requires use of icpc to link in C++
229    # runtimes (icc does not)
230    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
231        env['LINK'] = env['CXX']
232    
233    # default compiler/linker options
234    cc_flags = ''
235    cc_optim = ''
236    cc_debug = ''
237    omp_flags = ''
238    omp_ldflags = ''
239    fatalwarning = '' # switch to turn warnings into errors
240    sysheaderopt = '' # how to indicate that a header is a system header
241    
242    # env['CC'] might be a full path
243    cc_name=os.path.basename(env['CXX'])
244    
245    if cc_name == 'icpc':
246        # Intel compiler
247        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
248        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
249        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas"
250        cc_optim    = "-O3 -ftz -fno-alias -inline-level=2 -ipo -xHost"
251        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
252        omp_flags   = "-openmp"
253        omp_ldflags = "-openmp -openmp_report=1"
254        fatalwarning = "-Werror"
255    elif cc_name[:3] == 'g++':
256        # GNU C++ on any system
257        # note that -ffast-math is not used because it breaks isnan(),
258        # see mantis #691
259        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
260        cc_optim     = "-O3"
261        #max-vartrack-size: avoid vartrack limit being exceeded with escriptcpp.cpp
262        cc_debug     = "-g3 -O0 -D_GLIBCXX_DEBUG -DDOASSERT -DDOPROF -DBOUNDS_CHECK --param=max-vartrack-size=100000000"
263        omp_flags    = "-fopenmp"
264        omp_ldflags  = "-fopenmp"
265        fatalwarning = "-Werror"
266        sysheaderopt = "-isystem"
267    elif cc_name == 'cl':
268        # Microsoft Visual C on Windows
269        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
270        cc_optim     = "/O2 /Op /W3"
271        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
272        fatalwarning = "/WX"
273    elif cc_name == 'icl':
274        # Intel C on Windows
275        cc_flags     = '/EHsc /GR /MD'
276        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
277        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
278        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
279        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
280    
281    env['sysheaderopt']=sysheaderopt
282    
283    # set defaults if not otherwise specified
284    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
285    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
286    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
287    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
288    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
289    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
290    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
291    
292    if env['nvccflags'] != 'default':
293        env['NVCCFLAGS'] = env['nvccflags']
294        env['SHNVCCFLAGS'] = env['nvccflags'] + ' -shared'
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    # set defaults for launchers if not otherwise specified
346    if env['prelaunch'] == 'default':
347        if env['mpi'] == 'INTELMPI' and env['openmp']:
348            env['prelaunch'] = "export I_MPI_PIN_DOMAIN=omp"
349        elif env['mpi'] == 'OPENMPI':
350            # transform comma-separated list to '-x a -x b -x c ...'
351            env['prelaunch'] = "EE=$(echo -x %e|sed -e 's/,/ -x /g')"
352        elif env['mpi'] == 'MPT':
353            env['prelaunch'] = "export MPI_NUM_MEMORY_REGIONS=0"
354        elif env['mpi'] == 'MPICH2':
355            env['prelaunch'] = "mpdboot -n %n -r ssh -f %f"
356        else:
357            env['prelaunch'] = ""
358    
359    if env['launcher'] == 'default':
360        if env['mpi'] == 'INTELMPI':
361            env['launcher'] = "mpirun -hostfile %f -n %N -ppn %p %b"
362        elif env['mpi'] == 'OPENMPI':
363            env['launcher'] = "mpirun --gmca mpi_warn_on_fork 0 ${EE} --host %h -bynode -bind-to-core --cpus-per-rank %t -np %N %b"
364        elif env['mpi'] == 'MPT':
365            env['launcher'] = "mpirun %h -np %p %b"
366        elif env['mpi'] == 'MPICH':
367            env['launcher'] = "mpirun -machinefile %f -np %N %b"
368        elif env['mpi'] == 'MPICH2':
369            env['launcher'] = "mpiexec -genvlist %e -np %N %b"
370        else:
371            env['launcher'] = "%b"
372    
373    if env['postlaunch'] == 'default':
374        if env['mpi'] == 'MPICH2':
375            env['postlaunch'] = "mpdallexit"
376        else:
377            env['postlaunch'] = ""
378    
379    # determine svn revision
380    global_revision=ARGUMENTS.get('SVN_VERSION', None)
381    if global_revision:
382        global_revision = re.sub(':.*', '', global_revision)
383        global_revision = re.sub('[^0-9]', '', global_revision)
384        if global_revision == '': global_revision='-2'
385  else:  else:
386     if socket.gethostname().split('.')[0] == 'service0':    # Get the global Subversion revision number for the getVersion() method
387        env = Environment(tools = ['default', 'intelc'], options = opts)    try:
388     elif os.uname()[4]=='ia64':      global_revision = os.popen('svnversion -n .').read()
389        env = Environment(tools = ['default', 'intelc'], options = opts)      global_revision = re.sub(':.*', '', global_revision)
390        if env['CXX'] == 'icpc':      global_revision = re.sub('[^0-9]', '', global_revision)
391           env['LINK'] = env['CXX'] # version >=9 of intel c++ compiler requires use of icpc to link in C++ runtimes (icc does not)      if global_revision == '': global_revision='-2'
392     else:    except:
393        env = Environment(tools = ['default'], options = opts)      global_revision = '-1'
394  Help(opts.GenerateHelpText(env))  env['svn_revision']=global_revision
395    env['buildvars']['svn_revision']=global_revision
396  ############ Fill in compiler options if not set above #########  env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
397    
398  # Backwards compatibility: allow dodebug=yes and useMPI=yes  if IS_WINDOWS:
399  if env['dodebug']: env['usedebug'] = 1      if not env['build_shared']:
400  if env['useMPI']: env['usempi'] = 1          env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
401            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
402  # Default compiler options (override allowed in hostname_options.py, but should not be necessary)  
403  # For both C and C++ you get: cc_flags and either the optim flags or debug flags  env['IS_WINDOWS']=IS_WINDOWS
404    env['IS_OSX']=IS_OSX
405  sysheaderopt = ""       # how do we indicate that a header is a system header. Use "" for no action.  
406    ###################### Copy required environment vars ########################
407  if env["CC"] == "icc":  
408    # Intel compilers  # Windows doesn't use LD_LIBRARY_PATH but PATH instead
409    cc_flags      = "-fPIC -ansi -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"  if IS_WINDOWS:
410    cc_optim      = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias"      LD_LIBRARY_PATH_KEY='PATH'
411    cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"      env['ENV']['LD_LIBRARY_PATH']=''
412    omp_optim     = "-openmp -openmp_report0"  else:
413    omp_debug     = "-openmp -openmp_report0"      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
414    omp_libs      = ['guide', 'pthread']  
415    pedantic      = ""  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
416    fatalwarning      = ""        # Switch to turn warnings into errors  
417    sysheaderopt      = ""  # the following env variables are exported for the unit tests
418  elif env["CC"] == "gcc":  
419    # GNU C on any system  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
420    cc_flags      = "-pedantic -Wall -fPIC -ansi -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing"      try:
421  #the long long warning occurs on the Mac          env['ENV'][key] = os.environ[key]
422    cc_optim      = "-O3"      except KeyError:
423    cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"          env['ENV'][key] = '1'
424    omp_optim     = "-fopenmp"  
425    omp_debug     = "-fopenmp"  env_export=env['env_export']
426    omp_libs      = ['gomp']  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP','LD_PRELOAD'])
427    pedantic      = "-pedantic-errors -Wno-long-long"  
428    fatalwarning      = "-Werror"  for key in set(env_export):
429    sysheaderopt      = "-isystem "      try:
430  elif env["CC"] == "cl":          env['ENV'][key] = os.environ[key]
431    # Microsoft Visual C on Windows      except KeyError:
432    cc_flags      = "/FD /EHsc /GR /wd4068 -D_USE_MATH_DEFINES -DDLL_NETCDF"          pass
433    cc_optim      = "/O2 /Op /MT /W3"  
434    cc_debug      = "/Od /RTC1 /MTd /ZI -DBOUNDS_CHECK"  for key in os.environ.keys():
435    omp_optim     = ""      if key.startswith("SLURM_"):
436    omp_debug     = ""          env['ENV'][key] = os.environ[key]
   omp_libs      = []  
   pedantic      = ""  
   fatalwarning      = ""  
   sysheaderopt      = ""  
 elif env["CC"] == "icl":  
   # intel C on Windows, see windows_intelc_options.py for a start  
   pedantic      = ""  
   fatalwarning      = ""  
   sysheaderopt      = ""  
   
   
 # If not specified in hostname_options.py then set them here  
 if env["cc_flags"]  == "-DEFAULT_1": env['cc_flags'] = cc_flags  
 if env["cc_optim"]  == "-DEFAULT_2": env['cc_optim'] = cc_optim  
 if env["cc_debug"]  == "-DEFAULT_3": env['cc_debug'] = cc_debug  
 if env["omp_optim"] == "-DEFAULT_4": env['omp_optim'] = omp_optim  
 if env["omp_debug"] == "-DEFAULT_5": env['omp_debug'] = omp_debug  
 if env["omp_libs"]  == "-DEFAULT_6": env['omp_libs'] = omp_libs  
   
 #set up the autolazy values  
 if env['forcelazy']    != "leave_alone":  
   if env['forcelazy'] == 'on':  
     env.Append(CPPDEFINES='FAUTOLAZYON')  
   else:  
      if env['forcelazy'] == 'off':  
     env.Append(CPPDEFINES='FAUTOLAZYOFF')  
   
 # OpenMP is disabled if useopenmp=no or both variables omp_optim and omp_debug are empty  
 if not env["useopenmp"]:  
   env['omp_optim'] = ""  
   env['omp_debug'] = ""  
   env['omp_libs'] = []  
   
 if env['omp_optim'] == "" and env['omp_debug'] == "": env["useopenmp"] = 0  
   
 ############ Copy environment variables into scons env #########  
   
 try: env['ENV']['OMP_NUM_THREADS'] = os.environ['OMP_NUM_THREADS']  
 except KeyError: env['ENV']['OMP_NUM_THREADS'] = 1  
   
 try: env['ENV']['ESCRIPT_NUM_THREADS'] = os.environ['ESCRIPT_NUM_THREADS']  
 except KeyError: pass  
   
 try: env['ENV']['ESCRIPT_NUM_PROCS'] = os.environ['ESCRIPT_NUM_PROCS']  
 except KeyError: pass  
   
 try: env['ENV']['ESCRIPT_NUM_NODES'] = os.environ['ESCRIPT_NUM_NODES']  
 except KeyError: pass  
   
 try: env['ENV']['ESCRIPT_HOSTFILE'] = os.environ['ESCRIPT_HOSTFILE']  
 except KeyError: pass  
   
 try: env['ENV']['PATH'] = os.environ['PATH']  
 except KeyError: pass  
   
 try: env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']  
 except KeyError: pass  
   
 try: env['ENV']['C_INCLUDE_PATH'] = os.environ['C_INCLUDE_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['CPLUS_INCLUDE_PATH'] = os.environ['CPLUS_INCLUDE_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['LIBRARY_PATH'] = os.environ['LIBRARY_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['DISPLAY'] = os.environ['DISPLAY']  
 except KeyError: pass  
   
 try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  
 except KeyError: pass  
   
 try: env['ENV']['HOME'] = os.environ['HOME']  
 except KeyError: pass  
   
 # Configure for test suite  
 env.PrependENVPath('PYTHONPATH', prefix)  
 env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 env['ENV']['ESCRIPT_ROOT'] = prefix  
   
 ############ Set up paths for Configure() ######################  
   
 # Make a copy of an environment  
 # Use env.Clone if available, but fall back on env.Copy for older version of scons  
 def clone_env(env):  
   if 'Clone' in dir(env): return env.Clone()    # scons-0.98  
   else:                   return env.Copy() # scons-0.96  
   
 # Add cc option -I<Escript>/trunk/include  
 env.Append(CPPPATH      = [Dir('include')])  
   
 # Add cc option -L<Escript>/trunk/lib  
 env.Append(LIBPATH      = [Dir(env['libinstall'])])  
   
 if env['cc_extra'] != '': env.Append(CCFLAGS = env['cc_extra'])  
 if env['ld_extra'] != '': env.Append(LINKFLAGS = env['ld_extra'])  
   
 if env['usepedantic']: env.Append(CCFLAGS = pedantic)  
   
 # MS Windows  
 if IS_WINDOWS_PLATFORM:  
   env.AppendENVPath('PATH', [env['boost_lib_path']])  
   env.AppendENVPath('PATH', [env['libinstall']])  
   if not env['share_esysUtils'] :  
     env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])  
   if not env['share_paso'] :  
     env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])  
   
   if env['usenetcdf']:  
     env.AppendENVPath('PATH',   [env['netCDF_lib_path']])  
   
 env.Append(ARFLAGS = env['ar_flags'])  
   
 # Get the global Subversion revision number for getVersion() method  
 try:  
    global_revision = os.popen("svnversion -n .").read()  
    global_revision = re.sub(":.*", "", global_revision)  
    global_revision = re.sub("[^0-9]", "", global_revision)  
 except:  
    global_revision="-1"  
 if global_revision == "": global_revision="-2"  
 env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  
   
 ############ numarray (required) ###############################  
437    
438  try:  try:
439    from numarray import identity      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
440  except ImportError:  except KeyError:
441    print "Cannot import numarray, you need to set your PYTHONPATH"      pass
   sys.exit(1)  
   
 ############ C compiler (required) #############################  
   
 # Create a Configure() environment for checking existence of required libraries and headers  
 conf = Configure(clone_env(env))  
   
 # Test that the compiler is working  
 if not conf.CheckFunc('printf'):  
    print "Cannot run C compiler '%s' (or libc is missing)" % (env['CC'])  
    sys.exit(1)  
   
 if conf.CheckFunc('gethostname'):  
   conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])  
   
 ############ python libraries (required) #######################  
   
   
 if not sysheaderopt =="":  
   conf.env.Append(CCFLAGS=sysheaderopt+env['python_path'])  
 else:  
   conf.env.AppendUnique(CPPPATH     = [env['python_path']])  
   
 conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
   
 conf.env.PrependENVPath('LD_LIBRARY_PATH', env['python_lib_path'])  # The wrapper script needs to find these libs  
 conf.env.PrependENVPath('PYTHONPATH', prefix)  
 conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 if not conf.CheckCHeader('Python.h'):  
   print "Cannot find python include files (tried 'Python.h' in directory %s)" % (env['python_path'])  
   sys.exit(1)  
 if not conf.CheckFunc('Py_Exit'):  
   print "Cannot find python library method Py_Main (tried lib %s in directory %s)" % (env['python_libs'], env['python_lib_path'])  
   sys.exit(1)  
   
 ############ boost (required) ##################################  
   
 if not sysheaderopt =="":  
 # This is required because we can't -isystem /usr/system because it breaks std includes  
   if os.path.normpath(env['boost_path']) =="/usr/include":  
     conf.env.Append(CCFLAGS=sysheaderopt+os.path.join(env['boost_path'],'boost'))  
   else:  
     conf.env.Append(CCFLAGS=sysheaderopt+env['boost_path'])  
 else:  
   conf.env.AppendUnique(CPPPATH     = [env['boost_path']])  
   
 conf.env.AppendUnique(LIBPATH       = [env['boost_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['boost_libs']])  
   
 conf.env.PrependENVPath('LD_LIBRARY_PATH', env['boost_lib_path'])   # The wrapper script needs to find these libs  
 #ensure that our path entries remain at the front  
 conf.env.PrependENVPath('PYTHONPATH', prefix)  
 conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 if not conf.CheckCXXHeader('boost/python.hpp'):  
   print "Cannot find boost include files (tried boost/python.hpp in directory %s)" % (env['boost_path'])  
   sys.exit(1)  
   
 if not conf.CheckFunc('PyObject_SetAttr'):  
   print "Cannot find boost library method PyObject_SetAttr (tried method PyObject_SetAttr in library %s in directory %s)" % (env['boost_libs'], env['boost_lib_path'])  
   sys.exit(1)  
   
 # Commit changes to environment  
 env = conf.Finish()  
   
 ############ VTK (optional) ####################################  
442    
443  if env['usevtk']:  if IS_OSX:
444    try:    try:
445      import vtk      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
446      env['usevtk'] = 1    except KeyError:
447    except ImportError:      pass
     env['usevtk'] = 0  
   
 # Add VTK to environment env if it was found  
 if env['usevtk']:  
   env.Append(CPPDEFINES = ['USE_VTK'])  
   
 ############ NetCDF (optional) #################################  
   
 conf = Configure(clone_env(env))  
   
 if env['usenetcdf']:  
   conf.env.AppendUnique(CPPPATH = [env['netCDF_path']])  
   conf.env.AppendUnique(LIBPATH = [env['netCDF_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['netCDF_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['netCDF_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 if env['usenetcdf'] and not conf.CheckCHeader('netcdf.h'): env['usenetcdf'] = 0  
 if env['usenetcdf'] and not conf.CheckFunc('nc_open'): env['usenetcdf'] = 0  
   
 # Add NetCDF to environment env if it was found  
 if env['usenetcdf']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['USE_NETCDF'])  
 else:  
   conf.Finish()  
   
 ############ PAPI (optional) ###################################  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env))  
   
 if env['usepapi']:  
   conf.env.AppendUnique(CPPPATH = [env['papi_path']])  
   conf.env.AppendUnique(LIBPATH = [env['papi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['papi_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['papi_lib_path'])  # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 if env['usepapi'] and not conf.CheckCHeader('papi.h'): env['usepapi'] = 0  
 if env['usepapi'] and not conf.CheckFunc('PAPI_start_counters'): env['usepapi'] = 0  
   
 # Add PAPI to environment env if it was found  
 if env['usepapi']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['BLOCKPAPI'])  
 else:  
   conf.Finish()  
   
 ############ MKL (optional) ####################################  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env))  
   
 if env['usemkl']:  
   conf.env.AppendUnique(CPPPATH = [env['mkl_path']])  
   conf.env.AppendUnique(LIBPATH = [env['mkl_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['mkl_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['mkl_lib_path'])   # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 if env['usemkl'] and not conf.CheckCHeader('mkl_solver.h'): env['usemkl'] = 0  
 if env['usemkl'] and not conf.CheckFunc('pardiso'): env['usemkl'] = 0  
   
 # Add MKL to environment env if it was found  
 if env['usemkl']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['MKL'])  
 else:  
   conf.Finish()  
448    
 ############ UMFPACK (optional) ################################  
449    
450  # Start a new configure environment that reflects what we've already found  # these shouldn't be needed
451  conf = Configure(clone_env(env))  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
452    #    try:
453    #        env['ENV'][key] = os.environ[key]
454    #    except KeyError:
455    #        pass
456    
457  if env['useumfpack']:  try:
458    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
459    conf.env.AppendUnique(CPPPATH = [env['umf_path']])  except KeyError:
460    conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])      pass
   conf.env.AppendUnique(LIBS    = [env['umf_libs']])  
   conf.env.AppendUnique(CPPPATH = [env['amd_path']])  
   conf.env.AppendUnique(LIBPATH = [env['amd_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['amd_libs']])  
   conf.env.AppendUnique(CPPPATH = [env['blas_path']])  
   conf.env.AppendUnique(LIBPATH = [env['blas_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['blas_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['umf_lib_path'])   # The wrapper script needs to find these libs  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['amd_lib_path'])   # The wrapper script needs to find these libs  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['blas_lib_path'])  # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0  
 if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0  
 # if env['useumfpack'] and not conf.CheckFunc('daxpy'): env['useumfpack'] = 0 # this does not work on shake73?  
   
 # Add UMFPACK to environment env if it was found  
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
 else:  
   conf.Finish()  
461    
462  ############ Silo (optional) ###################################  ######################## Add some custom builders ############################
463    
464  if env['usesilo']:  if env['pythoncmd']=='python':
465    conf = Configure(clone_env(env))      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
   conf.env.AppendUnique(CPPPATH = [env['silo_path']])  
   conf.env.AppendUnique(LIBPATH = [env['silo_lib_path']])  
   conf.env.AppendUnique(LIBS = [env['silo_libs']])  
   if not conf.CheckCHeader('silo.h'): env['usesilo'] = 0  
   if not conf.CheckFunc('DBMkDir'): env['usesilo'] = 0  
   conf.Finish()  
   
 # Add the path to Silo to environment env if it was found.  
 # Note that we do not add the libs since they are only needed for the  
 # escriptreader library and tools.  
 if env['usesilo']:  
   env.AppendUnique(CPPPATH = [env['silo_path']])  
   env.AppendUnique(LIBPATH = [env['silo_lib_path']])  
   env.Append(CPPDEFINES = ['HAVE_SILO'])  
   
 ############ Add the compiler flags ############################  
   
 # Enable debug by choosing either cc_debug or cc_optim  
 if env['usedebug']:  
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
466  else:  else:
467    env.Append(CCFLAGS        = env['cc_optim'])      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
   env.Append(CCFLAGS        = env['omp_optim'])  
   
 # Always use cc_flags  
 env.Append(CCFLAGS      = env['cc_flags'])  
 env.Append(LIBS         = [env['omp_libs']])  
   
 ############ Add some custom builders ##########################  
   
 py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  
468  env.Append(BUILDERS = {'PyCompile' : py_builder});  env.Append(BUILDERS = {'PyCompile' : py_builder});
469    
470  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
471  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
472    
473  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
474  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
475    
476  epstopdfbuilder = Builder(action = scons_extensions.eps2pdf, suffix=".pdf", src_suffix=".eps", single_source=True)  runPyExample_builder = Builder(action = runPyExample, suffix = '.passed', src_suffic='.py', single_source=True)
477  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});  env.Append(BUILDERS = {'RunPyExample' : runPyExample_builder});
   
 ############ MPI (optional) ####################################  
 if not env['usempi']: env['mpi_flavour']='none'  
   
 # Create a modified environment for MPI programs (identical to env if usempi=no)  
 env_mpi = clone_env(env)  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env_mpi))  
   
 if env_mpi['usempi']:  
   VALID_MPIs=[ "MPT", "MPICH", "MPICH2", "OPENMPI", "INTELMPI" ]  
   if not env_mpi['mpi_flavour'] in VALID_MPIs:  
       raise ValueError,"MPI is enabled but mpi_flavour = %s is not a valid key from %s."%( env_mpi['mpi_flavour'],VALID_MPIs)  
   conf.env.AppendUnique(CPPPATH = [env_mpi['mpi_path']])  
   conf.env.AppendUnique(LIBPATH = [env_mpi['mpi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['mpi_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['mpi_lib_path'])   # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 if env_mpi['usempi'] and not conf.CheckCHeader('mpi.h'): env_mpi['usempi'] = 0  
 # if env_mpi['usempi'] and not conf.CheckFunc('MPI_Init'): env_mpi['usempi'] = 0  
   
 # Add MPI to environment env_mpi if it was found  
 if env_mpi['usempi']:  
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['PASO_MPI', 'MPI_NO_CPPBIND', env_mpi['MPICH_IGNORE_CXX_SEEK']])  
 else:  
   conf.Finish()  
478    
479  env['usempi'] = env_mpi['usempi']  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
480    env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
481    
482    ############################ Dependency checks ###############################
483    
484  ############ ParMETIS (optional) ###############################  ######## Compiler
485    env=checkCompiler(env)
486    
487  # Start a new configure environment that reflects what we've already found  ######## Python headers & library (required)
488  conf = Configure(clone_env(env_mpi))  env=checkPython(env)
489    
490  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0  ######## boost & boost-python (required)
491    env=checkBoost(env)
492    
493  if env_mpi['useparmetis']:  ######## NVCC version (optional)
494    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  if env['cuda']:
495    conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])      env=checkCudaVersion(env)
496    conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])      env=checkCUDA(env)
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['parmetis_lib_path'])  # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
497    
498  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  ######## numpy (required) and numpy headers (optional)
499  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0  env=checkNumpy(env)
500    
501  # Add ParMETIS to environment env_mpi if it was found  ######## CppUnit (required for tests)
502  if env_mpi['useparmetis']:  env=checkCppUnit(env)
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  
 else:  
   conf.Finish()  
503    
504  env['useparmetis'] = env_mpi['useparmetis']  ######## optional python modules (sympy, pyproj)
505    env=checkOptionalModules(env)
506    
507  ############ Now we switch on Warnings as errors ###############  ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
508    env=checkOptionalLibraries(env)
509    
510  #this needs to be done after configuration because the scons test files have warnings in them  #use gmsh info to set some defines
511    if env['gmsh'] == 's':
512        env.Append(CPPDEFINES=['GMSH'])
513    elif env['gmsh'] == 'm':
514        env.Append(CPPDEFINES=['GMSH','GMSH_MPI'])
515    
516  if ((fatalwarning != "") and (env['usewarnings'])):  ######## PDFLaTeX (for documentation)
517    env.Append(CCFLAGS        = fatalwarning)  env=checkPDFLatex(env)
   env_mpi.Append(CCFLAGS        = fatalwarning)  
   
 ############ Summarize our environment #########################  
   
 print ""  
 print "Summary of configuration (see ./config.log for information)"  
 print " Using python libraries"  
 print " Using numarray"  
 print " Using boost"  
 if env['usenetcdf']: print "    Using NetCDF"  
 else: print "   Not using NetCDF"  
 if env['usevtk']: print "   Using VTK"  
 else: print "   Not using VTK"  
 if env['usemkl']: print "   Using MKL"  
 else: print "   Not using MKL"  
 if env['useumfpack']: print "   Using UMFPACK"  
 else: print "   Not using UMFPACK"  
 if env['usesilo']: print "  Using Silo"  
 else: print "   Not using Silo"  
 if env['useopenmp']: print "    Using OpenMP"  
 else: print "   Not using OpenMP"  
 if env['usempi']: print "   Using MPI (flavour = %s)"%env['mpi_flavour']  
 else: print "   Not using MPI"  
 if env['useparmetis']: print "  Using ParMETIS"  
 else: print "   Not using ParMETIS (requires MPI)"  
 if env['usepapi']: print "  Using PAPI"  
 else: print "   Not using PAPI"  
 if env['usedebug']: print " Compiling for debug"  
 else: print "   Not compiling for debug"  
 print " Installing in", prefix  
 if ((fatalwarning != "") and (env['usewarnings'])): print " Treating warnings as errors"  
 else: print "   Not treating warnings as errors"  
 print ""  
   
 ############ Delete option-dependent files #####################  
   
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.debug")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.mpi")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.openmp")))  
 Execute(Delete(os.path.join(env['libinstall'],"pyversion")))  
 Execute(Delete(os.path.join(env['libinstall'],"buildvars")))  
 if not env['usempi']: Execute(Delete(os.path.join(env['libinstall'],"pythonMPI")))  
518    
519    # keep some of our install paths first in the list for the unit tests
520    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
521    env.PrependENVPath('PYTHONPATH', prefix)
522    env['ENV']['ESCRIPT_ROOT'] = prefix
523    
524  ############ Build the subdirectories ##########################  if not env['verbose']:
525        env['CXXCOMSTR'] = "Compiling $TARGET"
526        env['SHCXXCOMSTR'] = "Compiling $TARGET"
527        env['ARCOMSTR'] = "Linking $TARGET"
528        env['LINKCOMSTR'] = "Linking $TARGET"
529        env['SHLINKCOMSTR'] = "Linking $TARGET"
530        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
531        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
532        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
533        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
534        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
535    
536    ####################### Configure the subdirectories #########################
537    
538    # remove obsolete files
539    if not env['usempi']:
540        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
541        Execute(Delete(os.path.join(env['bininstall'], 'escript-overlord')))
542        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
543    
544  from grouptest import *  from grouptest import *
   
545  TestGroups=[]  TestGroups=[]
546    
547  Export(  # keep an environment without warnings-as-errors
548    ["env",  dodgy_env=env.Clone()
    "env_mpi",  
    "clone_env",  
    "IS_WINDOWS_PLATFORM",  
    "TestGroups"  
    ]  
   )  
   
 env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
 env.SConscript(dirs = ['tools/libescriptreader/src'], build_dir='build/$PLATFORM/tools/libescriptreader', duplicate=0)  
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', 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)  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 env.SConscript(dirs = ['scripts'], build_dir='build/$PLATFORM/scripts', duplicate=0)  
 env.SConscript(dirs = ['paso/profiling'], build_dir='build/$PLATFORM/paso/profiling', duplicate=0)  
   
   
 ############ Remember what optimizations we used ###############  
   
 remember_list = []  
549    
550  if env['usedebug']:  # now add warnings-as-errors flags. This needs to be done after configuration
551    remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.debug"), None, Touch('$TARGET'))  # because the scons test files have warnings in them
552    if ((fatalwarning != '') and (env['werror'])):
553        env.Append(CCFLAGS = fatalwarning)
554    
555  if env['usempi']:  Export(
556    remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.mpi"), None, Touch('$TARGET'))    ['env',
557       'dodgy_env',
558  if env['useopenmp']:     'IS_WINDOWS',
559    remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.openmp"), None, Touch('$TARGET'))     'TestGroups'
560      ]
561    )
562    
563  env.Alias('remember_options', remember_list)  #do not auto build
564    env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
565    env.SConscript(dirs = ['tools/overlord'], variant_dir='$BUILD_DIR/$PLATFORM/tools/overlord', duplicate=0)
566    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
567    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
568    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
569    
570    env.SConscript(dirs = ['cusplibrary'])
571    
572    #This will pull in the escriptcore/py_src and escriptcore/test
573    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
574    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
575    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
576    if 'dudley' in env['domains']:
577        env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
578    if 'finley' in env['domains']:
579        env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
580    if 'ripley' in env['domains']:
581        env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
582    if 'speckley' in env['domains']:
583        env.SConscript(dirs = ['speckley/src'], variant_dir='$BUILD_DIR/$PLATFORM/speckley', duplicate=0)
584    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
585    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
586    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
587    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
588    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
589    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
590    
591    
592    ######################## Populate the buildvars file #########################
593    
594    write_buildvars(env)
595    
596  ############### Record python interpreter version ##############  write_launcher(env)
597    
598  if not IS_WINDOWS_PLATFORM:  ################### Targets to build and install libraries ###################
   versionstring="Python "+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])  
   os.system("echo "+versionstring+" > "+os.path.join(env['libinstall'],"pyversion"))  
599    
600  ############## Populate the buildvars file #####################  target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
601    env.Alias('target_init', [target_init])
602    # delete buildvars upon cleanup
603    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
604    
605  buildvars=open(os.path.join(env['libinstall'],'buildvars'),'w')  # The headers have to be installed prior to build in order to satisfy
606  buildvars.write('python='+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+'\n')  # #include <paso/Common.h>
607    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
608    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
609    
610  # Find the boost version by extracting it from version.hpp  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
611  boosthpp=open(os.path.join(env['boost_path'],'boost','version.hpp'))  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
 boostversion='unknown'  
 try:  
     for line in boosthpp:  
         ver=re.match(r'#define BOOST_VERSION (\d+)',line)  
         if ver:  
             boostversion=ver.group(1)  
 except StopIteration:  
     pass  
 buildvars.write("boost="+boostversion+"\n")  
 buildvars.write("svn_revision="+str(global_revision)+"\n")  
 out="usedebug="  
 if env['usedebug']:  
     out+="y"  
 else:  
     out+="n"  
 out+="\nusempi="  
 if env['usempi']:  
     out+="y"  
 else:  
     out+="n"  
 out+="\nuseopenmp="  
 if env['useopenmp']:  
     out+="y"  
 else:  
     out+="n"  
 buildvars.write(out+"\n")  
 buildvars.write("mpi_flavour="+env['mpi_flavour']+'\n')  
612    
613  buildvars.close()  env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
614    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
615    
616    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
617    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
618    
619  ############ Targets to build and install libraries ############  if 'dudley' in env['domains']:
620        env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
621        env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
622    
623  target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  if 'finley' in env['domains']:
624  env.Alias('target_init', [target_init])      env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
625        env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
626    
627  # The headers have to be installed prior to build in order to satisfy #include <paso/Common.h>  if 'ripley' in env['domains']:
628  env.Alias('build_esysUtils', ['target_install_esysUtils_headers', 'target_esysUtils_a'])      env.Alias('build_ripley', ['install_cusp_headers', 'install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
629  env.Alias('install_esysUtils', ['build_esysUtils', 'target_install_esysUtils_a'])      env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
630    
631  env.Alias('build_paso', ['target_install_paso_headers', 'target_paso_a'])  if 'speckley' in env['domains']:
632  env.Alias('install_paso', ['build_paso', 'target_install_paso_a'])      env.Alias('build_speckley', ['install_speckley_headers', 'build_speckley_lib', 'build_speckleycpp_lib'])
633        env.Alias('install_speckley', ['build_speckley', 'install_speckley_lib', 'install_speckleycpp_lib', 'install_speckley_py'])
634    
635  env.Alias('build_escript', ['target_install_escript_headers', 'target_escript_so', 'target_escriptcpp_so'])  env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
636  env.Alias('install_escript', ['build_escript', 'target_install_escript_so', 'target_install_escriptcpp_so', 'target_install_escript_py'])  env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
637    
638  env.Alias('build_finley', ['target_install_finley_headers', 'target_finley_so', 'target_finleycpp_so'])  env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
639  env.Alias('install_finley', ['build_finley', 'target_install_finley_so', 'target_install_finleycpp_so', 'target_install_finley_py'])  env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
640    
641  # Now gather all the above into a couple easy targets: build_all and install_all  # Now gather all the above into some easy targets: build_all and install_all
642  build_all_list = []  build_all_list = []
643  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
644  build_all_list += ['build_paso']  build_all_list += ['build_paso']
645  build_all_list += ['build_escript']  build_all_list += ['build_escript']
646  build_all_list += ['build_finley']  build_all_list += ['build_pasowrap']
647  if env['usempi']:       build_all_list += ['target_pythonMPI_exe']  if 'dudley' in env['domains']: build_all_list += ['build_dudley']
648  if not IS_WINDOWS_PLATFORM: build_all_list += ['target_escript_wrapper']  if 'finley' in env['domains']: build_all_list += ['build_finley']
649  if env['usesilo']:  build_all_list += ['target_escript2silo']  if 'ripley' in env['domains']: build_all_list += ['build_ripley']
650    if 'speckley' in env['domains']: build_all_list += ['build_speckley']
651    build_all_list += ['build_weipa']
652    if not IS_WINDOWS and 'finley' in env['domains']:
653        build_all_list += ['build_escriptreader']
654    if env['usempi']:
655        build_all_list += ['build_pythonMPI', 'build_overlord']
656  env.Alias('build_all', build_all_list)  env.Alias('build_all', build_all_list)
657    
658  install_all_list = []  install_all_list = []
# Line 805  install_all_list += ['target_init'] Line 660  install_all_list += ['target_init']
660  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
661  install_all_list += ['install_paso']  install_all_list += ['install_paso']
662  install_all_list += ['install_escript']  install_all_list += ['install_escript']
663  install_all_list += ['install_finley']  install_all_list += ['install_pasowrap']
664  install_all_list += ['target_install_pyvisi_py']  if 'dudley' in env['domains']: install_all_list += ['install_dudley']
665  install_all_list += ['target_install_modellib_py']  if 'finley' in env['domains']: install_all_list += ['install_finley']
666  install_all_list += ['target_install_pycad_py']  if 'ripley' in env['domains']: install_all_list += ['install_ripley']
667  if env['usempi']:       install_all_list += ['target_install_pythonMPI_exe']  if 'speckley' in env['domains']: install_all_list += ['install_speckley']
668  if not IS_WINDOWS_PLATFORM: install_all_list += ['target_install_escript_wrapper']  install_all_list += ['install_weipa']
669  if env['usesilo']:  install_all_list += ['target_install_escript2silo']  if not IS_WINDOWS and 'finley' in env['domains']:
670  install_all_list += ['remember_options']      install_all_list += ['install_escriptreader']
671    install_all_list += ['install_downunder_py']
672    install_all_list += ['install_modellib_py']
673    install_all_list += ['install_pycad_py']
674    if env['usempi']:
675        install_all_list += ['install_pythonMPI', 'install_overlord']
676  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
677    
678  # Default target is install  # Default target is install
679  env.Default('install_all')  env.Default('install_all')
680    
681  ############ Targets to build and run the test suite ###########  ################## Targets to build and run the test suite ###################
682    
683  env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  if not env['cppunit']:
684  env.Alias('install_cppunittest', ['build_cppunittest', 'target_install_cppunittest_a'])      test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
685  env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])      env.Alias('run_tests', test_msg)
686  env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])      env.Alias('build_tests', '')
687    env.Alias('run_tests', ['install_all'])
688    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
689  env.Alias('build_full',['install_all','build_tests','build_py_tests'])  env.Alias('build_full',['install_all','build_tests','build_py_tests'])
690    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
691    Requires('py_tests', 'install_all')
692    
693  ############ Targets to build the documentation ################  ##################### Targets to build the documentation #####################
694    
695  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html','install_pdf'])  env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
696    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
697    env.Alias('docs', ['basedocs', 'sphinxdoc'])
698    env.Alias('release_prep', ['docs', 'install_all'])
699    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
700    
701    # The test scripts are always generated, this target allows us to
702    # generate the testscripts without doing a full build
703    env.Alias('testscripts',[])
704    
705    if not IS_WINDOWS:
706        generateTestScripts(env, TestGroups)
707    
708    
709    ######################## Summarize our environment ###########################
710    def print_summary():
711        print("")
712        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
713        print("Escript/Finley revision %s"%global_revision)
714        print("  Install prefix:  %s"%env['prefix'])
715        print("          Python:  %s"%sysconfig.PREFIX)
716        print("           boost:  %s"%env['boost_prefix'])
717        if env['numpy_h']:
718            print("           numpy:  YES (with headers)")
719        else:
720            print("           numpy:  YES (without headers)")
721        if env['usempi']:
722            print("             MPI:  YES (flavour: %s)"%env['mpi'])
723        else:
724            print("             MPI:  NO")
725        if env['uselapack']:
726            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
727        else:
728            print("          LAPACK:  NO")
729        if env['cuda']:
730            print("            CUDA:  YES (nvcc: %s)"%env['nvcc_version'])
731        else:
732            print("            CUDA:  NO")
733        d_list=[]
734        e_list=[]
735        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit':
736            if env[i]: e_list.append(i)
737            else: d_list.append(i)
738        for i in e_list:
739            print("%16s:  YES"%i)
740        for i in d_list:
741            print("%16s:  NO"%i)
742        if env['cppunit']:
743            print("         CppUnit:  YES")
744        else:
745            print("         CppUnit:  NO")
746        if env['gmshpy']:
747            gmshpy=" + python module"
748        else:
749            gmshpy=""
750        if env['gmsh']=='m':
751            print("            gmsh:  YES, MPI-ENABLED"+gmshpy)
752        elif env['gmsh']=='s':
753            print("            gmsh:  YES"+gmshpy)
754        else:
755            if env['gmshpy']:
756                print("            gmsh:  python module only")
757            else:
758                print("            gmsh:  NO")
759        print(    "            gzip:  " + ("YES" if env['compressed_files'] else "NO"))
760    
761        if ((fatalwarning != '') and (env['werror'])):
762            print("  Treating warnings as errors")
763        else:
764            print("  NOT treating warnings as errors")
765        print("")
766        for w in env['warnings']:
767            print("WARNING: %s"%w)
768        if len(GetBuildFailures()):
769            print("\nERROR: build stopped due to errors\n")
770        else:
771            print("\nSUCCESS: build complete\n")
772    
773  if not IS_WINDOWS_PLATFORM:  atexit.register(print_summary)
    try:  
     utest=open("utest.sh","w")  
     build_platform=os.name      #Sometimes Mac python says it is posix  
     if (build_platform=='posix') and platform.system()=="Darwin":  
         build_platform='darwin'  
     utest.write(GroupTest.makeHeader(build_platform))  
     for tests in TestGroups:  
         utest.write(tests.makeString())  
     utest.close()  
     os.chmod("utest.sh",stat.S_IRWXU|stat.S_IRGRP|stat.S_IXGRP|stat.S_IROTH|stat.S_IXOTH)  
     print "utest.sh written"  
    except IOError:  
     print "Error attempting to write unittests file."  
     sys.exit(1)  
774    

Legend:
Removed from v.2387  
changed lines
  Added in v.5496

  ViewVC Help
Powered by ViewVC 1.1.26