/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 1866 by ksteube, Thu Oct 9 04:01:06 2008 UTC revision 5184 by caltinay, Wed Oct 1 04:19:22 2014 UTC
# Line 1  Line 1 
1    ##############################################################################
 ########################################################  
2  #  #
3  # Copyright (c) 2003-2008 by University of Queensland  # Copyright (c) 2003-2014 by University of Queensland
4  # Earth Systems Science Computational Center (ESSCC)  # http://www.uq.edu.au
 # http://www.uq.edu.au/esscc  
5  #  #
6  # Primary Business: Queensland, Australia  # Primary Business: Queensland, Australia
7  # Licensed under the Open Software License version 3.0  # Licensed under the Open Software License version 3.0
8  # http://www.opensource.org/licenses/osl-3.0.php  # 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  EnsureSConsVersion(0,96,91)  #
14  EnsurePythonVersion(2,3)  ##############################################################################
   
 import sys, os, re, socket  
   
 # Add our extensions  
 if os.path.isdir('scons'): sys.path.append('scons')  
 import scons_extensions  
15    
16  # Use /usr/lib64 if available, else /usr/lib  EnsureSConsVersion(0,98,1)
17  usr_lib = '/usr/lib'  EnsurePythonVersion(2,5)
 if os.path.isfile('/usr/lib64/libc.so'): usr_lib = '/usr/lib64'  
18    
19  # The string python2.4 or python2.5  import atexit, sys, os, platform, re
20  python_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])  from distutils import sysconfig
21    from dependencies import *
22    from site_init import *
23    
24    # Version number to check for in options file. Increment when new features are
25    # added or existing options changed.
26    REQUIRED_OPTS_VERSION=202
27    
28  # MS Windows support, many thanks to PH  # MS Windows support, many thanks to PH
29  IS_WINDOWS_PLATFORM = (os.name== "nt")  IS_WINDOWS = (os.name == 'nt')
   
 prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  
   
 # Read configuration options from file scons/<hostname>_options.py  
 hostname = re.sub("[^0-9a-zA-Z]", "_", socket.gethostname().split('.')[0])  
 tmp = os.path.join("scons",hostname+"_options.py")  
 options_file = ARGUMENTS.get('options_file', tmp)  
 if not os.path.isfile(options_file):  
   options_file = False  
   print "Options file not found"  
 else:  
   print "Options file is", options_file  
30    
31  # Load options file and command-line arguments  IS_OSX = (os.uname()[0] == 'Darwin')
 opts = Options(options_file, ARGUMENTS)  
32    
33  ############ Load build options ################################  ########################## Determine options file ############################
34    # 1. command line
35    # 2. scons/<hostname>_options.py
36    # 3. name as part of a cluster
37    options_file=ARGUMENTS.get('options_file', None)
38    if not options_file:
39        ext_dir = os.path.join(os.getcwd(), 'scons')
40        hostname = platform.node().split('.')[0]
41        for name in hostname, effectiveName(hostname):
42            mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
43            options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
44            if os.path.isfile(options_file): break
45    
46  opts.AddOptions(  if not os.path.isfile(options_file):
47  # Where to install esys stuff      print("\nWARNING:\nOptions file %s" % options_file)
48    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),      print("not found! Default options will be used which is most likely suboptimal.")
49    ('incinstall', 'where the esys headers will be installed',             os.path.join(Dir('#.').abspath,'include')),      print("We recommend that you copy the most relavent options file in the scons/os/")
50    ('bininstall', 'where the esys binaries will be installed',            os.path.join(prefix,'bin')),      print("subdirectory and customize it to your needs.\n")
51    ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),      options_file = None
52    ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),  
53  # Compilation options  ############################### Build options ################################
54    BoolOption('dodebug', 'For backwards compatibility', 'no'),  
55    BoolOption('usedebug', 'Do you want a debug build?', 'no'),  default_prefix='/usr'
56    BoolOption('usevtk', 'Do you want to use VTK?', 'yes'),  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
57    ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  lapack_flavours=('none', 'clapack', 'mkl')
58    # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below  
59    ('cc_flags', 'C compiler flags to use', '-DEFAULT_1'),  vars = Variables(options_file, ARGUMENTS)
60    ('cc_optim', 'C compiler optimization flags to use', '-DEFAULT_2'),  vars.AddVariables(
61    ('cc_debug', 'C compiler debug flags to use', '-DEFAULT_3'),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
62    ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
63    ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
64    ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),    BoolVariable('verbose', 'Output full compile/link lines', False),
65    ('cc_extra', 'Extra C/C++ flags', ''),  # Compiler/Linker options
66      ('cxx', 'Path to C++ compiler', 'default'),
67      ('cc_flags', 'Base C++ compiler flags', 'default'),
68      ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
69      ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
70      ('cxx_extra', 'Extra C++ compiler flags', ''),
71    ('ld_extra', 'Extra linker flags', ''),    ('ld_extra', 'Extra linker flags', ''),
72    ('sys_libs', 'System libraries to link with', []),    ('nvcc', 'Path to CUDA compiler', 'default'),
73    ('ar_flags', 'Static library archiver flags to use', ''),    ('nvccflags', 'Base CUDA compiler flags', 'default'),
74    BoolOption('useopenmp', 'Compile parallel version using OpenMP', 'yes'),    BoolVariable('werror','Treat compiler warnings as errors', True),
75    BoolOption('usepedantic', 'Compile with -pedantic if using gcc', 'yes'),    BoolVariable('debug', 'Compile with debug flags', False),
76  # Python    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
77    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),    ('omp_flags', 'OpenMP compiler flags', 'default'),
78    ('python_lib_path', 'Path to Python libs', usr_lib),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
79    ('python_libs', 'Python libraries to link with', [python_version]),  # Mandatory libraries
80    ('python_cmd', 'Python command', 'python'),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
81  # Boost    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
82    ('boost_path', 'Path to Boost includes', '/usr/include'),  # Mandatory for tests
83    ('boost_lib_path', 'Path to Boost libs', usr_lib),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
84    ('boost_libs', 'Boost libraries to link with', ['boost_python']),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
85  # NetCDF  # Optional libraries and options
86    BoolOption('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
87    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
88    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
89    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    BoolVariable('netcdf', 'Enable netCDF file support', False),
90  # MPI    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
91    BoolOption('useMPI', 'For backwards compatibility', 'no'),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
92    BoolOption('usempi', 'Compile parallel version using MPI', 'no'),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
93    ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
94    ('mpi_path', 'Path to MPI includes', '/usr/include'),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
95    ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),    BoolVariable('papi', 'Enable PAPI', False),
96    ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
   ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', ['mpich' , 'pthread', 'rt']),  
 # ParMETIS  
   BoolOption('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),  
   ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),  
   ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),  
   ('parmetis_libs', 'ParMETIS library to link with', ['parmetis', 'metis']),  
 # PAPI  
   BoolOption('usepapi', 'switch on/off the usage of PAPI', 'no'),  
   ('papi_path', 'Path to PAPI includes', '/usr/include'),  
   ('papi_lib_path', 'Path to PAPI libs', usr_lib),  
