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

Diff of /branches/diaplayground/SConstruct

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

revision 1559 by ksteube, Wed May 21 04:27:15 2008 UTC revision 3977 by caltinay, Thu Sep 20 04:27:10 2012 UTC
# Line 1  Line 1 
1  #         Copyright 2006 by ACcESS MNRF  ########################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2012 by University of Queensland
4  #       Primary Business: Queensland, Australia  # Earth Systems Science Computational Center (ESSCC)
5  #  Licensed under the Open Software License version 3.0  # http://www.uq.edu.au/esscc
6  #     http://www.opensource.org/licenses/osl-3.0.php  #
7    # Primary Business: Queensland, Australia
8  # top-level Scons configuration file for all esys13 modules  # Licensed under the Open Software License version 3.0
9  # Begin initialisation Section  # http://www.opensource.org/licenses/osl-3.0.php
10  # all of this section just intialises default environments and helper  #
11  # scripts. You shouldn't need to modify this section.  ########################################################
12  EnsureSConsVersion(0,96,91)  
13  EnsurePythonVersion(2,3)  EnsureSConsVersion(0,98,1)
14    EnsurePythonVersion(2,5)
15  #===============================================================  
16  #   import tools:  import sys, os, platform, re
17  import glob  from distutils import sysconfig
18  import sys, os, re  from site_init import *
19  # Add our extensions  from subprocess import PIPE, Popen
20  if sys.path.count('scons')==0: sys.path.append('scons')  
21  import scons_extensions  # Version number to check for in options file. Increment when new features are
22    # added or existing options changed.
23  # We may also need to know where python's site-packages subdirectory lives  REQUIRED_OPTS_VERSION=201
24  python_version = 'python%s.%s'%(sys.version_info[0],sys.version_info[1])  
25    # MS Windows support, many thanks to PH
26  #===============================================================  IS_WINDOWS = (os.name == 'nt')
27    
28  tools_prefix="/usr"  ########################## Determine options file ############################
29    # 1. command line
30  #==============================================================================================      # 2. scons/<hostname>_options.py
31  #      # 3. name as part of a cluster
32  #    get the installation prefix  options_file=ARGUMENTS.get('options_file', None)
33  #  if not options_file:
34  prefix = ARGUMENTS.get('prefix', sys.prefix )      ext_dir = os.path.join(os.getcwd(), 'scons')
35        hostname = platform.node().split('.')[0]
36  # We may also need to know where python's site-packages subdirectory lives      for name in hostname, effectiveName(hostname):
37  python_version = 'python%s.%s'%(sys.version_info[0],sys.version_info[1])          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
38  # Install as a standard python package in /usr/lib64 if available, else in /usr/lib          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
39  if os.path.isdir(  prefix+"/lib64/"+python_version+"/site-packages"):          if os.path.isfile(options_file): break
40     sys_dir_packages =  prefix+"/lib64/"+python_version+"/site-packages/esys"  
41     sys_dir_libraries = prefix+"/lib64"  if not os.path.isfile(options_file):
42  else:      print("\nWARNING:\nOptions file %s" % options_file)
43     sys_dir_packages =  prefix+"/lib/"+python_version+"/site-packages/esys"      print("not found! Default options will be used which is most likely suboptimal.")
44     sys_dir_libraries = prefix+"/lib"      print("It is recommended that you copy one of the TEMPLATE files in the scons/")
45        print("subdirectory and customize it to your needs.\n")
46  sys_dir_examples = prefix+"/share/doc/esys"      options_file = None
47    
48  source_root = Dir('#.').abspath  ############################### Build options ################################
49    
50  dir_packages = os.path.join(source_root,"esys")  default_prefix='/usr'
51  dir_examples = os.path.join(source_root,"examples")  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
52  dir_libraries = os.path.join(source_root,"lib")  lapack_flavours=('none', 'clapack', 'mkl')
53    
54  print "Source root is : ",source_root  vars = Variables(options_file, ARGUMENTS)
55  print " Default packages local installation:    ", dir_packages  vars.AddVariables(
56  print " Default library local installation  ", dir_libraries    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
57  print " Default example local  installation:    ", dir_examples    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
58  print "Install prefix is: ", prefix    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
59  print " Default packages system installation:   ", sys_dir_packages    BoolVariable('verbose', 'Output full compile/link lines', False),
60  print " Default library system installation     ", sys_dir_libraries  # Compiler/Linker options
61  print " Default example system installation:    ", sys_dir_examples    ('cc', 'Path to C compiler', 'default'),
62      ('cxx', 'Path to C++ compiler', 'default'),
63  #==============================================================================================        ('cc_flags', 'Base C/C++ compiler flags', 'default'),
64      ('cc_optim', 'Additional C/C++ flags for a non-debug build', 'default'),
65  # Default options and options help text    ('cc_debug', 'Additional C/C++ flags for a debug build', 'default'),
66  # These are defaults and can be overridden using command line arguments or an options file.    ('cc_extra', 'Extra C compiler flags', ''),
67  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used    ('cxx_extra', 'Extra C++ compiler flags', ''),
68  # DO NOT CHANGE THEM HERE    ('ld_extra', 'Extra linker flags', ''),
69  # Where to install?    BoolVariable('werror','Treat compiler warnings as errors', True),
70  #==============================================================================================        BoolVariable('debug', 'Compile with debug flags', False),
71  #        BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
72  #    get the options file if present:    ('omp_flags', 'OpenMP compiler flags', 'default'),
73  #    ('omp_ldflags', 'OpenMP linker flags', 'default'),
74  options_file = ARGUMENTS.get('options_file','')  # Mandatory libraries
75      ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
76  if not os.path.isfile(options_file) :    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
77      options_file = False  # Mandatory for tests
78      ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
79  if not options_file :    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
80     import socket  # Optional libraries and options
81     hostname = re.sub("[^0-9a-zA-Z]", "_", socket.gethostname().split('.')[0])    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
82     tmp = os.path.join("scons",hostname+"_options.py")    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
83      ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
84     if os.path.isfile(tmp) :    BoolVariable('netcdf', 'Enable netCDF file support', False),
85        options_file = tmp    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
86      ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
87  IS_WINDOWS_PLATFORM = (os.name== "nt")    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
88      ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
89  # If you're not going to tell me then......    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
90  # FIXME: add one for the altix too.    BoolVariable('papi', 'Enable PAPI', False),
91  if not options_file :    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
92     if IS_WINDOWS_PLATFORM :    ('papi_libs', 'PAPI libraries to link with', ['papi']),
93        options_file = "scons/windows_mscv71_options.py"    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
94     else:    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
95        options_file = "scons/linux_gcc_eg_options.py"    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
96      ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
97  # and load it    BoolVariable('umfpack', 'Enable UMFPACK', False),
98  opts = Options(options_file, ARGUMENTS)    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
99  #================================================================    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
100  #    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
101  #   check if UMFPACK is installed on the system:    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
102  #    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
103  uf_root=None    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
104  for i in [ 'UMFPACK', 'umfpack', 'ufsparse', 'UFSPARSE']:    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
105     if os.path.isdir(os.path.join(tools_prefix,'include',i)):    ('lapack_libs', 'LAPACK libraries to link with', []),
106         uf_root=i    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
107         print i," is used form ",tools_prefix    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
108         break    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
109  if not uf_root==None:    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
110     umf_path_default=os.path.join(tools_prefix,'include',uf_root)    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
111     umf_lib_path_default=os.path.join(tools_prefix,'lib')    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
112     umf_libs_default=['umfpack']    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
113     amd_path_default=os.path.join(tools_prefix,'include',uf_root)  # Advanced settings
114     amd_lib_path_default=os.path.join(tools_prefix,'lib')    #dudley_assemble_flags = -funroll-loops      to actually do something
115     amd_libs_default=['amd']    ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
116     ufc_path_default=os.path.join(tools_prefix,'include',uf_root)    # To enable passing function pointers through python
117  else:    BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
118     umf_path_default=None    # An option for specifying the compiler tools (see windows branch)
119     umf_lib_path_default=None    ('tools_names', 'Compiler tools to use', ['default']),
120     umf_libs_default=None    ('env_export', 'Environment variables to be passed to tools',[]),
121     amd_path_default=None    EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
122     amd_lib_path_default=None    EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
123     amd_libs_default=None    # finer control over library building, intel aggressive global optimisation
124     ufc_path_default=None    # works with dynamic libraries on windows.
125  #    ('build_shared', 'Build dynamic libraries only', False),
126  #==========================================================================    ('sys_libs', 'Extra libraries to link with', []),
127  #    ('escript_opts_version', 'Version of options file (do not specify on command line)'),
128  #    python installation:    ('SVN_VERSION', 'Do not use from options file', -2),
129  #    ('pythoncmd', 'which python to compile with','python'),
130  python_path_default=os.path.join(tools_prefix,'include','python%s.%s'%(sys.version_info[0],sys.version_info[1]))    ('usepython3', 'Is this a python3 build? (experimental)', False),
131  python_lib_path_default=os.path.join(tools_prefix,'lib')    ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
132  python_lib_default="python%s.%s"%(sys.version_info[0],sys.version_info[1])    ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
133      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
134  #==========================================================================    BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
135  #  )
 #    boost installation:  
 #  
 boost_path_default=os.path.join(tools_prefix,'include')  
 boost_lib_path_default=os.path.join(tools_prefix,'lib')  
 boost_lib_default=['boost_python']  
136    
137  #==========================================================================  ##################### Create environment and help text #######################
 #  
 #    check if netCDF is installed on the system:  
 #  
 netCDF_path_default=os.path.join(tools_prefix,'include','netcdf-3')  
 netCDF_lib_path_default=os.path.join(tools_prefix,'lib')  
138    
139  if os.path.isdir(netCDF_path_default) and os.path.isdir(netCDF_lib_path_default):  # Intel's compiler uses regular expressions improperly and emits a warning
140       useNetCDF_default='yes'  # about failing to find the compilers. This warning can be safely ignored.
      netCDF_libs_default=[ 'netcdf_c++', 'netcdf' ]  
 else:  
      useNetCDF_default='no'  
      netCDF_path_default=None  
      netCDF_lib_path_default=None  
      netCDF_libs_default=None  
141    
142  #==========================================================================  # PATH is needed so the compiler, linker and tools are found if they are not
143  #  # in default locations.
144  #  MPI:  env = Environment(tools = ['default'], options = vars,
145  #                    ENV = {'PATH': os.environ['PATH']})
146  if IS_WINDOWS_PLATFORM:                    
147     useMPI_default='no'  
148     mpi_path_default=None  #set the vars for clang
149     mpi_lib_path_default=None  def mkclang(env):
150     mpi_libs_default=[]    env['CC']='clang'
151     mpi_run_default=None    env['CXX']='clang++'
152  else:                    
153     useMPI_default='no'                    
154     mpi_root='/usr/local'  if env['tools_names'] != 'default':
155     mpi_path_default=os.path.join(mpi_root,'include')      zz=env['tools_names']
156     mpi_lib_path_default=os.path.join(mpi_root,'lib')      if 'clang' in zz:
157     mpi_libs_default=[ 'mpich' , 'pthread', 'rt' ]          zz.remove('clang')
158     mpi_run_default='mpiexec -np 1'          zz.insert(0, mkclang)
159  #      env = Environment(tools = ['default'] + env['tools_names'], options = vars,
160  #==========================================================================                        ENV = {'PATH' : os.environ['PATH']})
161  #  
162  #    compile:  if options_file:
163  #      opts_valid=False
164  cc_flags_default='-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas -ansi'      if 'escript_opts_version' in env.Dictionary() and \
165  cc_flags_debug_default='-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas -ansi'          int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
166  cxx_flags_default='--no-warn -ansi'              opts_valid=True
167  cxx_flags_debug_default='--no-warn -ansi -DDOASSERT'      if opts_valid:
168            print("Using options in %s." % options_file)
169  #==============================================================================================          else:
170  # Default options and options help text          print("\nOptions file %s" % options_file)
171  # These are defaults and can be overridden using command line arguments or an options file.          print("is outdated! Please update the file by examining one of the TEMPLATE")
172  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used          print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
173  # DO NOT CHANGE THEM HERE          Exit(1)
174  opts.AddOptions(  
175  # Where to install esys stuff  # Generate help text (scons -h)
176    ('incinstall', 'where the esys headers will be installed',             Dir('#.').abspath+'/include'),  Help(vars.GenerateHelpText(env))
177    ('libinstall', 'where the esys libraries will be installed',           dir_libraries),  
178    ('pyinstall', 'where the esys python modules will be installed',       dir_packages),  # Check for superfluous options
179    ('exinstall', 'where the esys examples will be installed',             dir_examples),  if len(vars.UnknownVariables())>0:
180    ('sys_libinstall', 'where the system esys libraries will be installed',       sys_dir_libraries),      for k in vars.UnknownVariables():
181    ('sys_pyinstall', 'where the system esys python modules will be installed',   sys_dir_packages),          print("Unknown option '%s'" % k)
182    ('sys_exinstall', 'where the system esys examples will be installed',         sys_dir_examples),      Exit(1)
183    ('src_zipfile', 'the source zip file will be installed.',              Dir('#.').abspath+"/release/escript_src.zip"),  
184    ('test_zipfile', 'the test zip file will be installed.',               Dir('#.').abspath+"/release/escript_tests.zip"),  #################### Make sure install directories exist #####################
185    ('src_tarfile', 'the source tar file will be installed.',              Dir('#.').abspath+"/release/escript_src.tar.gz"),  
186    ('test_tarfile', 'the test tar file will be installed.',               Dir('#.').abspath+"/release/escript_tests.tar.gz"),  env['BUILD_DIR']=env['build_dir']
187    ('examples_tarfile', 'the examples tar file will be installed.',       Dir('#.').abspath+"/release/doc/escript_examples.tar.gz"),  prefix=Dir(env['prefix']).abspath
188    ('examples_zipfile', 'the examples zip file will be installed.',       Dir('#.').abspath+"/release/doc/escript_examples.zip"),  env['incinstall'] = os.path.join(prefix, 'include')
189    ('guide_pdf', 'name of the user guide in pdf format',                  Dir('#.').abspath+"/release/doc/user/guide.pdf"),  env['bininstall'] = os.path.join(prefix, 'bin')
190    ('api_epydoc', 'name of the epydoc api docs directory',                Dir('#.').abspath+"/release/doc/epydoc"),  env['libinstall'] = os.path.join(prefix, 'lib')
191    ('guide_html', 'name of the directory for user guide in html format',  Dir('#.').abspath+"/release/doc/user/html"),  env['pyinstall']  = os.path.join(prefix, 'esys')
192    ('api_doxygen', 'name of the doxygen api docs directory',prefix+"/release/doc/doxygen"),  if not os.path.isdir(env['bininstall']):
193  # Compilation options      os.makedirs(env['bininstall'])
194    BoolOption('dodebug', 'Do you want a debug build?', 'no'),  if not os.path.isdir(env['libinstall']):
195    BoolOption('bounds_check', 'Do you want extra array bounds checking?', 'no'),      os.makedirs(env['libinstall'])
196    ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/<hostname>_options.py)", options_file),  if not os.path.isdir(env['pyinstall']):
197    ('cc_defines','C/C++ defines to use', None),      os.makedirs(env['pyinstall'])
198    ('cc_flags','C compiler flags to use (Release build)', cc_flags_default),  
199    ('cc_flags_debug', 'C compiler flags to use (Debug build)', cc_flags_debug_default),  env.Append(CPPPATH = [env['incinstall']])
200    ('cxx_flags', 'C++ compiler flags to use (Release build)', cxx_flags_default),  env.Append(LIBPATH = [env['libinstall']])
201    ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', cxx_flags_debug_default),  
202    ('omp_flags', 'OpenMP compiler flags to use (Release build)', ''),  ################# Fill in compiler options if not set above ##################
203    ('omp_flags_debug', 'OpenMP compiler flags to use (Debug build)', ''),  
204    ('ar_flags', 'Static library archiver flags to use', None),  if env['cc'] != 'default': env['CC']=env['cc']
205    ('sys_libs', 'System libraries to link with', None),  if env['cxx'] != 'default': env['CXX']=env['cxx']
206    ('tar_flags','flags for zip files','-c -z'),  
207  # MKL  # version >=9 of intel C++ compiler requires use of icpc to link in C++
208    PathOption('mkl_path', 'Path to MKL includes', None),  # runtimes (icc does not)
209    PathOption('mkl_lib_path', 'Path to MKL libs', None),  if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
210    ('mkl_libs', 'MKL libraries to link with', None),      env['LINK'] = env['CXX']
211  # SCSL  
212    PathOption('scsl_path', 'Path to SCSL includes', None),  # default compiler/linker options
213    PathOption('scsl_lib_path', 'Path to SCSL libs', None),  cc_flags = ''
214    ('scsl_libs', 'SCSL libraries to link with', None),  cc_optim = ''
215    ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),  cc_debug = ''
216  # UMFPACK  omp_flags = ''
217    PathOption('ufc_path', 'Path to UFconfig includes', ufc_path_default),  omp_ldflags = ''
218    PathOption('umf_path', 'Path to UMFPACK includes', umf_path_default),  fatalwarning = '' # switch to turn warnings into errors
219    PathOption('umf_lib_path', 'Path to UMFPACK libs', umf_lib_path_default),  sysheaderopt = '' # how to indicate that a header is a system header
220    ('umf_libs', 'UMFPACK libraries to link with', umf_libs_default),  
221  # AMD (used by UMFPACK)  # env['CC'] might be a full path
222    PathOption('amd_path', 'Path to AMD includes', amd_path_default),  cc_name=os.path.basename(env['CC'])
223    PathOption('amd_lib_path', 'Path to AMD libs', amd_lib_path_default),  
224    ('amd_libs', 'AMD libraries to link with', amd_libs_default),  if cc_name == 'icc':
225  # ParMETIS      # Intel compiler
226    ('parmetis_path', 'Path to ParMETIS includes', ''),      cc_flags    = "-std=c99 -fPIC -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"
227    ('parmetis_lib_path', 'Path to ParMETIS library', ''),      cc_optim    = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias -ip"
228    ('parmetis_lib', 'ParMETIS library to link with', []),      cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
229  # TRILINOS      omp_flags   = "-openmp -openmp_report0"
230    PathOption('trilinos_path', 'Path to TRILINOS includes', None),      omp_ldflags = "-openmp -openmp_report0 -lpthread"
231    PathOption('trilinos_lib_path', 'Path to TRILINOS libs', None),      fatalwarning = "-Werror"
232    ('trilinos_libs', 'TRILINOS libraries to link with', None),  elif cc_name[:3] == 'gcc':
233  # BLAS      # GNU C on any system
234    PathOption('blas_path', 'Path to BLAS includes', None),      cc_flags     = "-pedantic -Wall -fPIC -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
235    PathOption('blas_lib_path', 'Path to BLAS libs', None),      cc_optim     = "-O3"
236    ('blas_libs', 'BLAS libraries to link with', None),      cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
237  # netCDF      omp_flags    = "-fopenmp"
238    ('useNetCDF', 'switch on/off the usage of netCDF', useNetCDF_default),      omp_ldflags  = "-fopenmp"
239    PathOption('netCDF_path', 'Path to netCDF includes', netCDF_path_default),      fatalwarning = "-Werror"
240    PathOption('netCDF_lib_path', 'Path to netCDF libs', netCDF_lib_path_default),      sysheaderopt = "-isystem"
241    ('netCDF_libs', 'netCDF C++ libraries to link with', netCDF_libs_default),  elif cc_name == 'cl':
242  # Python      # Microsoft Visual C on Windows
243  # locations of include files for python      cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
244  # FIXME: python_path should be python_inc_path and the same for boost etc.      cc_optim     = "/O2 /Op /W3"
245    PathOption('python_path', 'Path to Python includes', python_path_default),      cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
246    PathOption('python_lib_path', 'Path to Python libs', python_lib_path_default),      fatalwarning = "/WX"
247    ('python_lib', 'Python libraries to link with', python_lib_default),  elif cc_name == 'icl':
248    ('python_cmd', 'Python command', 'python'),      # Intel C on Windows
249  # Boost      cc_flags     = '/EHsc /GR /MD'
250    PathOption('boost_path', 'Path to Boost includes', boost_path_default),      cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
251    PathOption('boost_lib_path', 'Path to Boost libs', boost_lib_path_default),      cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
252    ('boost_lib', 'Boost libraries to link with', boost_lib_default),      omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
253  # Doc building      omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
254  #  PathOption('doxygen_path', 'Path to Doxygen executable', None),  
255  #  PathOption('epydoc_path', 'Path to Epydoc executable', None),  # set defaults if not otherwise specified
256  # PAPI  if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
257    PathOption('papi_path', 'Path to PAPI includes', None),  if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
258    PathOption('papi_lib_path', 'Path to PAPI libs', None),  if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
259    ('papi_libs', 'PAPI libraries to link with', None),  if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
260    ('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', None),  if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
261  # MPI  if env['cc_extra']  != '': env.Append(CFLAGS = env['cc_extra'])
262    BoolOption('useMPI', 'Compile parallel version using MPI', useMPI_default),  if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
263    ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),  if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
264    PathOption('mpi_path', 'Path to MPI includes', mpi_path_default),  
265    ('mpi_run', 'mpirun name' , mpi_run_default),  if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
266    PathOption('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)',mpi_lib_path_default),  
267    ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', mpi_libs_default)  if env['usepython3']:
268  )      env.Append(CPPDEFINES=['ESPYTHON3'])
269  #=================================================================================================  
270  #  # set up the autolazy values
271  #   Note: On the Altix the intel compilers are not automatically  if env['forcelazy'] == 'on':
272  #   detected by scons intelc.py script. The Altix has a different directory      env.Append(CPPDEFINES=['FAUTOLAZYON'])
273  #   path and in some locations the "modules" facility is used to support  elif env['forcelazy'] == 'off':
274  #   multiple compiler versions. This forces the need to import the users PATH      env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
275  #   environment which isn't the "scons way"  
276  #   This doesn't impact linux and windows which will use the default compiler (g++ or msvc, or the intel compiler if it is installed on both platforms)  # set up the collective resolve values
277  #   FIXME: Perhaps a modification to intelc.py will allow better support for ia64 on altix  if env['forcecollres'] == 'on':
278  #      env.Append(CPPDEFINES=['FRESCOLLECTON'])
279    elif env['forcecollres'] == 'off':
280  if IS_WINDOWS_PLATFORM:      env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
281        env = Environment(tools = ['default', 'msvc'], options = opts)  
282        #env = Environment(tools = ['default', 'intelc'], options = opts)  # allow non-standard C if requested
283  else:  if env['iknowwhatimdoing']:
284     if socket.gethostname().split('.')[0] == 'service0':      env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
285        env = Environment(tools = ['default', 'intelc'], options = opts)  
286     elif os.uname()[4]=='ia64':  # Disable OpenMP if no flags provided
287        env = Environment(tools = ['default', 'intelc'], options = opts)  if env['openmp'] and env['omp_flags'] == '':
288        if env['CXX'] == 'icpc':     print("OpenMP requested but no flags provided - disabling OpenMP!")
289           env['LINK'] = env['CXX'] # version >=9 of intel c++ compiler requires use of icpc to link in C++ runtimes (icc does not). FIXME: this behaviour could be directly incorporated into scons intelc.py     env['openmp'] = False
290     else:  
291        env = Environment(tools = ['default'], options = opts)  if env['openmp']:
292  Help(opts.GenerateHelpText(env))      env.Append(CCFLAGS = env['omp_flags'])
293        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
294  if env['bounds_check']:  else:
295     env.Append(CPPDEFINES = [ 'BOUNDS_CHECK' ])      env['omp_flags']=''
296     env.Append(CXXDEFINES = [ 'BOUNDS_CHECK' ])      env['omp_ldflags']=''
297     bounds_check = env['bounds_check']  
298    # add debug/non-debug compiler flags
299    if env['debug']:
300        env.Append(CCFLAGS = env['cc_debug'])
301    else:
302        env.Append(CCFLAGS = env['cc_optim'])
303    
304    # always add cc_flags
305    env.Append(CCFLAGS = env['cc_flags'])
306    
307    # add system libraries
308    env.AppendUnique(LIBS = env['sys_libs'])
309    
310    
311    global_revision=ARGUMENTS.get('SVN_VERSION', None)
312    if global_revision:
313        global_revision = re.sub(':.*', '', global_revision)
314        global_revision = re.sub('[^0-9]', '', global_revision)
315        if global_revision == '': global_revision='-2'
316    else:
317      # Get the global Subversion revision number for the getVersion() method
318      try:
319        global_revision = os.popen('svnversion -n .').read()
320        global_revision = re.sub(':.*', '', global_revision)
321        global_revision = re.sub('[^0-9]', '', global_revision)
322        if global_revision == '': global_revision='-2'
323      except:
324        global_revision = '-1'
325    env['svn_revision']=global_revision
326    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
327    
328    if IS_WINDOWS:
329        if not env['build_shared']:
330            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
331            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
332    
333    ###################### Copy required environment vars ########################
334    
335    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
336    if IS_WINDOWS:
337        LD_LIBRARY_PATH_KEY='PATH'
338        env['ENV']['LD_LIBRARY_PATH']=''
339  else:  else:
340     bounds_check = 0      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
341    
342  #=================================================================================================  # the following env variables are exported for the unit tests
 #  
 #     Initialise Scons Build Environment  
 #     check for user environment variables we are interested in  
 try:  
    tmp = os.environ['PYTHONPATH']  
    env['ENV']['PYTHONPATH'] = tmp  
 except KeyError:  
    pass  
