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

Diff of /branches/inv2jf/SConstruct

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

revision 2882 by caltinay, Thu Jan 28 02:27:49 2010 UTC revision 5277 by caltinay, Mon Nov 24 03:29:15 2014 UTC
# Line 1  Line 1 
1    ##############################################################################
 ########################################################  
2  #  #
3  # Copyright (c) 2003-2010 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, platform, stat  
 # For copy()  
 import shutil  
   
 # 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')
30    
31  prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  IS_OSX = (os.uname()[0] == 'Darwin')
32    
33  #Holds names of variables from the calling environment which need to be passed  ########################## Determine options file ############################
34  #to tools  # 1. command line
35  env_export=[]  # 2. scons/<hostname>_options.py
36    # 3. name as part of a cluster
 #Determine where to read options from use:  
 #1. command line  
 #2. scons/<hostname>_options.py  
 #3. name as part of a cluster  
37  options_file=ARGUMENTS.get('options_file', None)  options_file=ARGUMENTS.get('options_file', None)
 effective_hostname=socket.gethostname().split('.')[0]  
38  if not options_file:  if not options_file:
39    mangledhostname = re.sub("[^0-9a-zA-Z]", "_", effective_hostname)      ext_dir = os.path.join(os.getcwd(), 'scons')
40    options_file = os.path.join("scons",mangledhostname+"_options.py")      hostname = platform.node().split('.')[0]
41    #If there is no options file with that name see if there is a substitute      for name in hostname, effectiveName(hostname):
42    if not os.path.isfile(options_file):          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
43      effective_hostname = scons_extensions.effectiveName(effective_hostname)          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
44      mangledhostname = re.sub("[^0-9a-zA-Z]", "_", effective_hostname)          if os.path.isfile(options_file): break
     options_file = os.path.join("scons",mangledhostname+"_options.py")  
