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

Diff of /branches/inv2jf/SConstruct

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

revision 1708 by ksteube, Thu Aug 14 22:42:24 2008 UTC revision 4508 by jfenwick, Wed Jul 24 04:23:22 2013 UTC
# Line 1  Line 1 
1  #         Copyright 2006 by ACcESS MNRF  ##############################################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2013 by University of Queensland
4  #       Primary Business: Queensland, Australia  # http://www.uq.edu.au
5  #  Licensed under the Open Software License version 3.0  #
6  #     http://www.opensource.org/licenses/osl-3.0.php  # Primary Business: Queensland, Australia
7    # Licensed under the Open Software License version 3.0
8  EnsureSConsVersion(0,96,91)  # http://www.opensource.org/licenses/osl-3.0.php
9  EnsurePythonVersion(2,3)  #
10    # Development until 2012 by Earth Systems Science Computational Center (ESSCC)
11  import sys, os, re, socket  # Development since 2012 by School of Earth Sciences
12    #
13  # Add our extensions  ##############################################################################
 if os.path.isdir('scons'): sys.path.append('scons')  
 import scons_extensions  
   
 # Use /usr/lib64 if available, else /usr/lib  
 usr_lib = '/usr/lib'  
 if os.path.isfile('/usr/lib64/libc.so'): usr_lib = '/usr/lib64'  
14    
15  # The string python2.4 or python2.5  EnsureSConsVersion(0,98,1)
16  python_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])  EnsurePythonVersion(2,5)
17    
18  # MS Windows support, many thanks to PH  import atexit, sys, os, platform, re
19  IS_WINDOWS_PLATFORM = (os.name== "nt")  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  prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  # MS Windows support, many thanks to PH
28    IS_WINDOWS = (os.name == 'nt')
29    
30  # Read configuration options from file scons/<hostname>_options.py  ########################## Determine options file ############################
31  hostname = re.sub("[^0-9a-zA-Z]", "_", socket.gethostname().split('.')[0])  # 1. command line
32  tmp = os.path.join("scons",hostname+"_options.py")  # 2. scons/<hostname>_options.py
33  options_file = ARGUMENTS.get('options_file', tmp)  # 3. name as part of a cluster
34  if not os.path.isfile(options_file): options_file = False  options_file=ARGUMENTS.get('options_file', None)
35  else: print "Options file is", options_file  if not options_file:
36        ext_dir = os.path.join(os.getcwd(), 'scons')
37  # Load options file and command-line arguments      hostname = platform.node().split('.')[0]
38  opts = Options(options_file, ARGUMENTS)      for name in hostname, effectiveName(hostname):
39            mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
40  ############ Load build options ################################          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
41            if os.path.isfile(options_file): break
42  opts.AddOptions(  
43  # Where to install esys stuff  if not os.path.isfile(options_file):
44    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),      print("\nWARNING:\nOptions file %s" % options_file)
45    ('incinstall', 'where the esys headers will be installed',             os.path.join(Dir('#.').abspath,'include')),      print("not found! Default options will be used which is most likely suboptimal.")
46    ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),      print("We recommend that you copy one of the TEMPLATE files in the scons/")
47    ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),      print("subdirectory and customize it to your needs.\n")
48  # Compilation options      options_file = None
49    BoolOption('dodebug', 'For backwards compatibility', 'no'),  
50    BoolOption('usedebug', 'Do you want a debug build?', 'no'),  ############################### Build options ################################
51    BoolOption('usevtk', 'Do you want to use VTK?', 'yes'),  
52    ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  default_prefix='/usr'
53    # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
54    ('cc_flags', 'C compiler flags to use', '-DEFAULT_1'),  lapack_flavours=('none', 'clapack', 'mkl')
55    ('cc_optim', 'C compiler optimization flags to use', '-DEFAULT_2'),  
56    ('cc_debug', 'C compiler debug flags to use', '-DEFAULT_3'),  vars = Variables(options_file, ARGUMENTS)
57    ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),  vars.AddVariables(
58    ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
59    ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
60    ('cc_extra', 'Extra C/C++ flags', ''),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
61    ('sys_libs', 'System libraries to link with', []),    BoolVariable('verbose', 'Output full compile/link lines', False),
62    ('ar_flags', 'Static library archiver flags to use', ''),  # Compiler/Linker options
63    BoolOption('useopenmp', 'Compile parallel version using OpenMP', 'yes'),    ('cc', 'Path to C compiler', 'default'),
64    BoolOption('usepedantic', 'Compile with -pedantic if using gcc', 'yes'),    ('cxx', 'Path to C++ compiler', 'default'),
65  # Python    ('cc_flags', 'Base C/C++ compiler flags', 'default'),
66    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),    ('cc_optim', 'Additional C/C++ flags for a non-debug build', 'default'),
67    ('python_lib_path', 'Path to Python libs', usr_lib),    ('cc_debug', 'Additional C/C++ flags for a debug build', 'default'),
68    ('python_libs', 'Python libraries to link with', [python_version]),    ('cc_extra', 'Extra C compiler flags', ''),
69    ('python_cmd', 'Python command', 'python'),    ('cxx_extra', 'Extra C++ compiler flags', ''),
70  # Boost    ('ld_extra', 'Extra linker flags', ''),
71    ('boost_path', 'Path to Boost includes', '/usr/include'),    BoolVariable('werror','Treat compiler warnings as errors', True),
72    ('boost_lib_path', 'Path to Boost libs', usr_lib),    BoolVariable('debug', 'Compile with debug flags', False),
73    ('boost_libs', 'Boost libraries to link with', ['boost_python']),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74  # NetCDF    ('omp_flags', 'OpenMP compiler flags', 'default'),
75    BoolOption('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),  # Mandatory libraries
77    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79  # MPI  # Mandatory for tests
80    BoolOption('useMPI', 'For backwards compatibility', 'no'),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81    BoolOption('usempi', 'Compile parallel version using MPI', 'no'),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82    ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),  # Optional libraries and options
83    ('mpi_path', 'Path to MPI includes', '/usr/include'),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84    ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85    ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86    ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', ['mpich' , 'pthread', 'rt']),    BoolVariable('netcdf', 'Enable netCDF file support', False),
87  # ParMETIS    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88    BoolOption('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89    ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90    ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91    ('parmetis_libs', 'ParMETIS library to link with', ['parmetis', 'metis']),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92  # PAPI    BoolVariable('papi', 'Enable PAPI', False),
93    BoolOption('usepapi', 'switch on/off the usage of PAPI', 'no'),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
   ('papi_path', 'Path to PAPI includes', '/usr/include'),  
   ('papi_lib_path', 'Path to PAPI libs', usr_lib),  
