/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 1729 by ksteube, Tue Aug 26 06:48:40 2008 UTC revision 4244 by jfenwick, Mon Feb 25 05:37:50 2013 UTC
# Line 1  Line 1 
1  #         Copyright 2006 by ACcESS MNRF  ##############################################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2013 by University of Queensland
4  #       Primary Business: Queensland, Australia  # http://www.uq.edu.au
5  #  Licensed under the Open Software License version 3.0  #
6  #     http://www.opensource.org/licenses/osl-3.0.php  # Primary Business: Queensland, Australia
7    # Licensed under the Open Software License version 3.0
8  EnsureSConsVersion(0,96,91)  # http://www.opensource.org/licenses/osl-3.0.php
9  EnsurePythonVersion(2,3)  #
10    # Development until 2012 by Earth Systems Science Computational Center (ESSCC)
11  import sys, os, re, socket  # Development since 2012 by School of Earth Sciences
12    #
13  # Add our extensions  ##############################################################################
 if os.path.isdir('scons'): sys.path.append('scons')  
 import scons_extensions  
   
 # Use /usr/lib64 if available, else /usr/lib  
 usr_lib = '/usr/lib'  
 if os.path.isfile('/usr/lib64/libc.so'): usr_lib = '/usr/lib64'  
14    
15  # The string python2.4 or python2.5  EnsureSConsVersion(0,98,1)
16  python_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])  EnsurePythonVersion(2,5)
17    
18  # MS Windows support, many thanks to PH  import sys, os, platform, re
19  IS_WINDOWS_PLATFORM = (os.name== "nt")  from distutils import sysconfig
20    from site_init import *
21    from subprocess import PIPE, Popen
22    
23    # Version number to check for in options file. Increment when new features are
24    # added or existing options changed.
25    REQUIRED_OPTS_VERSION=201
26    
27  prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  # MS Windows support, many thanks to PH
28    IS_WINDOWS = (os.name == 'nt')
29    
30  # Read configuration options from file scons/<hostname>_options.py  ########################## Determine options file ############################
31  hostname = re.sub("[^0-9a-zA-Z]", "_", socket.gethostname().split('.')[0])  # 1. command line
32  tmp = os.path.join("scons",hostname+"_options.py")  # 2. scons/<hostname>_options.py
33  options_file = ARGUMENTS.get('options_file', tmp)  # 3. name as part of a cluster
34  if not os.path.isfile(options_file): options_file = False  options_file=ARGUMENTS.get('options_file', None)
35  else: print "Options file is", options_file  if not options_file:
36        ext_dir = os.path.join(os.getcwd(), 'scons')
37  # Load options file and command-line arguments      hostname = platform.node().split('.')[0]
38  opts = Options(options_file, ARGUMENTS)      for name in hostname, effectiveName(hostname):
39            mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
40  ############ Load build options ################################          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
41            if os.path.isfile(options_file): break
42  opts.AddOptions(  
43  # Where to install esys stuff  if not os.path.isfile(options_file):
44    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),      print("\nWARNING:\nOptions file %s" % options_file)
45    ('incinstall', 'where the esys headers will be installed',             os.path.join(Dir('#.').abspath,'include')),      print("not found! Default options will be used which is most likely suboptimal.")
46    ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),      print("It is recommended that you copy one of the TEMPLATE files in the scons/")
47    ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),      print("subdirectory and customize it to your needs.\n")
48  # Compilation options      options_file = None
49    BoolOption('dodebug', 'For backwards compatibility', 'no'),  
50    BoolOption('usedebug', 'Do you want a debug build?', 'no'),  ############################### Build options ################################
51    BoolOption('usevtk', 'Do you want to use VTK?', 'yes'),  
52    ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  default_prefix='/usr'
53    # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
54    ('cc_flags', 'C compiler flags to use', '-DEFAULT_1'),  lapack_flavours=('none', 'clapack', 'mkl')
55    ('cc_optim', 'C compiler optimization flags to use', '-DEFAULT_2'),  
56    ('cc_debug', 'C compiler debug flags to use', '-DEFAULT_3'),  vars = Variables(options_file, ARGUMENTS)
57    ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),  vars.AddVariables(
58    ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
59    ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
60    ('cc_extra', 'Extra C/C++ flags', ''),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
61    ('sys_libs', 'System libraries to link with', []),    BoolVariable('verbose', 'Output full compile/link lines', False),
62    ('ar_flags', 'Static library archiver flags to use', ''),  # Compiler/Linker options
63    BoolOption('useopenmp', 'Compile parallel version using OpenMP', 'yes'),    ('cc', 'Path to C compiler', 'default'),
64    BoolOption('usepedantic', 'Compile with -pedantic if using gcc', 'yes'),    ('cxx', 'Path to C++ compiler', 'default'),
65  # Python    ('cc_flags', 'Base C/C++ compiler flags', 'default'),
66    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),    ('cc_optim', 'Additional C/C++ flags for a non-debug build', 'default'),
67    ('python_lib_path', 'Path to Python libs', usr_lib),    ('cc_debug', 'Additional C/C++ flags for a debug build', 'default'),
68    ('python_libs', 'Python libraries to link with', [python_version]),    ('cc_extra', 'Extra C compiler flags', ''),
69    ('python_cmd', 'Python command', 'python'),    ('cxx_extra', 'Extra C++ compiler flags', ''),
70  # Boost    ('ld_extra', 'Extra linker flags', ''),
71    ('boost_path', 'Path to Boost includes', '/usr/include'),    BoolVariable('werror','Treat compiler warnings as errors', True),
72    ('boost_lib_path', 'Path to Boost libs', usr_lib),    BoolVariable('debug', 'Compile with debug flags', False),
73    ('boost_libs', 'Boost libraries to link with', ['boost_python']),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74  # NetCDF    ('omp_flags', 'OpenMP compiler flags', 'default'),
75    BoolOption('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),  # Mandatory libraries
77    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79  # MPI  # Mandatory for tests
80    BoolOption('useMPI', 'For backwards compatibility', 'no'),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81    BoolOption('usempi', 'Compile parallel version using MPI', 'no'),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82    ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),  # Optional libraries and options
83    ('mpi_path', 'Path to MPI includes', '/usr/include'),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84    ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85    ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86    ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', ['mpich' , 'pthread', 'rt']),    BoolVariable('netcdf', 'Enable netCDF file support', False),
87  # ParMETIS    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88    BoolOption('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89    ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90    ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91    ('parmetis_libs', 'ParMETIS library to link with', ['parmetis', 'metis']),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92  # PAPI    BoolVariable('papi', 'Enable PAPI', False),
93    BoolOption('usepapi', 'switch on/off the usage of PAPI', 'no'),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
   ('papi_path', 'Path to PAPI includes', '/usr/include'),  
   ('papi_lib_path', 'Path to PAPI libs', usr_lib),  
