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

Diff of /branches/diaplayground/SConstruct

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

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

  ViewVC Help
Powered by ViewVC 1.1.26