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

Diff of /branches/diaplayground/SConstruct

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

revision 1756 by ksteube, Mon Sep 8 01:45:46 2008 UTC revision 4640 by jfenwick, Fri Jan 31 00:56:51 2014 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  ##############################################################################
14  if os.path.isdir('scons'): sys.path.append('scons')  
15  import scons_extensions  EnsureSConsVersion(0,98,1)
16    EnsurePythonVersion(2,5)
 # Use /usr/lib64 if available, else /usr/lib  
 usr_lib = '/usr/lib'  
 if os.path.isfile('/usr/lib64/libc.so'): usr_lib = '/usr/lib64'  
17    
18  # The string python2.4 or python2.5  import atexit, sys, os, platform, re
19  python_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])  from distutils import sysconfig
20    from dependencies import *
21    from site_init import *
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  # MS Windows support, many thanks to PH  # MS Windows support, many thanks to PH
28  IS_WINDOWS_PLATFORM = (os.name== "nt")  IS_WINDOWS = (os.name == 'nt')
29    
30  prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  IS_OSX = (os.uname()[0] == 'Darwin')
31    
32  # Read configuration options from file scons/<hostname>_options.py  ########################## Determine options file ############################
33  hostname = re.sub("[^0-9a-zA-Z]", "_", socket.gethostname().split('.')[0])  # 1. command line
34  tmp = os.path.join("scons",hostname+"_options.py")  # 2. scons/<hostname>_options.py
35  options_file = ARGUMENTS.get('options_file', tmp)  # 3. name as part of a cluster
36  if not os.path.isfile(options_file): options_file = False  options_file=ARGUMENTS.get('options_file', None)
37  else: print "Options file is", options_file  if not options_file:
38        ext_dir = os.path.join(os.getcwd(), 'scons')
39  # Load options file and command-line arguments      hostname = platform.node().split('.')[0]
40  opts = Options(options_file, ARGUMENTS)      for name in hostname, effectiveName(hostname):
41            mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
42  ############ Load build options ################################          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
43            if os.path.isfile(options_file): break
44  opts.AddOptions(  
45  # Where to install esys stuff  if not os.path.isfile(options_file):
46    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),      print("\nWARNING:\nOptions file %s" % options_file)
47    ('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.")
48    ('bininstall', 'where the esys binaries will be installed',            os.path.join(prefix,'bin')),      print("We recommend that you copy one of the TEMPLATE files in the scons/")
49    ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),      print("subdirectory and customize it to your needs.\n")
50    ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),      options_file = None
51  # Compilation options  
52    BoolOption('dodebug', 'For backwards compatibility', 'no'),  ############################### Build options ################################
53    BoolOption('usedebug', 'Do you want a debug build?', 'no'),  
54    BoolOption('usevtk', 'Do you want to use VTK?', 'yes'),  default_prefix='/usr'
55    ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
56    # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below  lapack_flavours=('none', 'clapack', 'mkl')
57    ('cc_flags', 'C compiler flags to use', '-DEFAULT_1'),  
58    ('cc_optim', 'C compiler optimization flags to use', '-DEFAULT_2'),  vars = Variables(options_file, ARGUMENTS)
59    ('cc_debug', 'C compiler debug flags to use', '-DEFAULT_3'),  vars.AddVariables(
60    ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
61    ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
62    ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
63    ('cc_extra', 'Extra C/C++ flags', ''),    BoolVariable('verbose', 'Output full compile/link lines', False),
64    ('sys_libs', 'System libraries to link with', []),  # Compiler/Linker options
65    ('ar_flags', 'Static library archiver flags to use', ''),    ('cxx', 'Path to C++ compiler', 'default'),
66    BoolOption('useopenmp', 'Compile parallel version using OpenMP', 'yes'),    ('cc_flags', 'Base C++ compiler flags', 'default'),
67    BoolOption('usepedantic', 'Compile with -pedantic if using gcc', 'yes'),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
68  # Python    ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
69    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),    ('cxx_extra', 'Extra C++ compiler flags', ''),
70    ('python_lib_path', 'Path to Python libs', usr_lib),    ('ld_extra', 'Extra linker flags', ''),
71    ('python_libs', 'Python libraries to link with', [python_version]),    BoolVariable('werror','Treat compiler warnings as errors', True),
72    ('python_cmd', 'Python command', 'python'),    BoolVariable('debug', 'Compile with debug flags', False),
73  # Boost    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74    ('boost_path', 'Path to Boost includes', '/usr/include'),    ('omp_flags', 'OpenMP compiler flags', 'default'),
75    ('boost_lib_path', 'Path to Boost libs', usr_lib),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76    ('boost_libs', 'Boost libraries to link with', ['boost_python']),  # Mandatory libraries
77  # NetCDF    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78    BoolOption('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),  # Mandatory for tests
80    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82  # MPI  # Optional libraries and options
83    BoolOption('useMPI', 'For backwards compatibility', 'no'),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84    BoolOption('usempi', 'Compile parallel version using MPI', 'no'),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85    ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86    ('mpi_path', 'Path to MPI includes', '/usr/include'),    BoolVariable('netcdf', 'Enable netCDF file support', False),
87    ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88    ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89    ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', ['mpich' , 'pthread', 'rt']),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90  # ParMETIS    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91    BoolOption('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92    ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),    BoolVariable('papi', 'Enable PAPI', False),
93    ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
   ('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),  
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    # set the vars for clang
150    def mkclang(env):
151        env['CXX']='clang++'
152    
153    if env['tools_names'] != 'default':
154        zz=env['tools_names']
155        if 'clang' in zz:
156            zz.remove('clang')
157            zz.insert(0, mkclang)
158        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
159                          ENV = {'PATH' : os.environ['PATH']})
160    
161    if options_file:
162        opts_valid=False
163        if 'escript_opts_version' in env.Dictionary() and \
164            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
165                opts_valid=True
166        if opts_valid:
167            print("Using options in %s." % options_file)
168        else:
169            print("\nOptions file %s" % options_file)
170            print("is outdated! Please update the file by examining one of the TEMPLATE")
171            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
172            Exit(1)
173    
174    # Generate help text (scons -h)
175    Help(vars.GenerateHelpText(env))
176    
177    # Check for superfluous options
178    if len(vars.UnknownVariables())>0:
179        for k in vars.UnknownVariables():
180            print("Unknown option '%s'" % k)
181        Exit(1)
182    
183    # create dictionary which will be populated with info for buildvars file
184    env['buildvars']={}
185    # create list which will be populated with warnings if there are any
186    env['warnings']=[]
187    
188    #################### Make sure install directories exist #####################
189    
190    env['BUILD_DIR']=Dir(env['build_dir']).abspath
191    prefix=Dir(env['prefix']).abspath
192    env['buildvars']['prefix']=prefix
193    env['incinstall'] = os.path.join(prefix, 'include')
194    env['bininstall'] = os.path.join(prefix, 'bin')
195    env['libinstall'] = os.path.join(prefix, 'lib')
196    env['pyinstall']  = os.path.join(prefix, 'esys')
197    if not os.path.isdir(env['bininstall']):
198        os.makedirs(env['bininstall'])
199    if not os.path.isdir(env['libinstall']):
200        os.makedirs(env['libinstall'])
201    if not os.path.isdir(env['pyinstall']):
202        os.makedirs(env['pyinstall'])
203    
204    env.Append(CPPPATH = [env['incinstall']])
205    env.Append(LIBPATH = [env['libinstall']])
206    
207    ################# Fill in compiler options if not set above ##################
208    
209    if env['cxx'] != 'default': env['CXX']=env['cxx']
210    
211    # version >=9 of intel C++ compiler requires use of icpc to link in C++
212    # runtimes (icc does not)
213    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
214        env['LINK'] = env['CXX']
215    
216    # default compiler/linker options
217    cc_flags = ''
218    cc_optim = ''
219    cc_debug = ''
220    omp_flags = ''
221    omp_ldflags = ''
222    fatalwarning = '' # switch to turn warnings into errors
223    sysheaderopt = '' # how to indicate that a header is a system header
224    
225    # env['CC'] might be a full path
226    cc_name=os.path.basename(env['CXX'])
227    
228    if cc_name == 'icpc':
229        # Intel compiler
230        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
231        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
232        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas -DBLOCKTIMER -DCORE_ID1"
233        cc_optim    = "-O3 -ftz -fno-alias -ipo -xHost"
234        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
235        omp_flags   = "-openmp"
236        omp_ldflags = "-openmp -openmp_report=1"
237        fatalwarning = "-Werror"
238    elif cc_name[:3] == 'g++':
239        # GNU C on any system
240        # note that -ffast-math is not used because it breaks isnan(),
241        # see mantis #691
242        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
243        cc_optim     = "-O3"
244        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
245        omp_flags    = "-fopenmp"
246        omp_ldflags  = "-fopenmp"
247        fatalwarning = "-Werror"
248        sysheaderopt = "-isystem"
249    elif cc_name == 'cl':
250        # Microsoft Visual C on Windows
251        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
252        cc_optim     = "/O2 /Op /W3"
253        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
254        fatalwarning = "/WX"
255    elif cc_name == 'icl':
256        # Intel C on Windows
257        cc_flags     = '/EHsc /GR /MD'
258        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
259        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
260        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
261        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
262    
263    env['sysheaderopt']=sysheaderopt
264    
265    # set defaults if not otherwise specified
266    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
267    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
268    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
269    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
270    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
271    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
272    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
273    
274    if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
275    
276    if env['usepython3']:
277        env.Append(CPPDEFINES=['ESPYTHON3'])
278    
279    # set up the autolazy values
280    if env['forcelazy'] == 'on':
281        env.Append(CPPDEFINES=['FAUTOLAZYON'])
282    elif env['forcelazy'] == 'off':
283        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
284    
285    # set up the collective resolve values
286    if env['forcecollres'] == 'on':
287        env.Append(CPPDEFINES=['FRESCOLLECTON'])
288    elif env['forcecollres'] == 'off':
289        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
290    
291    # allow non-standard C if requested
292    if env['iknowwhatimdoing']:
293        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
294    
295    # Disable OpenMP if no flags provided
296    if env['openmp'] and env['omp_flags'] == '':
297       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
298       env['openmp'] = False
299    
300    if env['openmp']:
301        env.Append(CCFLAGS = env['omp_flags'])
302        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
303  else:  else:
304     if socket.gethostname().split('.')[0] == 'service0':      env['omp_flags']=''
305        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  
   
 try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  
 except KeyError: pass  
   
 try: env['ENV']['HOME'] = os.environ['HOME']  
 except KeyError: pass  
   
 # Configure for test suite  
 env.PrependENVPath('PYTHONPATH', prefix)  
 env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 env['ENV']['ESCRIPT_ROOT'] = prefix  
   
 ############ Set up paths for Configure() ######################  
   
 # Make a copy of an environment  
 # Use env.Clone if available, but fall back on env.Copy for older version of scons  
 def clone_env(env):  
   if 'Clone' in dir(env): return env.Clone()    # scons-0.98  
   else:                   return env.Copy() # scons-0.96  
   
 # Add cc option -I<Escript>/trunk/include  
 env.Append(CPPPATH      = [Dir('include')])  
   
 # Add cc option -L<Escript>/trunk/lib  
 env.Append(LIBPATH      = [Dir(env['libinstall'])])  
   
 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']])  
   
 env.Append(ARFLAGS = env['ar_flags'])  
   
 # Get the global Subversion revision number for getVersion() method  
 try:  
    global_revision = os.popen("svnversion -n .").read()  
    global_revision = re.sub(":.*", "", global_revision)  
    global_revision = re.sub("[^0-9]", "", global_revision)  
 except:  
    global_revision="-1"  
 if global_revision == "": global_revision="-2"  
 env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  
   
 ############ numarray (required) ###############################  
   
 try:  
   from numarray import identity  
 except ImportError:  
   print "Cannot import numarray, you need to set your PYTHONPATH"  
   sys.exit(1)  
   
 ############ C compiler (required) #############################  
   
 # Create a Configure() environment for checking existence of required libraries and headers  
 conf = Configure(clone_env(env))  
   
 # Test that the compiler is working  
 if not conf.CheckFunc('printf'):  
   print "Cannot run C compiler '%s' (or libc is missing)" % (env['CC'])  
   sys.exit(1)  
   
 if not conf.CheckFunc('gethostname'):  
   env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])  
   
 ############ python libraries (required) #######################  
   
 conf.env.AppendUnique(CPPPATH       = [env['python_path']])  
 conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
   
 if not conf.CheckCHeader('Python.h'):  
   print "Cannot find python include files (tried 'Python.h' in directory %s)" % (env['python_path'])  
   sys.exit(1)  
 if not conf.CheckFunc('Py_Main'):  
   print "Cannot find python library method Py_Main (tried lib %s in directory %s)" % (env['python_libs'], env['python_lib_path'])  
   sys.exit(1)  
   
 ############ boost (required) ##################################  