94    ('papi_libs', 'PAPI libraries to link with', ['papi']),    ('papi_libs', 'PAPI libraries to link with', ['papi']),
95    BoolOption('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', False),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
96  # MKL    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
97    BoolOption('usemkl', 'switch on/off the usage of MKL', 'no'),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
98    ('mkl_path', 'Path to MKL includes', '/sw/sdev/cmkl/10.0.2.18/include'),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
99    ('mkl_lib_path', 'Path to MKL libs', '/sw/sdev/cmkl/10.0.2.18/lib/em64t'),    BoolVariable('umfpack', 'Enable UMFPACK', False),
100    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver', 'mkl_em64t', 'guide', 'pthread']),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
101  # UMFPACK    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
102    BoolOption('useumfpack', 'switch on/off the usage of UMFPACK', 'no'),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
103    ('ufc_path', 'Path to UFconfig includes', '/usr/include/suitesparse'),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
104    ('umf_path', 'Path to UMFPACK includes', '/usr/include/suitesparse'),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
105    ('umf_lib_path', 'Path to UMFPACK libs', usr_lib),    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
106    ('umf_libs', 'UMFPACK libraries to link with', ['umfpack']),    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
107  # AMD (used by UMFPACK)    ('lapack_libs', 'LAPACK libraries to link with', []),
108    ('amd_path', 'Path to AMD includes', '/usr/include/suitesparse'),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
109    ('amd_lib_path', 'Path to AMD libs', usr_lib),    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
110    ('amd_libs', 'AMD libraries to link with', ['amd']),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
111  # BLAS (used by UMFPACK)    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
112    ('blas_path', 'Path to BLAS includes', '/usr/include/suitesparse'),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
113    ('blas_lib_path', 'Path to BLAS libs', usr_lib),    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
114    ('blas_libs', 'BLAS libraries to link with', ['blas'])    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
115    # Advanced settings
116      #dudley_assemble_flags = -funroll-loops      to actually do something
117      ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
118      # To enable passing function pointers through python
119      BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
120      # An option for specifying the compiler tools (see windows branch)
121      ('tools_names', 'Compiler tools to use', ['default']),
122      ('env_export', 'Environment variables to be passed to tools',[]),
123      EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
124      EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
125      # finer control over library building, intel aggressive global optimisation
126      # works with dynamic libraries on windows.
127      ('build_shared', 'Build dynamic libraries only', False),
128      ('sys_libs', 'Extra libraries to link with', []),
129      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
130      ('SVN_VERSION', 'Do not use from options file', -2),
131      ('pythoncmd', 'which python to compile with','python'),
132      ('usepython3', 'Is this a python3 build? (experimental)', False),
133      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
134      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
135      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
136      BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
137  )  )
138    
139  ############ Specify which compilers to use ####################  ##################### Create environment and help text #######################
140    
141  # intelc uses regular expressions improperly and emits a warning about  # Intel's compiler uses regular expressions improperly and emits a warning
142  # failing to find the compilers.  This warning can be safely ignored.  # about failing to find the compilers. This warning can be safely ignored.
143    
144  if IS_WINDOWS_PLATFORM:  # PATH is needed so the compiler, linker and tools are found if they are not
145        env = Environment(tools = ['default', 'msvc'], options = opts)  # in default locations.
146    env = Environment(tools = ['default'], options = vars,
147                      ENV = {'PATH': os.environ['PATH']})
148                      
149    
150    #set the vars for clang
151    def mkclang(env):
152      env['CC']='clang'
153      env['CXX']='clang++'
154                      
155                      
156    if env['tools_names'] != 'default':
157        zz=env['tools_names']
158        if 'clang' in zz:
159            zz.remove('clang')
160            zz.insert(0, mkclang)
161        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
162                          ENV = {'PATH' : os.environ['PATH']})
163    
164    if options_file:
165        opts_valid=False
166        if 'escript_opts_version' in env.Dictionary() and \
167            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
168                opts_valid=True
169        if opts_valid:
170            print("Using options in %s." % options_file)
171        else:
172            print("\nOptions file %s" % options_file)
173            print("is outdated! Please update the file by examining one of the TEMPLATE")
174            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
175            Exit(1)
176    
177    # Generate help text (scons -h)
178    Help(vars.GenerateHelpText(env))
179    
180    # Check for superfluous options
181    if len(vars.UnknownVariables())>0:
182        for k in vars.UnknownVariables():
183            print("Unknown option '%s'" % k)
184        Exit(1)
185    
186    #################### Make sure install directories exist #####################
187    
188    env['BUILD_DIR']=Dir(env['build_dir']).abspath
189    prefix=Dir(env['prefix']).abspath
190    env['incinstall'] = os.path.join(prefix, 'include')
191    env['bininstall'] = os.path.join(prefix, 'bin')
192    env['libinstall'] = os.path.join(prefix, 'lib')
193    env['pyinstall']  = os.path.join(prefix, 'esys')
194    if not os.path.isdir(env['bininstall']):
195        os.makedirs(env['bininstall'])
196    if not os.path.isdir(env['libinstall']):
197        os.makedirs(env['libinstall'])
198    if not os.path.isdir(env['pyinstall']):
199        os.makedirs(env['pyinstall'])
200    
201    env.Append(CPPPATH = [env['incinstall']])
202    env.Append(LIBPATH = [env['libinstall']])
203    
204    ################# Fill in compiler options if not set above ##################
205    
206    if env['cc'] != 'default': env['CC']=env['cc']
207    if env['cxx'] != 'default': env['CXX']=env['cxx']
208    
209    # version >=9 of intel C++ compiler requires use of icpc to link in C++
210    # runtimes (icc does not)
211    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
212        env['LINK'] = env['CXX']
213    
214    # default compiler/linker options
215    cc_flags = ''
216    cc_optim = ''
217    cc_debug = ''
218    omp_flags = ''
219    omp_ldflags = ''
220    fatalwarning = '' # switch to turn warnings into errors
221    sysheaderopt = '' # how to indicate that a header is a system header
222    
223    # env['CC'] might be a full path
224    cc_name=os.path.basename(env['CC'])
225    
226    if cc_name == 'icc':
227        # Intel compiler
228        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
229        cc_flags    = "-std=c99 -fPIC -w2 -wd1875 -Wno-unknown-pragmas -DBLOCKTIMER -DCORE_ID1"
230        cc_optim    = "-O3 -ftz -fno-alias -ipo -xHost"
231        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
232        omp_flags   = "-openmp"
233        omp_ldflags = "-openmp -openmp_report=1"
234        fatalwarning = "-Werror"
235    elif cc_name[:3] == 'gcc':
236        # GNU C on any system
237        # note that -ffast-math is not used because it breaks isnan(),
238        # see mantis #691
239        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
240        cc_optim     = "-O3"
241        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
242        omp_flags    = "-fopenmp"
243        omp_ldflags  = "-fopenmp"
244        fatalwarning = "-Werror"
245        sysheaderopt = "-isystem"
246    elif cc_name == 'cl':
247        # Microsoft Visual C on Windows
248        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
249        cc_optim     = "/O2 /Op /W3"
250        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
251        fatalwarning = "/WX"
252    elif cc_name == 'icl':
253        # Intel C on Windows
254        cc_flags     = '/EHsc /GR /MD'
255        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
256        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
257        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
258        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
259    
260    # set defaults if not otherwise specified
261    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
262    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
263    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
264    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
265    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
266    if env['cc_extra']  != '': env.Append(CFLAGS = env['cc_extra'])
267    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
268    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
269    
270    if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
271    
272    if env['usepython3']:
273        env.Append(CPPDEFINES=['ESPYTHON3'])
274    
275    # set up the autolazy values
276    if env['forcelazy'] == 'on':
277        env.Append(CPPDEFINES=['FAUTOLAZYON'])
278    elif env['forcelazy'] == 'off':
279        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
280    
281    # set up the collective resolve values
282    if env['forcecollres'] == 'on':
283        env.Append(CPPDEFINES=['FRESCOLLECTON'])
284    elif env['forcecollres'] == 'off':
285        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
286    
287    # allow non-standard C if requested
288    if env['iknowwhatimdoing']:
289        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
290    
291    # Disable OpenMP if no flags provided
292    if env['openmp'] and env['omp_flags'] == '':
293       print("OpenMP requested but no flags provided - disabling OpenMP!")
294       env['openmp'] = False
295    
296    if env['openmp']:
297        env.Append(CCFLAGS = env['omp_flags'])
298        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
299    else:
300        env['omp_flags']=''
301        env['omp_ldflags']=''
302    
303    # add debug/non-debug compiler flags
304    if env['debug']:
305        env.Append(CCFLAGS = env['cc_debug'])
306    else:
307        env.Append(CCFLAGS = env['cc_optim'])
308    
309    # always add cc_flags
310    env.Append(CCFLAGS = env['cc_flags'])
311    
312    # add system libraries
313    env.AppendUnique(LIBS = env['sys_libs'])
314    
315    
316    global_revision=ARGUMENTS.get('SVN_VERSION', None)
317    if global_revision:
318        global_revision = re.sub(':.*', '', global_revision)
319        global_revision = re.sub('[^0-9]', '', global_revision)
320        if global_revision == '': global_revision='-2'
321  else:  else:
322     if socket.gethostname().split('.')[0] == 'service0':    # Get the global Subversion revision number for the getVersion() method
323        env = Environment(tools = ['default', 'intelc'], options = opts)    try:
324     elif os.uname()[4]=='ia64':      global_revision = os.popen('svnversion -n .').read()
325        env = Environment(tools = ['default', 'intelc'], options = opts)      global_revision = re.sub(':.*', '', global_revision)
326        if env['CXX'] == 'icpc':      global_revision = re.sub('[^0-9]', '', global_revision)
327           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'
328     else:    except:
329        env = Environment(tools = ['default'], options = opts)      global_revision = '-1'
330  Help(opts.GenerateHelpText(env))  env['svn_revision']=global_revision
331    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
332  ############ Fill in compiler options if not set above #########  
333    if IS_WINDOWS:
334  # Backwards compatibility: allow dodebug=yes and useMPI=yes      if not env['build_shared']:
335  if env['dodebug']: env['usedebug'] = 1          env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
336  if env['useMPI']: env['usempi'] = 1          env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
337    
338  # Default compiler options (override allowed in hostname_options.py, but should not be necessary)  ###################### Copy required environment vars ########################
339  # For both C and C++ you get: cc_flags and either the optim flags or debug flags  
340    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
341  if env["CC"] == "icc":  if IS_WINDOWS:
342    # Intel compilers      LD_LIBRARY_PATH_KEY='PATH'
343    cc_flags      = "-fPIC -ansi -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"      env['ENV']['LD_LIBRARY_PATH']=''
344    cc_optim      = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias"  else:
345    cc_debug      = "-g -O0 -UDOASSERT -DDOPROF -DBOUNDS_CHECK"      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
346    omp_optim     = "-openmp -openmp_report0"  
347    omp_debug     = "-openmp -openmp_report0"  # the following env variables are exported for the unit tests
348    omp_libs      = ['guide', 'pthread']  
349    pedantic      = ""  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
350  elif env["CC"] == "gcc":      try:
351    # GNU C on any system          env['ENV'][key] = os.environ[key]
352    cc_flags      = "-fPIC -ansi -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER"      except KeyError:
353    cc_optim      = "-O3"          env['ENV'][key] = 1
354    cc_debug      = "-g -O0 -UDOASSERT -DDOPROF -DBOUNDS_CHECK"  
355    omp_optim     = ""  env_export=env['env_export']
356    omp_debug     = ""  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
357    omp_libs      = []  
358    pedantic      = "-pedantic-errors -Wno-long-long"  for key in set(env_export):
359  elif env["CC"] == "cl":      try:
360    # Microsoft Visual C on Windows          env['ENV'][key] = os.environ[key]
361    cc_flags      = "/FD /EHsc /GR /wd4068 -D_USE_MATH_DEFINES -DDLL_NETCDF"      except KeyError:
362    cc_optim      = "/O2 /Op /MT /W3"          pass
   cc_debug      = "/Od /RTC1 /MTd /ZI -DBOUNDS_CHECK"  
   omp_optim     = ""  
   omp_debug     = ""  
   omp_libs      = []  
   pedantic      = ""  
   
 # 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  
   
 # 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']['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'])  
   
 ############ 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'])])  
   
 env.Append(CPPDEFINES = ['ESCRIPT_EXPORTS', 'FINLEY_EXPORTS'])  
   
 if env['cc_extra'] != '': env.Append(CCFLAGS = env['cc_extra'])  
   
 if env['usepedantic']: env.Append(CCFLAGS = pedantic)  
   
 # MS Windows  
 if IS_WINDOWS_PLATFORM:  
   env.PrependENVPath('PATH',    [env['boost_lib_path']])  
   env.PrependENVPath('PATH',    [env['libinstall']])  
   if env['usenetcdf']:  
     env.PrependENVPath('PATH',  [env['netCDF_lib_path']])  
