/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.691  
changed lines
  Added in v.4173

  ViewVC Help
Powered by ViewVC 1.1.26