45    
46  if not os.path.isfile(options_file):  if not os.path.isfile(options_file):
47    print "Options file not found (expected '%s')" % options_file      print("\nWARNING:\nOptions file %s" % options_file)
48    options_file = False      print("not found! Default options will be used which is most likely suboptimal.")
49  else:      print("We recommend that you copy the most relavent options file in the scons/os/")
50    print "Options file is", options_file      print("subdirectory and customize it to your needs.\n")
51        options_file = None
52  #Does our scons support the newer Variables class or do we need to use Options?  
53    ############################### Build options ################################
54  try:  
55     dummyvar=Variables  default_prefix='/usr'
56     opts = Variables(options_file, ARGUMENTS)  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
57     adder = opts.AddVariables  lapack_flavours=('none', 'clapack', 'mkl')
58  except:  
59     opts = Options(options_file, ARGUMENTS)  vars = Variables(options_file, ARGUMENTS)
60     adder = opts.AddOptions  vars.AddVariables(
61     BoolVariable = BoolOption    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
62      PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
63  ############ Load build options ################################    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
64      BoolVariable('verbose', 'Output full compile/link lines', False),
65  adder(  # Compiler/Linker options
66  #opts.AddOptions(    ('cxx', 'Path to C++ compiler', 'default'),
67  # Where to install esys stuff    ('cc_flags', 'Base C++ compiler flags', 'default'),
68    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
69    ('incinstall', 'where the esys headers will be installed',             os.path.join(Dir('#.').abspath,'include')),    ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
70    ('bininstall', 'where the esys binaries will be installed',            os.path.join(prefix,'bin')),    ('cxx_extra', 'Extra C++ compiler flags', ''),
   ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),  
   ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),  
 # Compilation options  
   BoolVariable('dodebug', 'For backwards compatibility', 'no'),  
   BoolVariable('usedebug', 'Do you want a debug build?', 'no'),  
   BoolVariable('usevtk', 'Do you want to use VTK?', 'yes'),  
   ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  
   ('cc', 'path to C compiler', 'DEFAULT'),  
   ('cxx', 'path to C++ compiler', 'DEFAULT'),  
   ('win_cc_name', 'windows C compiler name if needed', 'msvc'),  
   # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below  
   ('cc_flags', 'C compiler flags to use', '-DEFAULT_1'),  
   ('cc_optim', 'C compiler optimization flags to use', '-DEFAULT_2'),  
   ('cc_debug', 'C compiler debug flags to use', '-DEFAULT_3'),  
   ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),  
   ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),  
   ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),  
   ('cc_extra', 'Extra C/C++ 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    BoolVariable('useopenmp', 'Compile parallel version using OpenMP', 'no'),    BoolVariable('werror','Treat compiler warnings as errors', True),
75    BoolVariable('usepedantic', 'Compile with -pedantic if using gcc', 'no'),    BoolVariable('debug', 'Compile with debug flags', False),
76    BoolVariable('usewarnings','Compile with warnings as errors if using gcc','yes'),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
77    ('forcelazy','for testing use only - set the default value for autolazy','leave_alone'),    ('omp_flags', 'OpenMP compiler flags', 'default'),
78    ('forcecollres','for testing use only - set the default value for force resolving collective ops','leave_alone'),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
79  # Python  # Mandatory libraries
80    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
81    ('python_lib_path', 'Path to Python libs', usr_lib),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
82    ('python_libs', 'Python libraries to link with', [python_version]),  # Mandatory for tests
83    ('python_cmd', 'Python command', 'python'),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
84  # Boost    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
85    ('boost_path', 'Path to Boost includes', '/usr/include'),  # Optional libraries and options
86    ('boost_lib_path', 'Path to Boost libs', usr_lib),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
87    ('boost_libs', 'Boost libraries to link with', ['boost_python']),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
88  # NetCDF    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
89    BoolVariable('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    BoolVariable('cuda', 'Enable GPU code with CUDA (requires thrust)', False),
90    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),    ('thrust_prefix', 'Prefix/Paths to NVidia thrust installation', default_prefix),
91    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    BoolVariable('netcdf', 'Enable netCDF file support', False),
92    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
93  # MPI    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
94    BoolVariable('useMPI', 'For backwards compatibility', 'no'),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
95    BoolVariable('usempi', 'Compile parallel version using MPI', 'no'),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
96    ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
97    ('mpi_path', 'Path to MPI includes', '/usr/include'),    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
98    ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
99    ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
100    ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', []),    BoolVariable('umfpack', 'Enable UMFPACK', False),
101    ('mpi_flavour','Type of MPI execution environment','none'),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
102  # ParMETIS    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
103    BoolVariable('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
104    ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
105    ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
106    ('parmetis_libs', 'ParMETIS library to link with', ['parmetis', 'metis']),    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
107  # PAPI    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
108    BoolVariable('usepapi', 'switch on/off the usage of PAPI', 'no'),    ('lapack_libs', 'LAPACK libraries to link with', []),
109    ('papi_path', 'Path to PAPI includes', '/usr/include'),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
110    ('papi_lib_path', 'Path to PAPI libs', usr_lib),    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
   ('papi_libs', 'PAPI libraries to link with', ['papi']),  
   BoolVariable('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', False),  
 # MKL  
   BoolVariable('usemkl', 'switch on/off the usage of MKL', 'no'),  
   ('mkl_path', 'Path to MKL includes', '/sw/sdev/cmkl/10.0.2.18/include'),  
   ('mkl_lib_path', 'Path to MKL libs', '/sw/sdev/cmkl/10.0.2.18/lib/em64t'),  
   ('mkl_libs', 'MKL libraries to link with', ['mkl_solver', 'mkl_em64t', 'guide', 'pthread']),  
 # UMFPACK  
   BoolVariable('useumfpack', 'switch on/off the usage of UMFPACK', 'no'),  
   ('ufc_path', 'Path to UFconfig includes', '/usr/include/suitesparse'),  
   ('umf_path', 'Path to UMFPACK includes', '/usr/include/suitesparse'),  
   ('umf_lib_path', 'Path to UMFPACK libs', usr_lib),  
   ('umf_libs', 'UMFPACK libraries to link with', ['umfpack']),  
 # Silo  
   BoolVariable('usesilo', 'switch on/off the usage of Silo', 'yes'),  
   ('silo_path', 'Path to Silo includes', '/usr/include'),  
   ('silo_lib_path', 'Path to Silo libs', usr_lib),  
111    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
112  # AMD (used by UMFPACK)    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
113    ('amd_path', 'Path to AMD includes', '/usr/include/suitesparse'),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
114    ('amd_lib_path', 'Path to AMD libs', usr_lib),    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
115    ('amd_libs', 'AMD libraries to link with', ['amd']),    ListVariable('domains', 'Which domains to build', 'all',\
116  # BLAS (used by UMFPACK)                 ['dudley','finley','ripley','speckley']),
117    ('blas_path', 'Path to BLAS includes', '/usr/include/suitesparse'),  # Advanced settings
118    ('blas_lib_path', 'Path to BLAS libs', usr_lib),    ('launcher', 'Launcher command (e.g. mpirun)', 'default'),
119    ('blas_libs', 'BLAS libraries to link with', ['blas']),    ('prelaunch', 'Command to execute before launcher (e.g. mpdboot)', 'default'),
120  #Lapack options    ('postlaunch', 'Command to execute after launcher (e.g. mpdexit)', 'default'),
121    BoolVariable('uselapack','switch on/off use of Lapack','no'),    #dudley_assemble_flags = -funroll-loops      to actually do something
122    ('lapack_path', 'Path to Lapack includes','/usr/include'),    ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
123    ('lapack_lib_path', 'Path to Lapack libs', usr_lib),    # To enable passing function pointers through python
124    ('lapack_libs', 'Lapack libraries to link with', []),    BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
125    ('lapack_type', '{clapack,mkl}','clapack'),    # An option for specifying the compiler tools
126  # An option for specifying the compiler tools set (see windows branch).    ('tools_names', 'Compiler tools to use', ['default']),
127    ('tools_names', 'allow control over the tools in the env setup', ['intelc']),    ('env_export', 'Environment variables to be passed to tools',[]),
128  # finer control over library building, intel aggressive global optimisation    EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
129  # works with dynamic libraries on windows.    EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
130    ('share_esysUtils', 'control static or dynamic esysUtils lib', False),    ('build_shared', 'Build dynamic libraries only', False),
131    ('share_paso', 'control static or dynamic paso lib', False),    ('sys_libs', 'Extra libraries to link with', []),
132    ('env_export','Environment variables to be passed to children',[]),    ('escript_opts_version', 'Version of options file (do not specify on command line)'),
133  #To enable passing function pointers through python    ('SVN_VERSION', 'Do not use from options file', -2),
134    BoolVariable('iknowwhatimdoing','allow nonstandard C',False)    ('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    ##################### Create environment and help text #######################
150    
151    # Intel's compiler uses regular expressions improperly and emits a warning
152    # about failing to find the compilers. This warning can be safely ignored.
153    
154  ############ Specify which compilers to use ####################  # PATH is needed so the compiler, linker and tools are found if they are not
155    # in default locations.
156  # intelc uses regular expressions improperly and emits a warning about  env = Environment(tools = ['default'], options = vars,
157  # failing to find the compilers.  This warning can be safely ignored.                    ENV = {'PATH': os.environ['PATH']})
158    
159  if IS_WINDOWS_PLATFORM:  # set the vars for clang
160        env = Environment(options = opts)  def mkclang(env):
161        env = Environment(tools = ['default'] + env['tools_names'],      env['CXX']='clang++'
162                          options = opts)  
163  else:  if env['tools_names'] != ['default']:
164     if effective_hostname == 'service0':      zz=env['tools_names']
165        env = Environment(tools = ['default', 'intelc'], options = opts)      if 'clang' in zz:
166     elif os.uname()[4]=='ia64':          zz.remove('clang')
167        env = Environment(tools = ['default', 'intelc'], options = opts)          zz.insert(0, mkclang)
168        if env['CXX'] == 'icpc':      env = Environment(tools = ['default'] + env['tools_names'], options = vars,
169           env['LINK'] = env['CXX'] # version >=9 of intel c++ compiler requires use of icpc to link in C++ runtimes (icc does not)                        ENV = {'PATH' : os.environ['PATH']})
170     else:  
171        env = Environment(tools = ['default'], options = opts)  if options_file:
172        opts_valid=False
173  # Override compiler choice if provided      if 'escript_opts_version' in env.Dictionary() and \
174  if env['cc'] != 'DEFAULT': env['CC']=env['cc']          int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
175  if env['cxx'] != 'DEFAULT': env['CXX']=env['cxx']              opts_valid=True
176        if opts_valid:
177  Help(opts.GenerateHelpText(env))          print("Using options in %s." % options_file)
178        else:
179  ############ Make sure target directories exist ################          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']):  if not os.path.isdir(env['bininstall']):
213      os.makedirs(env['bininstall'])      os.makedirs(env['bininstall'])
214  if not os.path.isdir(env['libinstall']):  if not os.path.isdir(env['libinstall']):
# Line 216  if not os.path.isdir(env['libinstall']): Line 216  if not os.path.isdir(env['libinstall']):
216  if not os.path.isdir(env['pyinstall']):  if not os.path.isdir(env['pyinstall']):
217      os.makedirs(env['pyinstall'])      os.makedirs(env['pyinstall'])
218    
219  ########## Copy required environment vars ######################  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  for i in env['env_export']:  # version >=9 of intel C++ compiler requires use of icpc to link in C++
227     env.Append(ENV = {i:os.environ[i]})  # runtimes (icc does not)
228    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
229  ############ Fill in compiler options if not set above #########      env['LINK'] = env['CXX']
230    
231  # Backwards compatibility: allow dodebug=yes and useMPI=yes  # default compiler/linker options
232  if env['dodebug']: env['usedebug'] = 1  cc_flags = ''
233  if env['useMPI']: env['usempi'] = 1  cc_optim = ''
234    cc_debug = ''
235  # Default compiler options (override allowed in hostname_options.py, but should not be necessary)  omp_flags = ''
236  # For both C and C++ you get: cc_flags and either the optim flags or debug flags  omp_ldflags = ''
237    fatalwarning = '' # switch to turn warnings into errors
238  sysheaderopt = ""       # how do we indicate that a header is a system header. Use "" for no action.  sysheaderopt = '' # how to indicate that a header is a system header
239    
240  cc_flags = ""  # env['CC'] might be a full path
241  cc_optim = ""  cc_name=os.path.basename(env['CXX'])
242  cc_debug = ""  
243  omp_optim = ""  if cc_name == 'icpc':
244  omp_debug = ""      # Intel compiler
245  omp_libs = []      # #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  if env["CC"] == "icc":      cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas"
248    # Intel compilers      cc_optim    = "-O3 -ftz -fno-alias -inline-level=2 -ipo -xHost"
249    cc_flags      = "-fPIC -ansi -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"      cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
250    cc_optim      = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias"      omp_flags   = "-openmp"
251    cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"      omp_ldflags = "-openmp -openmp_report=1"
252    omp_optim     = "-openmp -openmp_report0"      fatalwarning = "-Werror"
253    omp_debug     = "-openmp -openmp_report0"  elif cc_name[:3] == 'g++':
254    omp_libs      = ['guide', 'pthread']      # GNU C++ on any system
255    pedantic      = ""      # note that -ffast-math is not used because it breaks isnan(),
256    fatalwarning      = ""        # Switch to turn warnings into errors      # see mantis #691
257    sysheaderopt      = ""      cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
258  elif env["CC"][:3] == "gcc":      cc_optim     = "-O3"
259    # GNU C on any system      #max-vartrack-size: avoid vartrack limit being exceeded with escriptcpp.cpp
260    cc_flags      = "-pedantic -Wall -fPIC -ansi -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing"      cc_debug     = "-g3 -O0 -D_GLIBCXX_DEBUG -DDOASSERT -DDOPROF -DBOUNDS_CHECK --param=max-vartrack-size=100000000"
261  #the long long warning occurs on the Mac      omp_flags    = "-fopenmp"
262    cc_optim      = "-O3"      omp_ldflags  = "-fopenmp"
263    cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"      fatalwarning = "-Werror"
264    omp_optim     = "-fopenmp"      sysheaderopt = "-isystem"
265    omp_debug     = "-fopenmp"  elif cc_name == 'cl':
266    omp_libs      = []      # Microsoft Visual C on Windows
267    pedantic      = "-pedantic-errors -Wno-long-long"      cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
268    fatalwarning      = "-Werror"      cc_optim     = "/O2 /Op /W3"
269    sysheaderopt      = "-isystem "      cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
270  elif env["CC"] == "cl":      fatalwarning = "/WX"
271    # Microsoft Visual C on Windows  elif cc_name == 'icl':
272    cc_flags      = "/FD /EHsc /GR /wd4068 -D_USE_MATH_DEFINES -DDLL_NETCDF"      # Intel C on Windows
273    cc_optim      = "/O2 /Op /MT /W3"      cc_flags     = '/EHsc /GR /MD'
274    cc_debug      = "/Od /RTC1 /MTd /ZI -DBOUNDS_CHECK"      cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
275    omp_optim     = ""      cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
276    omp_debug     = ""      omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
277    omp_libs      = []      omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
278    pedantic      = ""  
279    fatalwarning      = ""  env['sysheaderopt']=sysheaderopt
280    sysheaderopt      = ""  
281  elif env["CC"] == "icl":  # set defaults if not otherwise specified
282    # intel C on Windows, see windows_intelc_options.py for a start  if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
283    pedantic      = ""  if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
284    fatalwarning      = ""  if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
285    sysheaderopt      = ""  if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
286    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
287    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
288  # If not specified in hostname_options.py then set them here  if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
289  if env["cc_flags"]  == "-DEFAULT_1": env['cc_flags'] = cc_flags  
290  if env["cc_optim"]  == "-DEFAULT_2": env['cc_optim'] = cc_optim  if env['nvccflags'] != 'default':
291  if env["cc_debug"]  == "-DEFAULT_3": env['cc_debug'] = cc_debug      env['NVCCFLAGS'] = env['nvccflags']
292  if env["omp_optim"] == "-DEFAULT_4": env['omp_optim'] = omp_optim      env['SHNVCCFLAGS'] = env['nvccflags'] + ' -shared'
293  if env["omp_debug"] == "-DEFAULT_5": env['omp_debug'] = omp_debug  
294  if env["omp_libs"]  == "-DEFAULT_6": env['omp_libs'] = omp_libs  if env['BADPYTHONMACROS']:
295        env.Append(CPPDEFINES = ['BADPYTHONMACROS'])
296  #set up the autolazy values  
297  if env['forcelazy']    != "leave_alone":  if env['longindices']:
298    if env['forcelazy'] == 'on':      env.Append(CPPDEFINES = ['ESYS_INDEXTYPE_LONG'])
299      env.Append(CPPDEFINES=['FAUTOLAZYON'])  
300    else:  if env['usepython3']:
301       if env['forcelazy'] == 'off':      env.Append(CPPDEFINES=['ESPYTHON3'])
302      env.Append(CPPDEFINES=['FAUTOLAZYOFF'])  
303    # set up the autolazy values
304  #set up the colective resolve values  if env['forcelazy'] == 'on':
305  if env['forcecollres']    != "leave_alone":      env.Append(CPPDEFINES=['FAUTOLAZYON'])
306    print env['forcecollres']  elif env['forcelazy'] == 'off':
307    if env['forcecollres'] == 'on':      env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
308      env.Append(CPPDEFINES=['FRESCOLLECTON'])  
309    else:  # set up the collective resolve values
310       if env['forcecollres'] == 'off':  if env['forcecollres'] == 'on':
311      env.Append(CPPDEFINES=['FRESCOLLECTOFF'])      env.Append(CPPDEFINES=['FRESCOLLECTON'])
312    elif env['forcecollres'] == 'off':
313        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
314    
315    # allow non-standard C if requested
316  if env['iknowwhatimdoing']:  if env['iknowwhatimdoing']:
317      env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])      env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
318    
319  # OpenMP is disabled if useopenmp=no or both variables omp_optim and omp_debug are empty  # Disable OpenMP if no flags provided
320  if not env["useopenmp"]:  if env['openmp'] and env['omp_flags'] == '':
321    env['omp_optim'] = ""     env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
322    env['omp_debug'] = ""     env['openmp'] = False
323    env['omp_libs'] = []  
324    if env['openmp']:
325        env.Append(CCFLAGS = env['omp_flags'])
326        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
327    else:
328        env['omp_flags']=''
329        env['omp_ldflags']=''
330    
331    env['buildvars']['openmp']=int(env['openmp'])
332    
333    # add debug/non-debug compiler flags
334    env['buildvars']['debug']=int(env['debug'])
335    if env['debug']:
336        env.Append(CCFLAGS = env['cc_debug'])
337    else:
338        env.Append(CCFLAGS = env['cc_optim'])
339    
340    # always add cc_flags
341    env.Append(CCFLAGS = env['cc_flags'])
342    
343    # add system libraries
344    env.AppendUnique(LIBS = env['sys_libs'])
345    
346    # set defaults for launchers if not otherwise specified
347    if env['prelaunch'] == 'default':
348        if env['mpi'] == 'INTELMPI' and env['openmp']:
349            env['prelaunch'] = "export I_MPI_PIN_DOMAIN=omp"
350        elif env['mpi'] == 'OPENMPI':
351            # transform comma-separated list to '-x a -x b -x c ...'
352            env['prelaunch'] = "EE=$(echo %e|sed -e 's/,/ -x /g')"
353        elif env['mpi'] == 'MPT':
354            env['prelaunch'] = "export MPI_NUM_MEMORY_REGIONS=0"
355        elif env['mpi'] == 'MPICH2':
356            env['prelaunch'] = "mpdboot -n %n -r ssh -f %f"
357        else:
358            env['prelaunch'] = ""
359    
360    if env['launcher'] == 'default':
361        if env['mpi'] == 'INTELMPI':
362            env['launcher'] = "mpirun -hostfile %f -n %N -ppn %p %b"
363        elif env['mpi'] == 'OPENMPI':
364            env['launcher'] = "mpirun --gmca mpi_warn_on_fork 0 -x ${EE} --host %h -bynode -bind-to-core --cpus-per-rank %t -np %N %b"
365        elif env['mpi'] == 'MPT':
366            env['launcher'] = "mpirun %h -np %p %b"
367        elif env['mpi'] == 'MPICH':
368            env['launcher'] = "mpirun -machinefile %f -np %N %b"
369        elif env['mpi'] == 'MPICH2':
370            env['launcher'] = "mpiexec -genvlist %e -np %N %b"
371        else:
372            env['launcher'] = "%b"
373    
374    if env['postlaunch'] == 'default':
375        if env['mpi'] == 'MPICH2':
376            env['postlaunch'] = "mpdallexit"
377        else:
378            env['postlaunch'] = ""
379    
380    # determine svn revision
381    global_revision=ARGUMENTS.get('SVN_VERSION', None)
382    if global_revision:
383        global_revision = re.sub(':.*', '', global_revision)
384        global_revision = re.sub('[^0-9]', '', global_revision)
385        if global_revision == '': global_revision='-2'
386    else:
387      # Get the global Subversion revision number for the getVersion() method
388      try:
389        global_revision = os.popen('svnversion -n .').read()
390        global_revision = re.sub(':.*', '', global_revision)
391        global_revision = re.sub('[^0-9]', '', global_revision)
392        if global_revision == '': global_revision='-2'
393      except:
394        global_revision = '-1'
395    env['svn_revision']=global_revision
396    env['buildvars']['svn_revision']=global_revision
397    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
398    
399    if IS_WINDOWS:
400        if not env['build_shared']:
401            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
402            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
403    
404  if env['omp_optim'] == "" and env['omp_debug'] == "": env["useopenmp"] = 0  env['IS_WINDOWS']=IS_WINDOWS
405    
406    ###################### Copy required environment vars ########################
407    
408  # Windows doesn't use LD_LIBRARY_PATH but PATH instead  # Windows doesn't use LD_LIBRARY_PATH but PATH instead
409  if IS_WINDOWS_PLATFORM:  if IS_WINDOWS:
410      LD_LIBRARY_PATH_KEY='PATH'      LD_LIBRARY_PATH_KEY='PATH'
411      env['ENV']['LD_LIBRARY_PATH']=''      env['ENV']['LD_LIBRARY_PATH']=''
412  else:  else:
413      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
 ############ 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']['ESCRIPT_NUM_THREADS'] = os.environ['ESCRIPT_NUM_THREADS']  
 except KeyError: pass  
   
 try: env['ENV']['ESCRIPT_NUM_PROCS'] = os.environ['ESCRIPT_NUM_PROCS']  
 except KeyError: env['ENV']['ESCRIPT_NUM_PROCS']=1  
   
 try: env['ENV']['ESCRIPT_NUM_NODES'] = os.environ['ESCRIPT_NUM_NODES']  
 except KeyError: env['ENV']['ESCRIPT_NUM_NODES']=1  
   
 try: env['ENV']['ESCRIPT_HOSTFILE'] = os.environ['ESCRIPT_HOSTFILE']  
 except KeyError: pass  
   
 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  
414    
415  try: env['ENV']['CPLUS_INCLUDE_PATH'] = os.environ['CPLUS_INCLUDE_PATH']  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
 except KeyError: pass  
416    
417  try: env.PrependENVPath(LD_LIBRARY_PATH_KEY,os.environ['LD_LIBRARY_PATH'])  # the following env variables are exported for the unit tests
 except KeyError: pass  
418    
419  try: env['ENV']['LIBRARY_PATH'] = os.environ['LIBRARY_PATH']  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
420  except KeyError: pass      try:
421            env['ENV'][key] = os.environ[key]
422  try: env['ENV']['DISPLAY'] = os.environ['DISPLAY']      except KeyError:
423  except KeyError: pass          env['ENV'][key] = '1'
424    
425  try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  env_export=env['env_export']
426  except KeyError: pass  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP','LD_PRELOAD'])
427    
428  try: env['ENV']['HOME'] = os.environ['HOME']  for key in set(env_export):
429  except KeyError: pass      try:
430            env['ENV'][key] = os.environ[key]
431  # Configure for test suite      except KeyError:
432            pass
   
 env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
 env.PrependENVPath('PYTHONPATH', prefix)  
 env['ENV']['ESCRIPT_ROOT'] = prefix  
   
 ############ Set up paths for Configure() ######################  
   
 # Make a copy of an environment  
 # Use env.Clone if available, but fall back on env.Copy for older version of scons  
 def clone_env(env):  
   if 'Clone' in dir(env): return env.Clone()    # scons-0.98  
   else:                   return env.Copy() # scons-0.96  
   
 # Add cc option -I<Escript>/trunk/include  
 env.Append(CPPPATH      = [Dir('include')])  
   
 # Add cc option -L<Escript>/trunk/lib  
 env.Append(LIBPATH      = [Dir(env['libinstall'])])  
   
 if env['cc_extra'] != '': env.Append(CCFLAGS = env['cc_extra'])  
 if env['ld_extra'] != '': env.Append(LINKFLAGS = env['ld_extra'])  
   
 if env['usepedantic']: env.Append(CCFLAGS = pedantic)  
   
 # MS Windows  
 if IS_WINDOWS_PLATFORM:  
   env.AppendENVPath('PATH', [env['boost_lib_path']])  
   env.AppendENVPath('PATH', [env['libinstall']])  
   if not env['share_esysUtils'] :  
     env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])  
   if not env['share_paso'] :  
     env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])  
   
   if env['usenetcdf']:  
     env.AppendENVPath('PATH',   [env['netCDF_lib_path']])  
   
 env.Append(ARFLAGS = env['ar_flags'])  
   
 # Get the global Subversion revision number for getVersion() method  
 try:  
    global_revision = os.popen("svnversion -n .").read()  
    global_revision = re.sub(":.*", "", global_revision)  
    global_revision = re.sub("[^0-9]", "", global_revision)  
 except:  
    global_revision="-1"  
 if global_revision == "": global_revision="-2"  
 env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  
   
 ############ numpy (required) ###############################  