363    
364  env.Append(ARFLAGS = env['ar_flags'])  try:
365        env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
366    except KeyError:
367        pass
368    
369    # these shouldn't be needed
370    #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
371    #    try:
372    #        env['ENV'][key] = os.environ[key]
373    #    except KeyError:
374    #        pass
375    
 # Get the global Subversion revision number for getVersion() method  
376  try:  try:
377     global_revision = os.popen("svnversion -n .").read()      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
378     global_revision = re.sub(":.*", "", global_revision)  except KeyError:
379     global_revision = re.sub("[^0-9]", "", global_revision)      pass
 except:  
    global_revision="-1"  
 if global_revision == "": global_revision="-2"  
 env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  
380    
381  ############ numarray (required) ###############################  ######################## Add some custom builders ############################
382    
383  try:  if env['pythoncmd']=='python':
384    from numarray import identity      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
385  except ImportError:  else:
386    print "Cannot import numarray, you need to set your PYTHONPATH"      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
387    sys.exit(1)  env.Append(BUILDERS = {'PyCompile' : py_builder});
388    
389  ############ C compiler (required) #############################  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
390    env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
391    
392  # Create a Configure() environment for checking existence of required libraries and headers  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
393  conf = Configure(clone_env(env))  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
394    
395  # Test that the compiler is working  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
396  if not conf.CheckFunc('printf'):  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
   print "Cannot run C compiler '%s' (or libc is missing)" % (env['CC'])  
   sys.exit(1)  
