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

Diff of /branches/diaplayground/SConstruct

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

revision 3096 by caltinay, Thu Aug 19 01:40:52 2010 UTC revision 4640 by jfenwick, Fri Jan 31 00:56:51 2014 UTC
# Line 1  Line 1 
1    ##############################################################################
 ########################################################  
2  #  #
3  # Copyright (c) 2003-2010 by University of Queensland  # Copyright (c) 2003-2013 by University of Queensland
4  # Earth Systems Science Computational Center (ESSCC)  # http://www.uq.edu.au
 # http://www.uq.edu.au/esscc  
5  #  #
6  # Primary Business: Queensland, Australia  # Primary Business: Queensland, Australia
7  # Licensed under the Open Software License version 3.0  # Licensed under the Open Software License version 3.0
8  # http://www.opensource.org/licenses/osl-3.0.php  # http://www.opensource.org/licenses/osl-3.0.php
9  #  #
10  ########################################################  # Development until 2012 by Earth Systems Science Computational Center (ESSCC)
11    # Development since 2012 by School of Earth Sciences
12    #
13  EnsureSConsVersion(0,96,91)  ##############################################################################
 EnsurePythonVersion(2,3)  
   
 import sys, os, re, socket, platform, stat  
 # For copy()  
 import shutil  
   
 # Add our extensions  
 if os.path.isdir('scons'): sys.path.append('scons')  
 import scons_extensions  
14    
15  # Use /usr/lib64 if available, else /usr/lib  EnsureSConsVersion(0,98,1)
16  usr_lib = '/usr/lib'  EnsurePythonVersion(2,5)
 if os.path.isfile('/usr/lib64/libc.so'): usr_lib = '/usr/lib64'  
17    
18  # The string python2.4 or python2.5  import atexit, sys, os, platform, re
19  python_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])  from distutils import sysconfig
20    from dependencies import *
21    from site_init import *
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  # MS Windows support, many thanks to PH
28  IS_WINDOWS_PLATFORM = (os.name== "nt")  IS_WINDOWS = (os.name == 'nt')
29    
30  prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  IS_OSX = (os.uname()[0] == 'Darwin')
31    
32  #Holds names of variables from the calling environment which need to be passed  ########################## Determine options file ############################
33  #to tools  # 1. command line
34  env_export=[]  # 2. scons/<hostname>_options.py
35    # 3. name as part of a cluster
 #Determine where to read options from use:  
 #1. command line  
 #2. scons/<hostname>_options.py  
 #3. name as part of a cluster  
36  options_file=ARGUMENTS.get('options_file', None)  options_file=ARGUMENTS.get('options_file', None)
 effective_hostname=socket.gethostname().split('.')[0]  
37  if not options_file:  if not options_file:
38    mangledhostname = re.sub("[^0-9a-zA-Z]", "_", effective_hostname)      ext_dir = os.path.join(os.getcwd(), 'scons')
39    options_file = os.path.join("scons",mangledhostname+"_options.py")      hostname = platform.node().split('.')[0]
40    #If there is no options file with that name see if there is a substitute      for name in hostname, effectiveName(hostname):
41    if not os.path.isfile(options_file):          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
42      effective_hostname = scons_extensions.effectiveName(effective_hostname)          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
43      mangledhostname = re.sub("[^0-9a-zA-Z]", "_", effective_hostname)          if os.path.isfile(options_file): break
     options_file = os.path.join("scons",mangledhostname+"_options.py")  
44    
45  if not os.path.isfile(options_file):  if not os.path.isfile(options_file):
46    print "Options file not found (expected '%s')" % options_file      print("\nWARNING:\nOptions file %s" % options_file)
47    options_file = False      print("not found! Default options will be used which is most likely suboptimal.")
48  else:      print("We recommend that you copy one of the TEMPLATE files in the scons/")
49    print "Options file is", options_file      print("subdirectory and customize it to your needs.\n")
50        options_file = None
51  #Does our scons support the newer Variables class or do we need to use Options?  
52    ############################### Build options ################################
53  try:  
54     dummyvar=Variables  default_prefix='/usr'
55     opts = Variables(options_file, ARGUMENTS)  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
56     adder = opts.AddVariables  lapack_flavours=('none', 'clapack', 'mkl')
57  except:  
58     opts = Options(options_file, ARGUMENTS)  vars = Variables(options_file, ARGUMENTS)
59     adder = opts.AddOptions  vars.AddVariables(
60     BoolVariable = BoolOption    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
61      PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
62  ############ Load build options ################################    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
63      BoolVariable('verbose', 'Output full compile/link lines', False),
64  adder(  # Compiler/Linker options
65  #opts.AddOptions(    ('cxx', 'Path to C++ compiler', 'default'),
66  # Where to install esys stuff    ('cc_flags', 'Base C++ compiler flags', 'default'),
67    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
68    ('incinstall', 'where the esys headers will be installed',             os.path.join(Dir('#.').abspath,'include')),    ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
   ('bininstall', 'where the esys binaries will be installed',            os.path.join(prefix,'bin')),  
   ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),  
   ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),  
 # Compilation options  
   BoolVariable('dodebug', 'For backwards compatibility', 'no'),  
   BoolVariable('usedebug', 'Do you want a debug build?', 'no'),  
   BoolVariable('usevtk', 'Do you want to use VTK?', 'yes'),  
   ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  
   ('cc', 'path to C compiler', 'DEFAULT'),  
   ('cxx', 'path to C++ compiler', 'DEFAULT'),  
   ('win_cc_name', 'windows C compiler name if needed', 'msvc'),  
   # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below  
   ('cc_flags', 'C/C++ compiler flags to use', '-DEFAULT_1'),  
   ('cc_optim', 'C/C++ optimization flags to use', '-DEFAULT_2'),  
   ('cc_debug', 'C/C++ debug flags to use', '-DEFAULT_3'),  
   ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),  
   ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),  
   ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),  
   ('cc_extra', 'Extra C compiler flags', ''),  
69    ('cxx_extra', 'Extra C++ compiler flags', ''),    ('cxx_extra', 'Extra C++ compiler flags', ''),
70    ('ld_extra', 'Extra linker flags', ''),    ('ld_extra', 'Extra linker flags', ''),
71    ('sys_libs', 'System libraries to link with', []),    BoolVariable('werror','Treat compiler warnings as errors', True),
72    ('ar_flags', 'Static library archiver flags to use', ''),    BoolVariable('debug', 'Compile with debug flags', False),
73    BoolVariable('useopenmp', 'Compile parallel version using OpenMP', 'no'),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74    BoolVariable('usepedantic', 'Compile with -pedantic if using gcc', 'no'),    ('omp_flags', 'OpenMP compiler flags', 'default'),
75    BoolVariable('usewarnings','Compile with warnings as errors if using gcc','yes'),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76    ('forcelazy','for testing use only - set the default value for autolazy','leave_alone'),  # Mandatory libraries
77    ('forcecollres','for testing use only - set the default value for force resolving collective ops','leave_alone'),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78  # Python    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),  # Mandatory for tests
80    ('python_lib_path', 'Path to Python libs', usr_lib),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81    ('python_libs', 'Python libraries to link with', [python_version]),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82    ('python_cmd', 'Python command', 'python'),  # Optional libraries and options
83  # Boost    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84    ('boost_path', 'Path to Boost includes', '/usr/include'),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85    ('boost_lib_path', 'Path to Boost libs', usr_lib),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86    ('boost_libs', 'Boost libraries to link with', ['boost_python']),    BoolVariable('netcdf', 'Enable netCDF file support', False),
87  # NetCDF    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88    BoolVariable('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92  # MPI    BoolVariable('papi', 'Enable PAPI', False),
93    BoolVariable('useMPI', 'For backwards compatibility', 'no'),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
   BoolVariable('usempi', 'Compile parallel version using MPI', 'no'),  
   ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),  
   ('mpi_path', 'Path to MPI includes', '/usr/include'),  
   ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),  
   ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),  
   ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', []),  
   ('mpi_flavour','Type of MPI execution environment','none'),  
 # ParMETIS  
   BoolVariable('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),  
   ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),  
   ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),  
   ('parmetis_libs', 'ParMETIS library to link with', ['parmetis', 'metis']),  
 # PAPI  
   BoolVariable('usepapi', 'switch on/off the usage of PAPI', 'no'),  
   ('papi_path', 'Path to PAPI includes', '/usr/include'),  
   ('papi_lib_path', 'Path to PAPI libs', usr_lib),  