97    ('papi_libs', 'PAPI libraries to link with', ['papi']),    ('papi_libs', 'PAPI libraries to link with', ['papi']),
98    BoolOption('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', False),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
99  # MKL    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
100    BoolOption('usemkl', 'switch on/off the usage of MKL', 'no'),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
101    ('mkl_path', 'Path to MKL includes', '/sw/sdev/cmkl/10.0.2.18/include'),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
102    ('mkl_lib_path', 'Path to MKL libs', '/sw/sdev/cmkl/10.0.2.18/lib/em64t'),    BoolVariable('umfpack', 'Enable UMFPACK', False),
103    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver', 'mkl_em64t', 'guide', 'pthread']),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
104  # UMFPACK    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
105    BoolOption('useumfpack', 'switch on/off the usage of UMFPACK', 'no'),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
106    ('ufc_path', 'Path to UFconfig includes', '/usr/include/suitesparse'),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
107    ('umf_path', 'Path to UMFPACK includes', '/usr/include/suitesparse'),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
108    ('umf_lib_path', 'Path to UMFPACK libs', usr_lib),    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
109    ('umf_libs', 'UMFPACK libraries to link with', ['umfpack']),    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
110  # AMD (used by UMFPACK)    ('lapack_libs', 'LAPACK libraries to link with', []),
111    ('amd_path', 'Path to AMD includes', '/usr/include/suitesparse'),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
112    ('amd_lib_path', 'Path to AMD libs', usr_lib),    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
113    ('amd_libs', 'AMD libraries to link with', ['amd']),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
114  # BLAS (used by UMFPACK)    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
115    ('blas_path', 'Path to BLAS includes', '/usr/include/suitesparse'),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
116    ('blas_lib_path', 'Path to BLAS libs', usr_lib),    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
117    ('blas_libs', 'BLAS libraries to link with', ['blas'])    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
118      BoolVariable('cuda', 'Enable GPU code with CUDA (requires thrust)', False),
119      ListVariable('domains', 'Which domains to build', 'all',\
120                   ['dudley','finley','ripley','speckley']),
121      ('thrust_prefix', 'Prefix/Paths to NVidia thrust installation', default_prefix),
122    # Advanced settings
123      #dudley_assemble_flags = -funroll-loops      to actually do something
124      ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
125      # To enable passing function pointers through python
126      BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
127      # An option for specifying the compiler tools (see windows branch)
128      ('tools_names', 'Compiler tools to use', ['default']),
129      ('env_export', 'Environment variables to be passed to tools',[]),
130      EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
131      EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
132      # finer control over library building, intel aggressive global optimisation
133      # works with dynamic libraries on windows.
134      ('build_shared', 'Build dynamic libraries only', False),
135      ('sys_libs', 'Extra libraries to link with', []),
136      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
137      ('SVN_VERSION', 'Do not use from options file', -2),
138      ('pythoncmd', 'which python to compile with','python'),
139      ('usepython3', 'Is this a python3 build? (experimental)', False),
140      ('longindices', 'use long indices (for very large matrices)', False),
141      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
142      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
143      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
144      BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
145      BoolVariable('compressed_files','Enables reading from compressed binary files', True),
146      ('compression_libs', 'Compression libraries to link with', ['boost_iostreams'])
147  )  )
148    
149  ############ Specify which compilers to use ####################  ##################### Create environment and help text #######################
150    
151  # intelc uses regular expressions improperly and emits a warning about  # Intel's compiler uses regular expressions improperly and emits a warning
152  # failing to find the compilers.  This warning can be safely ignored.  # about failing to find the compilers. This warning can be safely ignored.
153    
154  if IS_WINDOWS_PLATFORM:  # PATH is needed so the compiler, linker and tools are found if they are not
155        env = Environment(tools = ['default', 'msvc'], options = opts)  # in default locations.
156    env = Environment(tools = ['default'], options = vars,
157                      ENV = {'PATH': os.environ['PATH']})
158    
159    # set the vars for clang
160    def mkclang(env):
161        env['CXX']='clang++'
162    
163    if env['tools_names'] != ['default']:
164        zz=env['tools_names']
165        if 'clang' in zz:
166            zz.remove('clang')
167            zz.insert(0, mkclang)
168        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        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK --param=max-vartrack-size=90000000" #avoids vartrack limit being exceeded with escriptcpp.cpp
260        omp_flags    = "-fopenmp"
261        omp_ldflags  = "-fopenmp"
262        fatalwarning = "-Werror"
263        sysheaderopt = "-isystem"
264    elif cc_name == 'cl':
265        # Microsoft Visual C on Windows
266        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
267        cc_optim     = "/O2 /Op /W3"
268        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
269        fatalwarning = "/WX"
270    elif cc_name == 'icl':
271        # Intel C on Windows
272        cc_flags     = '/EHsc /GR /MD'
273        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
274        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
275        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
276        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
277    
278    env['sysheaderopt']=sysheaderopt
279    
280    # set defaults if not otherwise specified
281    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
282    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
283    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
284    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
285    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
286    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
287    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
288    
289    if env['nvccflags'] != 'default':
290        env['NVCCFLAGS'] = env['nvccflags']
291        env['SHNVCCFLAGS'] = env['nvccflags'] + ' -shared'
292    
293    if env['BADPYTHONMACROS']:
294        env.Append(CPPDEFINES = ['BADPYTHONMACROS'])
295    
296    if env['longindices']:
297        env.Append(CPPDEFINES = ['ESYS_INDEXTYPE_LONG'])
298    
299    if env['usepython3']:
300        env.Append(CPPDEFINES=['ESPYTHON3'])
301    
302    # set up the autolazy values
303    if env['forcelazy'] == 'on':
304        env.Append(CPPDEFINES=['FAUTOLAZYON'])
305    elif env['forcelazy'] == 'off':
306        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
307    
308    # set up the collective resolve values
309    if env['forcecollres'] == 'on':
310        env.Append(CPPDEFINES=['FRESCOLLECTON'])
311    elif env['forcecollres'] == 'off':
312        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
313    
314    # allow non-standard C if requested
315    if env['iknowwhatimdoing']:
316        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
317    
318    # Disable OpenMP if no flags provided
319    if env['openmp'] and env['omp_flags'] == '':
320       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
321       env['openmp'] = False
322    
323    if env['openmp']:
324        env.Append(CCFLAGS = env['omp_flags'])
325        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
326  else:  else:
327     if socket.gethostname().split('.')[0] == 'service0':      env['omp_flags']=''
328        env = Environment(tools = ['default', 'intelc'], options = opts)      env['omp_ldflags']=''
    elif os.uname()[4]=='ia64':  
       env = Environment(tools = ['default', 'intelc'], options = opts)  
       if env['CXX'] == 'icpc':  
          env['LINK'] = env['CXX'] # version >=9 of intel c++ compiler requires use of icpc to link in C++ runtimes (icc does not)  
    else:  
       env = Environment(tools = ['default'], options = opts)  
 Help(opts.GenerateHelpText(env))  
   
 ############ Fill in compiler options if not set above #########  
   
 # Backwards compatibility: allow dodebug=yes and useMPI=yes  
 if env['dodebug']: env['usedebug'] = 1  
 if env['useMPI']: env['usempi'] = 1  
   
 # Default compiler options (override allowed in hostname_options.py, but should not be necessary)  
 # For both C and C++ you get: cc_flags and either the optim flags or debug flags  
   
 if env["CC"] == "icc":  
   # Intel compilers  
   cc_flags      = "-fPIC -ansi -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"  
   cc_optim      = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias"  
   cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"  
   omp_optim     = "-openmp -openmp_report0"  
   omp_debug     = "-openmp -openmp_report0"  
   omp_libs      = ['guide', 'pthread']  
   pedantic      = ""  
 elif env["CC"] == "gcc":  
   # GNU C on any system  
   cc_flags      = "-fPIC -ansi -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER"  
   cc_optim      = "-O3"  
   cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"  
   omp_optim     = ""  
   omp_debug     = ""  
   omp_libs      = []  
   pedantic      = "-pedantic-errors -Wno-long-long"  
 elif env["CC"] == "cl":  
   # Microsoft Visual C on Windows  
   cc_flags      = "/FD /EHsc /GR /wd4068 -D_USE_MATH_DEFINES -DDLL_NETCDF"  
   cc_optim      = "/O2 /Op /MT /W3"  
   cc_debug      = "/Od /RTC1 /MTd /ZI -DBOUNDS_CHECK"  
   omp_optim     = ""  
   omp_debug     = ""  
   omp_libs      = []  
   pedantic      = ""  
   
 # If not specified in hostname_options.py then set them here  
 if env["cc_flags"]  == "-DEFAULT_1": env['cc_flags'] = cc_flags  
 if env["cc_optim"]  == "-DEFAULT_2": env['cc_optim'] = cc_optim  
 if env["cc_debug"]  == "-DEFAULT_3": env['cc_debug'] = cc_debug  
 if env["omp_optim"] == "-DEFAULT_4": env['omp_optim'] = omp_optim  
 if env["omp_debug"] == "-DEFAULT_5": env['omp_debug'] = omp_debug  
 if env["omp_libs"]  == "-DEFAULT_6": env['omp_libs'] = omp_libs  
   
 # OpenMP is disabled if useopenmp=no or both variables omp_optim and omp_debug are empty  
 if not env["useopenmp"]:  
   env['omp_optim'] = ""  
   env['omp_debug'] = ""  
   env['omp_libs'] = []  
   
 if env['omp_optim'] == "" and env['omp_debug'] == "": env["useopenmp"] = 0  
   
 ############ Copy environment variables into scons env #########  
   
 try: env['ENV']['OMP_NUM_THREADS'] = os.environ['OMP_NUM_THREADS']  
 except KeyError: env['ENV']['OMP_NUM_THREADS'] = 1  
   
 try: env['ENV']['PATH'] = os.environ['PATH']  
 except KeyError: pass  
   
 try: env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']  
 except KeyError: pass  
   
 try: env['ENV']['C_INCLUDE_PATH'] = os.environ['C_INCLUDE_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['CPLUS_INCLUDE_PATH'] = os.environ['CPLUS_INCLUDE_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['LIBRARY_PATH'] = os.environ['LIBRARY_PATH']  
 except KeyError: pass  
   
 try: env['ENV']['DISPLAY'] = os.environ['DISPLAY']  
 except KeyError: pass  
   
 try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  
 except KeyError: pass  
329    
330  try: env['ENV']['HOME'] = os.environ['HOME']  env['buildvars']['openmp']=int(env['openmp'])
 except KeyError: pass  
   
 # Configure for test suite  
 env.PrependENVPath('PYTHONPATH', prefix)  
 env.PrependENVPath('LD_LIBRARY_PATH', env['libinstall'])  
   
 env['ENV']['ESCRIPT_ROOT'] = prefix  
331    
332  ############ Set up paths for Configure() ######################  # add debug/non-debug compiler flags
333    env['buildvars']['debug']=int(env['debug'])
334  # Make a copy of an environment  if env['debug']:
335  # Use env.Clone if available, but fall back on env.Copy for older version of scons      env.Append(CCFLAGS = env['cc_debug'])
336  def clone_env(env):  else:
337    if 'Clone' in dir(env): return env.Clone()    # scons-0.98      env.Append(CCFLAGS = env['cc_optim'])
   else:                   return env.Copy() # scons-0.96  
   
 # Add cc option -I<Escript>/trunk/include  
 env.Append(CPPPATH      = [Dir('include')])  
338    
339  # Add cc option -L<Escript>/trunk/lib  # always add cc_flags
340  env.Append(LIBPATH      = [Dir(env['libinstall'])])  env.Append(CCFLAGS = env['cc_flags'])
341    
342  env.Append(CPPDEFINES = ['ESCRIPT_EXPORTS', 'FINLEY_EXPORTS'])  # add system libraries
343    env.AppendUnique(LIBS = env['sys_libs'])
344    
345  if env['cc_extra'] != '': env.Append(CCFLAGS = env['cc_extra'])  # determine svn revision
346  if env['ld_extra'] != '': env.Append(LINKFLAGS = env['ld_extra'])  global_revision=ARGUMENTS.get('SVN_VERSION', None)
347    if global_revision:
348        global_revision = re.sub(':.*', '', global_revision)
349        global_revision = re.sub('[^0-9]', '', global_revision)
350        if global_revision == '': global_revision='-2'
351    else:
352      # Get the global Subversion revision number for the getVersion() method
353      try:
354        global_revision = os.popen('svnversion -n .').read()
355        global_revision = re.sub(':.*', '', global_revision)
356        global_revision = re.sub('[^0-9]', '', global_revision)
357        if global_revision == '': global_revision='-2'
358      except:
359        global_revision = '-1'
360    env['svn_revision']=global_revision
361    env['buildvars']['svn_revision']=global_revision
362    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
363    
364    if IS_WINDOWS:
365        if not env['build_shared']:
366            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
367            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
368    
369    # VSL random numbers
370    env['buildvars']['vsl_random']=int(env['vsl_random'])
371    if env['vsl_random']:
372        env.Append(CPPDEFINES = ['MKLRANDOM'])
373    
374    env['IS_WINDOWS']=IS_WINDOWS
375    
376    ###################### Copy required environment vars ########################
377    
378    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
379    if IS_WINDOWS:
380        LD_LIBRARY_PATH_KEY='PATH'
381        env['ENV']['LD_LIBRARY_PATH']=''
382    else:
383        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
384    
385  if env['usepedantic']: env.Append(CCFLAGS = pedantic)  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
386    
387  # MS Windows  # the following env variables are exported for the unit tests
 if IS_WINDOWS_PLATFORM:  
   env.PrependENVPath('PATH',    [env['boost_lib_path']])  
   env.PrependENVPath('PATH',    [env['libinstall']])  
   if env['usenetcdf']:  
     env.PrependENVPath('PATH',  [env['netCDF_lib_path']])  
388    
389  env.Append(ARFLAGS = env['ar_flags'])  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
390        try:
391            env['ENV'][key] = os.environ[key]
392        except KeyError:
393            env['ENV'][key] = '1'
394    
395    env_export=env['env_export']
396    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP','LD_PRELOAD'])
397    
398    for key in set(env_export):
399        try:
400            env['ENV'][key] = os.environ[key]
401        except KeyError:
402            pass
403    
 # Get the global Subversion revision number for getVersion() method  
404  try:  try:
405     global_revision = os.popen("svnversion -n .").read()      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
406     global_revision = re.sub(":.*", "", global_revision)  except KeyError:
407     global_revision = re.sub("[^0-9]", "", global_revision)      pass
 except:  
    global_revision="-1"  
 if global_revision == "": global_revision="-2"  
 env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  
   
 ############ numarray (required) ###############################  
   
 try:  
   from numarray import identity  
 except ImportError:  
   print "Cannot import numarray, you need to set your PYTHONPATH"  
   sys.exit(1)  
   
 ############ C compiler (required) #############################  
   
 # Create a Configure() environment for checking existence of required libraries and headers  
 conf = Configure(clone_env(env))  
   
 # Test that the compiler is working  
 if not conf.CheckFunc('printf'):  
   print "Cannot run C compiler '%s' (or libc is missing)" % (env['CC'])  
   sys.exit(1)  
   
 if conf.CheckFunc('gethostname'):  
   conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])  
   
 ############ python libraries (required) #######################  
   
 conf.env.AppendUnique(CPPPATH       = [env['python_path']])  
 conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