433    
434  try:  try:
435    from numpy import identity      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
436  except ImportError:  except KeyError:
437    print "Cannot import numpy, you need to set your PYTHONPATH"      pass
   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) #######################  
   
   
 if not sysheaderopt =="":  
   conf.env.Append(CCFLAGS=sysheaderopt+env['python_path'])  
 else:  
   conf.env.AppendUnique(CPPPATH     = [env['python_path']])  
   
 conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
   
 conf.env.PrependENVPath('PYTHONPATH', prefix)  
 conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['python_lib_path'])    # The wrapper script needs to find these libs  
 conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 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_Exit'):  
   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) ##################################  
   
 if not sysheaderopt =="":  
 # This is required because we can't -isystem /usr/system because it breaks std includes  
   if os.path.normpath(env['boost_path']) =="/usr/include":  
     conf.env.Append(CCFLAGS=sysheaderopt+os.path.join(env['boost_path'],'boost'))  
   else:  
     conf.env.Append(CCFLAGS=sysheaderopt+env['boost_path'])  
 else:  
   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_KEY, env['boost_lib_path']) # The wrapper script needs to find these libs  
 #ensure that our path entries remain at the front  
 conf.env.PrependENVPath('PYTHONPATH', prefix)  
 conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 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) ####################################  
438    
439  if env['usevtk']:  if IS_OSX:
440    try:    try:
441      import vtk      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
442      env['usevtk'] = 1    except KeyError:
443    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_KEY, env['netCDF_lib_path'])  # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 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_KEY, env['papi_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 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) ####################################  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env))  
   
 if env['usemkl']:  
   conf.env.AppendUnique(CPPPATH = [env['mkl_path']])  
   conf.env.AppendUnique(LIBPATH = [env['mkl_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['mkl_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['mkl_lib_path']) # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 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()  
444    
 ############ UMFPACK (optional) ################################  
445    
446  # Start a new configure environment that reflects what we've already found  # these shouldn't be needed
447  conf = Configure(clone_env(env))  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
448    #    try:
449    #        env['ENV'][key] = os.environ[key]
450    #    except KeyError:
451    #        pass
452    
453  if env['useumfpack']:  try:
454    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
455    conf.env.AppendUnique(CPPPATH = [env['umf_path']])  except KeyError:
456    conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])      pass
   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_KEY, env['umf_lib_path']) # The wrapper script needs to find these libs  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['amd_lib_path']) # The wrapper script needs to find these libs  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['blas_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 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  
 # if env['useumfpack'] and not conf.CheckFunc('daxpy'): env['useumfpack'] = 0 # this does not work on shake73?  
   
 # Add UMFPACK to environment env if it was found  
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
 else:  
   conf.Finish()  
