/[escript]/branches/4.0fordebian/SConstruct
ViewVC logotype

Diff of /branches/4.0fordebian/SConstruct

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

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

  ViewVC Help
Powered by ViewVC 1.1.26