343    
344  env.PrependENVPath('PYTHONPATH', source_root)  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
345        try:
346            env['ENV'][key] = os.environ[key]
347        except KeyError:
348            env['ENV'][key] = 1
349    
350  try:  env_export=env['env_export']
351     omp_num_threads = os.environ['OMP_NUM_THREADS']  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
352  except KeyError:  
353     omp_num_threads = 1  for key in set(env_export):
354  env['ENV']['OMP_NUM_THREADS'] = omp_num_threads      try:
355            env['ENV'][key] = os.environ[key]
356        except KeyError:
357            pass
358    
359  try:  try:
360     path = os.environ['PATH']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env['ENV']['PATH'] = path  
361  except KeyError:  except KeyError:
362     omp_num_threads = 1      pass
363    
364  env['ENV']['OMP_NUM_THREADS'] = omp_num_threads  # these shouldn't be needed
365    #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
366    #    try:
367    #        env['ENV'][key] = os.environ[key]
368    #    except KeyError:
369    #        pass
370    
   
 # Copy some variables from the system environment to the build environment  
371  try:  try:
372     env['ENV']['DISPLAY'] = os.environ['DISPLAY']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
    env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  
    home_temp = os.environ['HOME']   # MPICH2's mpd needs $HOME to find $HOME/.mpd.conf  
    env['ENV']['HOME'] = home_temp  