94    ('papi_libs', 'PAPI libraries to link with', ['papi']),    ('papi_libs', 'PAPI libraries to link with', ['papi']),
95    BoolVariable('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', False),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
96  # MKL    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
97    BoolVariable('usemkl', 'switch on/off the usage of MKL', 'no'),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
98    ('mkl_path', 'Path to MKL includes', '/sw/sdev/cmkl/10.0.2.18/include'),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
99    ('mkl_lib_path', 'Path to MKL libs', '/sw/sdev/cmkl/10.0.2.18/lib/em64t'),    BoolVariable('umfpack', 'Enable UMFPACK', False),
100    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver', 'mkl_em64t', 'guide', 'pthread']),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
101  # UMFPACK    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
102    BoolVariable('useumfpack', 'switch on/off the usage of UMFPACK', 'no'),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
103    ('ufc_path', 'Path to UFconfig includes', '/usr/include/suitesparse'),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
104    ('umf_path', 'Path to UMFPACK includes', '/usr/include/suitesparse'),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
105    ('umf_lib_path', 'Path to UMFPACK libs', usr_lib),    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
106    ('umf_libs', 'UMFPACK libraries to link with', ['umfpack']),    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
107  # Silo    ('lapack_libs', 'LAPACK libraries to link with', []),
108    BoolVariable('usesilo', 'switch on/off the usage of Silo', 'yes'),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
109    ('silo_path', 'Path to Silo includes', '/usr/include'),    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
   ('silo_lib_path', 'Path to Silo libs', usr_lib),  
110    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
111  # VisIt    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
112    BoolVariable('usevisit', 'switch on/off the usage of the VisIt sim library', 'no'),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
113    ('visit_path', 'Path to VisIt libsim includes', '/usr/include'),    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
114    ('visit_lib_path', 'Path to VisIt sim library', usr_lib),    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
115  # AMD (used by UMFPACK)  # Advanced settings
116    ('amd_path', 'Path to AMD includes', '/usr/include/suitesparse'),    #dudley_assemble_flags = -funroll-loops      to actually do something
117    ('amd_lib_path', 'Path to AMD libs', usr_lib),    ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
118    ('amd_libs', 'AMD libraries to link with', ['amd']),    # To enable passing function pointers through python
119  # BLAS (used by UMFPACK)    BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
120    ('blas_path', 'Path to BLAS includes', '/usr/include/suitesparse'),    # An option for specifying the compiler tools (see windows branch)
121    ('blas_lib_path', 'Path to BLAS libs', usr_lib),    ('tools_names', 'Compiler tools to use', ['default']),
122    ('blas_libs', 'BLAS libraries to link with', ['blas']),    ('env_export', 'Environment variables to be passed to tools',[]),
123  #Lapack options    EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
124    BoolVariable('uselapack','switch on/off use of Lapack','no'),    EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
125    ('lapack_path', 'Path to Lapack includes','/usr/include'),    # finer control over library building, intel aggressive global optimisation
126    ('lapack_lib_path', 'Path to Lapack libs', usr_lib),    # works with dynamic libraries on windows.
127    ('lapack_libs', 'Lapack libraries to link with', []),    ('build_shared', 'Build dynamic libraries only', False),
128    ('lapack_type', '{clapack,mkl}','clapack'),    ('sys_libs', 'Extra libraries to link with', []),
129  # An option for specifying the compiler tools set (see windows branch).    ('escript_opts_version', 'Version of options file (do not specify on command line)'),
130    ('tools_names', 'allow control over the tools in the env setup', ['default']),    ('SVN_VERSION', 'Do not use from options file', -2),
131  # finer control over library building, intel aggressive global optimisation    ('pythoncmd', 'which python to compile with','python'),
132  # works with dynamic libraries on windows.    ('usepython3', 'Is this a python3 build? (experimental)', False),
133    ('share_esysUtils', 'control static or dynamic esysUtils lib', False),    ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
134    ('share_paso', 'control static or dynamic paso lib', False),    ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
135    ('env_export','Environment variables to be passed to children',[]),    ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
136  #To enable passing function pointers through python    BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
   BoolVariable('iknowwhatimdoing','allow nonstandard C',False)  
137  )  )
138    
139    ##################### Create environment and help text #######################
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.
 # This is only to support old versions of scons which don't accept  
 # the variant_dir parameter (older than 0.98 I think).  
 # Once these are no longer an issue we can go back to a direct call  
 # to obj.SConscript  
 import SCons  
 vs=SCons.__version__.split('.')  
 cantusevariantdir=float(vs[0]+'.'+vs[1])<0.98  
   
   
 def CallSConscript(obj, **kw):  
     if cantusevariantdir:  
         if 'variant_dir' in kw:  
         kw['build_dir']=kw['variant_dir']  
         del kw['variant_dir']  
     obj.SConscript(**kw)  
   
   
 ############ Specify which compilers to use ####################  
   
 # intelc uses regular expressions improperly and emits a warning about  
 # failing to find the compilers.  This warning can be safely ignored.  
   
 if IS_WINDOWS_PLATFORM:  
       env = Environment(options = opts)  
       env = Environment(tools = ['default'] + env['tools_names'],  
                         options = opts)  
 else:  
    if os.uname()[4]=='ia64':  
       env = Environment(tools = ['default', 'intelc'], options = opts)  
       if env['CXX'] == 'icpc':  
          env['LINK'] = env['CXX'] # version >=9 of intel c++ compiler requires use of icpc to link in C++ runtimes (icc does not)  
    else:  
       env = Environment(tools = ['default'], options = opts)  
       if env['tools_names']!='default':  
     env=Environment(tools = ['default'] +env['tools_names'], options=opts)  
   
 # Override compiler choice if provided  
 if env['cc'] != 'DEFAULT': env['CC']=env['cc']  
 if env['cxx'] != 'DEFAULT': env['CXX']=env['cxx']  
   
 Help(opts.GenerateHelpText(env))  
   
 ############ Make sure target directories exist ################  