306    
307  conf.env.AppendUnique(CPPPATH       = [env['boost_path']])  env['buildvars']['openmp']=int(env['openmp'])
 conf.env.AppendUnique(LIBPATH       = [env['boost_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['boost_libs']])  
308    
309  if not conf.CheckCXXHeader('boost/python.hpp'):  # add debug/non-debug compiler flags
310    print "Cannot find boost include files (tried boost/python.hpp in directory %s)" % (env['boost_path'])  env['buildvars']['debug']=int(env['debug'])
311    sys.exit(1)  if env['debug']:
312  if not conf.CheckFunc('PyObject_SetAttr'):      env.Append(CCFLAGS = env['cc_debug'])
   print "Cannot find boost library method PyObject_SetAttr (tried method PyObject_SetAttr in library %s in directory %s)" % (env['boost_libs'], env['boost_lib_path'])  
   sys.exit(1)  
   
 # Commit changes to environment  
 env = conf.Finish()  
   
 ############ VTK (optional) ####################################  
   
 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'])  
313  else:  else:
314    conf.Finish()      env.Append(CCFLAGS = env['cc_optim'])
315    
316  ############ PAPI (optional) ###################################  # always add cc_flags
317    env.Append(CCFLAGS = env['cc_flags'])
318    
319  # Start a new configure environment that reflects what we've already found  # add system libraries
320  conf = Configure(clone_env(env))  env.AppendUnique(LIBS = env['sys_libs'])
321    
322  if env['usepapi']:  # determine svn revision
323    conf.env.AppendUnique(CPPPATH = [env['papi_path']])  global_revision=ARGUMENTS.get('SVN_VERSION', None)
324    conf.env.AppendUnique(LIBPATH = [env['papi_lib_path']])  if global_revision:
325    conf.env.AppendUnique(LIBS    = [env['papi_libs']])      global_revision = re.sub(':.*', '', global_revision)
326        global_revision = re.sub('[^0-9]', '', global_revision)
327  if env['usepapi'] and not conf.CheckCHeader('papi.h'): env['usepapi'] = 0      if global_revision == '': global_revision='-2'
 if env['usepapi'] and not conf.CheckFunc('PAPI_start_counters'): env['usepapi'] = 0  
   
 # Add PAPI to environment env if it was found  
 if env['usepapi']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['BLOCKPAPI'])  
328  else:  else:
329    conf.Finish()    # Get the global Subversion revision number for the getVersion() method
330      try:
331  ############ MKL (optional) ####################################      global_revision = os.popen('svnversion -n .').read()
332        global_revision = re.sub(':.*', '', global_revision)
333  # Start a new configure environment that reflects what we've already found      global_revision = re.sub('[^0-9]', '', global_revision)
334  conf = Configure(clone_env(env))      if global_revision == '': global_revision='-2'
335      except:
336  if env['usemkl']:      global_revision = '-1'
337    conf.env.AppendUnique(CPPPATH = [env['mkl_path']])  env['svn_revision']=global_revision
338    conf.env.AppendUnique(LIBPATH = [env['mkl_lib_path']])  env['buildvars']['svn_revision']=global_revision
339    conf.env.AppendUnique(LIBS    = [env['mkl_libs']])  env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
340    
341  if env['usemkl'] and not conf.CheckCHeader('mkl_solver.h'): env['usemkl'] = 0  if IS_WINDOWS:
342  if env['usemkl'] and not conf.CheckFunc('pardiso_'): env['usemkl'] = 0      if not env['build_shared']:
343            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
344  # Add MKL to environment env if it was found          env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
345  if env['usemkl']:  
346    env = conf.Finish()  # VSL random numbers
347    env.Append(CPPDEFINES = ['MKL'])  env['buildvars']['vsl_random']=int(env['vsl_random'])
348    if env['vsl_random']:
349        env.Append(CPPDEFINES = ['MKLRANDOM'])
350    
351    env['IS_WINDOWS']=IS_WINDOWS
352    
353    ###################### Copy required environment vars ########################
354    
355    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
356    if IS_WINDOWS:
357        LD_LIBRARY_PATH_KEY='PATH'
358        env['ENV']['LD_LIBRARY_PATH']=''
359  else:  else:
360    conf.Finish()      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
361    
362  ############ UMFPACK (optional) ################################  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
363    
364  # Start a new configure environment that reflects what we've already found  # the following env variables are exported for the unit tests
 conf = Configure(clone_env(env))  
365    
366  if env['useumfpack']:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
367    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])      try:
368    conf.env.AppendUnique(CPPPATH = [env['umf_path']])          env['ENV'][key] = os.environ[key]
369    conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])      except KeyError:
370    conf.env.AppendUnique(LIBS    = [env['umf_libs']])          env['ENV'][key] = 1
371    conf.env.AppendUnique(CPPPATH = [env['amd_path']])  
372    conf.env.AppendUnique(LIBPATH = [env['amd_lib_path']])  env_export=env['env_export']
373    conf.env.AppendUnique(LIBS    = [env['amd_libs']])  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
374    conf.env.AppendUnique(CPPPATH = [env['blas_path']])  
375    conf.env.AppendUnique(LIBPATH = [env['blas_lib_path']])  for key in set(env_export):
376    conf.env.AppendUnique(LIBS    = [env['blas_libs']])      try:
377            env['ENV'][key] = os.environ[key]
378  if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0      except KeyError:
379  if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0          pass
   
 # Add UMFPACK to environment env if it was found  
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
 else:  
   conf.Finish()  
   
 ############ Add the compiler flags ############################  
   
 # Enable debug by choosing either cc_debug or cc_optim  
 if env['usedebug']:  
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
 else:  
   env.Append(CCFLAGS        = env['cc_optim'])  
   env.Append(CCFLAGS        = env['omp_optim'])  