397    
398  if not conf.CheckFunc('gethostname'):  ############################ Dependency checks ###############################
   env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])  
399    
400  ############ python libraries (required) #######################  # Create a Configure() environment to check for compilers and python
401    conf = Configure(env.Clone())
402    
403  conf.env.AppendUnique(CPPPATH       = [env['python_path']])  ######## Test that the compilers work
404  conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  
405  conf.env.AppendUnique(LIBS      = [env['python_libs']])  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
406        if not conf.CheckCC():
407            print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
408            Exit(1)
409        if not conf.CheckCXX():
410            print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
411            Exit(1)
412    else:
413        if not conf.CheckFunc('printf', language='c'):
414            print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
415            Exit(1)
416        if not conf.CheckFunc('printf', language='c++'):
417            print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
418            Exit(1)
419    
420    if conf.CheckFunc('gethostname'):
421        conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])
422    
423    ######## Python headers & library (required)
424    
425    #First we check to see if the config file has specified
426    ##Where to find the filae. Ideally, this should be automatic
427    #But we need to deal with the case where python is not in its INSTALL
428    #Directory
429    # Use the python scons is running
430    if env['pythoncmd']=='python':
431        python_inc_path=sysconfig.get_python_inc()
432        if IS_WINDOWS:
433            python_lib_path=os.path.join(sysconfig.get_config_var('prefix'), 'libs')
434        elif env['PLATFORM']=='darwin':
435            python_lib_path=sysconfig.get_config_var('LIBPL')
436        else:
437            python_lib_path=sysconfig.get_config_var('LIBDIR')
438    
439        #python_libs=[sysconfig.get_config_var('LDLIBRARY')] # only on linux
440        if IS_WINDOWS:
441            python_libs=['python%s%s'%(sys.version_info[0], sys.version_info[1])]
442        else:
443            python_libs=['python'+sysconfig.get_python_version()]
444    
445    #if we want to use a python other than the one scons is running
446    else:
447        initstring='from __future__ import print_function;from distutils import sysconfig;'
448        if env['pythonlibname']!='':
449            python_libs=env['pythonlibname']
450        else:   # work it out by calling python    
451            if IS_WINDOWS:
452                cmd='print("python%s%s"%(sys.version_info[0], sys.version_info[1]))'
453            else:
454                cmd='print("python"+sysconfig.get_python_version())'
455            p=Popen([env['pythoncmd'], '-c', initstring+cmd], stdout=PIPE)
456            python_libs=p.stdout.readline()
457            if env['usepython3']:       # This is to convert unicode str into py2 string
458                python_libs=python_libs.encode() # If scons runs on py3 then this must be rethought
459            p.wait()
460            python_libs=python_libs.strip()
461    
462      
463        # Now we know whether we are using python3 or not
464        p=Popen([env['pythoncmd'], '-c',  initstring+'print(sysconfig.get_python_inc())'], stdout=PIPE)
465        python_inc_path=p.stdout.readline()
466        if env['usepython3']:
467             python_inc_path=python_inc_path.encode()
468        p.wait()  
469        python_inc_path=python_inc_path.strip()
470        if IS_WINDOWS:
471            cmd="os.path.join(sysconfig.get_config_var('prefix'), 'libs')"
472        elif env['PLATFORM']=='darwin':
473            cmd="sysconfig.get_config_var(\"LIBPL\")"
474        else:
475            cmd="sysconfig.get_config_var(\"LIBDIR\")"
476    
477        p=Popen([env['pythoncmd'], '-c', initstring+'print('+cmd+')'], stdout=PIPE)
478        python_lib_path=p.stdout.readline()
479        if env['usepython3']:
480            python_lib_path=python_lib_path.decode()
481        p.wait()
482        python_lib_path=python_lib_path.strip()
483    
484    #Check for an override from the config file.
485    #Ideally, this should be automatic
486    #But we need to deal with the case where python is not in its INSTALL
487    #Directory
488    if env['pythonlibpath']!='':
489        python_lib_path=env['pythonlibpath']
490    
491    if env['pythonincpath']!='':
492        python_inc_path=env['pythonincpath']
493    
494    
495    if sysheaderopt == '':
496        conf.env.AppendUnique(CPPPATH = [python_inc_path])
497    else:
498        conf.env.Append(CCFLAGS = [sysheaderopt, python_inc_path])
499    
500    conf.env.AppendUnique(LIBPATH = [python_lib_path])
501    conf.env.AppendUnique(LIBS = python_libs)
502    # The wrapper script needs to find the libs
503    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, python_lib_path)
504    
505  if not conf.CheckCHeader('Python.h'):  if not conf.CheckCHeader('Python.h'):
506    print "Cannot find python include files (tried 'Python.h' in directory %s)" % (env['python_path'])      print("Cannot find python include files (tried 'Python.h' in directory %s)" % (python_inc_path))
507    sys.exit(1)      Exit(1)
508  if not conf.CheckFunc('Py_Main'):  if not conf.CheckFunc('Py_Exit'):
509    print "Cannot find python library method Py_Main (tried lib %s in directory %s)" % (env['python_libs'], env['python_lib_path'])      print("Cannot find python library method Py_Main (tried %s in directory %s)" % (python_libs, python_lib_path))
510    sys.exit(1)      Exit(1)
511    
512  ############ boost (required) ##################################  ## reuse conf to check for numpy header (optional)
513    if env['usepython3']:
514  conf.env.AppendUnique(CPPPATH       = [env['boost_path']])      # FIXME: This is until we can work out how to make the checks in python 3
515  conf.env.AppendUnique(LIBPATH       = [env['boost_lib_path']])      conf.env['numpy_h']=False
516  conf.env.AppendUnique(LIBS      = [env['boost_libs']])  else:
517        if conf.CheckCXXHeader(['Python.h','numpy/ndarrayobject.h']):
518  if not conf.CheckCXXHeader('boost/python.hpp'):          conf.env.Append(CPPDEFINES = ['HAVE_NUMPY_H'])
519    print "Cannot find boost include files (tried boost/python.hpp in directory %s)" % (env['boost_path'])          conf.env['numpy_h']=True
520    sys.exit(1)      else:
521  if not conf.CheckFunc('PyObject_SetAttr'):          conf.env['numpy_h']=False
   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)  