457    
458  ############ Silo (optional) ###################################  ######################## Add some custom builders ############################
459    
460  if env['usesilo']:  if env['pythoncmd']=='python':
461    conf = Configure(clone_env(env))      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
   conf.env.AppendUnique(CPPPATH = [env['silo_path']])  
   conf.env.AppendUnique(LIBPATH = [env['silo_lib_path']])  
   conf.env.AppendUnique(LIBS = [env['silo_libs']])  
   if not conf.CheckCHeader('silo.h'): env['usesilo'] = 0  
   if not conf.CheckFunc('DBMkDir'): env['usesilo'] = 0  
   conf.Finish()  
   
 # Add the path to Silo to environment env if it was found.  
 # Note that we do not add the libs since they are only needed for the  
 # escriptexport library and tools.  
 if env['usesilo']:  
   env.AppendUnique(CPPPATH = [env['silo_path']])  
   env.AppendUnique(LIBPATH = [env['silo_lib_path']])  
   env.Append(CPPDEFINES = ['USE_SILO'])  
   
 ########### Lapack (optional) ##################################  
   
 if env['uselapack']:  
     env.AppendUnique(CPPDEFINES='USE_LAPACK')  
     env.AppendUnique(CPPPATH = [env['lapack_path']])  
     env.AppendUnique(LIBPATH =[env['lapack_lib_path']])  
   
     env.Append(LIBPATH = '/usr/lib/atlas')  
     env.Append(LIBS = [env['lapack_libs']])  
     if env['lapack_type']=='mkl':  
        if not env['usemkl']:  
         env['uselapack']=0  
         print "mkl_lapack requires mkl"  
        else:  
         env.AppendUnique(CPPDEFINES='MKL_LAPACK')  
         
   
 ############ Add the compiler flags ############################  
   
 # Enable debug by choosing either cc_debug or cc_optim  
 if env['usedebug']:  
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
462  else:  else:
463    env.Append(CCFLAGS        = env['cc_optim'])      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
   env.Append(CCFLAGS        = env['omp_optim'])  
   
 # Always use cc_flags  
 env.Append(CCFLAGS      = env['cc_flags'])  
 env.Append(LIBS         = [env['omp_libs']])  
   
 ############ Add some custom builders ##########################  
   
 py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  
