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

Diff of /branches/diaplayground/SConstruct

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

revision 898 by gross, Sun Nov 12 23:56:26 2006 UTC revision 4046 by caltinay, Tue Oct 30 04:43:25 2012 UTC
# Line 1  Line 1 
1  #          Copyright 2006 by ACcESS MNRF  ##############################################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2012 by University of Queensland
4  #       Primary Business: Queensland, Australia  # http://www.uq.edu.au
 #  Licensed under the Open Software License version 3.0  
 #     http://www.opensource.org/licenses/osl-3.0.php  
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)
 # all of this section just intialises default environments and helper  
 # scripts. You shouldn't need to modify this section.  
 EnsureSConsVersion(0,96,91)  
 EnsurePythonVersion(2,3)  
   
 # import tools:  
 import glob  
 import sys, os  
 import socket  
 # Add our extensions  
 if sys.path.count('scons')==0: sys.path.append('scons')  
 import scons_extensions  
   
 # check if UMFPACK is installed on the system:  
 if os.path.isdir('/opt/UMFPACK/Include') and os.path.isdir('/opt/UMFPACK/Lib'):  
    umf_path_default='/opt/UMFPACK/Include'  
    umf_lib_path_default='/opt/UMFPACK/Lib'  
    umf_libs_default=['umfpack']  
 else:  
    umf_path_default=None  
    umf_lib_path_default=None  
    umf_libs_default=None  
   
 if os.path.isdir('/opt/AMD/Include') and os.path.isdir('/opt/AMD/Lib'):  
    amd_path_default='/opt/AMD/Include'  
    amd_lib_path_default='/opt/AMD/Lib'  
    amd_libs_default=['amd']  
 else:  
    amd_path_default=None  
    amd_lib_path_default=None  
    amd_libs_default=None  
   
 if os.path.isdir('/opt/UFconfig'):  
    ufc_path_default='/opt/UFconfig'  
 else:  
    ufc_path_default=None  
   
 # Default options and options help text  
 # These are defaults and can be overridden using command line arguments or an options file.  
 # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used  
 # DO NOT CHANGE THEM HERE  
 if ARGUMENTS.get('options_file',0):  
    options_file = ARGUMENTS.get('options_file',0)  
 else:  
    from string import ascii_letters,digits  
    hostname=""  
    for s in socket.gethostname().split('.')[0]:  
       if s in ascii_letters+digits:  
          hostname+=s  
       else:  
          hostname+="_"  
    options_file = "scons/"+hostname+"_options.py"  
   
 opts = Options(options_file, ARGUMENTS)  
 opts.AddOptions(  
 # Where to install esys stuff  
   ('incinstall', 'where the esys headers will be installed', Dir('#.').abspath+'/include'),  
   ('libinstall', 'where the esys libraries will be installed', Dir('#.').abspath+'/lib'),  
   ('pyinstall', 'where the esys python modules will be installed', Dir('#.').abspath),  
   ('src_zipfile', 'the source zip file will be installed.', Dir('#.').abspath+"/release/escript_src.zip"),  
   ('test_zipfile', 'the test zip file will be installed.', Dir('#.').abspath+"/release/escript_tests.zip"),  
   ('src_tarfile', 'the source tar file will be installed.', Dir('#.').abspath+"/release/escript_src.tar.gz"),  
   ('test_tarfile', 'the test tar file will be installed.', Dir('#.').abspath+"/release/escript_tests.tar.gz"),  
   ('examples_tarfile', 'the examples tar file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.tar.gz"),  
   ('examples_zipfile', 'the examples zip file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.zip"),  
   ('guide_pdf', 'name of the user guide in pdf format', Dir('#.').abspath+"/release/doc/user/guide.pdf"),  
   ('api_epydoc', 'name of the epydoc api docs directory',Dir('#.').abspath+"/release/doc/epydoc"),  
   ('guide_html', 'name of the directory for user guide in html format', Dir('#.').abspath+"/release/doc/user/html"),  
 # Compilation options  
   BoolOption('dodebug', 'Do you want a debug build?', 'no'),  
   ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/hostname_options.py)", options_file),  
   ('cc_defines','C/C++ defines to use', None),  
   ('cc_flags','C compiler flags to use (Release build)', '-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas'),  
   ('cc_flags_debug', 'C compiler flags to use (Debug build)', '-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas'),  
   ('cxx_flags', 'C++ compiler flags to use (Release build)', '--no-warn -ansi'),  
   ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', '--no-warn -ansi -DDOASSERT -DDOPROF'),  
   ('cc_flags_MPI','C compiler flags to use (Release MPI build)', '-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias -fno-alias -c99 -w1 -fpic -wd161'),  
   ('cc_flags_debug_MPI', 'C compiler flags to use (Debug MPI build)', '-g -O0 -c99 -w1 -fpic -wd161'),  
   ('cxx_flags_MPI', 'C++ compiler flags to use (Release MPI build)', '-ansi -wd1563 -wd161'),  
   ('cxx_flags_debug_MPI', 'C++ compiler flags to use (Debug MPI build)', '-ansi -DDOASSERT -DDOPROF -wd1563 -wd161'),  
   ('ar_flags', 'Static library archiver flags to use', None),  
   ('sys_libs', 'System libraries to link with', None),  
   ('tar_flags','flags for zip files','-c -z'),  
 # MKL  
   PathOption('mkl_path', 'Path to MKL includes', None),  
   PathOption('mkl_lib_path', 'Path to MKL libs', None),  
   ('mkl_libs', 'MKL libraries to link with', None),  
 # SCSL  
   PathOption('scsl_path', 'Path to SCSL includes', None),  
   PathOption('scsl_lib_path', 'Path to SCSL libs', None),  
   ('scsl_libs', 'SCSL libraries to link with', None),  
   ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),  
 # UMFPACK  
   PathOption('ufc_path', 'Path to UFconfig includes', ufc_path_default),  
   PathOption('umf_path', 'Path to UMFPACK includes', umf_path_default),  
   PathOption('umf_lib_path', 'Path to UMFPACK libs', umf_lib_path_default),  
   ('umf_libs', 'UMFPACK libraries to link with', umf_libs_default),  
 # AMD (used by UMFPACK)  
   PathOption('amd_path', 'Path to AMD includes', amd_path_default),  
   PathOption('amd_lib_path', 'Path to AMD libs', amd_lib_path_default),  
   ('amd_libs', 'AMD libraries to link with', amd_libs_default),  
 # BLAS  
   PathOption('blas_path', 'Path to BLAS includes', None),  
   PathOption('blas_lib_path', 'Path to BLAS libs', None),  
   ('blas_libs', 'BLAS libraries to link with', None),  
 # Python  
 # locations of include files for python  
   PathOption('python_path', 'Path to Python includes', '/usr/include/python%s.%s'%(sys.version_info[0],sys.version_info[1])),  
   PathOption('python_lib_path', 'Path to Python libs', '/usr/lib'),  
   ('python_lib', 'Python libraries to link with', ["python%s.%s"%(sys.version_info[0],sys.version_info[1]),]),  
 # Boost  
   PathOption('boost_path', 'Path to Boost includes', '/usr/include'),  
   PathOption('boost_lib_path', 'Path to Boost libs', '/usr/lib'),  
   ('boost_lib', 'Boost libraries to link with', ['boost_python',]),  
 # Doc building  
 #  PathOption('doxygen_path', 'Path to Doxygen executable', None),  
 #  PathOption('epydoc_path', 'Path to Epydoc executable', None),  
 # PAPI  
   PathOption('papi_path', 'Path to PAPI includes', None),  
   PathOption('papi_lib_path', 'Path to PAPI libs', None),  
   ('papi_libs', 'PAPI libraries to link with', None),  
 # MPI  
   BoolOption('useMPI', 'Compile parallel version using MPI', 'no'),  
 )  
   
 # Initialise Scons Build Environment  
 # 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 = ''  