522    
523  # Commit changes to environment  # Commit changes to environment
524  env = conf.Finish()  env = conf.Finish()
525    
526  ############ VTK (optional) ####################################  ######## boost (required)
   
 if env['usevtk']:  
   try:  
     import vtk  
     env['usevtk'] = 1  
   except ImportError:  
     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']])  
   
 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))  
527    
528  if env['usepapi']:  boost_inc_path,boost_lib_path=findLibWithHeader(env, env['boost_libs'], 'boost/python.hpp', env['boost_prefix'], lang='c++')
529    conf.env.AppendUnique(CPPPATH = [env['papi_path']])  if sysheaderopt == '':
530    conf.env.AppendUnique(LIBPATH = [env['papi_lib_path']])      env.AppendUnique(CPPPATH = [boost_inc_path])
531    conf.env.AppendUnique(LIBS    = [env['papi_libs']])  else:
532        # This is required because we can't -isystem /usr/include since it breaks
533  if env['usepapi'] and not conf.CheckCHeader('papi.h'): env['usepapi'] = 0      # std includes
534  if env['usepapi'] and not conf.CheckFunc('PAPI_start_counters'): env['usepapi'] = 0      if os.path.normpath(boost_inc_path) == '/usr/include':
535            conf.env.Append(CCFLAGS=[sysheaderopt, os.path.join(boost_inc_path,'boost')])
536  # Add PAPI to environment env if it was found      else:
537  if env['usepapi']:          env.Append(CCFLAGS=[sysheaderopt, boost_inc_path])
538    env = conf.Finish()  
539    env.Append(CPPDEFINES = ['BLOCKPAPI'])  env.AppendUnique(LIBPATH = [boost_lib_path])
540  else:  env.AppendUnique(LIBS = env['boost_libs'])
541    conf.Finish()  env.PrependENVPath(LD_LIBRARY_PATH_KEY, boost_lib_path)
542    
543    ######## numpy (required)
544    
545    if not detectModule(env, 'numpy'):
546        print("Cannot import numpy. If it is installed try setting your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
547        Exit(1)
548    
549  ############ MKL (optional) ####################################  ######## CppUnit (required for tests)
   
 # 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']])  
   
 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()  
550    
551  ############ UMFPACK (optional) ################################  try:
552        cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
553  # Start a new configure environment that reflects what we've already found      env.AppendUnique(CPPPATH = [cppunit_inc_path])
554  conf = Configure(clone_env(env))      env.AppendUnique(LIBPATH = [cppunit_lib_path])
555        env.PrependENVPath(LD_LIBRARY_PATH_KEY, cppunit_lib_path)
556  if env['useumfpack']:      env['cppunit']=True
557    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])  except:
558    conf.env.AppendUnique(CPPPATH = [env['umf_path']])      env['cppunit']=False
   conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])  
   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']])  
   
 if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0  
 if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0  
   
 # Add UMFPACK to environment env if it was found  
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
 else:  
   conf.Finish()  
