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

Diff of /branches/py3_attempt2/SConstruct

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

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

Legend:
Removed from v.2879  
changed lines
  Added in v.3871

  ViewVC Help
Powered by ViewVC 1.1.26