408    
409  conf.env.PrependENVPath('LD_LIBRARY_PATH', env['python_lib_path'])  # The wrapper script needs to find these libs  if IS_OSX:
   
 if not conf.CheckCHeader('Python.h'):  
   print "Cannot find python include files (tried 'Python.h' in directory %s)" % (env['python_path'])  
   sys.exit(1)  
 if not conf.CheckFunc('Py_Main'):  
   print "Cannot find python library method Py_Main (tried lib %s in directory %s)" % (env['python_libs'], env['python_lib_path'])  
   sys.exit(1)  
   
 ############ boost (required) ##################################  
   
 conf.env.AppendUnique(CPPPATH       = [env['boost_path']])  
 conf.env.AppendUnique(LIBPATH       = [env['boost_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['boost_libs']])  
   
 conf.env.PrependENVPath('LD_LIBRARY_PATH', env['boost_lib_path'])   # The wrapper script needs to find these libs  
   
 if not conf.CheckCXXHeader('boost/python.hpp'):  
   print "Cannot find boost include files (tried boost/python.hpp in directory %s)" % (env['boost_path'])  
   sys.exit(1)  
 if not conf.CheckFunc('PyObject_SetAttr'):  
   print "Cannot find boost library method PyObject_SetAttr (tried method PyObject_SetAttr in library %s in directory %s)" % (env['boost_libs'], env['boost_lib_path'])  
   sys.exit(1)  
   
 # Commit changes to environment  
 env = conf.Finish()  
   
 ############ VTK (optional) ####################################  
   
 if env['usevtk']:  
410    try:    try:
411      import vtk      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
412      env['usevtk'] = 1    except KeyError:
413    except ImportError:      pass
     env['usevtk'] = 0  
   
 # Add VTK to environment env if it was found  
 if env['usevtk']:  
   env.Append(CPPDEFINES = ['USE_VTK'])  
   
 ############ NetCDF (optional) #################################  
   
 conf = Configure(clone_env(env))  
   
 if env['usenetcdf']:  
   conf.env.AppendUnique(CPPPATH = [env['netCDF_path']])  
   conf.env.AppendUnique(LIBPATH = [env['netCDF_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['netCDF_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['netCDF_lib_path'])    # The wrapper script needs to find these libs  
   
 if env['usenetcdf'] and not conf.CheckCHeader('netcdf.h'): env['usenetcdf'] = 0  
 if env['usenetcdf'] and not conf.CheckFunc('nc_open'): env['usenetcdf'] = 0  
   
 # Add NetCDF to environment env if it was found  
 if env['usenetcdf']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['USE_NETCDF'])  
 else:  
   conf.Finish()  
   
 ############ PAPI (optional) ###################################  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env))  
   
 if env['usepapi']:  
   conf.env.AppendUnique(CPPPATH = [env['papi_path']])  
   conf.env.AppendUnique(LIBPATH = [env['papi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['papi_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['papi_lib_path'])  # The wrapper script needs to find these libs  
   
 if env['usepapi'] and not conf.CheckCHeader('papi.h'): env['usepapi'] = 0  
 if env['usepapi'] and not conf.CheckFunc('PAPI_start_counters'): env['usepapi'] = 0  
   
 # Add PAPI to environment env if it was found  
 if env['usepapi']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['BLOCKPAPI'])  
 else:  
   conf.Finish()  
   
 ############ MKL (optional) ####################################  
414    
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env))  
415    
416  if env['usemkl']:  # these shouldn't be needed
417    conf.env.AppendUnique(CPPPATH = [env['mkl_path']])  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
418    conf.env.AppendUnique(LIBPATH = [env['mkl_lib_path']])  #    try:
419    conf.env.AppendUnique(LIBS    = [env['mkl_libs']])  #        env['ENV'][key] = os.environ[key]
420    conf.env.PrependENVPath('LD_LIBRARY_PATH', env['mkl_lib_path'])   # The wrapper script needs to find these libs  #    except KeyError:
421    #        pass
 if env['usemkl'] and not conf.CheckCHeader('mkl_solver.h'): env['usemkl'] = 0  
 if env['usemkl'] and not conf.CheckFunc('pardiso_'): env['usemkl'] = 0  
   
 # Add MKL to environment env if it was found  
 if env['usemkl']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['MKL'])  
 else:  
   conf.Finish()  
422    
423  ############ UMFPACK (optional) ################################  try:
424        env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
425    except KeyError:
426        pass
427    
428  # Start a new configure environment that reflects what we've already found  ######################## Add some custom builders ############################
 conf = Configure(clone_env(env))  
429    
430  if env['useumfpack']:  if env['pythoncmd']=='python':
431    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
   conf.env.AppendUnique(CPPPATH = [env['umf_path']])  
   conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['umf_libs']])  
   conf.env.AppendUnique(CPPPATH = [env['amd_path']])  
   conf.env.AppendUnique(LIBPATH = [env['amd_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['amd_libs']])  
   conf.env.AppendUnique(CPPPATH = [env['blas_path']])  
   conf.env.AppendUnique(LIBPATH = [env['blas_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['blas_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['umf_lib_path'])   # The wrapper script needs to find these libs  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['amd_lib_path'])   # The wrapper script needs to find these libs  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['blas_lib_path'])  # The wrapper script needs to find these libs  
   
 if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0  
 if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0  
   
 # Add UMFPACK to environment env if it was found  
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
432  else:  else:
433    conf.Finish()      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
434    env.Append(BUILDERS = {'PyCompile' : py_builder});
435    
436  ############ Add the compiler flags ############################  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
437    env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
438    
439  # Enable debug by choosing either cc_debug or cc_optim  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
440  if env['usedebug']:  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
 else:  
   env.Append(CCFLAGS        = env['cc_optim'])  
   env.Append(CCFLAGS        = env['omp_optim'])  
441    
442  # Always use cc_flags  runPyExample_builder = Builder(action = runPyExample, suffix = '.passed', src_suffic='.py', single_source=True)
443  env.Append(CCFLAGS      = env['cc_flags'])  env.Append(BUILDERS = {'RunPyExample' : runPyExample_builder});
 env.Append(LIBS         = [env['omp_libs']])  
   
 ############ MPI (optional) ####################################  
   
 # Create a modified environment for MPI programs (identical to env if usempi=no)  
 env_mpi = clone_env(env)  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env_mpi))  
   
 if env_mpi['usempi']:  
   conf.env.AppendUnique(CPPPATH = [env_mpi['mpi_path']])  
   conf.env.AppendUnique(LIBPATH = [env_mpi['mpi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['mpi_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['mpi_lib_path'])   # The wrapper script needs to find these libs  
   
 if env_mpi['usempi'] and not conf.CheckCHeader('mpi.h'): env_mpi['usempi'] = 0  
 if env_mpi['usempi'] and not conf.CheckFunc('MPI_Init'): env_mpi['usempi'] = 0  
   
 # Add MPI to environment env_mpi if it was found  
 if env_mpi['usempi']:  
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['PASO_MPI', 'MPI_NO_CPPBIND', env_mpi['MPICH_IGNORE_CXX_SEEK']])  
 else:  
   conf.Finish()  
444    
445  env['usempi'] = env_mpi['usempi']  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
446    env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
447    
448  ############ ParMETIS (optional) ###############################  ############################ Dependency checks ###############################
449    
450  # Start a new configure environment that reflects what we've already found  ######## Compiler
451  conf = Configure(clone_env(env_mpi))  env=checkCompiler(env)
452    
453  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0  ######## Python headers & library (required)
454    env=checkPython(env)
455    
456  if env_mpi['useparmetis']:  ######## boost & boost-python (required)
457    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  env=checkBoost(env)
   conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  
   conf.env.PrependENVPath('LD_LIBRARY_PATH', env['parmetis_lib_path'])  # The wrapper script needs to find these libs  
458    
459  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  ######## NVCC version (optional)
460  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0  if env['cuda']:
461        env=checkCudaVersion(env)
462    
463  # Add ParMETIS to environment env_mpi if it was found  ######## numpy (required) and numpy headers (optional)
464  if env_mpi['useparmetis']:  env=checkNumpy(env)
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  
 else:  
   conf.Finish()  
465    
466  env['useparmetis'] = env_mpi['useparmetis']  ######## CppUnit (required for tests)
467    env=checkCppUnit(env)
468    
469  ############ Summarize our environment #########################  ######## optional python modules (sympy, pyproj)
470    env=checkOptionalModules(env)
471    
472  print ""  ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
473  print "Summary of configuration (see ./config.log for information)"  env=checkOptionalLibraries(env)
 print " Using python libraries"  
 print " Using numarray"  
 print " Using boost"  
 if env['usenetcdf']: print "    Using NetCDF"  
 else: print "   Not using NetCDF"  
 if env['usevtk']: print "   Using VTK"  
 else: print "   Not using VTK"  
 if env['usemkl']: print "   Using MKL"  
 else: print "   Not using MKL"  
 if env['useumfpack']: print "   Using UMFPACK"  
 else: print "   Not using UMFPACK"  
 if env['useopenmp']: print "    Using OpenMP"  
 else: print "   Not using OpenMP"  
 if env['usempi']: print "   Using MPI"  
 else: print "   Not using MPI"  
 if env['useparmetis']: print "  Using ParMETIS"  
 else: print "   Not using ParMETIS (requires MPI)"  
 if env['usepapi']: print "  Using PAPI"  
 else: print "   Not using PAPI"  
 if env['usedebug']: print " Compiling for debug"  
 else: print "   Not compiling for debug"  
 print " Installing in", prefix  
 print ""  
   
 ############ Delete option-dependent files #####################  
   
 Execute(Delete(env['libinstall'] + "/Compiled.with.debug"))  
 Execute(Delete(env['libinstall'] + "/Compiled.with.mpi"))  
 Execute(Delete(env['libinstall'] + "/Compiled.with.openmp"))  
 if not env['usempi']: Execute(Delete(env['libinstall'] + "/pythonMPI"))  
474    
475  ############ Add some custom builders ##########################  ######## PDFLaTeX (for documentation)
476    env=checkPDFLatex(env)
477    
478  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  # keep some of our install paths first in the list for the unit tests
479  env.Append(BUILDERS = {'PyCompile' : py_builder});  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
480    env.PrependENVPath('PYTHONPATH', prefix)
481    env['ENV']['ESCRIPT_ROOT'] = prefix
482    
483  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  if not env['verbose']:
484  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});      env['CXXCOMSTR'] = "Compiling $TARGET"
485        env['SHCXXCOMSTR'] = "Compiling $TARGET"
486        env['ARCOMSTR'] = "Linking $TARGET"
487        env['LINKCOMSTR'] = "Linking $TARGET"
488        env['SHLINKCOMSTR'] = "Linking $TARGET"
489        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
490        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
491        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
492        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
493        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
494    
495    ####################### Configure the subdirectories #########################
496    
497    # remove obsolete files
498    if not env['usempi']:
499        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
500        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
501    
502    from grouptest import *
503    TestGroups=[]
504    
505    # keep an environment without warnings-as-errors
506    dodgy_env=env.Clone()
507    
508    # now add warnings-as-errors flags. This needs to be done after configuration
509    # because the scons test files have warnings in them
510    if ((fatalwarning != '') and (env['werror'])):
511        env.Append(CCFLAGS = fatalwarning)
512    
513    Export(
514      ['env',
515       'dodgy_env',
516       'IS_WINDOWS',
517       'TestGroups'
518      ]
519    )
520    
521  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  #do not auto build
522  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
523    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
524    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
525    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
526    
527    env.SConscript(dirs = ['cusplibrary'])
528    
529    #This will pull in the escriptcore/py_src and escriptcore/test
530    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
531    #env.SConscript(dirs = ['escript/test'], variant_dir='$BUILD_DIR/$PLATFORM/escript/test', duplicate=0)
532    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
533    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
534    if 'dudley' in env['domains']:
535        env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
536    if 'finley' in env['domains']:
537        env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
538    if 'ripley' in env['domains']:
539        env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
540    if 'speckley' in env['domains']:
541        env.SConscript(dirs = ['speckley/src'], variant_dir='$BUILD_DIR/$PLATFORM/speckley', duplicate=0)
542    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
543    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
544    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
545    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
546    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
547    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
548    
 ############ Build the subdirectories ##########################  
549    
550  Export(["env", "env_mpi", "clone_env"])  ######################## Populate the buildvars file #########################
551    
552  env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  write_buildvars(env)
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
 env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  
 env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  
 env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 env.SConscript(dirs = ['scripts'], build_dir='build/$PLATFORM/scripts', duplicate=0)  
553    
554  ############ Remember what optimizations we used ###############  ################### Targets to build and install libraries ###################
555    
556  remember_list = []  target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
557    env.Alias('target_init', [target_init])
558    # delete buildvars upon cleanup
559    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
560    
561  if env['usedebug']:  # The headers have to be installed prior to build in order to satisfy
562    remember_list += env.Command(env['libinstall'] + "/Compiled.with.debug", None, Touch('$TARGET'))  # #include <paso/Common.h>
563    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
564    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
565    
566  if env['usempi']:  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
567    remember_list += env.Command(env['libinstall'] + "/Compiled.with.mpi", None, Touch('$TARGET'))  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
568    
569  if env['omp_optim'] != '':  env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
570    remember_list += env.Command(env['libinstall'] + "/Compiled.with.openmp", None, Touch('$TARGET'))  env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
571    
572  env.Alias('remember_options', remember_list)  env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
573    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
574    
575  ############ Targets to build and install libraries ############  if 'dudley' in env['domains']:
576        env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
577        env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
578    
579  target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  if 'finley' in env['domains']:
580  env.Alias('target_init', [target_init])      env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
581        env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
582    
583  # The headers have to be installed prior to build in order to satisfy #include <paso/Common.h>  if 'ripley' in env['domains']:
584  env.Alias('build_esysUtils', ['target_install_esysUtils_headers', 'target_esysUtils_a'])      env.Alias('build_ripley', ['install_cusp_headers', 'install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
585  env.Alias('install_esysUtils', ['build_esysUtils', 'target_install_esysUtils_a'])      env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
586    
587  env.Alias('build_paso', ['target_install_paso_headers', 'target_paso_a'])  if 'speckley' in env['domains']:
588  env.Alias('install_paso', ['build_paso', 'target_install_paso_a'])      env.Alias('build_speckley', ['install_speckley_headers', 'build_speckley_lib', 'build_speckleycpp_lib'])
589        env.Alias('install_speckley', ['build_speckley', 'install_speckley_lib', 'install_speckleycpp_lib', 'install_speckley_py'])
590    
591  env.Alias('build_escript', ['target_install_escript_headers', 'target_escript_so', 'target_escriptcpp_so'])  env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
592  env.Alias('install_escript', ['build_escript', 'target_install_escript_so', 'target_install_escriptcpp_so', 'target_install_escript_py'])  env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
593    
594  env.Alias('build_finley', ['target_install_finley_headers', 'target_finley_so', 'target_finleycpp_so'])  env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
595  env.Alias('install_finley', ['build_finley', 'target_install_finley_so', 'target_install_finleycpp_so', 'target_install_finley_py'])  env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
596    
597  # Now gather all the above into a couple easy targets: build_all and install_all  # Now gather all the above into some easy targets: build_all and install_all
598  build_all_list = []  build_all_list = []
599  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
600  build_all_list += ['build_paso']  build_all_list += ['build_paso']
601  build_all_list += ['build_escript']  build_all_list += ['build_escript']
602  build_all_list += ['build_finley']  build_all_list += ['build_pasowrap']
603  if env['usempi']:       build_all_list += ['target_pythonMPI_exe']  if 'dudley' in env['domains']: build_all_list += ['build_dudley']
604  if not IS_WINDOWS_PLATFORM: build_all_list += ['target_finley_wrapper']  if 'finley' in env['domains']: build_all_list += ['build_finley']
605    if 'ripley' in env['domains']: build_all_list += ['build_ripley']
606    if 'speckley' in env['domains']: build_all_list += ['build_speckley']
607    build_all_list += ['build_weipa']
608    if not IS_WINDOWS and 'finley' in env['domains']:
609        build_all_list += ['build_escriptreader']
610    if env['usempi']:   build_all_list += ['build_pythonMPI']
611  env.Alias('build_all', build_all_list)  env.Alias('build_all', build_all_list)
612    
613  install_all_list = []  install_all_list = []
# Line 610  install_all_list += ['target_init'] Line 615  install_all_list += ['target_init']
615  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
616  install_all_list += ['install_paso']  install_all_list += ['install_paso']
617  install_all_list += ['install_escript']  install_all_list += ['install_escript']
618  install_all_list += ['install_finley']  install_all_list += ['install_pasowrap']
619  install_all_list += ['target_install_pyvisi_py']  if 'dudley' in env['domains']: install_all_list += ['install_dudley']
620  install_all_list += ['target_install_modellib_py']  if 'finley' in env['domains']: install_all_list += ['install_finley']
621  install_all_list += ['target_install_pycad_py']  if 'ripley' in env['domains']: install_all_list += ['install_ripley']
622  if env['usempi']:       install_all_list += ['target_install_pythonMPI_exe']  if 'speckley' in env['domains']: install_all_list += ['install_speckley']
623  if not IS_WINDOWS_PLATFORM: install_all_list += ['target_install_finley_wrapper']  install_all_list += ['install_weipa']
624  install_all_list += ['remember_options']  if not IS_WINDOWS and 'finley' in env['domains']:
625        install_all_list += ['install_escriptreader']
626    install_all_list += ['install_downunder_py']
627    install_all_list += ['install_modellib_py']
628    install_all_list += ['install_pycad_py']
629    if env['usempi']:   install_all_list += ['install_pythonMPI']
630  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
631    
632  # Default target is install  # Default target is install
633  env.Default('install_all')  env.Default('install_all')
634    
635  ############ Targets to build and run the test suite ###########  ################## Targets to build and run the test suite ###################
   
 env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  
 env.Alias('install_cppunittest', ['build_cppunittest', 'target_install_cppunittest_a'])  
 env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])  
 env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])  
