/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 1026 by phornby, Tue Mar 13 08:25:00 2007 UTC revision 4640 by jfenwick, Fri Jan 31 00:56:51 2014 UTC
# Line 1  Line 1 
1  #         Copyright 2006 by ACcESS MNRF  ##############################################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2013 by University of Queensland
4  #       Primary Business: Queensland, Australia  # http://www.uq.edu.au
 #  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  
17    
18  if os.path.isdir('/opt/UFconfig'):  import atexit, sys, os, platform, re
19     ufc_path_default='/opt/UFconfig'  from distutils import sysconfig
20  else:  from dependencies import *
21     ufc_path_default=None  from site_init import *
22    
23  # Default options and options help text  # Version number to check for in options file. Increment when new features are
24  # These are defaults and can be overridden using command line arguments or an options file.  # added or existing options changed.
25  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used  REQUIRED_OPTS_VERSION=201
26  # DO NOT CHANGE THEM HERE  
27  if ARGUMENTS.get('options_file',0):  # MS Windows support, many thanks to PH
28     options_file = ARGUMENTS.get('options_file',0)  IS_WINDOWS = (os.name == 'nt')
29  else:  
30     from string import ascii_letters,digits  IS_OSX = (os.uname()[0] == 'Darwin')
31     hostname=""  
32     for s in socket.gethostname().split('.')[0]:  ########################## Determine options file ############################
33        if s in ascii_letters+digits:  # 1. command line
34           hostname+=s  # 2. scons/<hostname>_options.py
35        else:  # 3. name as part of a cluster
36           hostname+="_"  options_file=ARGUMENTS.get('options_file', None)
37     options_file = "scons/"+hostname+"_options.py"  if not options_file:
38  print "option file is ",options_file      ext_dir = os.path.join(os.getcwd(), 'scons')
39        hostname = platform.node().split('.')[0]
40  opts = Options(options_file, ARGUMENTS)      for name in hostname, effectiveName(hostname):
41  opts.AddOptions(          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
42  # Where to install esys stuff          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
43    ('incinstall', 'where the esys headers will be installed', Dir('#.').abspath+'/include'),          if os.path.isfile(options_file): break
44    ('libinstall', 'where the esys libraries will be installed', Dir('#.').abspath+'/lib'),  
45    ('pyinstall', 'where the esys python modules will be installed', Dir('#.').abspath),  if not os.path.isfile(options_file):
46    ('src_zipfile', 'the source zip file will be installed.', Dir('#.').abspath+"/release/escript_src.zip"),      print("\nWARNING:\nOptions file %s" % options_file)
47    ('test_zipfile', 'the test zip file will be installed.', Dir('#.').abspath+"/release/escript_tests.zip"),      print("not found! Default options will be used which is most likely suboptimal.")
48    ('src_tarfile', 'the source tar file will be installed.', Dir('#.').abspath+"/release/escript_src.tar.gz"),      print("We recommend that you copy one of the TEMPLATE files in the scons/")
49    ('test_tarfile', 'the test tar file will be installed.', Dir('#.').abspath+"/release/escript_tests.tar.gz"),      print("subdirectory and customize it to your needs.\n")
50    ('examples_tarfile', 'the examples tar file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.tar.gz"),      options_file = None
51    ('examples_zipfile', 'the examples zip file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.zip"),  
52    ('guide_pdf', 'name of the user guide in pdf format', Dir('#.').abspath+"/release/doc/user/guide.pdf"),  ############################### Build options ################################
53    ('api_epydoc', 'name of the epydoc api docs directory',Dir('#.').abspath+"/release/doc/epydoc"),  
54    ('guide_html', 'name of the directory for user guide in html format', Dir('#.').abspath+"/release/doc/user/html"),  default_prefix='/usr'
55  # Compilation options  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
56    BoolOption('dodebug', 'Do you want a debug build?', 'no'),  lapack_flavours=('none', 'clapack', 'mkl')
57    ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/hostname_options.py)", options_file),  
58    ('cc_defines','C/C++ defines to use', None),  vars = Variables(options_file, ARGUMENTS)
59    ('cc_flags','C compiler flags to use (Release build)', '-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas'),  vars.AddVariables(
60    ('cc_flags_debug', 'C compiler flags to use (Debug build)', '-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas'),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
61    ('cxx_flags', 'C++ compiler flags to use (Release build)', '--no-warn -ansi'),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
62    ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', '--no-warn -ansi -DDOASSERT -DDOPROF'),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
63    ('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'),    BoolVariable('verbose', 'Output full compile/link lines', False),
64    ('cc_flags_debug_MPI', 'C compiler flags to use (Debug MPI build)', '-g -O0 -c99 -w1 -fpic -wd161'),  # Compiler/Linker options
65    ('cxx_flags_MPI', 'C++ compiler flags to use (Release MPI build)', '-ansi -wd1563 -wd161'),    ('cxx', 'Path to C++ compiler', 'default'),
66    ('cxx_flags_debug_MPI', 'C++ compiler flags to use (Debug MPI build)', '-ansi -DDOASSERT -DDOPROF -wd1563 -wd161'),    ('cc_flags', 'Base C++ compiler flags', 'default'),
67    ('ar_flags', 'Static library archiver flags to use', None),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
68    ('sys_libs', 'System libraries to link with', None),    ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
69    ('tar_flags','flags for zip files','-c -z'),    ('cxx_extra', 'Extra C++ compiler flags', ''),
70  # MKL    ('ld_extra', 'Extra linker flags', ''),
71    PathOption('mkl_path', 'Path to MKL includes', None),    BoolVariable('werror','Treat compiler warnings as errors', True),
72    PathOption('mkl_lib_path', 'Path to MKL libs', None),    BoolVariable('debug', 'Compile with debug flags', False),
73    ('mkl_libs', 'MKL libraries to link with', None),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74  # SCSL    ('omp_flags', 'OpenMP compiler flags', 'default'),
75    PathOption('scsl_path', 'Path to SCSL includes', None),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76    PathOption('scsl_lib_path', 'Path to SCSL libs', None),  # Mandatory libraries
77    ('scsl_libs', 'SCSL libraries to link with', None),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78    ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79  # UMFPACK  # Mandatory for tests
80    PathOption('ufc_path', 'Path to UFconfig includes', ufc_path_default),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81    PathOption('umf_path', 'Path to UMFPACK includes', umf_path_default),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82    PathOption('umf_lib_path', 'Path to UMFPACK libs', umf_lib_path_default),  # Optional libraries and options
83    ('umf_libs', 'UMFPACK libraries to link with', umf_libs_default),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84  # AMD (used by UMFPACK)    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85    PathOption('amd_path', 'Path to AMD includes', amd_path_default),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86    PathOption('amd_lib_path', 'Path to AMD libs', amd_lib_path_default),    BoolVariable('netcdf', 'Enable netCDF file support', False),
87    ('amd_libs', 'AMD libraries to link with', amd_libs_default),    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88  # BLAS    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89    PathOption('blas_path', 'Path to BLAS includes', None),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90    PathOption('blas_lib_path', 'Path to BLAS libs', None),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91    ('blas_libs', 'BLAS libraries to link with', None),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92  # netCDF    BoolVariable('papi', 'Enable PAPI', False),
93    ('useNetCDF', 'switch on/off the usage of netCDF', 'yes'),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
94    PathOption('netCDF_path', 'Path to netCDF includes', '/usr/local/include'),    ('papi_libs', 'PAPI libraries to link with', ['papi']),
95    PathOption('netCDF_lib_path', 'Path to netCDF libs', '/usr/local/lib'),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
96    ('netCDF_libs_cxx', 'netCDF C++ libraries to link with', [ 'netcdf_c++', 'netcdf'] ),    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
97  # Python    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
98  # locations of include files for python    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
99    PathOption('python_path', 'Path to Python includes', '/usr/include/python%s.%s'%(sys.version_info[0],sys.version_info[1])),    BoolVariable('umfpack', 'Enable UMFPACK', False),
100    PathOption('python_lib_path', 'Path to Python libs', '/usr/lib'),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
101    ('python_lib', 'Python libraries to link with', ["python%s.%s"%(sys.version_info[0],sys.version_info[1]),]),    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
102  # Boost    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
103    PathOption('boost_path', 'Path to Boost includes', '/usr/include'),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
104    PathOption('boost_lib_path', 'Path to Boost libs', '/usr/lib'),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
105    ('boost_lib', 'Boost libraries to link with', ['boost_python',]),    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
106  # Doc building    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
107  #  PathOption('doxygen_path', 'Path to Doxygen executable', None),    ('lapack_libs', 'LAPACK libraries to link with', []),
108  #  PathOption('epydoc_path', 'Path to Epydoc executable', None),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
109  # PAPI    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
110    PathOption('papi_path', 'Path to PAPI includes', None),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
111    PathOption('papi_lib_path', 'Path to PAPI libs', None),    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
112    ('papi_libs', 'PAPI libraries to link with', None),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
113  # MPI    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
114    BoolOption('useMPI', 'Compile parallel version using MPI', 'no'),    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  )  )
 # Note: On the Altix the intel compilers are not automatically  
 # detected by scons intelc.py script. The Altix has a different directory  
 # path and in some locations the "modules" facility is used to support  
 # multiple compiler versions. This forces the need to import the users PATH  
 # environment which isn't the "scons way"  
 # This doesn't impact linux and windows which will use the default compiler (g++ or msvc, or the intel compiler if it is installed on both platforms)  
 # FIXME: Perhaps a modification to intelc.py will allow better support for ia64 on altix  
   
 if os.name != "nt" and os.uname()[4]=='ia64':  
    env = Environment(tools = ['default', 'intelc'], options = opts)  
    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":  
    env = Environment(tools = ['default', 'msvc'], options = opts)  
 else:  
    env = Environment(tools = ['default'], options = opts)  
 # Initialise Scons Build Environment  
 # check for user environment variables we are interested in  
 try:  
    python_path = os.environ['PYTHONPATH']  
    env['ENV']['PYTHONPATH'] = python_path  
 except KeyError:  
    python_path = ''  
   
 try:  
    path = os.environ['PATH']  
    env['ENV']['PATH'] = path  
 except KeyError:  
    path = ''  
 try:  
    ld_library_path = os.environ['LD_LIBRARY_PATH']  
    env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
 except KeyError:  
    ld_library_path = ''  
138    
139    ##################### Create environment and help text #######################
140    
141  # Setup help for options  # Intel's compiler uses regular expressions improperly and emits a warning
142  Help(opts.GenerateHelpText(env))  # about failing to find the compilers. This warning can be safely ignored.
143    
144  # Add some customer builders  # PATH is needed so the compiler, linker and tools are found if they are not
145  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  # in default locations.
146  env.Append(BUILDERS = {'PyCompile' : py_builder});  env = Environment(tools = ['default'], options = vars,
147                      ENV = {'PATH': os.environ['PATH']})
148  if env['PLATFORM'] == "win32":  
149     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  # set the vars for clang
150    def mkclang(env):
151        env['CXX']='clang++'
152    
153    if env['tools_names'] != 'default':
154        zz=env['tools_names']
155        if 'clang' in zz:
156            zz.remove('clang')
157            zz.insert(0, mkclang)
158        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
159                          ENV = {'PATH' : os.environ['PATH']})
160    
161    if options_file:
162        opts_valid=False
163        if 'escript_opts_version' in env.Dictionary() and \
164            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
165                opts_valid=True
166        if opts_valid:
167            print("Using options in %s." % options_file)
168        else:
169            print("\nOptions file %s" % options_file)
170            print("is outdated! Please update the file by examining one of the TEMPLATE")
171            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
172            Exit(1)
173    
174    # Generate help text (scons -h)
175    Help(vars.GenerateHelpText(env))
176    
177    # Check for superfluous options
178    if len(vars.UnknownVariables())>0:
179        for k in vars.UnknownVariables():
180            print("Unknown option '%s'" % k)
181        Exit(1)
182    
183    # create dictionary which will be populated with info for buildvars file
184    env['buildvars']={}
185    # create list which will be populated with warnings if there are any
186    env['warnings']=[]
187    
188    #################### Make sure install directories exist #####################
189    
190    env['BUILD_DIR']=Dir(env['build_dir']).abspath
191    prefix=Dir(env['prefix']).abspath
192    env['buildvars']['prefix']=prefix
193    env['incinstall'] = os.path.join(prefix, 'include')
194    env['bininstall'] = os.path.join(prefix, 'bin')
195    env['libinstall'] = os.path.join(prefix, 'lib')
196    env['pyinstall']  = os.path.join(prefix, 'esys')
197    if not os.path.isdir(env['bininstall']):
198        os.makedirs(env['bininstall'])
199    if not os.path.isdir(env['libinstall']):
200        os.makedirs(env['libinstall'])
201    if not os.path.isdir(env['pyinstall']):
202        os.makedirs(env['pyinstall'])
203    
204    env.Append(CPPPATH = [env['incinstall']])
205    env.Append(LIBPATH = [env['libinstall']])
206    
207    ################# Fill in compiler options if not set above ##################
208    
209    if env['cxx'] != 'default': env['CXX']=env['cxx']
210    
211    # version >=9 of intel C++ compiler requires use of icpc to link in C++
212    # runtimes (icc does not)
213    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
214        env['LINK'] = env['CXX']
215    
216    # default compiler/linker options
217    cc_flags = ''
218    cc_optim = ''
219    cc_debug = ''
220    omp_flags = ''
221    omp_ldflags = ''
222    fatalwarning = '' # switch to turn warnings into errors
223    sysheaderopt = '' # how to indicate that a header is a system header
224    
225    # env['CC'] might be a full path
226    cc_name=os.path.basename(env['CXX'])
227    
228    if cc_name == 'icpc':
229        # Intel compiler
230        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
231        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
232        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas -DBLOCKTIMER -DCORE_ID1"
233        cc_optim    = "-O3 -ftz -fno-alias -ipo -xHost"
234        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
235        omp_flags   = "-openmp"
236        omp_ldflags = "-openmp -openmp_report=1"
237        fatalwarning = "-Werror"
238    elif cc_name[:3] == 'g++':
239        # GNU C on any system
240        # note that -ffast-math is not used because it breaks isnan(),
241        # see mantis #691
242        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
243        cc_optim     = "-O3"
244        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
245        omp_flags    = "-fopenmp"
246        omp_ldflags  = "-fopenmp"
247        fatalwarning = "-Werror"
248        sysheaderopt = "-isystem"
249    elif cc_name == 'cl':
250        # Microsoft Visual C on Windows
251        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
252        cc_optim     = "/O2 /Op /W3"
253        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
254        fatalwarning = "/WX"
255    elif cc_name == 'icl':
256        # Intel C on Windows
257        cc_flags     = '/EHsc /GR /MD'
258        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
259        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
260        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
261        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
262    
263    env['sysheaderopt']=sysheaderopt
264    
265    # set defaults if not otherwise specified
266    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
267    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
268    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
269    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
270    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
271    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
272    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
273    
274    if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
275    
276    if env['usepython3']:
277        env.Append(CPPDEFINES=['ESPYTHON3'])
278    
279    # set up the autolazy values
280    if env['forcelazy'] == 'on':
281        env.Append(CPPDEFINES=['FAUTOLAZYON'])
282    elif env['forcelazy'] == 'off':
283        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
284    
285    # set up the collective resolve values
286    if env['forcecollres'] == 'on':
287        env.Append(CPPDEFINES=['FRESCOLLECTON'])
288    elif env['forcecollres'] == 'off':
289        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
290    
291    # allow non-standard C if requested
292    if env['iknowwhatimdoing']:
293        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
294    
295    # Disable OpenMP if no flags provided
296    if env['openmp'] and env['omp_flags'] == '':
297       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
298       env['openmp'] = False
299    
300    if env['openmp']:
301        env.Append(CCFLAGS = env['omp_flags'])
302        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
303    else:
304        env['omp_flags']=''
305        env['omp_ldflags']=''
306    
307    env['buildvars']['openmp']=int(env['openmp'])
308    
309    # add debug/non-debug compiler flags
310    env['buildvars']['debug']=int(env['debug'])
311    if env['debug']:
312        env.Append(CCFLAGS = env['cc_debug'])
313    else:
314        env.Append(CCFLAGS = env['cc_optim'])
315    
316    # always add cc_flags
317    env.Append(CCFLAGS = env['cc_flags'])
318    
319    # add system libraries
320    env.AppendUnique(LIBS = env['sys_libs'])
321    
322    # determine svn revision
323    global_revision=ARGUMENTS.get('SVN_VERSION', None)
324    if global_revision:
325        global_revision = re.sub(':.*', '', global_revision)
326        global_revision = re.sub('[^0-9]', '', global_revision)
327        if global_revision == '': global_revision='-2'
328  else:  else:
329     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', single_source=True)    # Get the global Subversion revision number for the getVersion() method
330  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});    try:
331        global_revision = os.popen('svnversion -n .').read()
332  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)      global_revision = re.sub(':.*', '', global_revision)
333  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});      global_revision = re.sub('[^0-9]', '', global_revision)
334        if global_revision == '': global_revision='-2'
335      except:
336        global_revision = '-1'
337    env['svn_revision']=global_revision
338    env['buildvars']['svn_revision']=global_revision
339    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
340    
341    if IS_WINDOWS:
342        if not env['build_shared']:
343            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
344            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
345    
346    # VSL random numbers
347    env['buildvars']['vsl_random']=int(env['vsl_random'])
348    if env['vsl_random']:
349        env.Append(CPPDEFINES = ['MKLRANDOM'])
350    
351    env['IS_WINDOWS']=IS_WINDOWS
352    
353    ###################### Copy required environment vars ########################
354    
355    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
356    if IS_WINDOWS:
357        LD_LIBRARY_PATH_KEY='PATH'
358        env['ENV']['LD_LIBRARY_PATH']=''
359    else:
360        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
361    
362  # Convert the options which are held in environment variable into python variables for ease of handling and configure compilation options  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
 try:  
    incinstall = env['incinstall']  
    env.Append(CPPPATH = [incinstall,])  
 except KeyError:  
    incinstall = None  
 try:  
    libinstall = env['libinstall']  
    env.Append(LIBPATH = [libinstall,])  
    env.PrependENVPath('LD_LIBRARY_PATH', libinstall)  
    if env['PLATFORM'] == "win32":  
       env.PrependENVPath('PATH', libinstall)  
       env.PrependENVPath('PATH', env['boost_lib_path'])  
 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:  
    useMPI = env['useMPI']  
 except KeyError:  
    useMPI = None  
 try:  
    cc_defines = env['cc_defines']  
    env.Append(CPPDEFINES = cc_defines)  
 except KeyError:  
    pass  
