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

Diff of /branches/diaplayground/SConstruct

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

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

Legend:
Removed from v.3036  
changed lines
  Added in v.3942

  ViewVC Help
Powered by ViewVC 1.1.26