17    
18  # Note: On the Altix the intel compilers are not automatically  import sys, os, platform, re
19  # detected by scons intelc.py script. The Altix has a different directory  from distutils import sysconfig
20  # path and in some locations the "modules" facility is used to support  from site_init import *
21  # multiple compiler versions. This forces the need to import the users PATH  from subprocess import PIPE, Popen
22  # environment which isn't the "scons way"  
23  # 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)  # Version number to check for in options file. Increment when new features are
24  # FIXME: Perhaps a modification to intelc.py will allow better support for ia64 on altix  # added or existing options changed.
25    REQUIRED_OPTS_VERSION=201
26  if os.name != "nt" and os.uname()[4]=='ia64':  
27     env = Environment(ENV = {'PATH':path}, tools = ['default', 'intelc'], options = opts)  # MS Windows support, many thanks to PH
28     env['ENV']['PATH'] = path  IS_WINDOWS = (os.name == 'nt')
29     env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
30     env['ENV']['PYTHONPATH'] = python_path  ########################## Determine options file ############################
31     if env['CXX'] == 'icpc':  # 1. command line
32        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  # 2. scons/<hostname>_options.py
33  elif os.name == "nt":  # 3. name as part of a cluster
34     env = Environment(tools = ['default', 'intelc'], options = opts)  options_file=ARGUMENTS.get('options_file', None)
35     env['ENV']['PYTHONPATH'] = python_path  if not options_file:
36  else:      ext_dir = os.path.join(os.getcwd(), 'scons')
37     env = Environment(tools = ['default'], options = opts)      hostname = platform.node().split('.')[0]
38     env['ENV']['PATH'] = path      for name in hostname, effectiveName(hostname):
39     env['ENV']['LD_LIBRARY_PATH'] = ld_library_path          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
40     env['ENV']['PYTHONPATH'] = python_path          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
41            if os.path.isfile(options_file): break
42    
43    if not os.path.isfile(options_file):
44        print("\nWARNING:\nOptions file %s" % options_file)
45        print("not found! Default options will be used which is most likely suboptimal.")
46        print("It is recommended that you copy one of the TEMPLATE files in the scons/")
47        print("subdirectory and customize it to your needs.\n")
48        options_file = None
49    
50    ############################### Build options ################################
51    
52    default_prefix='/usr'
53    mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
54    lapack_flavours=('none', 'clapack', 'mkl')
55    
56    vars = Variables(options_file, ARGUMENTS)
57    vars.AddVariables(
58      PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
59      PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
60      PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
61      BoolVariable('verbose', 'Output full compile/link lines', False),
62    # Compiler/Linker options
63      ('cc', 'Path to C compiler', 'default'),
64      ('cxx', 'Path to C++ compiler', 'default'),
65      ('cc_flags', 'Base C/C++ compiler flags', 'default'),
66      ('cc_optim', 'Additional C/C++ flags for a non-debug build', 'default'),
67      ('cc_debug', 'Additional C/C++ flags for a debug build', 'default'),
68      ('cc_extra', 'Extra C compiler flags', ''),
69      ('cxx_extra', 'Extra C++ compiler flags', ''),
70      ('ld_extra', 'Extra linker flags', ''),
71      BoolVariable('werror','Treat compiler warnings as errors', True),
72      BoolVariable('debug', 'Compile with debug flags', False),
73      BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74      ('omp_flags', 'OpenMP compiler flags', 'default'),
75      ('omp_ldflags', 'OpenMP linker flags', 'default'),
76    # Mandatory libraries
77      ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78      ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79    # Mandatory for tests
80      ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81      ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82    # Optional libraries and options
83      EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84      ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85      ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86      BoolVariable('netcdf', 'Enable netCDF file support', False),
87      ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88      ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89      BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90      ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91      ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92      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  # Setup help for options  ##################### Create environment and help text #######################
 Help(opts.GenerateHelpText(env))  
140    
141  # Add some customer builders  # Intel's compiler uses regular expressions improperly and emits a warning
142  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  # about failing to find the compilers. This warning can be safely ignored.
 env.Append(BUILDERS = {'PyCompile' : py_builder});  
143    
144  if env['PLATFORM'] == "win32":  # PATH is needed so the compiler, linker and tools are found if they are not
145     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  # 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        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 debug/non-debug compiler flags
301    if env['debug']:
302        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    # add system libraries
310    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  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)      global_revision = re.sub(':.*', '', global_revision)
323  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});      global_revision = re.sub('[^0-9]', '', global_revision)
324        if global_revision == '': global_revision='-2'
325  # Convert the options which are held in environment variable into python variables for ease of handling and configure compilation options    except:
326  try:      global_revision = '-1'
327     incinstall = env['incinstall']  env['svn_revision']=global_revision
328     env.Append(CPPPATH = [incinstall,])  env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
329  except KeyError:  
330     incinstall = None  if IS_WINDOWS:
331  try:      if not env['build_shared']:
332     libinstall = env['libinstall']          env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
333     env.Append(LIBPATH = [libinstall,])          env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
334     env.PrependENVPath('LD_LIBRARY_PATH', libinstall)  
335     if env['PLATFORM'] == "win32":  ###################### Copy required environment vars ########################
336        env.PrependENVPath('PATH', libinstall)  
337        env.PrependENVPath('PATH', env['boost_lib_path'])  # Windows doesn't use LD_LIBRARY_PATH but PATH instead
338  except KeyError:  if IS_WINDOWS:
339     libinstall = None      LD_LIBRARY_PATH_KEY='PATH'
340  try:      env['ENV']['LD_LIBRARY_PATH']=''
341     pyinstall = env['pyinstall']+'/esys' # all targets will install into pyinstall/esys but PYTHONPATH points at straight pyinstall so you go import esys.escript etc  else:
342     env.PrependENVPath('PYTHONPATH', env['pyinstall'])      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
 except KeyError:  
    pyinstall = None  
 try:  
    dodebug = env['dodebug']  
 except KeyError:  
    dodebug = None  
 try:  
    useMPI = env['useMPI']  
 except KeyError:  
    useMPI = None  
 try:  
    cc_defines = env['cc_defines']  
    env.Append(CPPDEFINES = cc_defines)  
 except KeyError:  
    pass  