559    
560  ############ Add the compiler flags ############################  ######## sympy (optional)
561    
562  # Enable debug by choosing either cc_debug or cc_optim  if detectModule(env, 'sympy'):
563  if env['usedebug']:      env['sympy'] = True
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
564  else:  else:
565    env.Append(CCFLAGS        = env['cc_optim'])      print("Cannot import sympy. Symbolic toolbox and nonlinear PDEs will not be available.")
566    env.Append(CCFLAGS        = env['omp_optim'])      env['sympy'] = False
567    
568  # Always use cc_flags  ######## pyproj (optional)
569  env.Append(CCFLAGS      = env['cc_flags'])  
570  env.Append(LIBS         = [env['omp_libs']])  if detectModule(env, 'pyproj'):
571        env['pyproj'] = True
572  ############ MPI (optional) ####################################  else:
573        print("Cannot import pyproj. Inversions may not work.")
574  # Create a modified environment for MPI programs (identical to env if usempi=no)      env['pyproj'] = False
575  env_mpi = clone_env(env)  
576    ######## netCDF (optional)
577  # Start a new configure environment that reflects what we've already found  
578  conf = Configure(clone_env(env_mpi))  netcdf_inc_path=''
579    netcdf_lib_path=''
580  if env_mpi['usempi']:  if env['netcdf']:
581    conf.env.AppendUnique(CPPPATH = [env_mpi['mpi_path']])      netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'netcdf.h', env['netcdf_prefix'], lang='c++')
582    conf.env.AppendUnique(LIBPATH = [env_mpi['mpi_lib_path']])      env.AppendUnique(CPPPATH = [netcdf_inc_path])
583    conf.env.AppendUnique(LIBS    = [env_mpi['mpi_libs']])      env.AppendUnique(LIBPATH = [netcdf_lib_path])
584        env.AppendUnique(LIBS = env['netcdf_libs'])
585        env.PrependENVPath(LD_LIBRARY_PATH_KEY, netcdf_lib_path)
586        env.Append(CPPDEFINES = ['USE_NETCDF'])
587    
588    ######## PAPI (optional)
589    
590    papi_inc_path=''
591    papi_lib_path=''
592    if env['papi']:
593        papi_inc_path,papi_lib_path=findLibWithHeader(env, env['papi_libs'], 'papi.h', env['papi_prefix'], lang='c')
594        env.AppendUnique(CPPPATH = [papi_inc_path])
595        env.AppendUnique(LIBPATH = [papi_lib_path])
596        env.AppendUnique(LIBS = env['papi_libs'])
597        env.PrependENVPath(LD_LIBRARY_PATH_KEY, papi_lib_path)
598        env.Append(CPPDEFINES = ['BLOCKPAPI'])
599    
600    ######## MKL (optional)
601    
602    mkl_inc_path=''
603    mkl_lib_path=''
604    if env['mkl']:
605        mkl_inc_path,mkl_lib_path=findLibWithHeader(env, env['mkl_libs'], 'mkl_solver.h', env['mkl_prefix'], lang='c')
606        env.AppendUnique(CPPPATH = [mkl_inc_path])
607        env.AppendUnique(LIBPATH = [mkl_lib_path])
608        env.AppendUnique(LIBS = env['mkl_libs'])
609        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mkl_lib_path)
610        env.Append(CPPDEFINES = ['MKL'])
611    
612    ######## UMFPACK (optional)
613    
614    umfpack_inc_path=''
615    umfpack_lib_path=''
616    if env['umfpack']:
617        umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c')
618        env.AppendUnique(CPPPATH = [umfpack_inc_path])
619        env.AppendUnique(LIBPATH = [umfpack_lib_path])
620        env.AppendUnique(LIBS = env['umfpack_libs'])
621        env.PrependENVPath(LD_LIBRARY_PATH_KEY, umfpack_lib_path)
622        env.Append(CPPDEFINES = ['UMFPACK'])
623    
624    ######## LAPACK (optional)
625    
626    if env['lapack']=='mkl' and not env['mkl']:
627        print("mkl_lapack requires MKL!")
628        Exit(1)
629    
630    env['uselapack'] = env['lapack']!='none'
631    lapack_inc_path=''
632    lapack_lib_path=''
633    if env['uselapack']:
634        header='clapack.h'
635        if env['lapack']=='mkl':
636            env.AppendUnique(CPPDEFINES = ['MKL_LAPACK'])
637            header='mkl_lapack.h'
638        lapack_inc_path,lapack_lib_path=findLibWithHeader(env, env['lapack_libs'], header, env['lapack_prefix'], lang='c')
639        env.AppendUnique(CPPPATH = [lapack_inc_path])
640        env.AppendUnique(LIBPATH = [lapack_lib_path])
641        env.AppendUnique(LIBS = env['lapack_libs'])
642        env.Append(CPPDEFINES = ['USE_LAPACK'])
643    
644    ######## Silo (optional)
645    
646    silo_inc_path=''
647    silo_lib_path=''
648    if env['silo']:
649        silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c')
650        env.AppendUnique(CPPPATH = [silo_inc_path])
651        env.AppendUnique(LIBPATH = [silo_lib_path])
652        # Note that we do not add the libs since they are only needed for the
653        # weipa library and tools.
654        #env.AppendUnique(LIBS = [env['silo_libs']])
655    
656    ######## VSL random numbers (optional)
657    if env['vsl_random']:
658        env.Append(CPPDEFINES = ['MKLRANDOM'])
659    
660    ######## VisIt (optional)
661    
662    visit_inc_path=''
663    visit_lib_path=''
664    if env['visit']:
665        visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c')
666        env.AppendUnique(CPPPATH = [visit_inc_path])
667        env.AppendUnique(LIBPATH = [visit_lib_path])
668    
669    ######## MPI (optional)
670    
671    if env['mpi']=='no':
672        env['mpi']='none'
673    
674    env['usempi'] = env['mpi']!='none'
675    mpi_inc_path=''
676    mpi_lib_path=''
677    if env['usempi']:
678        mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c')
679        env.AppendUnique(CPPPATH = [mpi_inc_path])
680        env.AppendUnique(LIBPATH = [mpi_lib_path])
681        env.AppendUnique(LIBS = env['mpi_libs'])
682        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mpi_lib_path)
683        env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
684        # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
685        # On the other hand MPT and OpenMPI don't define the latter so we have to
686        # do that here
687        if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
688            env.Append(CPPDEFINES = ['MPI_INCLUDED'])
689    
690    ######## BOOMERAMG (optional)
691    
692    if env['mpi'] == 'none': env['boomeramg'] = False
693    
694    boomeramg_inc_path=''
695    boomeramg_lib_path=''
696    if env['boomeramg']:
697        boomeramg_inc_path,boomeramg_lib_path=findLibWithHeader(env, env['boomeramg_libs'], 'HYPRE.h', env['boomeramg_prefix'], lang='c')
698        env.AppendUnique(CPPPATH = [boomeramg_inc_path])
699        env.AppendUnique(LIBPATH = [boomeramg_lib_path])
700        env.AppendUnique(LIBS = env['boomeramg_libs'])
701        env.PrependENVPath(LD_LIBRARY_PATH_KEY, boomeramg_lib_path)
702        env.Append(CPPDEFINES = ['BOOMERAMG'])
703    
704    ######## ParMETIS (optional)
705    
706    if not env['usempi']: env['parmetis'] = False
707    
708    parmetis_inc_path=''
709    parmetis_lib_path=''
710    if env['parmetis']:
711        parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c')
712        env.AppendUnique(CPPPATH = [parmetis_inc_path])
713        env.AppendUnique(LIBPATH = [parmetis_lib_path])
714        env.AppendUnique(LIBS = env['parmetis_libs'])
715        env.PrependENVPath(LD_LIBRARY_PATH_KEY, parmetis_lib_path)
716        env.Append(CPPDEFINES = ['USE_PARMETIS'])
717    
718  if env_mpi['usempi'] and not conf.CheckCHeader('mpi.h'): env_mpi['usempi'] = 0  ######## gmsh (optional, for tests)
 if env_mpi['usempi'] and not conf.CheckFunc('MPI_Init'): env_mpi['usempi'] = 0  
719    
720  # Add MPI to environment env_mpi if it was found  try:
721  if env_mpi['usempi']:      p=Popen(['gmsh', '-info'], stderr=PIPE)
722    env_mpi = conf.Finish()      _,e=p.communicate()
723    env_mpi.Append(CPPDEFINES = ['PASO_MPI', 'MPI_NO_CPPBIND', env_mpi['MPICH_IGNORE_CXX_SEEK']])      if e.split().count("MPI"):
724            env['gmsh']='m'
725        else:
726            env['gmsh']='s'
727    except OSError:
728        env['gmsh']=False
729    
730    ######## PDFLaTeX (for documentation)
731    if 'PDF' in dir(env) and '.tex' in env.PDF.builder.src_suffixes(env):
732        env['pdflatex']=True
733  else:  else:
734    conf.Finish()      env['pdflatex']=False
   
 env['usempi'] = env_mpi['usempi']  
   
 ############ ParMETIS (optional) ###############################  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env_mpi))  
735    
736  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0  ######################## Summarize our environment ###########################
737    
738  if env_mpi['useparmetis']:  # keep some of our install paths first in the list for the unit tests
739    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
740    conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])  env.PrependENVPath('PYTHONPATH', prefix)
741    conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  env['ENV']['ESCRIPT_ROOT'] = prefix
   
 if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  
 if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0  