373  except KeyError:  except KeyError:
374     pass      pass
375    
376  try:  ######################## Add some custom builders ############################
    tmp = os.environ['PATH']  
    env['ENV']['PATH'] = tmp  
 except KeyError:  
    pass  
377    
378  try:  if env['pythoncmd']=='python':
379     tmp = os.environ['LD_LIBRARY_PATH']      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
380     env['ENV']['LD_LIBRARY_PATH'] = tmp  else:
381  except KeyError:      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
    pass  
 #==========================================================================  
 #  
 #    Add some customer builders  
 #  
 py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  
382  env.Append(BUILDERS = {'PyCompile' : py_builder});  env.Append(BUILDERS = {'PyCompile' : py_builder});
383    
384  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed',  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
                               src_suffix=env['PROGSUFFIX'], single_source=True)  
   
385  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
386    
387  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)
388  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
389    
390  # Convert the options which are held in environment variable into python variables for ease of handling and configure compilation options  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
391  try:  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
    incinstall = env['incinstall']  
    env.Append(CPPPATH = [incinstall,])  
 except KeyError:  
    incinstall = None  
 try:  
    libinstall = env['libinstall']  
    env.Append(LIBPATH = [libinstall,]) # Adds -L for building of libescript.so libfinley.so escriptcpp.so finleycpp.so  
    env.PrependENVPath('LD_LIBRARY_PATH', libinstall)  
    if IS_WINDOWS_PLATFORM :  
       env.PrependENVPath('PATH', libinstall)  
       env.PrependENVPath('PATH', env['boost_lib_path'])  
 except KeyError:  
    libinstall = None  
 try:  
    pyinstall = env['pyinstall'] # all targets will install into pyinstall/esys but PYTHONPATH points at straight pyinstall so you go import esys.escript etc  
 except KeyError:  
    pyinstall = None  
   
 try:  
    cc_defines = env['cc_defines']  
    env.Append(CPPDEFINES = cc_defines)  
 except KeyError:  
    pass  
 try:  
    flags = env['ar_flags']  
    env.Append(ARFLAGS = flags)  
 except KeyError:  
    ar_flags = None  
 try:  
    sys_libs = env['sys_libs']  
 except KeyError:  
    sys_libs = []  
   
 try:  
    tar_flags = env['tar_flags']  
    env.Replace(TARFLAGS = tar_flags)  
 except KeyError:  
    pass  
   
 try:  
    exinstall = env['exinstall']  
 except KeyError:  
    exinstall = None  
 try:  
    sys_libinstall = env['sys_libinstall']  
 except KeyError:  
    sys_libinstall = None  
 try:  
    sys_pyinstall = env['sys_pyinstall']  
 except KeyError:  
    sys_pyinstall = None  
 try:  
    sys_exinstall = env['sys_exinstall']  
 except KeyError:  
    sys_exinstall = None  
   
 # ====================== debugging ===================================  
 try:  
    dodebug = env['dodebug']  
 except KeyError:  
    dodebug = None  