464  env.Append(BUILDERS = {'PyCompile' : py_builder});  env.Append(BUILDERS = {'PyCompile' : py_builder});
465    
466  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
467  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
468    
469  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
470  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
471    
472  epstopdfbuilder = Builder(action = scons_extensions.eps2pdf, suffix=".pdf", src_suffix=".eps", single_source=True)  runPyExample_builder = Builder(action = runPyExample, suffix = '.passed', src_suffic='.py', single_source=True)
473  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});  env.Append(BUILDERS = {'RunPyExample' : runPyExample_builder});
   
 ############ MPI (optional) ####################################  
 if not env['usempi']: env['mpi_flavour']='none'  
   
 # 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']:  
   VALID_MPIs=[ "MPT", "MPICH", "MPICH2", "OPENMPI", "INTELMPI" ]  
   if not env_mpi['mpi_flavour'] in VALID_MPIs:  
       raise ValueError,"MPI is enabled but mpi_flavour = %s is not a valid key from %s."%( env_mpi['mpi_flavour'],VALID_MPIs)  
   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_KEY, env['mpi_lib_path']) # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 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()  
   
 env['usempi'] = env_mpi['usempi']  
474    
475  ############ ParMETIS (optional) ###############################  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
476    env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
477    
478  # Start a new configure environment that reflects what we've already found  ############################ Dependency checks ###############################
 conf = Configure(clone_env(env_mpi))  