343    
344  if 'shake71' == socket.gethostname().split('.')[0]:  # the following env variables are exported for the unit tests
   if useMPI:  
     env['CC'] = 'mpicc'  
     env['CXX'] = 'mpiCC'  
345    
346  if dodebug:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
   if useMPI:  
347      try:      try:
348        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
349      except KeyError:      except KeyError:
350        pass          env['ENV'][key] = 1
351    else:  
352    env_export=env['env_export']
353    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
354    
355    for key in set(env_export):
356      try:      try:
357        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
358      except KeyError:      except KeyError:
       pass  
 else:  
   if useMPI:  
    try:  
      flags = env['cc_flags_MPI']  
      env.Append(CCFLAGS = flags)  
    except KeyError:  
       pass  
   else:  
    try:  
       flags = env['cc_flags']  
       env.Append(CCFLAGS = flags)  
    except KeyError:  
       pass  
 if dodebug:  
    if useMPI:  
      try:  
         flags = env['cxx_flags_debug_MPI']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
359          pass          pass
    else:  
      try:  
         flags = env['cxx_flags_debug']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
 else:  
    if useMPI:  
      try:  
         flags = env['cxx_flags_MPI']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
    else:  
      try:  
         flags = env['cxx_flags']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
 try:  
    flags = env['ar_flags']  
    env.Append(ARFLAGS = flags)  
 except KeyError:  
    ar_flags = None  
 try:  
    sys_libs = env['sys_libs']  
 except KeyError:  
    sys_libs = ''  