380    
381  # Always use cc_flags  try:
382  env.Append(CCFLAGS      = env['cc_flags'])      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
383  env.Append(LIBS         = [env['omp_libs']])  except KeyError:
384        pass
385    
386  ############ MPI (optional) ####################################  if IS_OSX:
387      try:
388        env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
389      except KeyError:
390        pass
391    
 # Create a modified environment for MPI programs (identical to env if usempi=no)  
 env_mpi = clone_env(env)  
392    
393  # Start a new configure environment that reflects what we've already found  # these shouldn't be needed
394  conf = Configure(clone_env(env_mpi))  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
395    #    try:
396    #        env['ENV'][key] = os.environ[key]
397    #    except KeyError:
398    #        pass
399    
400  if env_mpi['usempi']:  try:
401    conf.env.AppendUnique(CPPPATH = [env_mpi['mpi_path']])      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
402    conf.env.AppendUnique(LIBPATH = [env_mpi['mpi_lib_path']])  except KeyError:
403    conf.env.AppendUnique(LIBS    = [env_mpi['mpi_libs']])      pass
404    
405  if env_mpi['usempi'] and not conf.CheckCHeader('mpi.h'): env_mpi['usempi'] = 0  ######################## Add some custom builders ############################
 if env_mpi['usempi'] and not conf.CheckFunc('MPI_Init'): env_mpi['usempi'] = 0  