479    
480  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0  ######## Compiler
481    env=checkCompiler(env)
482    
483  if env_mpi['useparmetis']:  ######## Python headers & library (required)
484    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  env=checkPython(env)
   conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['parmetis_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
485    
486  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  ######## boost & boost-python (required)
487  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0  env=checkBoost(env)
488    
489  # Add ParMETIS to environment env_mpi if it was found  ######## NVCC version (optional)
490  if env_mpi['useparmetis']:  if env['cuda']:
491    env_mpi = conf.Finish()      env=checkCudaVersion(env)
   env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  
 else:  
   conf.Finish()  
492    
493  env['useparmetis'] = env_mpi['useparmetis']  ######## numpy (required) and numpy headers (optional)
494    env=checkNumpy(env)
495    
496  ############ Summarize our environment #########################  ######## CppUnit (required for tests)
497    env=checkCppUnit(env)
498    
499  print ""  ######## optional python modules (sympy, pyproj)
500  print "Summary of configuration (see ./config.log for information)"  env=checkOptionalModules(env)
 print " Using python libraries"  
 print " Using numpy"  
 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['usesilo']: print "  Using Silo"  
 else: print "   Not using Silo"  
 if env['useopenmp']: print "    Using OpenMP"  
 else: print "   Not using OpenMP"  
 if env['usempi']: print "   Using MPI (flavour = %s)"%env['mpi_flavour']  
 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['uselapack']: print "    Using Lapack"  
 else: print "   Not using Lapack"  
 if env['usedebug']: print " Compiling for debug"  
 else: print "   Not compiling for debug"  
 print " Installing in", prefix  
 if ((fatalwarning != "") and (env['usewarnings'])): print " Treating warnings as errors"  
 else: print "   Not treating warnings as errors"  
 print ""  
   
 ############ Delete option-dependent files #####################  
   
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.debug")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.mpi")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.openmp")))  
 Execute(Delete(os.path.join(env['libinstall'],"pyversion")))  
 Execute(Delete(os.path.join(env['libinstall'],"buildvars")))  
 if not env['usempi']: Execute(Delete(os.path.join(env['libinstall'],"pythonMPI")))  
501    
502    ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
503    env=checkOptionalLibraries(env)
504    
505  ############ Build the subdirectories ##########################  ######## PDFLaTeX (for documentation)
506    env=checkPDFLatex(env)
507    
508  if env['usepedantic']: env_mpi.Append(CCFLAGS = pedantic)  # keep some of our install paths first in the list for the unit tests
509    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
510    env.PrependENVPath('PYTHONPATH', prefix)
511    env['ENV']['ESCRIPT_ROOT'] = prefix
512    
513    if not env['verbose']:
514        env['CXXCOMSTR'] = "Compiling $TARGET"
515        env['SHCXXCOMSTR'] = "Compiling $TARGET"
516        env['ARCOMSTR'] = "Linking $TARGET"
517        env['LINKCOMSTR'] = "Linking $TARGET"
518        env['SHLINKCOMSTR'] = "Linking $TARGET"
519        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
520        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
521        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
522        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
523        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
524    
525    ####################### Configure the subdirectories #########################
526    
527    # remove obsolete files
528    if not env['usempi']:
529        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
530        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
531    
532  from grouptest import *  from grouptest import *
   
533  TestGroups=[]  TestGroups=[]
534    
535  dodgy_env=clone_env(env_mpi)    # Environment without pedantic options  # keep an environment without warnings-as-errors
536    dodgy_env=env.Clone()
 ############ Now we switch on Warnings as errors ###############  
   
 #this needs to be done after configuration because the scons test files have warnings in them  
   
 if ((fatalwarning != "") and (env['usewarnings'])):  
   env.Append(CCFLAGS        = fatalwarning)  
   env_mpi.Append(CCFLAGS        = fatalwarning)  