742    
743  # Add ParMETIS to environment env_mpi if it was found  if not env['verbose']:
744  if env_mpi['useparmetis']:      env['CCCOMSTR'] = "Compiling $TARGET"
745    env_mpi = conf.Finish()      env['CXXCOMSTR'] = "Compiling $TARGET"
746    env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])      env['SHCCCOMSTR'] = "Compiling $TARGET"
747        env['SHCXXCOMSTR'] = "Compiling $TARGET"
748        env['ARCOMSTR'] = "Linking $TARGET"
749        env['LINKCOMSTR'] = "Linking $TARGET"
750        env['SHLINKCOMSTR'] = "Linking $TARGET"
751        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
752        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
753        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
754        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
755        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
756    
757    print("")
758    print("*** Config Summary (see config.log and lib/buildvars for details) ***")
759    print("Escript/Finley revision %s"%global_revision)
760    print("  Install prefix:  %s"%env['prefix'])
761    print("          Python:  %s"%sysconfig.PREFIX)
762    print("           boost:  %s"%env['boost_prefix'])
763    print("           numpy:  YES")
764    if env['usempi']:
765        print("             MPI:  YES (flavour: %s)"%env['mpi'])
766  else:  else:
767    conf.Finish()      print("             MPI:  DISABLED")
768    if env['uselapack']:
769  env['useparmetis'] = env_mpi['useparmetis']      print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
770    else:
771  ############ Summarize our environment #########################      print("          LAPACK:  DISABLED")
772    d_list=[]
773  print ""  e_list=[]
774  print "Summary of configuration (see ./config.log for information)"  for i in 'debug','openmp','boomeramg','mkl','netcdf','papi','parmetis','pyproj','silo','sympy','umfpack','visit','vsl_random':
775  print " Using python libraries"      if env[i]: e_list.append(i)
776  print " Using numarray"      else: d_list.append(i)
777  print " Using boost"  for i in e_list:
778  if env['usenetcdf']: print "    Using NetCDF"      print("%16s:  YES"%i)
779  else: print "   Not using NetCDF"  for i in d_list:
780  if env['usevtk']: print "   Using VTK"      print("%16s:  DISABLED"%i)
781  else: print "   Not using VTK"  if env['cppunit']:
782  if env['usemkl']: print "   Using MKL"      print("         CppUnit:  FOUND")
783  else: print "   Not using MKL"  else:
784  if env['useumfpack']: print "   Using UMFPACK"      print("         CppUnit:  NOT FOUND")
785  else: print "   Not using UMFPACK"  if env['gmsh']=='m':
786  if env['useopenmp']: print "    Using OpenMP"      print("            gmsh:  FOUND, MPI-ENABLED")
787  else: print "   Not using OpenMP"  elif env['gmsh']=='s':
788  if env['usempi']: print "   Using MPI"      print("            gmsh:  FOUND")
789  else: print "   Not using MPI"  else:
790  if env['useparmetis']: print "  Using ParMETIS"      print("            gmsh:  NOT FOUND")
791  else: print "   Not using ParMETIS (requires MPI)"  if env['numpy_h']:
792  if env['usepapi']: print "  Using PAPI"      print("   numpy headers:  FOUND")
793  else: print "   Not using PAPI"  else:
794  if env['usedebug']: print " Compiling for debug"      print("   numpy headers:  NOT FOUND")
795  else: print "   Not compiling for debug"  print("   vsl_random:  %s"%env['vsl_random'])
796  print " Installing in", prefix      
797  print ""  if ((fatalwarning != '') and (env['werror'])):
798        print("  Treating warnings as errors")
799  ############ Add some custom builders ##########################  else:
800        print("  NOT treating warnings as errors")
801  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  print("")
802  env.Append(BUILDERS = {'PyCompile' : py_builder});  
803    ####################### Configure the subdirectories #########################
804  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  
805  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  from grouptest import *
806    
807  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  TestGroups=[]
808  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  
809    # keep an environment without warnings-as-errors
810  ############ Build the desired subdirectories ##################  dodgy_env=env.Clone()
811    
812  Export(["env", "env_mpi", "clone_env"])  # now add warnings-as-errors flags. This needs to be done after configuration
813    # because the scons test files have warnings in them
814  env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  if ((fatalwarning != '') and (env['werror'])):
815  env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)      env.Append(CCFLAGS = fatalwarning)
816  env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
817  env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  Export(
818  env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)    ['env',
819  env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)     'dodgy_env',
820  env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)     'IS_WINDOWS',
821  env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)     'TestGroups'
822  env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)    ]
823  env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  )
824    
825  ############ Remember what optimizations we used ###############  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
826    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
827    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
828    env.SConscript(dirs = ['escript/src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
829    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
830    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
831    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
832    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
833    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
834    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
835    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
836    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
837    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
838    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
839    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
840    
841    
842    ######################## Populate the buildvars file #########################
843    
844    # remove obsolete file
845    if not env['usempi']:
846        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
847        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
848    
849    # Try to extract the boost version from version.hpp
850    boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
851    boostversion='unknown'
852    try:
853        for line in boosthpp:
854            ver=re.match(r'#define BOOST_VERSION (\d+)',line)
855            if ver:
856                boostversion=ver.group(1)
857    except StopIteration:
858        pass
859    boosthpp.close()
860    
861    
862    buildvars=open(os.path.join(env['libinstall'], 'buildvars'), 'w')
863    buildvars.write("svn_revision="+str(global_revision)+"\n")
864    buildvars.write("prefix="+prefix+"\n")
865    buildvars.write("cc="+env['CC']+"\n")
866    buildvars.write("cxx="+env['CXX']+"\n")
867    if env['pythoncmd']=='python':
868        buildvars.write("python="+sys.executable+"\n")
869        buildvars.write("python_version="+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+"\n")
870    else:
871        buildvars.write("python="+env['pythoncmd']+"\n")
872        p=Popen([env['pythoncmd'], '-c', 'from __future__ import print_function;import sys;print(str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2]))'], stdout=PIPE)
873        verstring=p.stdout.readline().strip()
874        p.wait()
875        buildvars.write("python_version="+verstring+"\n")
876    buildvars.write("boost_inc_path="+boost_inc_path+"\n")
877    buildvars.write("boost_lib_path="+boost_lib_path+"\n")
878    buildvars.write("boost_version="+boostversion+"\n")
879    buildvars.write("debug=%d\n"%int(env['debug']))
880    buildvars.write("openmp=%d\n"%int(env['openmp']))
881    buildvars.write("mpi=%s\n"%env['mpi'])
882    buildvars.write("mpi_inc_path=%s\n"%mpi_inc_path)
883    buildvars.write("mpi_lib_path=%s\n"%mpi_lib_path)
884    buildvars.write("lapack=%s\n"%env['lapack'])
885    buildvars.write("vsl_random=%d\n"%int(env['vsl_random']))
886    for i in 'netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit':
887        buildvars.write("%s=%d\n"%(i, int(env[i])))
888        if env[i]:
889            buildvars.write("%s_inc_path=%s\n"%(i, eval(i+'_inc_path')))
890            buildvars.write("%s_lib_path=%s\n"%(i, eval(i+'_lib_path')))
891    buildvars.close()
892    
893  remember_list = []  ################### Targets to build and install libraries ###################
894    
895  if env['usedebug']:  target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
896    remember_list += env.Command(env['libinstall'] + "/Compiled.with.debug", None, Touch('$TARGET'))  env.Alias('target_init', [target_init])
897  else:  # delete buildvars upon cleanup
898    remember_list += env.Command(env['libinstall'] + "/Compiled.with.debug", None, Delete('$TARGET'))  env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
899    
900  if env['usempi']:  # The headers have to be installed prior to build in order to satisfy
901    remember_list += env.Command(env['libinstall'] + "/Compiled.with.mpi", None, Touch('$TARGET'))  # #include <paso/Common.h>
902  else:  env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
903    remember_list += env.Command(env['libinstall'] + "/Compiled.with.mpi", None, Delete('$TARGET'))  env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
904    
905  if env['omp_optim'] != '':  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
906    remember_list += env.Command(env['libinstall'] + "/Compiled.with.openmp", None, Touch('$TARGET'))  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
 else:  
   remember_list += env.Command(env['libinstall'] + "/Compiled.with.openmp", None, Delete('$TARGET'))  
907    
908  env.Alias('remember_options', remember_list)  env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
909    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escript_py'])
910    
911  ############ Targets to build and install libraries ############  env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
912    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
913    
914  target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
915  env.Alias('target_init', [target_init])  env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
916    
917  # The headers have to be installed prior to build in order to satisfy #include <paso/Common.h>  env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
918  env.Alias('build_esysUtils', ['target_install_esysUtils_headers', 'target_esysUtils_a'])  env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
 env.Alias('install_esysUtils', ['build_esysUtils', 'target_install_esysUtils_a'])  
919    
920  env.Alias('build_paso', ['target_install_paso_headers', 'target_paso_a'])  env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
921  env.Alias('install_paso', ['build_paso', 'target_install_paso_a'])  env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
922    
923  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'])
924  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'])
925    
926  env.Alias('build_finley', ['target_install_finley_headers', 'target_finley_so', 'target_finleycpp_so'])  env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
927  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'])
928    
929  # 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
930  build_all_list = []  build_all_list = []
931  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
932  build_all_list += ['build_paso']  build_all_list += ['build_paso']
933  build_all_list += ['build_escript']  build_all_list += ['build_escript']
934    build_all_list += ['build_pasowrap']
935    build_all_list += ['build_dudley']
936  build_all_list += ['build_finley']  build_all_list += ['build_finley']
937  if env['usempi']: build_all_list += ['target_pythonMPI_exe']  build_all_list += ['build_ripley']
938    build_all_list += ['build_weipa']
939    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
940    if env['usempi']:   build_all_list += ['build_pythonMPI']
941    build_all_list += ['build_escriptconvert']
942  env.Alias('build_all', build_all_list)  env.Alias('build_all', build_all_list)
943    
944  install_all_list = []  install_all_list = []
# Line 580  install_all_list += ['target_init'] Line 946  install_all_list += ['target_init']
946  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
947  install_all_list += ['install_paso']  install_all_list += ['install_paso']
948  install_all_list += ['install_escript']  install_all_list += ['install_escript']
949    install_all_list += ['install_pasowrap']
950    install_all_list += ['install_dudley']
951  install_all_list += ['install_finley']  install_all_list += ['install_finley']
952  install_all_list += ['target_install_pyvisi_py']  install_all_list += ['install_ripley']
953  install_all_list += ['target_install_modellib_py']  install_all_list += ['install_weipa']
954  install_all_list += ['target_install_pycad_py']  if not IS_WINDOWS: install_all_list += ['install_escriptreader']
955  if env['usempi']: install_all_list += ['target_install_pythonMPI_exe']  install_all_list += ['install_downunder_py']
956  install_all_list += ['remember_options']  install_all_list += ['install_modellib_py']
957    install_all_list += ['install_pycad_py']
958    if env['usempi']:   install_all_list += ['install_pythonMPI']
959    install_all_list += ['install_escriptconvert']
960  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
961    
962  # Default target is install  # Default target is install
963  env.Default('install_all')  env.Default('install_all')
964    
965  ############ Targets to build and run the test suite ###########  ################## Targets to build and run the test suite ###################
   
 env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  
 env.Alias('install_cppunittest', ['build_cppunittest', 'target_install_cppunittest_a'])  
 env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])  
 env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])  
   
 ############ Targets to build the documentation ################  
