/[escript]/branches/4.0fordebian/SConstruct
ViewVC logotype

Diff of /branches/4.0fordebian/SConstruct

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

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

Legend:
Removed from v.2294  
changed lines
  Added in v.3896

  ViewVC Help
Powered by ViewVC 1.1.26