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

Diff of /branches/diaplayground/SConstruct

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

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

Legend:
Removed from v.1149  
changed lines
  Added in v.4173

  ViewVC Help
Powered by ViewVC 1.1.26