966    
967  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html'])  if not env['cppunit']:
968        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C/C++ unit tests, CppUnit not found!";exit 1')
969        env.Alias('run_tests', test_msg)
970    env.Alias('run_tests', ['install_all'])
971    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
972    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
973    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
974    
975    ##################### Targets to build the documentation #####################
976    
977    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
978    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
979    env.Alias('docs', ['basedocs', 'sphinxdoc'])
980    env.Alias('release_prep', ['docs', 'install_all'])
981    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
982    
983    
984    # The test scripts are always generated, this target allows us to
985    # generate the testscripts without doing a full build
986    env.Alias('testscripts',[])
987    
988    if not IS_WINDOWS:
989        try:
990            utest=open('utest.sh','w')
991            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix, False))
992            for tests in TestGroups:
993                utest.write(tests.makeString())
994            utest.close()
995            Execute(Chmod('utest.sh', 0o755))
996            print("Generated utest.sh.")
997            # This version contains only python tests - I want this to be usable
998            # From a binary only install if you have the test files
999            utest=open('itest.sh','w')
1000            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix, True))
1001            for tests in TestGroups:
1002              if tests.exec_cmd=='$PYTHONRUNNER ':
1003                utest.write(tests.makeString())
1004            utest.close()
1005            Execute(Chmod('itest.sh', 0o755))
1006            print("Generated itest.sh.")        
1007        except IOError:
1008            print("Error attempting to write unittests file.")
1009            Exit(1)
1010    
1011        # delete utest.sh upon cleanup
1012        env.Clean('target_init', 'utest.sh')
1013        env.Clean('target_init', 'itest.sh')
1014    
1015        # Make sure that the escript wrapper is in place
1016        if not os.path.isfile(os.path.join(env['bininstall'], 'run-escript')):
1017            print("Copying escript wrapper.")
1018            Execute(Copy(os.path.join(env['bininstall'],'run-escript'), 'bin/run-escript'))
1019    

Legend:
Removed from v.1729  
changed lines
  Added in v.4244

  ViewVC Help
Powered by ViewVC 1.1.26