360    
361  try:  try:
362     tar_flags = env['tar_flags']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Replace(TARFLAGS = tar_flags)  
363  except KeyError:  except KeyError:
364     pass      pass
365    
366  try:  # these shouldn't be needed
367     includes = env['mkl_path']  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
368     env.Append(CPPPATH = [includes,])  #    try:
369  except KeyError:  #        env['ENV'][key] = os.environ[key]
370     pass  #    except KeyError:
371    #        pass
372    
373  try:  try:
374     lib_path = env['mkl_lib_path']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
    env.Append(LIBPATH = [lib_path,])  
375  except KeyError:  except KeyError:
376     pass      pass
   
 if useMPI:  
    mkl_libs = ''  
 else:  
    try:  
       mkl_libs = env['mkl_libs']  
    except KeyError:  
       mkl_libs = ''  
377    
378  try:  ######################## Add some custom builders ############################
    includes = env['scsl_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
379    
380  try:  if env['pythoncmd']=='python':
381     lib_path = env['scsl_lib_path']      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
   
 if useMPI:  
   try:  
     scsl_libs = env['scsl_libs_MPI']  
   except KeyError:  
     scsl_libs = ''  
382  else:  else:
383    try:      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
384      scsl_libs = env['scsl_libs']  env.Append(BUILDERS = {'PyCompile' : py_builder});
   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  
   
 if useMPI:  
     umf_libs = ''  
 else:  
    try:  
       umf_libs = env['umf_libs']  
    except KeyError:  
       umf_libs = ''  
   
 try:  
    includes = env['ufc_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
   
 try:  
    includes = env['amd_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
   
 try:  
    lib_path = env['amd_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
   
 if useMPI:  
     amd_libs = ''  
 else:  
    try:  
       amd_libs = env['amd_libs']  
    except KeyError:  
       amd_libs = ''  
   
 try:  
    includes = env['blas_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
   
 try:  
    lib_path = env['blas_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
   
 try:  
    blas_libs = env['blas_libs']  
 except KeyError:  
    blas_libs = ''  
385    
386  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
387     includes = env['boost_path']  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
    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:  
    includes = env['papi_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['papi_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    papi_libs = env['papi_libs']  
 except KeyError:  
    papi_libs = None  
388    
389    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
390    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
391    
392  try:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
393     src_zipfile = env.File(env['src_zipfile'])  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
 except KeyError:  
    src_zipfile = None  
 try:  
    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  
394    
395  try:  ############################ Dependency checks ###############################
    src_tarfile = env.File(env['src_tarfile'])  
 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  
396    
397  try:  # Create a Configure() environment to check for compilers and python
398     guide_pdf = env.File(env['guide_pdf'])  conf = Configure(env.Clone())
 except KeyError:  
    guide_pdf = None  
399    
400  try:  ######## Test that the compilers work
401     guide_html_index = env.File('index.htm',env['guide_html'])  
402  except KeyError:  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
403     guide_html_index = None      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    
459      
460        # Now we know whether we are using python3 or not
461        p=Popen([env['pythoncmd'], '-c',  initstring+'print(sysconfig.get_python_inc())'], stdout=PIPE)
462        python_inc_path=p.stdout.readline()
463        if env['usepython3']:
464             python_inc_path=python_inc_path.encode()
465        p.wait()  
466        python_inc_path=python_inc_path.strip()
467        if IS_WINDOWS:
468            cmd="os.path.join(sysconfig.get_config_var('prefix'), 'libs')"
469        elif env['PLATFORM']=='darwin':
470            cmd="sysconfig.get_config_var(\"LIBPL\")"
471        else:
472            cmd="sysconfig.get_config_var(\"LIBDIR\")"
473    
474        p=Popen([env['pythoncmd'], '-c', initstring+'print('+cmd+')'], stdout=PIPE)
475        python_lib_path=p.stdout.readline()
476        if env['usepython3']:
477            python_lib_path=python_lib_path.decode()
478        p.wait()
479        python_lib_path=python_lib_path.strip()
480    
481    #Check for an override from the config file.
482    #Ideally, this should be automatic
483    #But we need to deal with the case where python is not in its INSTALL
484    #Directory
485    if env['pythonlibpath']!='':
486        python_lib_path=env['pythonlibpath']
487    
488    if env['pythonincpath']!='':
489        python_inc_path=env['pythonincpath']
490    
491    
492    if sysheaderopt == '':
493        conf.env.AppendUnique(CPPPATH = [python_inc_path])
494    else:
495        conf.env.Append(CCFLAGS = [sysheaderopt, python_inc_path])
496    
497    conf.env.AppendUnique(LIBPATH = [python_lib_path])
498    conf.env.AppendUnique(LIBS = python_libs)
499    # The wrapper script needs to find the libs
500    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, python_lib_path)
501    
502    if not conf.CheckCHeader('Python.h'):
503        print("Cannot find python include files (tried 'Python.h' in directory %s)" % (python_inc_path))
504        Exit(1)
505    if not conf.CheckFunc('Py_Exit'):
506        print("Cannot find python library method Py_Main (tried %s in directory %s)" % (python_libs, python_lib_path))
507        Exit(1)
508    
509    ## reuse conf to check for numpy header (optional)
510    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  try:  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
815     api_epydoc = env.Dir(env['api_epydoc'])  env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
816  except KeyError:  env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
817     api_epydoc = None  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  # Zipgets  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    
 env.Default(libinstall)  
 env.Default(incinstall)  
 env.Default(pyinstall)  
 env.Alias('release_src',[ src_zipfile, src_tarfile ])  
 env.Alias('release_tests',[ test_zipfile, test_tarfile])  
 env.Alias('release_examples',[ examples_zipfile, examples_tarfile])  
 env.Alias('api_epydoc',api_epydoc)  
 env.Alias('guide_pdf', guide_pdf)  
 env.Alias('docs',[ 'release_examples', 'guide_pdf', guide_html_index, api_epydoc])  
 env.Alias('release', ['release_src', 'release_tests', 'docs'])  
 env.Alias('build_tests')    # target to build all C++ tests  
 env.Alias('build_py_tests') # target to build all python tests  
 env.Alias('build_all_tests', [ 'build_tests', 'build_py_tests' ] ) # target to build all python tests  
 env.Alias('run_tests', 'build_tests')   # target to run all C++ test  
 env.Alias('py_tests', 'build_py_tests') # taget to run all released python tests  
 env.Alias('all_tests', ['run_tests', 'py_tests']) # target to run all C++ and released python tests  
   
 # Python install - esys __init__.py  
 init_target = env.Command(pyinstall+'/__init__.py', None, Touch('$TARGET'))  
 env.Alias(init_target)  
   
 # Allow sconscripts to see the env  
 Export(["env", "incinstall", "libinstall", "pyinstall", "dodebug", "mkl_libs", "scsl_libs", "umf_libs", "amd_libs", "blas_libs",  
     "boost_lib", "python_lib", "doxygen_path", "epydoc_path", "papi_libs",  
         "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "examples_tarfile", "examples_zipfile",  
         "guide_pdf", "guide_html_index", "api_epydoc", "useMPI"])  
   
 # End initialisation section  
 # Begin configuration section  
 # adds this file and the scons option directore to the source tar  
 release_srcfiles=[env.File('SConstruct'),]+[ env.File(x) for x in glob.glob('scons/*.py') ]  
 release_testfiles=[env.File('README_TESTS'),]  
 env.Zip(src_zipfile, release_srcfiles)  
 env.Zip(test_zipfile, release_testfiles)  
 env.Tar(src_tarfile, release_srcfiles)  
 env.Tar(test_tarfile, release_testfiles)  
   
 # 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)  
 env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)  
   
 # added by Ben Cumming  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 #env.SConscript(dirs = ['../test'], build_dir='../test/build', duplicate=0)  

Legend:
Removed from v.898  
changed lines
  Added in v.4046

  ViewVC Help
Powered by ViewVC 1.1.26