392    
393  # === switch on omp ===================================================  ############################ Dependency checks ###############################
 try:  
   omp_flags = env['omp_flags']  
 except KeyError:  
   omp_flags = ''  
394    
395  try:  # Create a Configure() environment to check for compilers and python
396    omp_flags_debug = env['omp_flags_debug']  conf = Configure(env.Clone())
 except KeyError:  
   omp_flags_debug = ''  
   
 # ========= use mpi? =====================================================  
 try:  
    useMPI = env['useMPI']  
 except KeyError:  
    useMPI = None  
 # ========= set compiler flags ===========================================  
397    
398  if dodebug:  ######## Test that the compilers work
399      try:  
400        flags = env['cc_flags_debug'] + ' ' + omp_flags_debug  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
401        env.Append(CCFLAGS = flags)      if not conf.CheckCC():
402      except KeyError:          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
403        pass          Exit(1)
404  else:      if not conf.CheckCXX():
405     try:          print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
406        flags = env['cc_flags'] + ' ' + omp_flags          Exit(1)
407        env.Append(CCFLAGS = flags)  else:
408     except KeyError:      if not conf.CheckFunc('printf', language='c'):
409        pass          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
410  if dodebug:          Exit(1)
411       try:      if not conf.CheckFunc('printf', language='c++'):
412          flags = env['cxx_flags_debug']          print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
413          env.Append(CXXFLAGS = flags)          Exit(1)
414       except KeyError:  
415          pass  if conf.CheckFunc('gethostname'):
416  else:      conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])
417       try:  
418          flags = env['cxx_flags']  ######## Python headers & library (required)
419          env.Append(CXXFLAGS = flags)  
420       except KeyError:  #First we check to see if the config file has specified
421          pass  ##Where to find the filae. Ideally, this should be automatic
422  try:  #But we need to deal with the case where python is not in its INSTALL
423       if env['CC'] == 'gcc': env.Append(CCFLAGS = "-pedantic-errors -Wno-long-long")  #Directory
424  except:  # Use the python scons is running
425       pass  if env['pythoncmd']=='python':
426        python_inc_path=sysconfig.get_python_inc()
427        if IS_WINDOWS:
428            python_lib_path=os.path.join(sysconfig.get_config_var('prefix'), 'libs')
429        elif env['PLATFORM']=='darwin':
430            python_lib_path=sysconfig.get_config_var('LIBPL')
431        else:
432            python_lib_path=sysconfig.get_config_var('LIBDIR')
433    
434        #python_libs=[sysconfig.get_config_var('LDLIBRARY')] # only on linux
435        if IS_WINDOWS:
436            python_libs=['python%s%s'%(sys.version_info[0], sys.version_info[1])]
437        else:
438            python_libs=['python'+sysconfig.get_python_version()]
439    
440    #if we want to use a python other than the one scons is running
441    else:
442        initstring='from __future__ import print_function;from distutils import sysconfig;'
443        if env['pythonlibname']!='':
444            python_libs=env['pythonlibname']
445        else:   # work it out by calling python    
446            if IS_WINDOWS:
447                cmd='print("python%s%s"%(sys.version_info[0], sys.version_info[1]))'
448            else:
449                cmd='print("python"+sysconfig.get_python_version())'
450            p=Popen([env['pythoncmd'], '-c', initstring+cmd], stdout=PIPE)
451            python_libs=p.stdout.readline()
452            if env['usepython3']:       # This is to convert unicode str into py2 string
453                python_libs=python_libs.encode() # If scons runs on py3 then this must be rethought
454            p.wait()
455            python_libs=python_libs.strip()
456    
 # ============= Remember what options were used in the compile =====================================  
 if not IS_WINDOWS_PLATFORM:  
   env.Execute("/bin/rm -f " + libinstall + "/Compiled.with.*")  
   if dodebug:       env.Execute("touch " + libinstall + "/Compiled.with.debug")  
   if useMPI:        env.Execute("touch " + libinstall + "/Compiled.with.mpi")  
   if omp_flags != '':   env.Execute("touch " + libinstall + "/Compiled.with.OpenMP")  
   if bounds_check:  env.Execute("touch " + libinstall + "/Compiled.with.bounds_check")  
   
 # ============= set mkl (but only of no MPI) =====================================  
 if not useMPI:  
    try:  
       includes = env['mkl_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['mkl_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
       env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
    except KeyError:  
       pass  
   
    try:  
       mkl_libs = env['mkl_libs']  
    except KeyError:  
       mkl_libs = []  
 else:  
      mkl_libs = []  
   
 # ============= set scsl (but only of no MPI) =====================================  
 if not useMPI:  
    try:  
       includes = env['scsl_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['scsl_lib_path']  
       env.Append(LIBPATH = [lib_path,])  
       env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
    except KeyError:  
       pass  
457        
458     try:      # Now we know whether we are using python3 or not
459        scsl_libs = env['scsl_libs']      p=Popen([env['pythoncmd'], '-c',  initstring+'print(sysconfig.get_python_inc())'], stdout=PIPE)
460     except KeyError:      python_inc_path=p.stdout.readline()
461        scsl_libs = [ ]      if env['usepython3']:
462             python_inc_path=python_inc_path.encode()
463  else:      p.wait()  
464      scsl_libs =  []      python_inc_path=python_inc_path.strip()
465        if IS_WINDOWS:
466  # ============= set TRILINOS (but only with MPI) =====================================          cmd="os.path.join(sysconfig.get_config_var('prefix'), 'libs')"
467  if useMPI:      elif env['PLATFORM']=='darwin':
468     try:          cmd="sysconfig.get_config_var(\"LIBPL\")"
469        includes = env['trilinos_path']      else:
470        env.Append(CPPPATH = [includes,])          cmd="sysconfig.get_config_var(\"LIBDIR\")"
471     except KeyError:  
472        pass      p=Popen([env['pythoncmd'], '-c', initstring+'print('+cmd+')'], stdout=PIPE)
473        python_lib_path=p.stdout.readline()
474     try:      if env['usepython3']:
475        lib_path = env['trilinos_lib_path']          python_lib_path=python_lib_path.decode()
476        env.Append(LIBPATH = [lib_path,])      p.wait()
477     except KeyError:      python_lib_path=python_lib_path.strip()
478        pass  
479    #Check for an override from the config file.
480     try:  #Ideally, this should be automatic
481        trilinos_libs = env['trilinos_libs']  #But we need to deal with the case where python is not in its INSTALL
482     except KeyError:  #Directory
483        trilinos_libs = []  if env['pythonlibpath']!='':
484  else:      python_lib_path=env['pythonlibpath']
485       trilinos_libs = []  
486    if env['pythonincpath']!='':
487        python_inc_path=env['pythonincpath']
488  # ============= set umfpack (but only without MPI) =====================================  
489  umf_libs=[ ]  
490  if not useMPI:  if sysheaderopt == '':
491     try:      conf.env.AppendUnique(CPPPATH = [python_inc_path])
492        includes = env['umf_path']  else:
493        env.Append(CPPPATH = [includes,])      conf.env.Append(CCFLAGS = [sysheaderopt, python_inc_path])
494     except KeyError:  
495        pass  conf.env.AppendUnique(LIBPATH = [python_lib_path])
496    conf.env.AppendUnique(LIBS = python_libs)
497     try:  # The wrapper script needs to find the libs
498        lib_path = env['umf_lib_path']  conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, python_lib_path)
499        env.Append(LIBPATH = [lib_path,])  
500     except KeyError:  if not conf.CheckCHeader('Python.h'):
501        pass      print("Cannot find python include files (tried 'Python.h' in directory %s)" % (python_inc_path))
502        Exit(1)
503     try:  if not conf.CheckFunc('Py_Exit'):
504        umf_libs = env['umf_libs']      print("Cannot find python library method Py_Main (tried %s in directory %s)" % (python_libs, python_lib_path))
505        umf_libs+=umf_libs      Exit(1)
506     except KeyError:  
507        pass  ## reuse conf to check for numpy header (optional)
508    if env['usepython3']:
509     try:      # FIXME: This is until we can work out how to make the checks in python 3
510        includes = env['ufc_path']      conf.env['numpy_h']=False
511        env.Append(CPPPATH = [includes,])  else:
512     except KeyError:      if conf.CheckCXXHeader(['Python.h','numpy/ndarrayobject.h']):
513        pass          conf.env.Append(CPPDEFINES = ['HAVE_NUMPY_H'])
514            conf.env['numpy_h']=True
515     try:      else:
516        includes = env['amd_path']          conf.env['numpy_h']=False
517        env.Append(CPPPATH = [includes,])  
518     except KeyError:  # Commit changes to environment
519        pass  env = conf.Finish()
520    
521     try:  ######## boost (required)
522        lib_path = env['amd_lib_path']  
523        env.Append(LIBPATH = [lib_path,])  boost_inc_path,boost_lib_path=findLibWithHeader(env, env['boost_libs'], 'boost/python.hpp', env['boost_prefix'], lang='c++')
524     except KeyError:  if sysheaderopt == '':
525        pass      env.AppendUnique(CPPPATH = [boost_inc_path])
526    else:
527     try:      # This is required because we can't -isystem /usr/include since it breaks
528        amd_libs = env['amd_libs']      # std includes
529        umf_libs+=amd_libs      if os.path.normpath(boost_inc_path) == '/usr/include':
530     except KeyError:          conf.env.Append(CCFLAGS=[sysheaderopt, os.path.join(boost_inc_path,'boost')])
531        pass      else:
532            env.Append(CCFLAGS=[sysheaderopt, boost_inc_path])
533  # ============= set TRILINOS (but only with MPI) =====================================  
534  if useMPI:  env.AppendUnique(LIBPATH = [boost_lib_path])
535     try:  env.AppendUnique(LIBS = env['boost_libs'])
536        includes = env['trilinos_path']  env.PrependENVPath(LD_LIBRARY_PATH_KEY, boost_lib_path)
537        env.Append(CPPPATH = [includes,])  
538     except KeyError:  ######## numpy (required)
539        pass  
540    if not detectModule(env, 'numpy'):
541     try:      print("Cannot import numpy. If it is installed try setting your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
542        lib_path = env['trilinos_lib_path']      Exit(1)
543        env.Append(LIBPATH = [lib_path,])  
544     except KeyError:  ######## CppUnit (required for tests)
545        pass  
546    try:
547     try:      cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
548        trilinos_libs = env['trilinos_libs']      env.AppendUnique(CPPPATH = [cppunit_inc_path])
549     except KeyError:      env.AppendUnique(LIBPATH = [cppunit_lib_path])
550        trilinos_libs = []      env.PrependENVPath(LD_LIBRARY_PATH_KEY, cppunit_lib_path)
551  else:      env['cppunit']=True
552       trilinos_libs = []  except:
553        env['cppunit']=False
 # ============= set blas =====================================  
 try:  
    includes = env['blas_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
   
 try:  
    lib_path = env['blas_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
554    
555  try:  ######## sympy (optional)
    blas_libs = env['blas_libs']  
 except KeyError:  
    blas_libs = [ ]  
556    
557  # ========== netcdf ====================================  if detectModule(env, 'sympy'):
558  try:      env['sympy'] = True
    useNetCDF = env['useNetCDF']  
 except KeyError:  
    useNetCDF = 'yes'  
    pass  
       
 if useNetCDF == 'yes':  
    try:  
       netCDF_libs = env['netCDF_libs']  
    except KeyError:  
       pass  
   
    env.Append(LIBS = netCDF_libs)  
    env.Append(CPPDEFINES = [ 'USE_NETCDF' ])  
    try:  
       includes = env['netCDF_path']  
       env.Append(CPPPATH = [includes,])  
    except KeyError:  
       pass  
   
    try:  
       lib_path = env['netCDF_lib_path']  
       env.Append(LIBPATH = [ lib_path, ])  
       env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
       if IS_WINDOWS_PLATFORM :  
          env.PrependENVPath('PATH', lib_path)  
    except KeyError:  
       pass  
559  else:  else:
560     print "Warning: Installation is not configured with netCDF. Some I/O function may not be available."      print("Cannot import sympy. Symbolic toolbox and nonlinear PDEs will not be available.")
561     netCDF_libs=[ ]      env['sympy'] = False
562    
563  # ====================== boost ======================================  ######## netCDF (optional)
564  try:  
565     includes = env['boost_path']  netcdf_inc_path=''
566     env.Append(CPPPATH = [includes,])  netcdf_lib_path=''
567  except KeyError:  if env['netcdf']:
568     pass      netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'netcdf.h', env['netcdf_prefix'], lang='c++')
569  try:      env.AppendUnique(CPPPATH = [netcdf_inc_path])
570     lib_path = env['boost_lib_path']      env.AppendUnique(LIBPATH = [netcdf_lib_path])
571     env.Append(LIBPATH = [lib_path,])      env.AppendUnique(LIBS = env['netcdf_libs'])
572     env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path      env.PrependENVPath(LD_LIBRARY_PATH_KEY, netcdf_lib_path)
573     if IS_WINDOWS_PLATFORM :      env.Append(CPPDEFINES = ['USE_NETCDF'])
574        env.PrependENVPath('PATH', lib_path)  
575  except KeyError:  ######## PAPI (optional)
576     pass  
577  try:  papi_inc_path=''
578     boost_lib = env['boost_lib']  papi_lib_path=''
579  except KeyError:  if env['papi']:
580     boost_lib = None      papi_inc_path,papi_lib_path=findLibWithHeader(env, env['papi_libs'], 'papi.h', env['papi_prefix'], lang='c')
581  # ====================== python ======================================      env.AppendUnique(CPPPATH = [papi_inc_path])
582  try:      env.AppendUnique(LIBPATH = [papi_lib_path])
583     includes = env['python_path']      env.AppendUnique(LIBS = env['papi_libs'])
584     env.Append(CPPPATH = [includes,])      env.PrependENVPath(LD_LIBRARY_PATH_KEY, papi_lib_path)
585  except KeyError:      env.Append(CPPDEFINES = ['BLOCKPAPI'])
586     pass  
587  try:  ######## MKL (optional)
588     lib_path = env['python_lib_path']  
589     env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  mkl_inc_path=''
590     env.Append(LIBPATH = [lib_path,])  mkl_lib_path=''
591  except KeyError:  if env['mkl']:
592     pass      mkl_inc_path,mkl_lib_path=findLibWithHeader(env, env['mkl_libs'], 'mkl_solver.h', env['mkl_prefix'], lang='c')
593  try:      env.AppendUnique(CPPPATH = [mkl_inc_path])
594     python_lib = env['python_lib']      env.AppendUnique(LIBPATH = [mkl_lib_path])
595  except KeyError:      env.AppendUnique(LIBS = env['mkl_libs'])
596     python_lib = None      env.PrependENVPath(LD_LIBRARY_PATH_KEY, mkl_lib_path)
597  # =============== documentation =======================================      env.Append(CPPDEFINES = ['MKL'])
598  try:  
599     doxygen_path = env['doxygen_path']  ######## UMFPACK (optional)
600  except KeyError:  
601     doxygen_path = None  umfpack_inc_path=''
602  try:  umfpack_lib_path=''
603     epydoc_path = env['epydoc_path']  if env['umfpack']:
604  except KeyError:      umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c')
605     epydoc_path = None      env.AppendUnique(CPPPATH = [umfpack_inc_path])
606  # =============== ParMETIS =======================================      env.AppendUnique(LIBPATH = [umfpack_lib_path])
607  try:      env.AppendUnique(LIBS = env['umfpack_libs'])
608     parmetis_path = env['parmetis_path']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, umfpack_lib_path)
609     parmetis_lib_path = env['parmetis_lib_path']      env.Append(CPPDEFINES = ['UMFPACK'])
610     parmetis_lib = env['parmetis_lib']  
611  except KeyError:  ######## LAPACK (optional)
612     parmetis_path = ''  
613     parmetis_lib_path = ''  if env['lapack']=='mkl' and not env['mkl']:
614     parmetis_lib = ''      print("mkl_lapack requires MKL!")
615        Exit(1)
616  if useMPI and os.path.isdir(parmetis_lib_path):  
617     env.Append(CPPDEFINES = [ 'PARMETIS' ])  env['uselapack'] = env['lapack']!='none'
618     env.Append(CXXDEFINES = [ 'PARMETIS' ])  lapack_inc_path=''
619     env.Append(CPPPATH = [parmetis_path])  lapack_lib_path=''
620     env.Append(LIBPATH = [parmetis_lib_path])  if env['uselapack']:
621     env.Append(LIBS = parmetis_lib)      header='clapack.h'
622  # =============== PAPI =======================================      if env['lapack']=='mkl':
623  try:          env.AppendUnique(CPPDEFINES = ['MKL_LAPACK'])
624     includes = env['papi_path']          header='mkl_lapack.h'
625     env.Append(CPPPATH = [includes,])      lapack_inc_path,lapack_lib_path=findLibWithHeader(env, env['lapack_libs'], header, env['lapack_prefix'], lang='c')
626  except KeyError:      env.AppendUnique(CPPPATH = [lapack_inc_path])
627     pass      env.AppendUnique(LIBPATH = [lapack_lib_path])
628  try:      env.AppendUnique(LIBS = env['lapack_libs'])
629     lib_path = env['papi_lib_path']      env.Append(CPPDEFINES = ['USE_LAPACK'])
630     env.Append(LIBPATH = [lib_path,])  
631  except KeyError:  ######## Silo (optional)
632     pass  
633  try:  silo_inc_path=''
634     papi_libs = env['papi_libs']  silo_lib_path=''
635  except KeyError:  if env['silo']:
636     papi_libs = None      silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c')
637  # ============= set mpi =====================================      env.AppendUnique(CPPPATH = [silo_inc_path])
638  if useMPI:      env.AppendUnique(LIBPATH = [silo_lib_path])
639     env.Append(CPPDEFINES=['PASO_MPI',])      # Note that we do not add the libs since they are only needed for the
640     try:      # weipa library and tools.
641        includes = env['mpi_path']      #env.AppendUnique(LIBS = [env['silo_libs']])
642        env.Append(CPPPATH = [includes,])  
643     except KeyError:  ######## VSL random numbers (optional)
644        pass  if env['vsl_random']:
645     try:      env.Append(CPPDEFINES = ['MKLRANDOM'])
646        lib_path = env['mpi_lib_path']  
647        env.Append(LIBPATH = [lib_path,])  ######## VisIt (optional)
648        env['ENV']['LD_LIBRARY_PATH']+=":"+lib_path  
649     except KeyError:  visit_inc_path=''
650        pass  visit_lib_path=''
651     try:  if env['visit']:
652        mpi_libs = env['mpi_libs']      visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c')
653     except KeyError:      env.AppendUnique(CPPPATH = [visit_inc_path])
654        mpi_libs = []      env.AppendUnique(LIBPATH = [visit_lib_path])
655    
656     try:  ######## MPI (optional)
657        mpi_run = env['mpi_run']  
658     except KeyError:  if env['mpi']=='no':
659        mpi_run = ''      env['mpi']='none'
660    
661     try:  env['usempi'] = env['mpi']!='none'
662         mpich_ignore_cxx_seek=env['MPICH_IGNORE_CXX_SEEK']  mpi_inc_path=''
663         env.Append(CPPDEFINES = [ mpich_ignore_cxx_seek ] )  mpi_lib_path=''
664     except KeyError:  if env['usempi']:
665        pass      mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c')
666  else:      env.AppendUnique(CPPPATH = [mpi_inc_path])
667    mpi_libs=[]      env.AppendUnique(LIBPATH = [mpi_lib_path])
668    mpi_run = mpi_run_default      env.AppendUnique(LIBS = env['mpi_libs'])
669  # =========== zip files ===========================================      env.PrependENVPath(LD_LIBRARY_PATH_KEY, mpi_lib_path)
670  try:      env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
671     includes = env['papi_path']      # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
672     env.Append(CPPPATH = [includes,])      # On the other hand MPT and OpenMPI don't define the latter so we have to
673  except KeyError:      # do that here
674     pass      if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
675  try:          env.Append(CPPDEFINES = ['MPI_INCLUDED'])
676     lib_path = env['papi_lib_path']  
677     env.Append(LIBPATH = [lib_path,])  ######## BOOMERAMG (optional)
678  except KeyError:  
679     pass  if env['mpi'] == 'none': env['boomeramg'] = False
680  try:  
681     papi_libs = env['papi_libs']  boomeramg_inc_path=''
682  except KeyError:  boomeramg_lib_path=''
683     papi_libs = None  if env['boomeramg']:
684  try:      boomeramg_inc_path,boomeramg_lib_path=findLibWithHeader(env, env['boomeramg_libs'], 'HYPRE.h', env['boomeramg_prefix'], lang='c')
685     papi_instrument_solver = env['papi_instrument_solver']      env.AppendUnique(CPPPATH = [boomeramg_inc_path])
686  except KeyError:      env.AppendUnique(LIBPATH = [boomeramg_lib_path])
687     papi_instrument_solver = None      env.AppendUnique(LIBS = env['boomeramg_libs'])
688        env.PrependENVPath(LD_LIBRARY_PATH_KEY, boomeramg_lib_path)
689        env.Append(CPPDEFINES = ['BOOMERAMG'])
690  # ============= and some helpers =====================================  
691  try:  ######## ParMETIS (optional)
692     doxygen_path = env['doxygen_path']  
693  except KeyError:  if not env['usempi']: env['parmetis'] = False
694     doxygen_path = None  
695  try:  parmetis_inc_path=''
696     epydoc_path = env['epydoc_path']  parmetis_lib_path=''
697  except KeyError:  if env['parmetis']:
698     epydoc_path = None      parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c')
699  try:      env.AppendUnique(CPPPATH = [parmetis_inc_path])
700     src_zipfile = env.File(env['src_zipfile'])      env.AppendUnique(LIBPATH = [parmetis_lib_path])
701  except KeyError:      env.AppendUnique(LIBS = env['parmetis_libs'])
702     src_zipfile = None      env.PrependENVPath(LD_LIBRARY_PATH_KEY, parmetis_lib_path)
703  try:      env.Append(CPPDEFINES = ['USE_PARMETIS'])
704     test_zipfile = env.File(env['test_zipfile'])  
705  except KeyError:  ######## gmsh (optional, for tests)
706     test_zipfile = None  
707  try:  try:
708     examples_zipfile = env.File(env['examples_zipfile'])      p=Popen(['gmsh', '-info'], stderr=PIPE)
709  except KeyError:      _,e=p.communicate()
710     examples_zipfile = None      if e.split().count("MPI"):
711            env['gmsh']='m'
712  try:      else:
713     src_tarfile = env.File(env['src_tarfile'])          env['gmsh']='s'
714  except KeyError:  except OSError:
715     src_tarfile = None      env['gmsh']=False
716  try:  
717     test_tarfile = env.File(env['test_tarfile'])  ######## PDFLaTeX (for documentation)
718  except KeyError:  if 'PDF' in dir(env) and '.tex' in env.PDF.builder.src_suffixes(env):
719     test_tarfile = None      env['pdflatex']=True
720  try:  else:
721     examples_tarfile = env.File(env['examples_tarfile'])      env['pdflatex']=False
722  except KeyError:  
723     examples_tarfile = None  ######################## Summarize our environment ###########################
724    
725  try:  # keep some of our install paths first in the list for the unit tests
726     guide_pdf = env.File(env['guide_pdf'])  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
727  except KeyError:  env.PrependENVPath('PYTHONPATH', prefix)
728     guide_pdf = None  env['ENV']['ESCRIPT_ROOT'] = prefix
729    
730  try:  if not env['verbose']:
731     guide_html_index = env.File('index.htm',env['guide_html'])      env['CCCOMSTR'] = "Compiling $TARGET"
732  except KeyError:      env['CXXCOMSTR'] = "Compiling $TARGET"
733     guide_html_index = None      env['SHCCCOMSTR'] = "Compiling $TARGET"
734        env['SHCXXCOMSTR'] = "Compiling $TARGET"
735  try:      env['ARCOMSTR'] = "Linking $TARGET"
736     api_epydoc = env.Dir(env['api_epydoc'])      env['LINKCOMSTR'] = "Linking $TARGET"
737  except KeyError:      env['SHLINKCOMSTR'] = "Linking $TARGET"
738     api_epydoc = None      env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
739        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
740  try:      env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
741     api_doxygen = env.Dir(env['api_doxygen'])      env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
742  except KeyError:      #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
743     api_doxygen = None  
744    print("")
745  try:  print("*** Config Summary (see config.log and lib/buildvars for details) ***")
746     svn_pipe = os.popen("svnversion -n .")  print("Escript/Finley revision %s"%global_revision)
747     global_revision = svn_pipe.readlines()  print("  Install prefix:  %s"%env['prefix'])
748     svn_pipe.close()  print("          Python:  %s"%sysconfig.PREFIX)
749     global_revision = re.sub(":.*", "", global_revision[0])  print("           boost:  %s"%env['boost_prefix'])
750     global_revision = re.sub("[^0-9]", "", global_revision)  print("           numpy:  YES")
751  except:  if env['usempi']:
752     global_revision="-1"      print("             MPI:  YES (flavour: %s)"%env['mpi'])
753     print "Warning: unable to recover global revsion number."  else:
754  if global_revision == "": global_revision="0"      print("             MPI:  DISABLED")
755  print "Revision number is %s."%global_revision  if env['uselapack']:
756  env.Append(CPPDEFINES = "SVN_VERSION="+global_revision)      print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
757    else:
758  # Python install - esys __init__.py      print("          LAPACK:  DISABLED")
759  init_target = env.Command(pyinstall+'/__init__.py', None, Touch('$TARGET'))  d_list=[]
760    e_list=[]
761  # FIXME: exinstall and friends related to examples are not working.  for i in 'debug','openmp','boomeramg','mkl','netcdf','papi','parmetis','silo','sympy','umfpack','visit','vsl_random':
762  build_target = env.Alias('build',[libinstall,incinstall,pyinstall,init_target])      if env[i]: e_list.append(i)
763        else: d_list.append(i)
764  env.Default(build_target)  for i in e_list:
765        print("%16s:  YES"%i)
766  # Zipgets  for i in d_list:
767  env.Alias('release_src',[ src_zipfile, src_tarfile ])      print("%16s:  DISABLED"%i)
768  env.Alias('release_tests',[ test_zipfile, test_tarfile])  if env['cppunit']:
769  env.Alias('release_examples',[ examples_zipfile, examples_tarfile])      print("         CppUnit:  FOUND")
770  env.Alias('examples_zipfile',examples_zipfile)  else:
771  env.Alias('examples_tarfile',examples_tarfile)      print("         CppUnit:  NOT FOUND")
772  env.Alias('api_epydoc',api_epydoc)  if env['gmsh']=='m':
773  env.Alias('api_doxygen',api_doxygen)      print("            gmsh:  FOUND, MPI-ENABLED")
774  env.Alias('guide_html_index',guide_html_index)  elif env['gmsh']=='s':
775  env.Alias('guide_pdf', guide_pdf)      print("            gmsh:  FOUND")
776  env.Alias('docs',[ 'release_examples', 'guide_pdf', api_epydoc, api_doxygen, guide_html_index])  else:
777  env.Alias('release', ['release_src', 'release_tests', 'docs'])      print("            gmsh:  NOT FOUND")
778    if env['numpy_h']:
779  env.Alias('build_tests',build_target)    # target to build all C++ tests      print("   numpy headers:  FOUND")
780  env.Alias('build_py_tests',build_target) # target to build all python tests  else:
781  env.Alias('build_all_tests', [ 'build_tests', 'build_py_tests' ] ) # target to build all python tests      print("   numpy headers:  NOT FOUND")
782  env.Alias('run_tests', 'build_tests')   # target to run all C++ test  print("   vsl_random:  %s"%env['vsl_random'])
783  env.Alias('py_tests', 'build_py_tests') # taget to run all released python tests      
784  env.Alias('all_tests', ['run_tests', 'py_tests']) # target to run all C++ and released python tests  if ((fatalwarning != '') and (env['werror'])):
785        print("  Treating warnings as errors")
786    else:
787  # Allow sconscripts to see the env      print("  NOT treating warnings as errors")
788  Export(["IS_WINDOWS_PLATFORM", "env", "incinstall", "libinstall", "pyinstall", "dodebug", "mkl_libs", "scsl_libs", "umf_libs", "blas_libs", "netCDF_libs", "useNetCDF", "mpi_run",  print("")
789      "boost_lib", "python_lib", "doxygen_path", "epydoc_path", "papi_libs",  
790          "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "examples_tarfile", "examples_zipfile", "trilinos_libs", "mpi_libs", "papi_instrument_solver",  ####################### Configure the subdirectories #########################
791          "guide_pdf", "guide_html_index", "api_epydoc", "api_doxygen", "useMPI" ])  
792    from grouptest import *
793  # End initialisation section  
794  # Begin configuration section  TestGroups=[]
795  # adds this file and the scons option directore to the source tar  
796  release_srcfiles=[env.File('SConstruct'),env.Dir('lib'),env.Dir('include'),]+[ env.File(x) for x in glob.glob('scons/*.py') ]  # keep an environment without warnings-as-errors
797  release_testfiles=[env.File('README_TESTS'),]  dodgy_env=env.Clone()
798  env.Zip(src_zipfile, release_srcfiles)  
799  env.Zip(test_zipfile, release_testfiles)  # now add warnings-as-errors flags. This needs to be done after configuration
800  try:  # because the scons test files have warnings in them
801     env.Tar(src_tarfile, release_srcfiles)  if ((fatalwarning != '') and (env['werror'])):
802     env.Tar(test_tarfile, release_testfiles)      env.Append(CCFLAGS = fatalwarning)
803  except AttributeError:  
804     pass  Export(
805  # Insert new components to be build here    ['env',
806  # FIXME: might be nice to replace this verbosity with a list of targets and some     'dodgy_env',
807  # FIXME: nifty python to create the lengthy but very similar env.Sconscript lines     'IS_WINDOWS',
808  # Third Party libraries     'TestGroups'
809  env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)    ]
810  # C/C++ Libraries  )
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 # bruce is removed for now as it doesn't really do anything  
 # env.SConscript(dirs = ['bruce/src'], build_dir='build/$PLATFORM/bruce', duplicate=0)  
 env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
 env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  
 env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  
 env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 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 = ['../test'], build_dir='../test/build', duplicate=0)  