94    ('papi_libs', 'PAPI libraries to link with', ['papi']),    ('papi_libs', 'PAPI libraries to link with', ['papi']),
95    BoolOption('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', False),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
96  # MKL    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
97    BoolOption('usemkl', 'switch on/off the usage of MKL', 'no'),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
98    ('mkl_path', 'Path to MKL includes', '/sw/sdev/cmkl/10.0.2.18/include'),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
99    ('mkl_lib_path', 'Path to MKL libs', '/sw/sdev/cmkl/10.0.2.18/lib/em64t'),    BoolVariable('umfpack', 'Enable UMFPACK', False),
100    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver', 'mkl_em64t', 'guide', 'pthread']),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
101  # UMFPACK    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
102    BoolOption('useumfpack', 'switch on/off the usage of UMFPACK', 'no'),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
103    ('ufc_path', 'Path to UFconfig includes', '/usr/include/suitesparse'),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
104    ('umf_path', 'Path to UMFPACK includes', '/usr/include/suitesparse'),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
105    ('umf_lib_path', 'Path to UMFPACK libs', usr_lib),    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
106    ('umf_libs', 'UMFPACK libraries to link with', ['umfpack']),    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
107  # AMD (used by UMFPACK)    ('lapack_libs', 'LAPACK libraries to link with', []),
108    ('amd_path', 'Path to AMD includes', '/usr/include/suitesparse'),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
109    ('amd_lib_path', 'Path to AMD libs', usr_lib),    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
110    ('amd_libs', 'AMD libraries to link with', ['amd']),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
111  # BLAS (used by UMFPACK)    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
112    ('blas_path', 'Path to BLAS includes', '/usr/include/suitesparse'),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
113    ('blas_lib_path', 'Path to BLAS libs', usr_lib),    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
114    ('blas_libs', 'BLAS libraries to link with', ['blas'])    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
115    # Advanced settings
116      #dudley_assemble_flags = -funroll-loops      to actually do something
117      ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
118      # To enable passing function pointers through python
119      BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
120      # An option for specifying the compiler tools (see windows branch)
121      ('tools_names', 'Compiler tools to use', ['default']),
122      ('env_export', 'Environment variables to be passed to tools',[]),
123      EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
124      EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
125      # finer control over library building, intel aggressive global optimisation
126      # works with dynamic libraries on windows.
127      ('build_shared', 'Build dynamic libraries only', False),
128      ('sys_libs', 'Extra libraries to link with', []),
129      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
130      ('SVN_VERSION', 'Do not use from options file', -2),
131      ('pythoncmd', 'which python to compile with','python'),
132      ('usepython3', 'Is this a python3 build? (experimental)', False),
133      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
134      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
135      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
136      BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
137  )  )
138    
139  ############ Specify which compilers to use ####################  ##################### Create environment and help text #######################
140    
141  # intelc uses regular expressions improperly and emits a warning about  # Intel's compiler uses regular expressions improperly and emits a warning
142  # failing to find the compilers.  This warning can be safely ignored.  # about failing to find the compilers. This warning can be safely ignored.
143    
144  if IS_WINDOWS_PLATFORM:  # PATH is needed so the compiler, linker and tools are found if they are not
145        env = Environment(tools = ['default', 'msvc'], options = opts)  # in default locations.
146    env = Environment(tools = ['default'], options = vars,
147                      ENV = {'PATH': os.environ['PATH']})
148    
149    # 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  if env["CC"] == "icc":  if env['vsl_random']:
351    # Intel compilers      env.Append(CPPDEFINES = ['MKLRANDOM'])
352    cc_flags      = "-fPIC -ansi -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"  
353    cc_optim      = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias"  env['IS_WINDOWS']=IS_WINDOWS
354    cc_debug      = "-g -O0 -UDOASSERT -DDOPROF -DBOUNDS_CHECK"  
355    omp_optim     = "-openmp -openmp_report0"  ###################### Copy required environment vars ########################
356    omp_debug     = "-openmp -openmp_report0"  
357    omp_libs      = ['guide', 'pthread']  # Windows doesn't use LD_LIBRARY_PATH but PATH instead
358    pedantic      = ""  if IS_WINDOWS:
359  elif env["CC"] == "gcc":      LD_LIBRARY_PATH_KEY='PATH'
360    # GNU C on any system      env['ENV']['LD_LIBRARY_PATH']=''
361    cc_flags      = "-fPIC -ansi -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER"  else:
362    cc_optim      = "-O3"      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
363    cc_debug      = "-g -O0 -UDOASSERT -DDOPROF -DBOUNDS_CHECK"  
364    omp_optim     = ""  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
365    omp_debug     = ""  
366    omp_libs      = []  # the following env variables are exported for the unit tests
367    pedantic      = "-pedantic-errors -Wno-long-long"  
368  elif env["CC"] == "cl":  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
369    # Microsoft Visual C on Windows      try:
370    cc_flags      = "/FD /EHsc /GR /wd4068 -D_USE_MATH_DEFINES -DDLL_NETCDF"          env['ENV'][key] = os.environ[key]
371    cc_optim      = "/O2 /Op /MT /W3"      except KeyError:
372    cc_debug      = "/Od /RTC1 /MTd /ZI -DBOUNDS_CHECK"          env['ENV'][key] = 1
373    omp_optim     = ""  
374    omp_debug     = ""  env_export=env['env_export']
375    omp_libs      = []  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
376    pedantic      = ""  
377    for key in set(env_export):
378  # If not specified in hostname_options.py then set them here      try:
379  if env["cc_flags"]  == "-DEFAULT_1": env['cc_flags'] = cc_flags          env['ENV'][key] = os.environ[key]
380  if env["cc_optim"]  == "-DEFAULT_2": env['cc_optim'] = cc_optim      except KeyError:
381  if env["cc_debug"]  == "-DEFAULT_3": env['cc_debug'] = cc_debug          pass
 if env["omp_optim"] == "-DEFAULT_4": env['omp_optim'] = omp_optim  
 if env["omp_debug"] == "-DEFAULT_5": env['omp_debug'] = omp_debug  
 if env["omp_libs"]  == "-DEFAULT_6": env['omp_libs'] = omp_libs  
   
 # OpenMP is disabled if useopenmp=no or both variables omp_optim and omp_debug are empty  
 if not env["useopenmp"]:  
   env['omp_optim'] = ""  
   env['omp_debug'] = ""  
   env['omp_libs'] = []  
   
 if env['omp_optim'] == "" and env['omp_debug'] == "": env["useopenmp"] = 0  
   
 ############ Copy environment variables into scons env #########  
   
 try: env['ENV']['OMP_NUM_THREADS'] = os.environ['OMP_NUM_THREADS']  
 except KeyError: env['ENV']['OMP_NUM_THREADS'] = 1  
   
 try: env['ENV']['PATH'] = os.environ['PATH']  
 except KeyError: pass  
   
 try: env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']  
 except KeyError: pass  
   
 try: env['ENV']['C_INCLUDE_PATH'] = os.environ['C_INCLUDE_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['CPLUS_INCLUDE_PATH'] = os.environ['CPLUS_INCLUDE_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['LIBRARY_PATH'] = os.environ['LIBRARY_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['DISPLAY'] = os.environ['DISPLAY']  
 except KeyError: pass  
   
 try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  
 except KeyError: pass  
   
 try: env['ENV']['HOME'] = os.environ['HOME']  
 except KeyError: pass  
   
 # Configure for test suite  
 env.PrependENVPath('PYTHONPATH', prefix)  
 env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 ############ Set up paths for Configure() ######################  
   
 # Make a copy of an environment  
 # Use env.Clone if available, but fall back on env.Copy for older version of scons  
 def clone_env(env):  
   if 'Clone' in dir(env): return env.Clone()    # scons-0.98  
   else:                   return env.Copy() # scons-0.96  
   
 # Add cc option -I<Escript>/trunk/include  
 env.Append(CPPPATH      = [Dir('include')])  
   
 # Add cc option -L<Escript>/trunk/lib  
 env.Append(LIBPATH      = [Dir('lib')])  
   
 env.Append(CPPDEFINES = ['ESCRIPT_EXPORTS', 'FINLEY_EXPORTS'])  
   
 if env['cc_extra'] != '': env.Append(CCFLAGS = env['cc_extra'])  
   
 if env['usepedantic']: env.Append(CCFLAGS = pedantic)  
   
 # MS Windows  
 if IS_WINDOWS_PLATFORM:  
   env.PrependENVPath('PATH',    [env['boost_lib_path']])  
   env.PrependENVPath('PATH',    [env['libinstall']])  
   if env['usenetcdf']:  
     env.PrependENVPath('PATH',  [env['netCDF_lib_path']])  
   
 env.Append(ARFLAGS = env['ar_flags'])  
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
387  except:  
388     global_revision="-1"  # these shouldn't be needed
389  if global_revision == "": global_revision="-2"  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
390  env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  #    try:
391    #        env['ENV'][key] = os.environ[key]
392  ############ numarray (required) ###############################  #    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 not conf.CheckFunc('gethostname'):  
   env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])  
   
 ############ python libraries (required) #######################  
   
 conf.env.AppendUnique(CPPPATH       = [env['python_path']])  
 conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
   
 if not conf.CheckCHeader('Python.h'):  
   print "Cannot find python include files (tried 'Python.h' in directory %s)" % (env['python_path'])  
   sys.exit(1)  
 if not conf.CheckFunc('Py_Main'):  
   print "Cannot find python library method Py_Main (tried lib %s in directory %s)" % (env['python_libs'], env['python_lib_path'])  
   sys.exit(1)  
   
 ############ boost (required) ##################################  
   
 conf.env.AppendUnique(CPPPATH       = [env['boost_path']])  
 conf.env.AppendUnique(LIBPATH       = [env['boost_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['boost_libs']])  
   
 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']])  
   
 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))  
399    
400  if env['usepapi']:  ######################## Add some custom builders ############################
   conf.env.AppendUnique(CPPPATH = [env['papi_path']])  
   conf.env.AppendUnique(LIBPATH = [env['papi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['papi_libs']])  
401    
402  if env['usepapi'] and not conf.CheckCHeader('papi.h'): env['usepapi'] = 0  if env['pythoncmd']=='python':
403  if env['usepapi'] and not conf.CheckFunc('PAPI_start_counters'): env['usepapi'] = 0      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
   
 # 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']])  
   
 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'])  
404  else:  else:
405    conf.Finish()      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
406    env.Append(BUILDERS = {'PyCompile' : py_builder});
 ############ 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']])  
   
 if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0  
 if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0  
   
 # Add UMFPACK to environment env if it was found  
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
 else:  
   conf.Finish()  
   
 ############ Add the compiler flags ############################  
   
 # Enable debug by choosing either cc_debug or cc_optim  
 if env['usedebug']:  
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
 else:  
   env.Append(CCFLAGS        = env['cc_optim'])  
   env.Append(CCFLAGS        = env['omp_optim'])  
   
 # Always use cc_flags  
 env.Append(CCFLAGS      = env['cc_flags'])  
 env.Append(LIBS         = [env['omp_libs']])  
   
 ############ MPI (optional) ####################################  
   
 # Create a modified environment for MPI programs (identical to env if usempi=no)  
 env_mpi = clone_env(env)  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env_mpi))  
   
 if env_mpi['usempi']:  
   conf.env.AppendUnique(CPPPATH = [env_mpi['mpi_path']])  
   conf.env.AppendUnique(LIBPATH = [env_mpi['mpi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['mpi_libs']])  
   
 if env_mpi['usempi'] and not conf.CheckCHeader('mpi.h'): env_mpi['usempi'] = 0  
 if env_mpi['usempi'] and not conf.CheckFunc('MPI_Init'): env_mpi['usempi'] = 0  
   
 # Add MPI to environment env_mpi if it was found  
 if env_mpi['usempi']:  
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['PASO_MPI', 'MPI_NO_CPPBIND', env_mpi['MPICH_IGNORE_CXX_SEEK']])  
 else:  
   conf.Finish()  
407    
408  env['usempi'] = env_mpi['usempi']  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
409    env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
410    
411  ############ ParMETIS (optional) ###############################  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
412    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
413    
414  # Start a new configure environment that reflects what we've already found  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
415  conf = Configure(clone_env(env_mpi))  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
416    
417  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0  ############################ Dependency checks ###############################
418    
419  if env_mpi['useparmetis']:  ######## Compiler
420    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  env=checkCompiler(env)
   conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  
421    
422  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  ######## Python headers & library (required)
423  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0  env=checkPython(env)
424    
425  # Add ParMETIS to environment env_mpi if it was found  ######## boost & boost-python (required)
426  if env_mpi['useparmetis']:  env=checkBoost(env)
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  
 else:  
   conf.Finish()  
427    
428  env['useparmetis'] = env_mpi['useparmetis']  ######## numpy (required) and numpy headers (optional)
429    env=checkNumpy(env)
430    
431  ############ Summarize our environment #########################  ######## CppUnit (required for tests)
432    env=checkCppUnit(env)
433    
434  print ""  ######## optional python modules (sympy, pyproj)
435  print "Summary of configuration (see ./config.log for information)"  env=checkOptionalModules(env)
 print " Using python libraries"  
 print " Using numarray"  
 print " Using boost"  
 if env['usenetcdf']: print "    Using NetCDF"  
 else: print "   Not using NetCDF"  
 if env['usevtk']: print "   Using VTK"  
 else: print "   Not using VTK"  
 if env['usemkl']: print "   Using MKL"  
 else: print "   Not using MKL"  
 if env['useumfpack']: print "   Using UMFPACK"  
 else: print "   Not using UMFPACK"  
 if env['useopenmp']: print "    Using OpenMP"  
 else: print "   Not using OpenMP"  
 if env['usempi']: print "   Using MPI"  
 else: print "   Not using MPI"  
 if env['useparmetis']: print "  Using ParMETIS"  
 else: print "   Not using ParMETIS (requires MPI)"  
 if env['usepapi']: print "  Using PAPI"  
 else: print "   Not using PAPI"  
 if env['usedebug']: print " Compiling for debug"  
 else: print "   Not compiling for debug"  
 print " Installing in", prefix  
 print ""  
436    
437  ############ Add some custom builders ##########################  ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
438    env=checkOptionalLibraries(env)
439    
440  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  ######## PDFLaTeX (for documentation)
441  env.Append(BUILDERS = {'PyCompile' : py_builder});  env=checkPDFLatex(env)
442    
443  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  # keep some of our install paths first in the list for the unit tests
444  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
445    env.PrependENVPath('PYTHONPATH', prefix)
446    env['ENV']['ESCRIPT_ROOT'] = prefix
447    
448  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  if not env['verbose']:
449  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});      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 *
470    TestGroups=[]
471    
472    # keep an environment without warnings-as-errors
473    dodgy_env=env.Clone()
474    
475    # 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    Export(
481      ['env',
482       'dodgy_env',
483       'IS_WINDOWS',
484       'TestGroups'
485      ]
486    )
487    
488  ############ Build the desired subdirectories ##################  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
489    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    
 Export(["env", "env_mpi", "clone_env"])  
508    
509  env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  ######################## Populate the buildvars file #########################
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
 env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  
 env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  
 env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
510    
511  ############ Remember what optimizations we used ###############  write_buildvars(env)
512    
513  remember_list = []  ################### Targets to build and install libraries ###################
514    
515  if env['usedebug']:  target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
516    remember_list += env.Command(env['libinstall'] + "/Compiled.with.debug", None, Touch('$TARGET'))  env.Alias('target_init', [target_init])
517  else:  # delete buildvars upon cleanup
518    remember_list += env.Command(env['libinstall'] + "/Compiled.with.debug", None, Delete('$TARGET'))  env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
519    
520  if env['usempi']:  # The headers have to be installed prior to build in order to satisfy
521    remember_list += env.Command(env['libinstall'] + "/Compiled.with.mpi", None, Touch('$TARGET'))  # #include <paso/Common.h>
522  else:  env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
523    remember_list += env.Command(env['libinstall'] + "/Compiled.with.mpi", None, Delete('$TARGET'))  env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
524    
525  if env['omp_optim'] != '':  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
526    remember_list += env.Command(env['libinstall'] + "/Compiled.with.openmp", None, Touch('$TARGET'))  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
 else:  
   remember_list += env.Command(env['libinstall'] + "/Compiled.with.openmp", None, Delete('$TARGET'))  
527    
528  env.Alias('remember_options', remember_list)  env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
529    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
530    
531  ############ Targets to build and install libraries ############  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  target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
535  env.Alias('target_init', [target_init])  env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
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    build_all_list += ['build_weipa']
559    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 580  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  install_all_list += ['remember_options']  install_all_list += ['install_modellib_py']
577    install_all_list += ['install_pycad_py']
578    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 ###################
   
 env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  
 env.Alias('install_cppunittest', ['build_cppunittest', 'target_install_cppunittest_a'])  
 env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])  
 env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])  
586    
587  ############ Targets to build the documentation ################  if not env['cppunit']:
588        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C/C++ unit tests, CppUnit not found!";exit 1')
589        env.Alias('run_tests', test_msg)
590        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'])
594    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
595    
596    ##################### Targets to build the documentation #####################
597    
598    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  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html'])  atexit.register(print_summary)
662    

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

  ViewVC Help
Powered by ViewVC 1.1.26