/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.2040  
changed lines
  Added in v.3961

  ViewVC Help
Powered by ViewVC 1.1.26