537    
538    # now add warnings-as-errors flags. This needs to be done after configuration
539    # because the scons test files have warnings in them
540    if ((fatalwarning != '') and (env['werror'])):
541        env.Append(CCFLAGS = fatalwarning)
542    
543  Export(  Export(
544    ["env",    ['env',
545     "env_mpi",     'dodgy_env',
546     "clone_env",     'IS_WINDOWS',
547     "dodgy_env",     'TestGroups'
548     "IS_WINDOWS_PLATFORM",    ]
549     "TestGroups"  )
    ]  
   )  
   
 env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
 env.SConscript(dirs = ['tools/escriptconvert'], build_dir='build/$PLATFORM/tools/escriptconvert', duplicate=0)  
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 env.SConscript(dirs = ['dataexporter/src'], build_dir='build/$PLATFORM/dataexporter', 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)  
 env.SConscript(dirs = ['paso/profiling'], build_dir='build/$PLATFORM/paso/profiling', duplicate=0)  
   
   
 ############ Remember what optimizations we used ###############  
   
 remember_list = []  
   
 if env['usedebug']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.debug"), None, Touch('$TARGET'))  
   
 if env['usempi']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.mpi"), None, Touch('$TARGET'))  
   
 if env['useopenmp']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.openmp"), None, Touch('$TARGET'))  
550    
551  env.Alias('remember_options', remember_list)  #do not auto build
552    env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
553    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
554    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
555    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
556    
557    env.SConscript(dirs = ['cusplibrary'])
558    
559    #This will pull in the escriptcore/py_src and escriptcore/test
560    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
561    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
562    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
563    if 'dudley' in env['domains']:
564        env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
565    if 'finley' in env['domains']:
566        env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
567    if 'ripley' in env['domains']:
568        env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
569    if 'speckley' in env['domains']:
570        env.SConscript(dirs = ['speckley/src'], variant_dir='$BUILD_DIR/$PLATFORM/speckley', duplicate=0)
571    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
572    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
573    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
574    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
575    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
576    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
577    
578    
579    ######################## Populate the buildvars file #########################
580    
581    write_buildvars(env)
582    
583  ############### Record python interpreter version ##############  write_launcher(env)
584    
585  if not IS_WINDOWS_PLATFORM:  ################### Targets to build and install libraries ###################
586    
587    versionstring="Python "+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])  target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
588    if sys.version_info[4] >0 : versionstring+="rc%s"%sys.version_info[4]  env.Alias('target_init', [target_init])
589    os.system("echo "+versionstring+" > "+os.path.join(env['libinstall'],"pyversion"))  # delete buildvars upon cleanup
590    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
591    
592  ############## Populate the buildvars file #####################  # The headers have to be installed prior to build in order to satisfy
593    # #include <paso/Common.h>
594    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
595    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
596    
597  buildvars=open(os.path.join(env['libinstall'],'buildvars'),'w')  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
598  buildvars.write('python='+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+'\n')  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
   
 # Find the boost version by extracting it from version.hpp  
 boosthpp=open(os.path.join(env['boost_path'],'boost','version.hpp'))  
 boostversion='unknown'  
 try:  
     for line in boosthpp:  
         ver=re.match(r'#define BOOST_VERSION (\d+)',line)  
         if ver:  
             boostversion=ver.group(1)  
 except StopIteration:  
     pass  
 buildvars.write("boost="+boostversion+"\n")  
 buildvars.write("svn_revision="+str(global_revision)+"\n")  
 out="usedebug="  
 if env['usedebug']:  
     out+="y"  
 else:  
     out+="n"  
 out+="\nusempi="  
 if env['usempi']:  
     out+="y"  
 else:  
     out+="n"  
 out+="\nuseopenmp="  
 if env['useopenmp']:  
     out+="y"  
 else:  
     out+="n"  
 buildvars.write(out+"\n")  
 buildvars.write("mpi_flavour="+env['mpi_flavour']+'\n')  
 out="lapack="  
 if env['uselapack']:  
    out+="y"  
 else:  
    out+="n"  
 out+="\nsilo="  
 if env['usesilo']:  
    out+="y"  
 else:  
    out+="n"  
 buildvars.write(out+"\n")  
 buildvars.close()  
