/[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 5406 by jfenwick, Thu Dec 18 01:54:42 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    if 'dudley' in env['domains']:
199        env['domains'].append('finley')
200    
201    # create dictionary which will be populated with info for buildvars file
202    env['buildvars']={}
203    # create list which will be populated with warnings if there are any
204    env['warnings']=[]
205    
206    #################### Make sure install directories exist #####################
207    
208    env['BUILD_DIR']=Dir(env['build_dir']).abspath
209    prefix=Dir(env['prefix']).abspath
210    env['buildvars']['prefix']=prefix
211    env['incinstall'] = os.path.join(prefix, 'include')
212    env['bininstall'] = os.path.join(prefix, 'bin')
213    env['libinstall'] = os.path.join(prefix, 'lib')
214    env['pyinstall']  = os.path.join(prefix, 'esys')
215    if not os.path.isdir(env['bininstall']):
216        os.makedirs(env['bininstall'])
217    if not os.path.isdir(env['libinstall']):
218        os.makedirs(env['libinstall'])
219    if not os.path.isdir(env['pyinstall']):
220        os.makedirs(env['pyinstall'])
221    
222    env.Append(CPPPATH = [env['incinstall']])
223    env.Append(LIBPATH = [env['libinstall']])
224    
225    ################# Fill in compiler options if not set above ##################
226    
227    if env['cxx'] != 'default': env['CXX']=env['cxx']
228    
229    # version >=9 of intel C++ compiler requires use of icpc to link in C++
230    # runtimes (icc does not)
231    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
232        env['LINK'] = env['CXX']
233    
234    # default compiler/linker options
235    cc_flags = ''
236    cc_optim = ''
237    cc_debug = ''
238    omp_flags = ''
239    omp_ldflags = ''
240    fatalwarning = '' # switch to turn warnings into errors
241    sysheaderopt = '' # how to indicate that a header is a system header
242    
243    # env['CC'] might be a full path
244    cc_name=os.path.basename(env['CXX'])
245    
246    if cc_name == 'icpc':
247        # Intel compiler
248        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
249        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
250        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas"
251        cc_optim    = "-O3 -ftz -fno-alias -inline-level=2 -ipo -xHost"
252        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
253        omp_flags   = "-openmp"
254        omp_ldflags = "-openmp -openmp_report=1"
255        fatalwarning = "-Werror"
256    elif cc_name[:3] == 'g++':
257        # GNU C++ on any system
258        # note that -ffast-math is not used because it breaks isnan(),
259        # see mantis #691
260        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
261        cc_optim     = "-O3"
262        #max-vartrack-size: avoid vartrack limit being exceeded with escriptcpp.cpp
263        cc_debug     = "-g3 -O0 -D_GLIBCXX_DEBUG -DDOASSERT -DDOPROF -DBOUNDS_CHECK --param=max-vartrack-size=100000000"
264        omp_flags    = "-fopenmp"
265        omp_ldflags  = "-fopenmp"
266        fatalwarning = "-Werror"
267        sysheaderopt = "-isystem"
268    elif cc_name == 'cl':
269        # Microsoft Visual C on Windows
270        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
271        cc_optim     = "/O2 /Op /W3"
272        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
273        fatalwarning = "/WX"
274    elif cc_name == 'icl':
275        # Intel C on Windows
276        cc_flags     = '/EHsc /GR /MD'
277        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
278        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
279        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
280        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
281    
282    env['sysheaderopt']=sysheaderopt
283    
284    # set defaults if not otherwise specified
285    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
286    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
287    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
288    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
289    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
290    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
291    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
292    
293    if env['nvccflags'] != 'default':
294        env['NVCCFLAGS'] = env['nvccflags']
295        env['SHNVCCFLAGS'] = env['nvccflags'] + ' -shared'
296    
297    if env['BADPYTHONMACROS']:
298        env.Append(CPPDEFINES = ['BADPYTHONMACROS'])
299    
300    if env['longindices']:
301        env.Append(CPPDEFINES = ['ESYS_INDEXTYPE_LONG'])
302    
303    if env['usepython3']:
304        env.Append(CPPDEFINES=['ESPYTHON3'])
305    
306    # set up the autolazy values
307    if env['forcelazy'] == 'on':
308        env.Append(CPPDEFINES=['FAUTOLAZYON'])
309    elif env['forcelazy'] == 'off':
310        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
311    
312    # set up the collective resolve values
313    if env['forcecollres'] == 'on':
314        env.Append(CPPDEFINES=['FRESCOLLECTON'])
315    elif env['forcecollres'] == 'off':
316        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
317    
318    # allow non-standard C if requested
319    if env['iknowwhatimdoing']:
320        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
321    
322    # Disable OpenMP if no flags provided
323    if env['openmp'] and env['omp_flags'] == '':
324       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
325       env['openmp'] = False
326    
327    if env['openmp']:
328        env.Append(CCFLAGS = env['omp_flags'])
329        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
330  else:  else:
331     env = Environment(tools = ['default'], options = opts)      env['omp_flags']=''
332     env['ENV']['PATH'] = path      env['omp_ldflags']=''
    env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
    env['ENV']['PYTHONPATH'] = python_path  
333    
334  # Setup help for options  env['buildvars']['openmp']=int(env['openmp'])
 Help(opts.GenerateHelpText(env))  
335    
336  # Add some customer builders  # add debug/non-debug compiler flags
337  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  env['buildvars']['debug']=int(env['debug'])
338  env.Append(BUILDERS = {'PyCompile' : py_builder});  if env['debug']:
339        env.Append(CCFLAGS = env['cc_debug'])
340    else:
341        env.Append(CCFLAGS = env['cc_optim'])
342    
343    # always add cc_flags
344    env.Append(CCFLAGS = env['cc_flags'])
345    
346    # add system libraries
347    env.AppendUnique(LIBS = env['sys_libs'])
348    
349  if env['PLATFORM'] == "win32":  # set defaults for launchers if not otherwise specified
350     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  if env['prelaunch'] == 'default':
351        if env['mpi'] == 'INTELMPI' and env['openmp']:
352            env['prelaunch'] = "export I_MPI_PIN_DOMAIN=omp"
353        elif env['mpi'] == 'OPENMPI':
354            # transform comma-separated list to '-x a -x b -x c ...'
355            env['prelaunch'] = "EE=$(echo %e|sed -e 's/,/ -x /g')"
356        elif env['mpi'] == 'MPT':
357            env['prelaunch'] = "export MPI_NUM_MEMORY_REGIONS=0"
358        elif env['mpi'] == 'MPICH2':
359            env['prelaunch'] = "mpdboot -n %n -r ssh -f %f"
360        else:
361            env['prelaunch'] = ""
362    
363    if env['launcher'] == 'default':
364        if env['mpi'] == 'INTELMPI':
365            env['launcher'] = "mpirun -hostfile %f -n %N -ppn %p %b"
366        elif env['mpi'] == 'OPENMPI':
367            env['launcher'] = "mpirun --gmca mpi_warn_on_fork 0 -x ${EE} --host %h -bynode -bind-to-core --cpus-per-rank %t -np %N %b"
368        elif env['mpi'] == 'MPT':
369            env['launcher'] = "mpirun %h -np %p %b"
370        elif env['mpi'] == 'MPICH':
371            env['launcher'] = "mpirun -machinefile %f -np %N %b"
372        elif env['mpi'] == 'MPICH2':
373            env['launcher'] = "mpiexec -genvlist %e -np %N %b"
374        else:
375            env['launcher'] = "%b"
376    
377    if env['postlaunch'] == 'default':
378        if env['mpi'] == 'MPICH2':
379            env['postlaunch'] = "mpdallexit"
380        else:
381            env['postlaunch'] = ""
382    
383    # determine svn revision
384    global_revision=ARGUMENTS.get('SVN_VERSION', None)
385    if global_revision:
386        global_revision = re.sub(':.*', '', global_revision)
387        global_revision = re.sub('[^0-9]', '', global_revision)
388        if global_revision == '': global_revision='-2'
389  else:  else:
390     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', single_source=True)    # Get the global Subversion revision number for the getVersion() method
391  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});    try:
392        global_revision = os.popen('svnversion -n .').read()
393        global_revision = re.sub(':.*', '', global_revision)
394        global_revision = re.sub('[^0-9]', '', global_revision)
395        if global_revision == '': global_revision='-2'
396      except:
397        global_revision = '-1'
398    env['svn_revision']=global_revision
399    env['buildvars']['svn_revision']=global_revision
400    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
401    
402    if IS_WINDOWS:
403        if not env['build_shared']:
404            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
405            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
406    
407    env['IS_WINDOWS']=IS_WINDOWS
408    env['IS_OSX']=IS_OSX
409    
410    ###################### Copy required environment vars ########################
411    
412    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
413    if IS_WINDOWS:
414        LD_LIBRARY_PATH_KEY='PATH'
415        env['ENV']['LD_LIBRARY_PATH']=''
416    else:
417        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
418    
419  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});  
420    
421  # 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
422  try:  
423     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:  
424      try:      try:
425        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
426      except KeyError:      except KeyError:
427        pass          env['ENV'][key] = '1'
428    else:                        
429    env_export=env['env_export']
430    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP','LD_PRELOAD'])
431    
432    for key in set(env_export):
433      try:      try:
434        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
435      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:  
436          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 = ''  
437    
438  try:  try:
439     tar_flags = env['tar_flags']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Replace(TARFLAGS = tar_flags)  
440  except KeyError:  except KeyError:
441     pass      pass
442    
443  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:          
444    try:    try:
445      scsl_libs = env['scsl_libs']      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
446    except KeyError:    except KeyError:
447      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    
448    
449    
450  try:  # these shouldn't be needed
451     src_zipfile = env.File(env['src_zipfile'])  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
452  except KeyError:  #    try:
453     src_zipfile = None    #        env['ENV'][key] = os.environ[key]
454  try:  #    except KeyError:
455     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    
456    
457  try:  try:
458     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'])  
459  except KeyError:  except KeyError:
460     examples_tarfile = None        pass
461    
462  try:  ######################## Add some custom builders ############################
    guide_pdf = env.File(env['guide_pdf'])  
 except KeyError:  
    guide_pdf = None    