143    
144    # PATH is needed so the compiler, linker and tools are found if they are not
145    # in default locations.
146    env = Environment(tools = ['default'], options = vars,
147                      ENV = {'PATH': os.environ['PATH']})
148    
149    # set the vars for clang
150    def mkclang(env):
151        env['CXX']='clang++'
152    
153    if env['tools_names'] != 'default':
154        zz=env['tools_names']
155        if 'clang' in zz:
156            zz.remove('clang')
157            zz.insert(0, mkclang)
158        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
159                          ENV = {'PATH' : os.environ['PATH']})
160    
161    if options_file:
162        opts_valid=False
163        if 'escript_opts_version' in env.Dictionary() and \
164            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
165                opts_valid=True
166        if opts_valid:
167            print("Using options in %s." % options_file)
168        else:
169            print("\nOptions file %s" % options_file)
170            print("is outdated! Please update the file by examining one of the TEMPLATE")
171            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
172            Exit(1)
173    
174    # Generate help text (scons -h)
175    Help(vars.GenerateHelpText(env))
176    
177    # Check for superfluous options
178    if len(vars.UnknownVariables())>0:
179        for k in vars.UnknownVariables():
180            print("Unknown option '%s'" % k)
181        Exit(1)
182    
183    # create dictionary which will be populated with info for buildvars file
184    env['buildvars']={}
185    # create list which will be populated with warnings if there are any
186    env['warnings']=[]
187    
188    #################### Make sure install directories exist #####################
189    
190    env['BUILD_DIR']=Dir(env['build_dir']).abspath
191    prefix=Dir(env['prefix']).abspath
192    env['buildvars']['prefix']=prefix
193    env['incinstall'] = os.path.join(prefix, 'include')
194    env['bininstall'] = os.path.join(prefix, 'bin')
195    env['libinstall'] = os.path.join(prefix, 'lib')
196    env['pyinstall']  = os.path.join(prefix, 'esys')
197  if not os.path.isdir(env['bininstall']):  if not os.path.isdir(env['bininstall']):
198      os.makedirs(env['bininstall'])      os.makedirs(env['bininstall'])
199  if not os.path.isdir(env['libinstall']):  if not os.path.isdir(env['libinstall']):
# Line 239  if not os.path.isdir(env['libinstall']): Line 201  if not os.path.isdir(env['libinstall']):
201  if not os.path.isdir(env['pyinstall']):  if not os.path.isdir(env['pyinstall']):
202      os.makedirs(env['pyinstall'])      os.makedirs(env['pyinstall'])
203    
204  ########## Copy required environment vars ######################  env.Append(CPPPATH = [env['incinstall']])
205    env.Append(LIBPATH = [env['libinstall']])
 for i in env['env_export']:  
    env.Append(ENV = {i:os.environ[i]})  
   
 ############ Fill in compiler options if not set above #########  
   
 # Backwards compatibility: allow dodebug=yes and useMPI=yes  
 if env['dodebug']: env['usedebug'] = 1  
 if env['useMPI']: env['usempi'] = 1  
   
 # Default compiler options (override allowed in hostname_options.py, but should not be necessary)  
 # For both C and C++ you get: cc_flags and either the optim flags or debug flags  
   
 sysheaderopt = ""       # how do we indicate that a header is a system header. Use "" for no action.  
   
 cc_flags = ""  
 cc_optim = ""  
 cc_debug = ""  
 omp_optim = ""  
 omp_debug = ""  
 omp_libs = []  
   
 if env["CC"] == "icc":  
   # Intel compilers  
   cc_flags      = "-std=c99 -fPIC -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"  
   cc_optim      = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias"  
   cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"  
   omp_optim     = "-openmp -openmp_report0"  
   omp_debug     = "-openmp -openmp_report0"  
   omp_libs      = ['guide', 'pthread']  
   pedantic      = ""  
   fatalwarning      = ""        # Switch to turn warnings into errors  
   sysheaderopt      = ""  
 elif env["CC"][:3] == "gcc":  
   # GNU C on any system  
   cc_flags      = "-pedantic -Wall -fPIC -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing"  
 #the long long warning occurs on the Mac  
   cc_optim      = "-O3"  
   cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"  
   omp_optim     = "-fopenmp"  
   omp_debug     = "-fopenmp"  
   omp_libs      = []  
   pedantic      = "-pedantic-errors -Wno-long-long"  
   fatalwarning      = "-Werror"  
   sysheaderopt      = "-isystem "  
 elif env["CC"] == "cl":  
   # Microsoft Visual C on Windows  
   cc_flags      = "/FD /EHsc /GR /wd4068 -D_USE_MATH_DEFINES -DDLL_NETCDF"  
   cc_optim      = "/O2 /Op /MT /W3"  
   cc_debug      = "/Od /RTC1 /MTd /ZI -DBOUNDS_CHECK"  
   omp_optim     = ""  
   omp_debug     = ""  
   omp_libs      = []  
   pedantic      = ""  
   fatalwarning      = ""  
   sysheaderopt      = ""  
 elif env["CC"] == "icl":  
   # intel C on Windows, see windows_intelc_options.py for a start  
   pedantic      = ""  
   fatalwarning      = ""  
   sysheaderopt      = ""  
   
   
 # If not specified in hostname_options.py then set them here  
 if env["cc_flags"]  == "-DEFAULT_1": env['cc_flags'] = cc_flags  
 if env["cc_optim"]  == "-DEFAULT_2": env['cc_optim'] = cc_optim  
 if env["cc_debug"]  == "-DEFAULT_3": env['cc_debug'] = cc_debug  
 if env["omp_optim"] == "-DEFAULT_4": env['omp_optim'] = omp_optim  
 if env["omp_debug"] == "-DEFAULT_5": env['omp_debug'] = omp_debug  
 if env["omp_libs"]  == "-DEFAULT_6": env['omp_libs'] = omp_libs  
   
 #set up the autolazy values  
 if env['forcelazy']    != "leave_alone":  
   if env['forcelazy'] == 'on':  
     env.Append(CPPDEFINES=['FAUTOLAZYON'])  
   else:  
      if env['forcelazy'] == 'off':  
     env.Append(CPPDEFINES=['FAUTOLAZYOFF'])  
   
 #set up the colective resolve values  
 if env['forcecollres']    != "leave_alone":  
   print env['forcecollres']  
   if env['forcecollres'] == 'on':  
     env.Append(CPPDEFINES=['FRESCOLLECTON'])  
   else:  
      if env['forcecollres'] == 'off':  
     env.Append(CPPDEFINES=['FRESCOLLECTOFF'])  
   
   
 if env['iknowwhatimdoing']:  
     env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])  
   
 # OpenMP is disabled if useopenmp=no or both variables omp_optim and omp_debug are empty  
 if not env["useopenmp"]:  
   env['omp_optim'] = ""  
   env['omp_debug'] = ""  
   env['omp_libs'] = []  
   
 if env['omp_optim'] == "" and env['omp_debug'] == "": env["useopenmp"] = 0  
   
 # Windows doesn't use LD_LIBRARY_PATH but PATH instead  
 if IS_WINDOWS_PLATFORM:  
     LD_LIBRARY_PATH_KEY='PATH'  
     env['ENV']['LD_LIBRARY_PATH']=''  
 else:  
     LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'  
 ############ Copy environment variables into scons env #########  
   
 try: env['ENV']['OMP_NUM_THREADS'] = os.environ['OMP_NUM_THREADS']  
 except KeyError: env['ENV']['OMP_NUM_THREADS'] = 1  
   
 try: env['ENV']['ESCRIPT_NUM_THREADS'] = os.environ['ESCRIPT_NUM_THREADS']  
 except KeyError: pass  
   
 try: env['ENV']['ESCRIPT_NUM_PROCS'] = os.environ['ESCRIPT_NUM_PROCS']  
 except KeyError: env['ENV']['ESCRIPT_NUM_PROCS']=1  
   
 try: env['ENV']['ESCRIPT_NUM_NODES'] = os.environ['ESCRIPT_NUM_NODES']  
 except KeyError: env['ENV']['ESCRIPT_NUM_NODES']=1  
   
 try: env['ENV']['ESCRIPT_HOSTFILE'] = os.environ['ESCRIPT_HOSTFILE']  
 except KeyError: pass  
   
 try: env['ENV']['PATH'] = os.environ['PATH']  
 except KeyError: pass  
   
 try: env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']  
 except KeyError: pass  
