/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.2358  
changed lines
  Added in v.4508

  ViewVC Help
Powered by ViewVC 1.1.26