363    
364  if 'shake71' == socket.gethostname().split('.')[0]:  # the following env variables are exported for the unit tests
   if useMPI:  
     env['CC'] = 'mpicc'  
     env['CXX'] = 'mpiCC'  
365    
366  if dodebug:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
   if useMPI:  
367      try:      try:
368        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
369      except KeyError:      except KeyError:
370        pass          env['ENV'][key] = 1
371    else:  
372    env_export=env['env_export']
373    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
374    
375    for key in set(env_export):
376      try:      try:
377        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
378      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:  
         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:  
379          pass          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 = ''  
   
 try:  
    tar_flags = env['tar_flags']  
    env.Replace(TARFLAGS = tar_flags)  
 except KeyError:  
    pass  
   
 try:  
    includes = env['mkl_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
380    
381  try:  try:
382     lib_path = env['mkl_lib_path']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Append(LIBPATH = [lib_path,])  
383  except KeyError:  except KeyError:
384     pass      pass
385    
386  if useMPI:  if IS_OSX:
    mkl_libs = ''  
 else:  
    try:  
       mkl_libs = env['mkl_libs']  
    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  
   
 if useMPI:  
387    try:    try:
388      scsl_libs = env['scsl_libs_MPI']      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
389    except KeyError:    except KeyError:
390      scsl_libs = ''      pass
 else:  
   try:  
     scsl_libs = env['scsl_libs']  
   except KeyError:  
     scsl_libs = ''  
391    
 try:  
    includes = env['umf_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
392    
393  try:  # these shouldn't be needed
394     lib_path = env['umf_lib_path']  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
395     env.Append(LIBPATH = [lib_path,])  #    try:
396  except KeyError:  #        env['ENV'][key] = os.environ[key]
397     pass  #    except KeyError:
398    #        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  
399    
400  try:  try:
401     blas_libs = env['blas_libs']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
402  except KeyError:  except KeyError:
403     blas_libs = ''      pass
404    
405  try:  ######################## Add some custom builders ############################
    useNetCDF = env['useNetCDF']  
 except KeyError:  
    useNetCDF = 'yes'  
    pass  
406    
407  if not useNetCDF == 'yes':  if env['pythoncmd']=='python':
408     print "Warning: Installation is not configured with netCDF. Some I/O function may not be available."      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
     
 if useNetCDF == 'yes':  
    try:  
       includes = env['netCDF_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['netCDF_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
    except KeyError:  
       pass  
   
    try:  
       netCDF_libs_cxx = env['netCDF_libs_cxx']  
    except KeyError:  
       netCDF_libs_cxx = [ ]  
409  else:  else:
410     netCDF_libs_cxx=[ ]      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
411    env.Append(BUILDERS = {'PyCompile' : py_builder});
412    
413  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
414     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  
415    
416    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
417    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
418    
419  try:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
420     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  
421    
422  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  
423    
424  try:  ######## Compiler
425     guide_pdf = env.File(env['guide_pdf'])  env=checkCompiler(env)
 except KeyError:  
    guide_pdf = None  
426    
427  try:  ######## Python headers & library (required)
428     guide_html_index = env.File('index.htm',env['guide_html'])  env=checkPython(env)
429  except KeyError:  
430     guide_html_index = None  ######## boost & boost-python (required)
431    env=checkBoost(env)
432    
433    ######## numpy (required) and numpy headers (optional)
434    env=checkNumpy(env)
435    
436    ######## CppUnit (required for tests)
437    env=checkCppUnit(env)
438    
439    ######## optional python modules (sympy, pyproj)
440    env=checkOptionalModules(env)
441    
442    ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
443    env=checkOptionalLibraries(env)
444    
445    ######## PDFLaTeX (for documentation)
446    env=checkPDFLatex(env)
447    
448    # keep some of our install paths first in the list for the unit tests
449    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
450    env.PrependENVPath('PYTHONPATH', prefix)
451    env['ENV']['ESCRIPT_ROOT'] = prefix
452    
453    if not env['verbose']:
454        env['CXXCOMSTR'] = "Compiling $TARGET"
455        env['SHCXXCOMSTR'] = "Compiling $TARGET"
456        env['ARCOMSTR'] = "Linking $TARGET"
457        env['LINKCOMSTR'] = "Linking $TARGET"
458        env['SHLINKCOMSTR'] = "Linking $TARGET"
459        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
460        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
461        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
462        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
463        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
464    
465    ####################### Configure the subdirectories #########################
466    
467    # remove obsolete files
468    if not env['usempi']:
469        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
470        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
471    
472    from grouptest import *
473    TestGroups=[]
474    
475    # keep an environment without warnings-as-errors
476    dodgy_env=env.Clone()
477    
478    # now add warnings-as-errors flags. This needs to be done after configuration
479    # because the scons test files have warnings in them
480    if ((fatalwarning != '') and (env['werror'])):
481        env.Append(CCFLAGS = fatalwarning)
482    
483    Export(
484      ['env',
485       'dodgy_env',
486       'IS_WINDOWS',
487       'TestGroups'
488      ]
489    )
490    
491  try:  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
492     api_epydoc = env.Dir(env['api_epydoc'])  env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
493  except KeyError:  env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
494     api_epydoc = None  env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
495    
496    #This will pull in the escriptcore/py_src and escriptcore/test
497    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
498    #env.SConscript(dirs = ['escript/test'], variant_dir='$BUILD_DIR/$PLATFORM/escript/test', duplicate=0)
499    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
500    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
501    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
502    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
503    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
504    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
505    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
506    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
507    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
508    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
509    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
510    
511    
512    ######################## Populate the buildvars file #########################
513    
514    write_buildvars(env)
515    
516    ################### Targets to build and install libraries ###################
517    
518    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
519    env.Alias('target_init', [target_init])
520    # delete buildvars upon cleanup
521    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
522    
523    # The headers have to be installed prior to build in order to satisfy
524    # #include <paso/Common.h>
525    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
526    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
527    
528    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
529    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
530    
531    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
532    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
533    
534    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
535    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
536    
537    env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
538    env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
539    
540    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
541    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
542    
543    env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
544    env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
545    
546    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
547    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
548    
549    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
550    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
551    
552    # Now gather all the above into some easy targets: build_all and install_all
553    build_all_list = []
554    build_all_list += ['build_esysUtils']
555    build_all_list += ['build_paso']
556    build_all_list += ['build_escript']
557    build_all_list += ['build_pasowrap']
558    build_all_list += ['build_dudley']
559    build_all_list += ['build_finley']
560    build_all_list += ['build_ripley']
561    build_all_list += ['build_weipa']
562    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
563    if env['usempi']:   build_all_list += ['build_pythonMPI']
564    build_all_list += ['build_escriptconvert']
565    env.Alias('build_all', build_all_list)
566    
567    install_all_list = []
568    install_all_list += ['target_init']
569    install_all_list += ['install_esysUtils']
570    install_all_list += ['install_paso']
571    install_all_list += ['install_escript']
572    install_all_list += ['install_pasowrap']
573    install_all_list += ['install_dudley']
574    install_all_list += ['install_finley']
575    install_all_list += ['install_ripley']
576    install_all_list += ['install_weipa']
577    if not IS_WINDOWS: install_all_list += ['install_escriptreader']
578    install_all_list += ['install_downunder_py']
579    install_all_list += ['install_modellib_py']
580    install_all_list += ['install_pycad_py']
581    if env['usempi']:   install_all_list += ['install_pythonMPI']
582    install_all_list += ['install_escriptconvert']
583    env.Alias('install_all', install_all_list)
584    
585    # Default target is install
586    env.Default('install_all')
587    
588    ################## Targets to build and run the test suite ###################
589    
590    if not env['cppunit']:
591        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
592        env.Alias('run_tests', test_msg)
593        env.Alias('build_tests', '')
594    env.Alias('run_tests', ['install_all'])
595    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
596    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
597    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
598    
599    ##################### Targets to build the documentation #####################
600    
601    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
602    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
603    env.Alias('docs', ['basedocs', 'sphinxdoc'])
604    env.Alias('release_prep', ['docs', 'install_all'])
605    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
606    
607    # The test scripts are always generated, this target allows us to
608    # generate the testscripts without doing a full build
609    env.Alias('testscripts',[])
610    
611    if not IS_WINDOWS:
612        generateTestScripts(env, TestGroups)
613    
614    
615    
616    ######################## Summarize our environment ###########################
617    def print_summary():
618        print("")
619        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
620        print("Escript/Finley revision %s"%global_revision)
621        print("  Install prefix:  %s"%env['prefix'])
622        print("          Python:  %s"%sysconfig.PREFIX)
623        print("           boost:  %s"%env['boost_prefix'])
624        if env['numpy_h']:
625            print("           numpy:  YES (with headers)")
626        else:
627            print("           numpy:  YES (without headers)")
628        if env['usempi']:
629            print("             MPI:  YES (flavour: %s)"%env['mpi'])
630        else:
631            print("             MPI:  DISABLED")
632        if env['uselapack']:
633            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
634        else:
635            print("          LAPACK:  DISABLED")
636        d_list=[]
637        e_list=[]
638        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit','vsl_random':
639            if env[i]: e_list.append(i)
640            else: d_list.append(i)
641        for i in e_list:
642            print("%16s:  YES"%i)
643        for i in d_list:
644            print("%16s:  DISABLED"%i)
645        if env['cppunit']:
646            print("         CppUnit:  FOUND")
647        else:
648            print("         CppUnit:  NOT FOUND")
649        if env['gmsh']=='m':
650            print("            gmsh:  FOUND, MPI-ENABLED")
651        elif env['gmsh']=='s':
652            print("            gmsh:  FOUND")
653        else:
654            print("            gmsh:  NOT FOUND")
655    
656        if ((fatalwarning != '') and (env['werror'])):
657            print("  Treating warnings as errors")
658        else:
659            print("  NOT treating warnings as errors")
660        print("")
661        for w in env['warnings']:
662            print("WARNING: %s"%w)
663    
664  # Zipgets  atexit.register(print_summary)
665    
 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", "netCDF_libs_cxx", "useNetCDF",  
     "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)  
 # bruce is removed for now as it doesn't really do anything  
 # 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.1026  
changed lines
  Added in v.4640

  ViewVC Help
Powered by ViewVC 1.1.26