811    
812    env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
813    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
814    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
815    env.SConscript(dirs = ['escript/src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
816    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
817    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
818    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
819    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
820    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
821    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
822    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
823    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
824    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
825    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
826    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
827    
828    
829    ######################## Populate the buildvars file #########################
830    
831    # remove obsolete file
832    if not env['usempi']:
833        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
834        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
835    
836    # Try to extract the boost version from version.hpp
837    boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
838    boostversion='unknown'
839    try:
840        for line in boosthpp:
841            ver=re.match(r'#define BOOST_VERSION (\d+)',line)
842            if ver:
843                boostversion=ver.group(1)
844    except StopIteration:
845        pass
846    boosthpp.close()
847    
848    
849    buildvars=open(os.path.join(env['libinstall'], 'buildvars'), 'w')
850    buildvars.write("svn_revision="+str(global_revision)+"\n")
851    buildvars.write("prefix="+prefix+"\n")
852    buildvars.write("cc="+env['CC']+"\n")
853    buildvars.write("cxx="+env['CXX']+"\n")
854    if env['pythoncmd']=='python':
855        buildvars.write("python="+sys.executable+"\n")
856        buildvars.write("python_version="+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+"\n")
857    else:
858        buildvars.write("python="+env['pythoncmd']+"\n")
859        p=Popen([env['pythoncmd'], '-c', 'from __future__ import print_function;import sys;print(str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2]))'], stdout=PIPE)
860        verstring=p.stdout.readline().strip()
861        p.wait()
862        buildvars.write("python_version="+verstring+"\n")
863    buildvars.write("boost_inc_path="+boost_inc_path+"\n")
864    buildvars.write("boost_lib_path="+boost_lib_path+"\n")
865    buildvars.write("boost_version="+boostversion+"\n")
866    buildvars.write("debug=%d\n"%int(env['debug']))
867    buildvars.write("openmp=%d\n"%int(env['openmp']))
868    buildvars.write("mpi=%s\n"%env['mpi'])
869    buildvars.write("mpi_inc_path=%s\n"%mpi_inc_path)
870    buildvars.write("mpi_lib_path=%s\n"%mpi_lib_path)
871    buildvars.write("lapack=%s\n"%env['lapack'])
872    buildvars.write("vsl_random=%d\n"%int(env['vsl_random']))
873    for i in 'netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit':
874        buildvars.write("%s=%d\n"%(i, int(env[i])))
875        if env[i]:
876            buildvars.write("%s_inc_path=%s\n"%(i, eval(i+'_inc_path')))
877            buildvars.write("%s_lib_path=%s\n"%(i, eval(i+'_lib_path')))
878    buildvars.close()
879    
880    ################### Targets to build and install libraries ###################
881    
882    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
883    env.Alias('target_init', [target_init])
884    # delete buildvars upon cleanup
885    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
886    
887    # The headers have to be installed prior to build in order to satisfy
888    # #include <paso/Common.h>
889    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
890    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
891    
892    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
893    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
894    
895    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
896    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escript_py'])
897    
898    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
899    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
900    
901    env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
902    env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
903    
904    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
905    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
906    
907    env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
908    env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
909    
910    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
911    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
912    
913    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
914    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
915    
916    # Now gather all the above into some easy targets: build_all and install_all
917    build_all_list = []
918    build_all_list += ['build_esysUtils']
919    build_all_list += ['build_paso']
920    build_all_list += ['build_escript']
921    build_all_list += ['build_pasowrap']
922    build_all_list += ['build_dudley']
923    build_all_list += ['build_finley']
924    build_all_list += ['build_ripley']
925    build_all_list += ['build_weipa']
926    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
927    if env['usempi']:   build_all_list += ['build_pythonMPI']
928    build_all_list += ['build_escriptconvert']
929    env.Alias('build_all', build_all_list)
930    
931    install_all_list = []
932    install_all_list += ['target_init']
933    install_all_list += ['install_esysUtils']
934    install_all_list += ['install_paso']
935    install_all_list += ['install_escript']
936    install_all_list += ['install_pasowrap']
937    install_all_list += ['install_dudley']
938    install_all_list += ['install_finley']
939    install_all_list += ['install_ripley']
940    install_all_list += ['install_weipa']
941    if not IS_WINDOWS: install_all_list += ['install_escriptreader']
942    install_all_list += ['install_downunder_py']
943    install_all_list += ['install_modellib_py']
944    install_all_list += ['install_pycad_py']
945    if env['usempi']:   install_all_list += ['install_pythonMPI']
946    install_all_list += ['install_escriptconvert']
947    env.Alias('install_all', install_all_list)
948    
949    # Default target is install
950    env.Default('install_all')
951    
952    ################## Targets to build and run the test suite ###################
953    
954    if not env['cppunit']:
955        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C/C++ unit tests, CppUnit not found!";exit 1')
956        env.Alias('run_tests', test_msg)
957    env.Alias('run_tests', ['install_all'])
958    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
959    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
960    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
961    
962    ##################### Targets to build the documentation #####################
963    
964    env.Alias('api_epydoc','install_all')
965    env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'user_pdf', 'install_pdf', 'cookbook_pdf'])
966    env.Alias('release_prep', ['docs', 'install_all'])
967    
968  syslib_install_target = env.installDirectory(sys_libinstall,libinstall)  if not IS_WINDOWS:
969  syspy_install_target = env.installDirectory(sys_pyinstall,pyinstall,recursive=True)      try:
970            utest=open('utest.sh','w')
971            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix))
972            for tests in TestGroups:
973                utest.write(tests.makeString())
974            utest.close()
975            Execute(Chmod('utest.sh', 0o755))
976            print("Generated utest.sh.")
977        except IOError:
978            print("Error attempting to write unittests file.")
979            Exit(1)
980    
981        # delete utest.sh upon cleanup
982        env.Clean('target_init', 'utest.sh')
983    
984        # Make sure that the escript wrapper is in place
985        if not os.path.isfile(os.path.join(env['bininstall'], 'run-escript')):
986            print("Copying escript wrapper.")
987            Execute(Copy(os.path.join(env['bininstall'],'run-escript'), 'bin/run-escript'))
988    
 install_target = env.Alias("install", env.Flatten([syslib_install_target, syspy_install_target]) )  

Legend:
Removed from v.1559  
changed lines
  Added in v.3977

  ViewVC Help
Powered by ViewVC 1.1.26