463    
464  try:  if env['pythoncmd']=='python':
465     guide_html_index = env.File('index.htm',env['guide_html'])      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
466  except KeyError:  else:
467     guide_html_index = None        py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
468    env.Append(BUILDERS = {'PyCompile' : py_builder});
469    
470  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
471     api_epydoc = env.Dir(env['api_epydoc'])  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
472  except KeyError:  
473     api_epydoc = None    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
474    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
475    
476    runPyExample_builder = Builder(action = runPyExample, suffix = '.passed', src_suffic='.py', single_source=True)
477    env.Append(BUILDERS = {'RunPyExample' : runPyExample_builder});
478    
479    epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
480    env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
481    
482    ############################ Dependency checks ###############################
483    
484    ######## Compiler
485    env=checkCompiler(env)
486    
487    ######## Python headers & library (required)
488    env=checkPython(env)
489    
490    ######## boost & boost-python (required)
491    env=checkBoost(env)
492    
493    ######## NVCC version (optional)
494    if env['cuda']:
495        env=checkCudaVersion(env)
496    
497    ######## numpy (required) and numpy headers (optional)
498    env=checkNumpy(env)
499    
500    ######## CppUnit (required for tests)
501    env=checkCppUnit(env)
502    
503    ######## optional python modules (sympy, pyproj)
504    env=checkOptionalModules(env)
505    
506    ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
507    env=checkOptionalLibraries(env)
508    
509    #use gmsh info to set some defines
510    if env['gmsh'] == 's':
511        env.Append(CPPDEFINES=['GMSH'])
512    elif env['gmsh'] == 'm':
513        env.Append(CPPDEFINES=['GMSH','GMSH_MPI'])
514    
515    ######## PDFLaTeX (for documentation)
516    env=checkPDFLatex(env)
517    
518    # keep some of our install paths first in the list for the unit tests
519    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
520    env.PrependENVPath('PYTHONPATH', prefix)
521    env['ENV']['ESCRIPT_ROOT'] = prefix
522    
523    if not env['verbose']:
524        env['CXXCOMSTR'] = "Compiling $TARGET"
525        env['SHCXXCOMSTR'] = "Compiling $TARGET"
526        env['ARCOMSTR'] = "Linking $TARGET"
527        env['LINKCOMSTR'] = "Linking $TARGET"
528        env['SHLINKCOMSTR'] = "Linking $TARGET"
529        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
530        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
531        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
532        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
533        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
534    
535    ####################### Configure the subdirectories #########################
536    
537    # remove obsolete files
538    if not env['usempi']:
539        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
540        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
541    
542    from grouptest import *
543    TestGroups=[]
544    
545    # keep an environment without warnings-as-errors
546    dodgy_env=env.Clone()
547    
548    # now add warnings-as-errors flags. This needs to be done after configuration
549    # because the scons test files have warnings in them
550    if ((fatalwarning != '') and (env['werror'])):
551        env.Append(CCFLAGS = fatalwarning)
552    
553    Export(
554      ['env',
555       'dodgy_env',
556       'IS_WINDOWS',
557       'TestGroups'
558      ]
559    )
560    
561    #do not auto build
562    env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
563    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
564    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
565    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
566    
567    env.SConscript(dirs = ['cusplibrary'])
568    
569    #This will pull in the escriptcore/py_src and escriptcore/test
570    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
571    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
572    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
573    if 'dudley' in env['domains']:
574        env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
575    if 'finley' in env['domains']:
576        env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
577    if 'ripley' in env['domains']:
578        env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
579    if 'speckley' in env['domains']:
580        env.SConscript(dirs = ['speckley/src'], variant_dir='$BUILD_DIR/$PLATFORM/speckley', duplicate=0)
581    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
582    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
583    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
584    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
585    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
586    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
587    
588    
589    ######################## Populate the buildvars file #########################
590    
591    write_buildvars(env)
592    
593    write_launcher(env)
594    
595    ################### Targets to build and install libraries ###################
596    
597    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
598    env.Alias('target_init', [target_init])
599    # delete buildvars upon cleanup
600    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
601    
602    # The headers have to be installed prior to build in order to satisfy
603    # #include <paso/Common.h>
604    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
605    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
606    
607    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
608    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
609    
610    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
611    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
612    
613    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
614    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
615    
616    if 'dudley' in env['domains']:
617        env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
618        env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
619    
620    if 'finley' in env['domains']:
621        env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
622        env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
623    
624    if 'ripley' in env['domains']:
625        env.Alias('build_ripley', ['install_cusp_headers', 'install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
626        env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
627    
628    if 'speckley' in env['domains']:
629        env.Alias('build_speckley', ['install_speckley_headers', 'build_speckley_lib', 'build_speckleycpp_lib'])
630        env.Alias('install_speckley', ['build_speckley', 'install_speckley_lib', 'install_speckleycpp_lib', 'install_speckley_py'])
631    
632    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
633    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
634    
635    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
636    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
637    
638    # Now gather all the above into some easy targets: build_all and install_all
639    build_all_list = []
640    build_all_list += ['build_esysUtils']
641    build_all_list += ['build_paso']
642    build_all_list += ['build_escript']
643    build_all_list += ['build_pasowrap']
644    if 'dudley' in env['domains']: build_all_list += ['build_dudley']
645    if 'finley' in env['domains']: build_all_list += ['build_finley']
646    if 'ripley' in env['domains']: build_all_list += ['build_ripley']
647    if 'speckley' in env['domains']: build_all_list += ['build_speckley']
648    build_all_list += ['build_weipa']
649    if not IS_WINDOWS and 'finley' in env['domains']:
650        build_all_list += ['build_escriptreader']
651    if env['usempi']:   build_all_list += ['build_pythonMPI']
652    env.Alias('build_all', build_all_list)
653    
654    install_all_list = []
655    install_all_list += ['target_init']
656    install_all_list += ['install_esysUtils']
657    install_all_list += ['install_paso']
658    install_all_list += ['install_escript']
659    install_all_list += ['install_pasowrap']
660    if 'dudley' in env['domains']: install_all_list += ['install_dudley']
661    if 'finley' in env['domains']: install_all_list += ['install_finley']
662    if 'ripley' in env['domains']: install_all_list += ['install_ripley']
663    if 'speckley' in env['domains']: install_all_list += ['install_speckley']
664    install_all_list += ['install_weipa']
665    if not IS_WINDOWS and 'finley' in env['domains']:
666        install_all_list += ['install_escriptreader']
667    install_all_list += ['install_downunder_py']
668    install_all_list += ['install_modellib_py']
669    install_all_list += ['install_pycad_py']
670    if env['usempi']:   install_all_list += ['install_pythonMPI']
671    env.Alias('install_all', install_all_list)
672    
673    # Default target is install
674    env.Default('install_all')
675    
676    ################## Targets to build and run the test suite ###################
677    
678    if not env['cppunit']:
679        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
680        env.Alias('run_tests', test_msg)
681        env.Alias('build_tests', '')
682    env.Alias('run_tests', ['install_all'])
683    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
684    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
685    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
686    
687    ##################### Targets to build the documentation #####################
688    
689    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
690    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
691    env.Alias('docs', ['basedocs', 'sphinxdoc'])
692    env.Alias('release_prep', ['docs', 'install_all'])
693    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
694    
695    # The test scripts are always generated, this target allows us to
696    # generate the testscripts without doing a full build
697    env.Alias('testscripts',[])
698    
699    if not IS_WINDOWS:
700        generateTestScripts(env, TestGroups)
701    
702    
703    ######################## Summarize our environment ###########################
704    def print_summary():
705        print("")
706        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
707        print("Escript/Finley revision %s"%global_revision)
708        print("  Install prefix:  %s"%env['prefix'])
709        print("          Python:  %s"%sysconfig.PREFIX)
710        print("           boost:  %s"%env['boost_prefix'])
711        if env['numpy_h']:
712            print("           numpy:  YES (with headers)")
713        else:
714            print("           numpy:  YES (without headers)")
715        if env['usempi']:
716            print("             MPI:  YES (flavour: %s)"%env['mpi'])
717        else:
718            print("             MPI:  NO")
719        if env['uselapack']:
720            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
721        else:
722            print("          LAPACK:  NO")
723        if env['cuda']:
724            print("            CUDA:  YES (nvcc: %s)"%env['nvcc_version'])
725        else:
726            print("            CUDA:  NO")
727        d_list=[]
728        e_list=[]
729        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit':
730            if env[i]: e_list.append(i)
731            else: d_list.append(i)
732        for i in e_list:
733            print("%16s:  YES"%i)
734        for i in d_list:
735            print("%16s:  NO"%i)
736        if env['cppunit']:
737            print("         CppUnit:  YES")
738        else:
739            print("         CppUnit:  NO")
740        if env['gmshpy']:
741            gmshpy=" + python module"
742        else:
743            gmshpy=""
744        if env['gmsh']=='m':
745            print("            gmsh:  YES, MPI-ENABLED"+gmshpy)
746        elif env['gmsh']=='s':
747            print("            gmsh:  YES"+gmshpy)
748        else:
749            if env['gmshpy']:
750                print("            gmsh:  python module only")
751            else:
752                print("            gmsh:  NO")
753        print(    "            gzip:  " + ("YES" if env['compressed_files'] else "NO"))
754    
755        if ((fatalwarning != '') and (env['werror'])):
756            print("  Treating warnings as errors")
757        else:
758            print("  NOT treating warnings as errors")
759        print("")
760        for w in env['warnings']:
761            print("WARNING: %s"%w)
762        if len(GetBuildFailures()):
763            print("\nERROR: build stopped due to errors\n")
764        else:
765            print("\nSUCCESS: build complete\n")
766    
767    atexit.register(print_summary)
768    
 # 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.5406

  ViewVC Help
Powered by ViewVC 1.1.26