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

Diff of /branches/diaplayground/SConstruct

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

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

Legend:
Removed from v.2884  
changed lines
  Added in v.4508

  ViewVC Help
Powered by ViewVC 1.1.26