599    
600    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
601    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
602    
603  ############ Targets to build and install libraries ############  env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
604    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
605    
606  target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  if 'dudley' in env['domains']:
607  env.Alias('target_init', [target_init])      env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
608        env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
609    
610  # The headers have to be installed prior to build in order to satisfy #include <paso/Common.h>  if 'finley' in env['domains']:
611  env.Alias('build_esysUtils', ['target_install_esysUtils_headers', 'target_esysUtils_a'])      env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
612  env.Alias('install_esysUtils', ['build_esysUtils', 'target_install_esysUtils_a'])      env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
613    
614  env.Alias('build_paso', ['target_install_paso_headers', 'target_paso_a'])  if 'ripley' in env['domains']:
615  env.Alias('install_paso', ['build_paso', 'target_install_paso_a'])      env.Alias('build_ripley', ['install_cusp_headers', 'install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
616        env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
617    
618  env.Alias('build_dataexporter', ['target_install_escriptexport_headers', 'target_escriptexport_so', 'target_escriptexportcpp_so'])  if 'speckley' in env['domains']:
619  env.Alias('install_dataexporter', ['build_dataexporter', 'target_install_escriptexport_so', 'target_install_escriptexportcpp_so', 'target_install_dataexporter_py'])      env.Alias('build_speckley', ['install_speckley_headers', 'build_speckley_lib', 'build_speckleycpp_lib'])
620        env.Alias('install_speckley', ['build_speckley', 'install_speckley_lib', 'install_speckleycpp_lib', 'install_speckley_py'])
621    
622  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'])
623  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'])
624    
625  env.Alias('build_finley', ['target_install_finley_headers', 'target_finley_so', 'target_finleycpp_so'])  env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
626  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'])
627    
628  # 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
629  build_all_list = []  build_all_list = []
630  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
631  build_all_list += ['build_paso']  build_all_list += ['build_paso']
 build_all_list += ['build_dataexporter']  
632  build_all_list += ['build_escript']  build_all_list += ['build_escript']
633  build_all_list += ['build_finley']  build_all_list += ['build_pasowrap']
634  if env['usempi']:       build_all_list += ['target_pythonMPI_exe']  if 'dudley' in env['domains']: build_all_list += ['build_dudley']
635  #if not IS_WINDOWS_PLATFORM:    build_all_list += ['target_escript_wrapper']  if 'finley' in env['domains']: build_all_list += ['build_finley']
636  if env['usesilo']:  build_all_list += ['target_escriptconvert']  if 'ripley' in env['domains']: build_all_list += ['build_ripley']
637    if 'speckley' in env['domains']: build_all_list += ['build_speckley']
638    build_all_list += ['build_weipa']
639    if not IS_WINDOWS and 'finley' in env['domains']:
640        build_all_list += ['build_escriptreader']
641    if env['usempi']:   build_all_list += ['build_pythonMPI']
642  env.Alias('build_all', build_all_list)  env.Alias('build_all', build_all_list)
643    
644  install_all_list = []  install_all_list = []
645  install_all_list += ['target_init']  install_all_list += ['target_init']
646  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
647  install_all_list += ['install_paso']  install_all_list += ['install_paso']
 install_all_list += ['install_dataexporter']  
648  install_all_list += ['install_escript']  install_all_list += ['install_escript']
649  install_all_list += ['install_finley']  install_all_list += ['install_pasowrap']
650  install_all_list += ['target_install_pyvisi_py']  if 'dudley' in env['domains']: install_all_list += ['install_dudley']
651  install_all_list += ['target_install_modellib_py']  if 'finley' in env['domains']: install_all_list += ['install_finley']
652  install_all_list += ['target_install_pycad_py']  if 'ripley' in env['domains']: install_all_list += ['install_ripley']
653  if env['usempi']:       install_all_list += ['target_install_pythonMPI_exe']  if 'speckley' in env['domains']: install_all_list += ['install_speckley']
654  #if not IS_WINDOWS_PLATFORM:    install_all_list += ['target_install_escript_wrapper']  install_all_list += ['install_weipa']
655  if env['usesilo']:  install_all_list += ['target_install_escriptconvert']  if not IS_WINDOWS and 'finley' in env['domains']:
656  install_all_list += ['remember_options']      install_all_list += ['install_escriptreader']
657    install_all_list += ['install_downunder_py']
658    install_all_list += ['install_modellib_py']
659    install_all_list += ['install_pycad_py']
660    if env['usempi']:   install_all_list += ['install_pythonMPI']
661  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
662    
663  # Default target is install  # Default target is install
664  env.Default('install_all')  env.Default('install_all')
665    
666  ############ Targets to build and run the test suite ###########  ################## Targets to build and run the test suite ###################
667    
668  env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  if not env['cppunit']:
669  env.Alias('install_cppunittest', ['build_cppunittest', 'target_install_cppunittest_a'])      test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
670  env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])      env.Alias('run_tests', test_msg)
671  env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])      env.Alias('build_tests', '')
672    env.Alias('run_tests', ['install_all'])
673    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
674  env.Alias('build_full',['install_all','build_tests','build_py_tests'])  env.Alias('build_full',['install_all','build_tests','build_py_tests'])
675    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
676    
677    ##################### Targets to build the documentation #####################
678    
679  ############ Targets to build the documentation ################  env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
680    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
681  env.Alias('api_epydoc','install_all')  env.Alias('docs', ['basedocs', 'sphinxdoc'])
682    env.Alias('release_prep', ['docs', 'install_all'])
683  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html','install_pdf'])  env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
684    
685  build_platform=os.name  # The test scripts are always generated, this target allows us to
686    # generate the testscripts without doing a full build
687  if not IS_WINDOWS_PLATFORM:  env.Alias('testscripts',[])
688     try:  
689      utest=open("utest.sh","w")  if not IS_WINDOWS:
690      #Sometimes Mac python says it is posix      generateTestScripts(env, TestGroups)
691      if (build_platform=='posix') and platform.system()=="Darwin":  
692          build_platform='darwin'  
693      utest.write(GroupTest.makeHeader(build_platform))  ######################## Summarize our environment ###########################
694      for tests in TestGroups:  def print_summary():
695          utest.write(tests.makeString())      print("")
696      utest.close()      print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
697      os.chmod("utest.sh",stat.S_IRWXU|stat.S_IRGRP|stat.S_IXGRP|stat.S_IROTH|stat.S_IXOTH)      print("Escript/Finley revision %s"%global_revision)
698      print "utest.sh written"      print("  Install prefix:  %s"%env['prefix'])
699     except IOError:      print("          Python:  %s"%sysconfig.PREFIX)
700      print "Error attempting to write unittests file."      print("           boost:  %s"%env['boost_prefix'])
701      sys.exit(1)      if env['numpy_h']:
702            print("           numpy:  YES (with headers)")
703     #Make sure that the escript wrapper is in place      else:
704     if not os.path.isfile(os.path.join(env['bininstall'],'escript')):          print("           numpy:  YES (without headers)")
705         print "Copying escript wrapper"      if env['usempi']:
706         shutil.copy("bin/escript",os.path.join(env['bininstall'],'escript'))          print("             MPI:  YES (flavour: %s)"%env['mpi'])
707        else:
708            print("             MPI:  NO")
709        if env['uselapack']:
710            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
711        else:
712            print("          LAPACK:  NO")
713        if env['cuda']:
714            print("            CUDA:  YES (nvcc: %s)"%env['nvcc_version'])
715        else:
716            print("            CUDA:  NO")
717        d_list=[]
718        e_list=[]
719        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit':
720            if env[i]: e_list.append(i)
721            else: d_list.append(i)
722        for i in e_list:
723            print("%16s:  YES"%i)
724        for i in d_list:
725            print("%16s:  NO"%i)
726        if env['cppunit']:
727            print("         CppUnit:  YES")
728        else:
729            print("         CppUnit:  NO")
730        if env['gmsh']=='m':
731            print("            gmsh:  YES, MPI-ENABLED")
732        elif env['gmsh']=='s':
733            print("            gmsh:  YES")
734        else:
735            print("            gmsh:  NO")
736        print(    "            gzip:  " + ("YES" if env['compressed_files'] else "NO"))
737    
738        if ((fatalwarning != '') and (env['werror'])):
739            print("  Treating warnings as errors")
740        else:
741            print("  NOT treating warnings as errors")
742        print("")
743        for w in env['warnings']:
744            print("WARNING: %s"%w)
745        if len(GetBuildFailures()):
746            print("\nERROR: build stopped due to errors\n")
747        else:
748            print("\nSUCCESS: build complete\n")
749    
750  ############ Targets to build PasoTests suite ################  atexit.register(print_summary)
751    
 env.Alias('build_PasoTests','build/'+build_platform+'/paso/profiling/PasoTests')  

Legend:
Removed from v.2882  
changed lines
  Added in v.5277

  ViewVC Help
Powered by ViewVC 1.1.26