406    
407  # Add MPI to environment env_mpi if it was found  if env['pythoncmd']=='python':
408  if env_mpi['usempi']:      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['PASO_MPI', 'MPI_NO_CPPBIND', env_mpi['MPICH_IGNORE_CXX_SEEK']])  
409  else:  else:
410    conf.Finish()      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
411    env.Append(BUILDERS = {'PyCompile' : py_builder});
412    
413  env['usempi'] = env_mpi['usempi']  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
414    env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
415    
416  ############ ParMETIS (optional) ###############################  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
417    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
418    
419  # Start a new configure environment that reflects what we've already found  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
420  conf = Configure(clone_env(env_mpi))  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
421    
422  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0  ############################ Dependency checks ###############################
423    
424  if env_mpi['useparmetis']:  ######## Compiler
425    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  env=checkCompiler(env)
   conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  
426    
427  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  ######## Python headers & library (required)
428  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0  env=checkPython(env)
429    
430  # Add ParMETIS to environment env_mpi if it was found  ######## boost & boost-python (required)
431  if env_mpi['useparmetis']:  env=checkBoost(env)
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  
 else:  
   conf.Finish()  
432    
433  env['useparmetis'] = env_mpi['useparmetis']  ######## numpy (required) and numpy headers (optional)
434    env=checkNumpy(env)
435    
436  ############ Summarize our environment #########################  ######## CppUnit (required for tests)
437    env=checkCppUnit(env)
438    
439  print ""  ######## optional python modules (sympy, pyproj)
440  print "Summary of configuration (see ./config.log for information)"  env=checkOptionalModules(env)
 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 ""  
   
 ############ Delete option-dependent files #####################  
   
 Execute(Delete(env['libinstall'] + "/Compiled.with.debug"))  
 Execute(Delete(env['libinstall'] + "/Compiled.with.mpi"))  
 Execute(Delete(env['libinstall'] + "/Compiled.with.openmp"))  
 if not env['usempi']: Execute(Delete(env['libinstall'] + "/pythonMPI"))  
