/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.1771  
changed lines
  Added in v.3942

  ViewVC Help
Powered by ViewVC 1.1.26