206    
207  try: env['ENV']['C_INCLUDE_PATH'] = os.environ['C_INCLUDE_PATH']  ################# Fill in compiler options if not set above ##################
 except KeyError: pass  
208    
209  try: env['ENV']['CPLUS_INCLUDE_PATH'] = os.environ['CPLUS_INCLUDE_PATH']  if env['cxx'] != 'default': env['CXX']=env['cxx']
 except KeyError: pass  
210    
211  try: env.PrependENVPath(LD_LIBRARY_PATH_KEY,os.environ['LD_LIBRARY_PATH'])  # version >=9 of intel C++ compiler requires use of icpc to link in C++
212  except KeyError: pass  # runtimes (icc does not)
213    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
214  try: env['ENV']['LIBRARY_PATH'] = os.environ['LIBRARY_PATH']      env['LINK'] = env['CXX']
215  except KeyError: pass  
216    # default compiler/linker options
217  try: env['ENV']['DISPLAY'] = os.environ['DISPLAY']  cc_flags = ''
218  except KeyError: pass  cc_optim = ''
219    cc_debug = ''
220  try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  omp_flags = ''
221  except KeyError: pass  omp_ldflags = ''
222    fatalwarning = '' # switch to turn warnings into errors
223  try: env['ENV']['HOME'] = os.environ['HOME']  sysheaderopt = '' # how to indicate that a header is a system header
224  except KeyError: pass  
225    # env['CC'] might be a full path
226  # Configure for test suite  cc_name=os.path.basename(env['CXX'])
227    
228    if cc_name == 'icpc':
229  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])      # Intel compiler
230  env.PrependENVPath('PYTHONPATH', prefix)      # #1875: offsetof applied to non-POD types is nonstandard (in boost)
231  env['ENV']['ESCRIPT_ROOT'] = prefix      # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
232        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas -DBLOCKTIMER -DCORE_ID1"
233  ############ Set up paths for Configure() ######################      cc_optim    = "-O3 -ftz -fno-alias -ipo -xHost"
234        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
235  # Make a copy of an environment      omp_flags   = "-openmp"
236  # Use env.Clone if available, but fall back on env.Copy for older version of scons      omp_ldflags = "-openmp -openmp_report=1"
237  def clone_env(env):      fatalwarning = "-Werror"
238    if 'Clone' in dir(env): return env.Clone()    # scons-0.98  elif cc_name[:3] == 'g++':
239    else:                   return env.Copy() # scons-0.96      # GNU C on any system
240        # note that -ffast-math is not used because it breaks isnan(),
241  # Add cc option -I<Escript>/trunk/include      # see mantis #691
242  env.Append(CPPPATH      = [Dir('include')])      cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
243        cc_optim     = "-O3"
244  # Add cc option -L<Escript>/trunk/lib      cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
245  env.Append(LIBPATH      = [Dir(env['libinstall'])])      omp_flags    = "-fopenmp"
246        omp_ldflags  = "-fopenmp"
247  if env['cc_extra'] != '': env.Append(CFLAGS = env['cc_extra'])      fatalwarning = "-Werror"
248        sysheaderopt = "-isystem"
249    elif cc_name == 'cl':
250        # Microsoft Visual C on Windows
251        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
252        cc_optim     = "/O2 /Op /W3"
253        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
254        fatalwarning = "/WX"
255    elif cc_name == 'icl':
256        # Intel C on Windows
257        cc_flags     = '/EHsc /GR /MD'
258        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
259        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
260        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
261        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
262    
263    env['sysheaderopt']=sysheaderopt
264    
265    # set defaults if not otherwise specified
266    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
267    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
268    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
269    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
270    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
271  if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])  if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
272  if env['ld_extra'] != '': env.Append(LINKFLAGS = env['ld_extra'])  if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
   
 if env['usepedantic']: env.Append(CCFLAGS = pedantic)  
273    
274  # MS Windows  if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
 if IS_WINDOWS_PLATFORM:  
   env.AppendENVPath('PATH', [env['boost_lib_path']])  
   env.AppendENVPath('PATH', [env['libinstall']])  
   if not env['share_esysUtils'] :  
     env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])  
   if not env['share_paso'] :  
     env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])  
275    
276    if env['usenetcdf']:  if env['usepython3']:
277      env.AppendENVPath('PATH',   [env['netCDF_lib_path']])      env.Append(CPPDEFINES=['ESPYTHON3'])
278    
279  env.Append(ARFLAGS = env['ar_flags'])  # set up the autolazy values
280    if env['forcelazy'] == 'on':
281        env.Append(CPPDEFINES=['FAUTOLAZYON'])
282    elif env['forcelazy'] == 'off':
283        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
284    
285    # set up the collective resolve values
286    if env['forcecollres'] == 'on':
287        env.Append(CPPDEFINES=['FRESCOLLECTON'])
288    elif env['forcecollres'] == 'off':
289        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
290    
291  # Get the global Subversion revision number for getVersion() method  # allow non-standard C if requested
292  try:  if env['iknowwhatimdoing']:
293     global_revision = os.popen("svnversion -n .").read()      env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
    global_revision = re.sub(":.*", "", global_revision)  
    global_revision = re.sub("[^0-9]", "", global_revision)  
 except:  
    global_revision="-1"  
 if global_revision == "": global_revision="-2"  
 env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  
   
 ############ numpy (required) ###############################  
   
 try:  
   from numpy import identity  
 except ImportError:  
   print "Cannot import numpy, you need to set your PYTHONPATH"  
   sys.exit(1)  
   
 ############ C compiler (required) #############################  
   
 # Create a Configure() environment for checking existence of required libraries and headers  
 conf = Configure(clone_env(env))  
   
 # Test that the compiler is working  
 if not conf.CheckFunc('printf'):  
    print "Cannot run C compiler '%s' (or libc is missing)" % (env['CC'])  
    sys.exit(1)  
   
 if conf.CheckFunc('gethostname'):  
   conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])  
   
 ############ python libraries (required) #######################  
294    
295    # Disable OpenMP if no flags provided
296    if env['openmp'] and env['omp_flags'] == '':
297       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
298       env['openmp'] = False
299    
300  if not sysheaderopt =="":  if env['openmp']:
301    conf.env.Append(CCFLAGS=sysheaderopt+env['python_path'])      env.Append(CCFLAGS = env['omp_flags'])
302        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
303  else:  else:
304    conf.env.AppendUnique(CPPPATH     = [env['python_path']])      env['omp_flags']=''
305        env['omp_ldflags']=''
306    
307  conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  env['buildvars']['openmp']=int(env['openmp'])
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
308    
309  conf.env.PrependENVPath('PYTHONPATH', prefix)  # add debug/non-debug compiler flags
310  conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['python_lib_path'])    # The wrapper script needs to find these libs  env['buildvars']['debug']=int(env['debug'])
311  conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  if env['debug']:
312        env.Append(CCFLAGS = env['cc_debug'])
 if not conf.CheckCHeader('Python.h'):  
   print "Cannot find python include files (tried 'Python.h' in directory %s)" % (env['python_path'])  
   sys.exit(1)  
 if not conf.CheckFunc('Py_Exit'):  
   print "Cannot find python library method Py_Main (tried lib %s in directory %s)" % (env['python_libs'], env['python_lib_path'])  
   sys.exit(1)  
   
 ############ boost (required) ##################################  
   
 if not sysheaderopt =="":  
 # This is required because we can't -isystem /usr/system because it breaks std includes  
   if os.path.normpath(env['boost_path']) =="/usr/include":  
     conf.env.Append(CCFLAGS=sysheaderopt+os.path.join(env['boost_path'],'boost'))  
   else:  
     conf.env.Append(CCFLAGS=sysheaderopt+env['boost_path'])  