441    
442  ############ Add some custom builders ##########################  ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
443    env=checkOptionalLibraries(env)
444    
445  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  ######## PDFLaTeX (for documentation)
446  env.Append(BUILDERS = {'PyCompile' : py_builder});  env=checkPDFLatex(env)
447    
448  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  # keep some of our install paths first in the list for the unit tests
449  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
450    env.PrependENVPath('PYTHONPATH', prefix)
451    env['ENV']['ESCRIPT_ROOT'] = prefix
452    
453  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  if not env['verbose']:
454  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});      env['CXXCOMSTR'] = "Compiling $TARGET"
455        env['SHCXXCOMSTR'] = "Compiling $TARGET"
456        env['ARCOMSTR'] = "Linking $TARGET"
457        env['LINKCOMSTR'] = "Linking $TARGET"
458        env['SHLINKCOMSTR'] = "Linking $TARGET"
459        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
460        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
461        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
462        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
463        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
464    
465    ####################### Configure the subdirectories #########################
466    
467    # remove obsolete files
468    if not env['usempi']:
469        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
470        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
471    
472    from grouptest import *
473    TestGroups=[]
474    
475    # keep an environment without warnings-as-errors
476    dodgy_env=env.Clone()
477    
478    # now add warnings-as-errors flags. This needs to be done after configuration
479    # because the scons test files have warnings in them
480    if ((fatalwarning != '') and (env['werror'])):
481        env.Append(CCFLAGS = fatalwarning)
482    
483    Export(
484      ['env',
485       'dodgy_env',
486       'IS_WINDOWS',
487       'TestGroups'
488      ]
489    )
490    
491  ############ Build the subdirectories ##########################  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
492    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
493    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
494    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
495    
496    #This will pull in the escriptcore/py_src and escriptcore/test
497    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
498    #env.SConscript(dirs = ['escript/test'], variant_dir='$BUILD_DIR/$PLATFORM/escript/test', duplicate=0)
499    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
500    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
501    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
502    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
503    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
504    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
505    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
506    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
507    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
508    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
509    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
510    
 Export(["env", "env_mpi", "clone_env"])  
