/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.2297  
changed lines
  Added in v.5939

  ViewVC Help
Powered by ViewVC 1.1.26