/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.720  
changed lines
  Added in v.4045

  ViewVC Help
Powered by ViewVC 1.1.26