313  else:  else:
314    conf.env.AppendUnique(CPPPATH     = [env['boost_path']])      env.Append(CCFLAGS = env['cc_optim'])
   
 conf.env.AppendUnique(LIBPATH       = [env['boost_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['boost_libs']])  
   
 conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['boost_lib_path']) # The wrapper script needs to find these libs  
 #ensure that our path entries remain at the front  
 conf.env.PrependENVPath('PYTHONPATH', prefix)  
 conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
   
 #Yep we still cant figure this one out. - working on it.  
 if not IS_WINDOWS_PLATFORM:  
   if not conf.CheckCXXHeader('boost/python.hpp'):  
     print "Cannot find boost include files (tried boost/python.hpp in directory %s)" % (env['boost_path'])  
     sys.exit(1)  
   
   if not conf.CheckFunc('PyObject_SetAttr'):  
     print "Cannot find boost library method PyObject_SetAttr (tried method PyObject_SetAttr in library %s in directory %s)" % (env['boost_libs'], env['boost_lib_path'])  
     sys.exit(1)  
315    
316    # always add cc_flags
317    env.Append(CCFLAGS = env['cc_flags'])
318    
319  # Commit changes to environment  # add system libraries
320  env = conf.Finish()  env.AppendUnique(LIBS = env['sys_libs'])
321    
322  ############ VTK (optional) ####################################  # determine svn revision
323    global_revision=ARGUMENTS.get('SVN_VERSION', None)
324  if env['usevtk']:  if global_revision:
325    try:      global_revision = re.sub(':.*', '', global_revision)
326      import vtk      global_revision = re.sub('[^0-9]', '', global_revision)
327      env['usevtk'] = 1      if global_revision == '': global_revision='-2'
   except ImportError:  
     env['usevtk'] = 0  
   
 # Add VTK to environment env if it was found  
 if env['usevtk']:  
   env.Append(CPPDEFINES = ['USE_VTK'])  
   
 ############ NetCDF (optional) #################################  
   
 conf = Configure(clone_env(env))  
   
 if env['usenetcdf']:  
   conf.env.AppendUnique(CPPPATH = [env['netCDF_path']])  
   conf.env.AppendUnique(LIBPATH = [env['netCDF_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['netCDF_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['netCDF_lib_path'])  # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 if env['usenetcdf'] and not conf.CheckCHeader('netcdf.h'): env['usenetcdf'] = 0  
 if env['usenetcdf'] and not conf.CheckFunc('nc_open'): env['usenetcdf'] = 0  
   
 # Add NetCDF to environment env if it was found  
 if env['usenetcdf']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['USE_NETCDF'])  
328  else:  else:
329    conf.Finish()    # Get the global Subversion revision number for the getVersion() method
330      try:
331        global_revision = os.popen('svnversion -n .').read()
332        global_revision = re.sub(':.*', '', global_revision)
333        global_revision = re.sub('[^0-9]', '', global_revision)
334        if global_revision == '': global_revision='-2'
335      except:
336        global_revision = '-1'
337    env['svn_revision']=global_revision
338    env['buildvars']['svn_revision']=global_revision
339    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
340    
341    if IS_WINDOWS:
342        if not env['build_shared']:
343            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
344            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
345    
346    # VSL random numbers
347    env['buildvars']['vsl_random']=int(env['vsl_random'])
348    if env['vsl_random']:
349        env.Append(CPPDEFINES = ['MKLRANDOM'])
350    
351  ############ PAPI (optional) ###################################  env['IS_WINDOWS']=IS_WINDOWS
352    
353  # Start a new configure environment that reflects what we've already found  ###################### Copy required environment vars ########################
 conf = Configure(clone_env(env))  
354    
355  if env['usepapi']:  # Windows doesn't use LD_LIBRARY_PATH but PATH instead
356    conf.env.AppendUnique(CPPPATH = [env['papi_path']])  if IS_WINDOWS:
357    conf.env.AppendUnique(LIBPATH = [env['papi_lib_path']])      LD_LIBRARY_PATH_KEY='PATH'
358    conf.env.AppendUnique(LIBS    = [env['papi_libs']])      env['ENV']['LD_LIBRARY_PATH']=''
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['papi_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 if env['usepapi'] and not conf.CheckCHeader('papi.h'): env['usepapi'] = 0  
 if env['usepapi'] and not conf.CheckFunc('PAPI_start_counters'): env['usepapi'] = 0  
   
 # Add PAPI to environment env if it was found  
 if env['usepapi']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['BLOCKPAPI'])  
359  else:  else:
360    conf.Finish()      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
   
 ############ MKL (optional) ####################################  
361    
362  # Start a new configure environment that reflects what we've already found  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
 conf = Configure(clone_env(env))  
363    
364  if env['usemkl']:  # the following env variables are exported for the unit tests
   conf.env.AppendUnique(CPPPATH = [env['mkl_path']])  
   conf.env.AppendUnique(LIBPATH = [env['mkl_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['mkl_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['mkl_lib_path']) # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 if env['usemkl'] and not conf.CheckCHeader('mkl_solver.h'): env['usemkl'] = 0  
 if env['usemkl'] and not conf.CheckFunc('pardiso'): env['usemkl'] = 0  
   
   
 # Add MKL to environment env if it was found  
 if env['usemkl']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['MKL'])  
 else:  
   conf.Finish()  
365    
366  ############ UMFPACK (optional) ################################  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
367        try:
368            env['ENV'][key] = os.environ[key]
369        except KeyError:
370            env['ENV'][key] = 1
371    
372    env_export=env['env_export']
373    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
374    
375    for key in set(env_export):
376        try:
377            env['ENV'][key] = os.environ[key]
378        except KeyError:
379            pass
380    
381  # Start a new configure environment that reflects what we've already found  try:
382  conf = Configure(clone_env(env))      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
383    except KeyError:
384        pass
385    
386  if env['useumfpack']:  if IS_OSX:
387    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])    try:
388    conf.env.AppendUnique(CPPPATH = [env['umf_path']])      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
389    conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])    except KeyError:
390    conf.env.AppendUnique(LIBS    = [env['umf_libs']])      pass
   conf.env.AppendUnique(CPPPATH = [env['amd_path']])  
   conf.env.AppendUnique(LIBPATH = [env['amd_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['amd_libs']])  
   conf.env.AppendUnique(CPPPATH = [env['blas_path']])  
   conf.env.AppendUnique(LIBPATH = [env['blas_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['blas_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['umf_lib_path']) # The wrapper script needs to find these libs  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['amd_lib_path']) # The wrapper script needs to find these libs  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['blas_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0  
 if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0  
 # if env['useumfpack'] and not conf.CheckFunc('daxpy'): env['useumfpack'] = 0 # this does not work on shake73?  
   
 # Add UMFPACK to environment env if it was found  
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
 else:  
   conf.Finish()  
391    
 ############ Silo (optional) ###################################  
392    
393  if env['usesilo']:  # these shouldn't be needed
394    conf = Configure(clone_env(env))  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
395    conf.env.AppendUnique(CPPPATH = [env['silo_path']])  #    try:
396    conf.env.AppendUnique(LIBPATH = [env['silo_lib_path']])  #        env['ENV'][key] = os.environ[key]
397    conf.env.AppendUnique(LIBS = [env['silo_libs']])  #    except KeyError:
398    if not conf.CheckCHeader('silo.h'): env['usesilo'] = 0  #        pass
   if not conf.CheckFunc('DBMkDir'): env['usesilo'] = 0  
   conf.Finish()  
   
 # Add the path to Silo to environment env if it was found.  
 # Note that we do not add the libs since they are only needed for the  
 # weipa library and tools.  
 if env['usesilo']:  
   env.AppendUnique(CPPPATH = [env['silo_path']])  
   env.AppendUnique(LIBPATH = [env['silo_lib_path']])  
   
 ############ VisIt (optional) ###################################  
   
 if env['usevisit']:  
   env.AppendUnique(CPPPATH = [env['visit_path']])  
   env.AppendUnique(LIBPATH = [env['visit_lib_path']])  
   
 ########### Lapack (optional) ##################################  
   
 if env['uselapack']:  
     env.AppendUnique(CPPDEFINES='USE_LAPACK')  
     env.AppendUnique(CPPPATH = [env['lapack_path']])  
     env.AppendUnique(LIBPATH =[env['lapack_lib_path']])  
   
     env.Append(LIBPATH = '/usr/lib/atlas')  
     env.Append(LIBS = [env['lapack_libs']])  
     if env['lapack_type']=='mkl':  
        if not env['usemkl']:  
         env['uselapack']=0  
         print "mkl_lapack requires mkl"  
        else:  
         env.AppendUnique(CPPDEFINES='MKL_LAPACK')  
         
   
 ############ Add the compiler flags ############################  
   
 # Enable debug by choosing either cc_debug or cc_optim  
 if env['usedebug']:  
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
 else:  
   env.Append(CCFLAGS        = env['cc_optim'])  
   env.Append(CCFLAGS        = env['omp_optim'])  
399    
400  # Always use cc_flags  try:
401  env.Append(CCFLAGS      = env['cc_flags'])      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
402  env.Append(LIBS         = [env['omp_libs']])  except KeyError:
403        pass
404    
405  ############ Add some custom builders ##########################  ######################## Add some custom builders ############################
406    
407  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  if env['pythoncmd']=='python':
408        py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
409    else:
410        py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
411  env.Append(BUILDERS = {'PyCompile' : py_builder});  env.Append(BUILDERS = {'PyCompile' : py_builder});
412    
413  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
414  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
415    
416  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)
417  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
418    
419  epstopdfbuilder = Builder(action = scons_extensions.eps2pdf, suffix=".pdf", src_suffix=".eps", single_source=True)  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
420  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
421    
422  ############ MPI (optional) ####################################  ############################ Dependency checks ###############################
 if not env['usempi']: env['mpi_flavour']='none'  
   
 # Create a modified environment for MPI programs (identical to env if usempi=no)  
 env_mpi = clone_env(env)  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env_mpi))  
423    
424  if env_mpi['usempi']:  ######## Compiler
425    VALID_MPIs=[ "MPT", "MPICH", "MPICH2", "OPENMPI", "INTELMPI" ]  env=checkCompiler(env)
   if not env_mpi['mpi_flavour'] in VALID_MPIs:  
       raise ValueError,"MPI is enabled but mpi_flavour = %s is not a valid key from %s."%( env_mpi['mpi_flavour'],VALID_MPIs)  
   conf.env.AppendUnique(CPPPATH = [env_mpi['mpi_path']])  
   conf.env.AppendUnique(LIBPATH = [env_mpi['mpi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['mpi_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['mpi_lib_path']) # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 if env_mpi['usempi'] and not conf.CheckCHeader('mpi.h'): env_mpi['usempi'] = 0  
 # if env_mpi['usempi'] and not conf.CheckFunc('MPI_Init'): env_mpi['usempi'] = 0  
   
 # Add MPI to environment env_mpi if it was found  
 if env_mpi['usempi']:  
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['PASO_MPI', 'MPI_NO_CPPBIND', env_mpi['MPICH_IGNORE_CXX_SEEK']])  
   # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!  
   # On the other hand MPT and OpenMPI don't define the latter so we have to  
   # do that here  
   if env['usenetcdf'] and env_mpi['mpi_flavour'] in ["MPT","OPENMPI"]:  
     env_mpi.Append(CPPDEFINES = ['MPI_INCLUDED'])  
 else:  
   conf.Finish()  
   
 env['usempi'] = env_mpi['usempi']  
426    
427  ############ ParMETIS (optional) ###############################  ######## Python headers & library (required)
428    env=checkPython(env)
429    
430  # Start a new configure environment that reflects what we've already found  ######## boost & boost-python (required)
431  conf = Configure(clone_env(env_mpi))  env=checkBoost(env)
432    
433  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0  ######## numpy (required) and numpy headers (optional)
434    env=checkNumpy(env)
435    
436  if env_mpi['useparmetis']:  ######## CppUnit (required for tests)
437    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  env=checkCppUnit(env)
   conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['parmetis_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
438    
439  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  ######## optional python modules (sympy, pyproj)
440  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0  env=checkOptionalModules(env)
   
 # Add ParMETIS to environment env_mpi if it was found  
 if env_mpi['useparmetis']:  
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  
 else:  
   conf.Finish()  
441    
442  env['useparmetis'] = env_mpi['useparmetis']  ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
443    env=checkOptionalLibraries(env)
444    
445  ############ Summarize our environment #########################  ######## PDFLaTeX (for documentation)
446    env=checkPDFLatex(env)
447    
448  print ""  # keep some of our install paths first in the list for the unit tests
449  print "Summary of configuration (see ./config.log for information)"  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
450  print " Using python libraries"  env.PrependENVPath('PYTHONPATH', prefix)
451  print " Using numpy"  env['ENV']['ESCRIPT_ROOT'] = prefix
 print " Using boost"  
 if env['usenetcdf']: print "    Using NetCDF"  
 else: print "   Not using NetCDF"  
 if env['usevtk']: print "   Using VTK"  
 else: print "   Not using VTK"  
 if env['usevisit']: print " Using VisIt"  
 else: print "   Not using VisIt"  
 if env['usemkl']: print "   Using MKL"  
 else: print "   Not using MKL"  
 if env['useumfpack']: print "   Using UMFPACK"  
 else: print "   Not using UMFPACK"  
 if env['usesilo']: print "  Using Silo"  
 else: print "   Not using Silo"  
 if env['useopenmp']: print "    Using OpenMP"  
 else: print "   Not using OpenMP"  
 if env['usempi']: print "   Using MPI (flavour = %s)"%env['mpi_flavour']  
 else: print "   Not using MPI"  
 if env['useparmetis']: print "  Using ParMETIS"  
 else: print "   Not using ParMETIS (requires MPI)"  
 if env['usepapi']: print "  Using PAPI"  
 else: print "   Not using PAPI"  
 if env['uselapack']: print "    Using Lapack"  
 else: print "   Not using Lapack"  
 if env['usedebug']: print " Compiling for debug"  
 else: print "   Not compiling for debug"  
 print " Installing in", prefix  
 if ((fatalwarning != "") and (env['usewarnings'])): print " Treating warnings as errors"  
 else: print "   Not treating warnings as errors"  
 print ""  
   
 ############ Delete option-dependent files #####################  
   
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.debug")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.mpi")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.openmp")))  
 Execute(Delete(os.path.join(env['libinstall'],"pyversion")))  
 Execute(Delete(os.path.join(env['libinstall'],"buildvars")))  
 if not env['usempi']: Execute(Delete(os.path.join(env['libinstall'],"pythonMPI")))  
   
   
 ############ Build the subdirectories ##########################  
   
 if env['usepedantic']: env_mpi.Append(CCFLAGS = pedantic)  
452    
453    if not env['verbose']:
454        env['CXXCOMSTR'] = "Compiling $TARGET"
455        env['SHCXXCOMSTR'] = "Compiling $TARGET"
456        env['ARCOMSTR'] = "Linking $TARGET"
457        env['LINKCOMSTR'] = "Linking $TARGET"
458        env['SHLINKCOMSTR'] = "Linking $TARGET"
459        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
460        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
461        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
462        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
463        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
464    
465    ####################### Configure the subdirectories #########################
466    
467    # remove obsolete files
468    if not env['usempi']:
469        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
470        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
471    
472  from grouptest import *  from grouptest import *
   
473  TestGroups=[]  TestGroups=[]
474    
475  dodgy_env=clone_env(env_mpi)    # Environment without pedantic options  # keep an environment without warnings-as-errors
476    dodgy_env=env.Clone()
 ############ Now we switch on Warnings as errors ###############  
   
 #this needs to be done after configuration because the scons test files have warnings in them  
   
 if ((fatalwarning != "") and (env['usewarnings'])):  
   env.Append(CCFLAGS        = fatalwarning)  
   env_mpi.Append(CCFLAGS        = fatalwarning)  
477    
478    # now add warnings-as-errors flags. This needs to be done after configuration
479    # because the scons test files have warnings in them
480    if ((fatalwarning != '') and (env['werror'])):
481        env.Append(CCFLAGS = fatalwarning)
482    
483  Export(  Export(
484    ["env",    ['env',
485     "env_mpi",     'dodgy_env',
486     "clone_env",     'IS_WINDOWS',
487     "dodgy_env",     'TestGroups'
488     "IS_WINDOWS_PLATFORM",    ]
489     "TestGroups",  )
    "CallSConscript",  
    "cantusevariantdir"  
    ]  
   )  
   
 CallSConscript(env, dirs = ['tools/CppUnitTest/src'], variant_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
 CallSConscript(env, dirs = ['tools/escriptconvert'], variant_dir='build/$PLATFORM/tools/escriptconvert', duplicate=0)  
 CallSConscript(env, dirs = ['paso/src'], variant_dir='build/$PLATFORM/paso', duplicate=0)  
 CallSConscript(env, dirs = ['weipa/src'], variant_dir='build/$PLATFORM/weipa', duplicate=0)  
 CallSConscript(env, dirs = ['escript/src'], variant_dir='build/$PLATFORM/escript', duplicate=0)  
 CallSConscript(env, dirs = ['esysUtils/src'], variant_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 CallSConscript(env, dirs = ['finley/src'], variant_dir='build/$PLATFORM/finley', duplicate=0)  
 CallSConscript(env, dirs = ['modellib/py_src'], variant_dir='build/$PLATFORM/modellib', duplicate=0)  
 CallSConscript(env, dirs = ['doc'], variant_dir='build/$PLATFORM/doc', duplicate=0)  
 CallSConscript(env, dirs = ['pyvisi/py_src'], variant_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 CallSConscript(env, dirs = ['pycad/py_src'], variant_dir='build/$PLATFORM/pycad', duplicate=0)  
 CallSConscript(env, dirs = ['pythonMPI/src'], variant_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 CallSConscript(env, dirs = ['scripts'], variant_dir='build/$PLATFORM/scripts', duplicate=0)  
 CallSConscript(env, dirs = ['paso/profiling'], variant_dir='build/$PLATFORM/paso/profiling', duplicate=0)  
   
   
 ############ Remember what optimizations we used ###############  
   
 remember_list = []  
   
 if env['usedebug']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.debug"), None, Touch('$TARGET'))  
   
 if env['usempi']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.mpi"), None, Touch('$TARGET'))  
   
 if env['useopenmp']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.openmp"), None, Touch('$TARGET'))  
   
 env.Alias('remember_options', remember_list)  
   
490    
491  ############### Record python interpreter version ##############  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
492    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
493    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
494    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
495    
496    #This will pull in the escriptcore/py_src and escriptcore/test
497    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
498    #env.SConscript(dirs = ['escript/test'], variant_dir='$BUILD_DIR/$PLATFORM/escript/test', duplicate=0)
499    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
500    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
501    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
502    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
503    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
504    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
505    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
506    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
507    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
508    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
509    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
510    
 if not IS_WINDOWS_PLATFORM:  
511    
512    versionstring="Python "+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])  ######################## Populate the buildvars file #########################
   if sys.version_info[4] >0 : versionstring+="rc%s"%sys.version_info[4]  
   os.system("echo "+versionstring+" > "+os.path.join(env['libinstall'],"pyversion"))  
513    
514  ############## Populate the buildvars file #####################  write_buildvars(env)
515    
516  buildvars=open(os.path.join(env['libinstall'],'buildvars'),'w')  ################### Targets to build and install libraries ###################
 buildvars.write('python='+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+'\n')  
   
 # Find the boost version by extracting it from version.hpp  
 boosthpp=open(os.path.join(env['boost_path'],'boost','version.hpp'))  
 boostversion='unknown'  
 try:  
     for line in boosthpp:  
         ver=re.match(r'#define BOOST_VERSION (\d+)',line)  
         if ver:  
             boostversion=ver.group(1)  
 except StopIteration:  
     pass  
 buildvars.write("boost="+boostversion+"\n")  
 buildvars.write("svn_revision="+str(global_revision)+"\n")  
 out="usedebug="  
 if env['usedebug']:  
     out+="y"  
 else:  
     out+="n"  
 out+="\nusempi="  
 if env['usempi']:  
     out+="y"  
 else:  
     out+="n"  
 out+="\nuseopenmp="  
 if env['useopenmp']:  
     out+="y"  
 else:  
     out+="n"  
 buildvars.write(out+"\n")  
 buildvars.write("mpi_flavour="+env['mpi_flavour']+'\n')  
 out="lapack="  
 if env['uselapack']:  
    out+="y"  
 else:  
    out+="n"  
 out+="\nsilo="  
 if env['usesilo']:  
    out+="y"  
 else:  
    out+="n"  
 out+="\nusevisit="  
 if env['usevisit']:  
    out+="y"  
 else:  
    out+="n"  
 buildvars.write(out+"\n")  
 buildvars.close()  
517    
518    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
519    env.Alias('target_init', [target_init])
520    # delete buildvars upon cleanup
521    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
522    
523  ############ Targets to build and install libraries ############  # The headers have to be installed prior to build in order to satisfy
524    # #include <paso/Common.h>
525    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
526    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
527    
528  target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
529  env.Alias('target_init', [target_init])  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
530    
531  # The headers have to be installed prior to build in order to satisfy #include <paso/Common.h>  env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
532  env.Alias('build_esysUtils', ['target_install_esysUtils_headers', 'target_esysUtils_a'])  env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
 env.Alias('install_esysUtils', ['build_esysUtils', 'target_install_esysUtils_a'])  
533    
534  env.Alias('build_paso', ['target_install_paso_headers', 'target_paso_a'])  env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
535  env.Alias('install_paso', ['build_paso', 'target_install_paso_a'])  env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
536    
537  env.Alias('build_weipa', ['target_install_weipa_headers', 'target_weipa_so', 'target_weipacpp_so'])  env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
538  env.Alias('install_weipa', ['build_weipa', 'target_install_weipa_so', 'target_install_weipacpp_so', 'target_install_weipa_py'])  env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
539    
540    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
541    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
542    
543  env.Alias('build_escriptreader', ['target_install_weipa_headers', 'target_escriptreader_a'])  env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
544  env.Alias('install_escriptreader', ['build_escriptreader', 'target_install_escriptreader_a'])  env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
545    
546  env.Alias('build_escript', ['target_install_escript_headers', 'target_escript_so', 'target_escriptcpp_so'])  env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
547  env.Alias('install_escript', ['build_escript', 'target_install_escript_so', 'target_install_escriptcpp_so', 'target_install_escript_py'])  env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
548    
549  env.Alias('build_finley', ['target_install_finley_headers', 'target_finley_so', 'target_finleycpp_so'])  env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
550  env.Alias('install_finley', ['build_finley', 'target_install_finley_so', 'target_install_finleycpp_so', 'target_install_finley_py'])  env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
551    
552  # Now gather all the above into a couple easy targets: build_all and install_all  # Now gather all the above into some easy targets: build_all and install_all
553  build_all_list = []  build_all_list = []
554  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
555  build_all_list += ['build_paso']  build_all_list += ['build_paso']
 build_all_list += ['build_weipa']  
556  build_all_list += ['build_escript']  build_all_list += ['build_escript']
557    build_all_list += ['build_pasowrap']
558    build_all_list += ['build_dudley']
559  build_all_list += ['build_finley']  build_all_list += ['build_finley']
560  if env['usempi']:       build_all_list += ['target_pythonMPI_exe']  build_all_list += ['build_ripley']
561  #if not IS_WINDOWS_PLATFORM:    build_all_list += ['target_escript_wrapper']  build_all_list += ['build_weipa']
562  build_all_list += ['target_escriptconvert']  if not IS_WINDOWS: build_all_list += ['build_escriptreader']
563    if env['usempi']:   build_all_list += ['build_pythonMPI']
564    build_all_list += ['build_escriptconvert']
565  env.Alias('build_all', build_all_list)  env.Alias('build_all', build_all_list)
566    
567  install_all_list = []  install_all_list = []
568  install_all_list += ['target_init']  install_all_list += ['target_init']
569  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
570  install_all_list += ['install_paso']  install_all_list += ['install_paso']
 install_all_list += ['install_weipa']  
571  install_all_list += ['install_escript']  install_all_list += ['install_escript']
572    install_all_list += ['install_pasowrap']
573    install_all_list += ['install_dudley']
574  install_all_list += ['install_finley']  install_all_list += ['install_finley']
575  install_all_list += ['target_install_pyvisi_py']  install_all_list += ['install_ripley']
576  install_all_list += ['target_install_modellib_py']  install_all_list += ['install_weipa']
577  install_all_list += ['target_install_pycad_py']  if not IS_WINDOWS: install_all_list += ['install_escriptreader']
578  if env['usempi']:       install_all_list += ['target_install_pythonMPI_exe']  install_all_list += ['install_downunder_py']
579  #if not IS_WINDOWS_PLATFORM:    install_all_list += ['target_install_escript_wrapper']  install_all_list += ['install_modellib_py']
580  if env['usesilo']:  install_all_list += ['target_install_escriptconvert']  install_all_list += ['install_pycad_py']
581  install_all_list += ['remember_options']  if env['usempi']:   install_all_list += ['install_pythonMPI']
582    install_all_list += ['install_escriptconvert']
583  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
584    
585  # Default target is install  # Default target is install
586  env.Default('install_all')  env.Default('install_all')
587    
588  ############ Targets to build and run the test suite ###########  ################## Targets to build and run the test suite ###################
589    
590  env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  if not env['cppunit']:
591  env.Alias('install_cppunittest', ['build_cppunittest', 'target_install_cppunittest_a'])      test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
592  env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])      env.Alias('run_tests', test_msg)
593  env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])      env.Alias('build_tests', '')
594    env.Alias('run_tests', ['install_all'])
595    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
596  env.Alias('build_full',['install_all','build_tests','build_py_tests'])  env.Alias('build_full',['install_all','build_tests','build_py_tests'])
597    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
598    
599    ##################### Targets to build the documentation #####################
600    
601  ############ Targets to build the documentation ################  env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
602    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
603  env.Alias('api_epydoc','install_all')  env.Alias('docs', ['basedocs', 'sphinxdoc'])
604    env.Alias('release_prep', ['docs', 'install_all'])
605    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
606    
607  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html','install_pdf', 'cookbook_pdf'])  # The test scripts are always generated, this target allows us to
608    # generate the testscripts without doing a full build
609    env.Alias('testscripts',[])
610    
611    if not IS_WINDOWS:
612        generateTestScripts(env, TestGroups)
613    
 build_platform=os.name  
614    
 if not IS_WINDOWS_PLATFORM:  
    try:  
     utest=open("utest.sh","w")  
     #Sometimes Mac python says it is posix  
     if (build_platform=='posix') and platform.system()=="Darwin":  
         build_platform='darwin'  
     utest.write(GroupTest.makeHeader(build_platform))  
     for tests in TestGroups:  
         utest.write(tests.makeString())  
     utest.close()  
     os.chmod("utest.sh",stat.S_IRWXU|stat.S_IRGRP|stat.S_IXGRP|stat.S_IROTH|stat.S_IXOTH)  
     print "utest.sh written"  
    except IOError:  
     print "Error attempting to write unittests file."  
     sys.exit(1)  
   
    #Make sure that the escript wrapper is in place  
    if not os.path.isfile(os.path.join(env['bininstall'],'escript')):  
        print "Copying escript wrapper"  
        shutil.copy("bin/escript",os.path.join(env['bininstall'],'escript'))  
615    
616  ############ Targets to build PasoTests suite ################  ######################## Summarize our environment ###########################
617    def print_summary():
618        print("")
619        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
620        print("Escript/Finley revision %s"%global_revision)
621        print("  Install prefix:  %s"%env['prefix'])
622        print("          Python:  %s"%sysconfig.PREFIX)
623        print("           boost:  %s"%env['boost_prefix'])
624        if env['numpy_h']:
625            print("           numpy:  YES (with headers)")
626        else:
627            print("           numpy:  YES (without headers)")
628        if env['usempi']:
629            print("             MPI:  YES (flavour: %s)"%env['mpi'])
630        else:
631            print("             MPI:  DISABLED")
632        if env['uselapack']:
633            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
634        else:
635            print("          LAPACK:  DISABLED")
636        d_list=[]
637        e_list=[]
638        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit','vsl_random':
639            if env[i]: e_list.append(i)
640            else: d_list.append(i)
641        for i in e_list:
642            print("%16s:  YES"%i)
643        for i in d_list:
644            print("%16s:  DISABLED"%i)
645        if env['cppunit']:
646            print("         CppUnit:  FOUND")
647        else:
648            print("         CppUnit:  NOT FOUND")
649        if env['gmsh']=='m':
650            print("            gmsh:  FOUND, MPI-ENABLED")
651        elif env['gmsh']=='s':
652            print("            gmsh:  FOUND")
653        else:
654            print("            gmsh:  NOT FOUND")
655    
656        if ((fatalwarning != '') and (env['werror'])):
657            print("  Treating warnings as errors")
658        else:
659            print("  NOT treating warnings as errors")
660        print("")
661        for w in env['warnings']:
662            print("WARNING: %s"%w)
663    
664  env.Alias('build_PasoTests','build/'+build_platform+'/paso/profiling/PasoTests')  atexit.register(print_summary)
665    
 env.Alias('release_prep', ['docs', 'install_all'])  

Legend:
Removed from v.3096  
changed lines
  Added in v.4640

  ViewVC Help
Powered by ViewVC 1.1.26