511    
512  env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  ######################## Populate the buildvars file #########################
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
 env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  
 env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  
 env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 env.SConscript(dirs = ['scripts'], build_dir='build/$PLATFORM/scripts', duplicate=0)  
513    
514  ############ Remember what optimizations we used ###############  write_buildvars(env)
515    
516  remember_list = []  ################### Targets to build and install libraries ###################
517    
518  if env['usedebug']:  target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
519    remember_list += env.Command(env['libinstall'] + "/Compiled.with.debug", None, Touch('$TARGET'))  env.Alias('target_init', [target_init])
520    # delete buildvars upon cleanup
521    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
522    
523  if env['usempi']:  # The headers have to be installed prior to build in order to satisfy
524    remember_list += env.Command(env['libinstall'] + "/Compiled.with.mpi", None, Touch('$TARGET'))  # #include <paso/Common.h>
525    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
526    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
527    
528  if env['omp_optim'] != '':  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
529    remember_list += env.Command(env['libinstall'] + "/Compiled.with.openmp", None, Touch('$TARGET'))  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
530    
531  env.Alias('remember_options', remember_list)  env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
532    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
533    
534  ############ Targets to build and install libraries ############  env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
535    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
536    
537  target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
538  env.Alias('target_init', [target_init])  env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
539    
540  # 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'])
541  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'])  
542    
543  env.Alias('build_paso', ['target_install_paso_headers', 'target_paso_a'])  env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
544  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'])
545    
546  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'])
547  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'])
548    
549  env.Alias('build_finley', ['target_install_finley_headers', 'target_finley_so', 'target_finleycpp_so'])  env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
550  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'])
551    
552  # 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
553  build_all_list = []  build_all_list = []
554  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
555  build_all_list += ['build_paso']  build_all_list += ['build_paso']
556  build_all_list += ['build_escript']  build_all_list += ['build_escript']
557    build_all_list += ['build_pasowrap']
558    build_all_list += ['build_dudley']
559  build_all_list += ['build_finley']  build_all_list += ['build_finley']
560  if env['usempi']:       build_all_list += ['target_pythonMPI_exe']  build_all_list += ['build_ripley']
561  if not IS_WINDOWS_PLATFORM: build_all_list += ['target_finley_wrapper']  build_all_list += ['build_weipa']
562    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
563    if env['usempi']:   build_all_list += ['build_pythonMPI']
564    build_all_list += ['build_escriptconvert']
565  env.Alias('build_all', build_all_list)  env.Alias('build_all', build_all_list)
566    
567  install_all_list = []  install_all_list = []
# Line 586  install_all_list += ['target_init'] Line 569  install_all_list += ['target_init']
569  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
570  install_all_list += ['install_paso']  install_all_list += ['install_paso']
571  install_all_list += ['install_escript']  install_all_list += ['install_escript']
572    install_all_list += ['install_pasowrap']
573    install_all_list += ['install_dudley']
574  install_all_list += ['install_finley']  install_all_list += ['install_finley']
575  install_all_list += ['target_install_pyvisi_py']  install_all_list += ['install_ripley']
576  install_all_list += ['target_install_modellib_py']  install_all_list += ['install_weipa']
577  install_all_list += ['target_install_pycad_py']  if not IS_WINDOWS: install_all_list += ['install_escriptreader']
578  if env['usempi']:       install_all_list += ['target_install_pythonMPI_exe']  install_all_list += ['install_downunder_py']
579  if not IS_WINDOWS_PLATFORM: install_all_list += ['target_install_finley_wrapper']  install_all_list += ['install_modellib_py']
580  install_all_list += ['remember_options']  install_all_list += ['install_pycad_py']
581    if env['usempi']:   install_all_list += ['install_pythonMPI']
582    install_all_list += ['install_escriptconvert']
583  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
584    
585  # Default target is install  # Default target is install
586  env.Default('install_all')  env.Default('install_all')
587    
588  ############ 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'])  
589    
590  ############ Targets to build the documentation ################  if not env['cppunit']:
591        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
592        env.Alias('run_tests', test_msg)
593        env.Alias('build_tests', '')
594    env.Alias('run_tests', ['install_all'])
595    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
596    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
597    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
598    
599    ##################### Targets to build the documentation #####################
600    
601    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
602    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
603    env.Alias('docs', ['basedocs', 'sphinxdoc'])
604    env.Alias('release_prep', ['docs', 'install_all'])
605    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
606    
607    # The test scripts are always generated, this target allows us to
608    # generate the testscripts without doing a full build
609    env.Alias('testscripts',[])
610    
611    if not IS_WINDOWS:
612        generateTestScripts(env, TestGroups)
613    
614    
615    
616    ######################## Summarize our environment ###########################
617    def print_summary():
618        print("")
619        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
620        print("Escript/Finley revision %s"%global_revision)
621        print("  Install prefix:  %s"%env['prefix'])
622        print("          Python:  %s"%sysconfig.PREFIX)
623        print("           boost:  %s"%env['boost_prefix'])
624        if env['numpy_h']:
625            print("           numpy:  YES (with headers)")
626        else:
627            print("           numpy:  YES (without headers)")
628        if env['usempi']:
629            print("             MPI:  YES (flavour: %s)"%env['mpi'])
630        else:
631            print("             MPI:  DISABLED")
632        if env['uselapack']:
633            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
634        else:
635            print("          LAPACK:  DISABLED")
636        d_list=[]
637        e_list=[]
638        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit','vsl_random':
639            if env[i]: e_list.append(i)
640            else: d_list.append(i)
641        for i in e_list:
642            print("%16s:  YES"%i)
643        for i in d_list:
644            print("%16s:  DISABLED"%i)
645        if env['cppunit']:
646            print("         CppUnit:  FOUND")
647        else:
648            print("         CppUnit:  NOT FOUND")
649        if env['gmsh']=='m':
650            print("            gmsh:  FOUND, MPI-ENABLED")
651        elif env['gmsh']=='s':
652            print("            gmsh:  FOUND")
653        else:
654            print("            gmsh:  NOT FOUND")
655    
656        if ((fatalwarning != '') and (env['werror'])):
657            print("  Treating warnings as errors")
658        else:
659            print("  NOT treating warnings as errors")
660        print("")
661        for w in env['warnings']:
662            print("WARNING: %s"%w)
663    
664  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html'])  atexit.register(print_summary)
665    

Legend:
Removed from v.1756  
changed lines
  Added in v.4640

  ViewVC Help
Powered by ViewVC 1.1.26