636    
637  ############ Targets to build the documentation ################  if not env['cppunit']:
638        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
639        env.Alias('run_tests', test_msg)
640        env.Alias('build_tests', '')
641    env.Alias('run_tests', ['install_all'])
642    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
643    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
644    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
645    
646    ##################### Targets to build the documentation #####################
647    
648    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
649    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
650    env.Alias('docs', ['basedocs', 'sphinxdoc'])
651    env.Alias('release_prep', ['docs', 'install_all'])
652    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
653    
654    # The test scripts are always generated, this target allows us to
655    # generate the testscripts without doing a full build
656    env.Alias('testscripts',[])
657    
658    if not IS_WINDOWS:
659        generateTestScripts(env, TestGroups)
660    
661    
662    
663    ######################## Summarize our environment ###########################
664    def print_summary():
665        print("")
666        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
667        print("Escript/Finley revision %s"%global_revision)
668        print("  Install prefix:  %s"%env['prefix'])
669        print("          Python:  %s"%sysconfig.PREFIX)
670        print("           boost:  %s"%env['boost_prefix'])
671        if env['numpy_h']:
672            print("           numpy:  YES (with headers)")
673        else:
674            print("           numpy:  YES (without headers)")
675        if env['usempi']:
676            print("             MPI:  YES (flavour: %s)"%env['mpi'])
677        else:
678            print("             MPI:  DISABLED")
679        if env['uselapack']:
680            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
681        else:
682            print("          LAPACK:  DISABLED")
683        if env['cuda']:
684            print("            CUDA:  YES (nvcc: %s)"%env['nvcc_version'])
685        else:
686            print("            CUDA:  DISABLED")
687        d_list=[]
688        e_list=[]
689        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit','vsl_random':
690            if env[i]: e_list.append(i)
691            else: d_list.append(i)
692        for i in e_list:
693            print("%16s:  YES"%i)
694        for i in d_list:
695            print("%16s:  DISABLED"%i)
696        if env['cppunit']:
697            print("         CppUnit:  FOUND")
698        else:
699            print("         CppUnit:  NOT FOUND")
700        if env['gmsh']=='m':
701            print("            gmsh:  FOUND, MPI-ENABLED")
702        elif env['gmsh']=='s':
703            print("            gmsh:  FOUND")
704        else:
705            print("            gmsh:  NOT FOUND")
706        print(    "            gzip:  " + ("YES" if env['compressed_files'] else "NO"))
707    
708        if ((fatalwarning != '') and (env['werror'])):
709            print("  Treating warnings as errors")
710        else:
711            print("  NOT treating warnings as errors")
712        print("")
713        for w in env['warnings']:
714            print("WARNING: %s"%w)
715        if len(GetBuildFailures()):
716            print("\nERROR: build stopped due to errors\n")
717        else:
718            print("\nSUCCESS: build complete\n")
719    
720  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html'])  atexit.register(print_summary)
721    

Legend:
Removed from v.1866  
changed lines
  Added in v.5184

  ViewVC Help
Powered by ViewVC 1.1.26