setup.py

import sys, os
import setuptools
from distutils import sysconfig
cfg_vars = sysconfig.get_config_vars()
for key, value in cfg_vars.items():
    if type(value) == str:
        cfg_vars[key] = cfg_vars[key].replace("-Wstrict-prototypes", "")
        cfg_vars[key] = cfg_vars[key].replace("-Wall", "-w")

from distutils.core import setup
from Cython.Build import cythonize
from Cython.Distutils.extension import Extension
from Cython.Distutils import build_ext

class custom_build_ext(build_ext):
    def build_extensions(self):
        self.parallel=True
        try:
            self.compiler.linker_so.remove('-Wl,-pie')
            self.compiler.compiler_so.remove('-fPIE')
            self.compiler.linker_so.remove('-fPIE')
            self.compiler.compiler.remove('-fPIE')
        except:
            pass
        build_ext.build_extensions(self)
        
import numpy
## \file setup.py setup.py
#  \brief The python script for building proteus
#
#  Set the DISTUTILS_DEBUG environment variable to print detailed information while setup.py is running.
#
sys.path.append(os.path.join(os.path.dirname(__file__)))#, '..', 'MyPackage'))
from proteus import config
from proteus.config import *
###to turn on debugging in c++
##\todo Finishing cleaning up setup.py/setup.cfg, config.py...

PROTEUS_PETSC_EXTRA_LINK_ARGS = getattr(config, 'PROTEUS_PETSC_EXTRA_LINK_ARGS', [])
PROTEUS_PETSC_EXTRA_COMPILE_ARGS = getattr(config, 'PROTEUS_PETSC_EXTRA_COMPILE_ARGS', [])
PROTEUS_CHRONO_CXX_FLAGS = getattr(config, 'PROTEUS_CHRONO_CXX_FLAGS', [])

proteus_install_path = os.path.join(sysconfig.get_python_lib(), 'proteus')

# handle non-system installations
for arg in sys.argv:
    if arg.startswith('--root'):
        proteus_install_path = proteus_install_path.partition(sys.prefix + '/')[-1]
        break
    if arg.startswith('--prefix'):
        proteus_install_path = proteus_install_path.partition(sys.prefix + '/')[-1]
        break

def get_xtensor_include():
    return [str(get_pybind_include()),
            str(get_pybind_include(user=True)),
            str(get_numpy_include()),
            os.path.join(prefix, 'include'),
            os.path.join(sys.prefix, 'include'),
            os.path.join(sys.prefix, 'Library', 'include'),
            'proteus',
            'proteus/xtensor/pybind11/include',
            'proteus/xtensor/xtensor-python/include',
            'proteus/xtensor/xtensor/include',
            'proteus/xtensor/xtl/include']

class get_pybind_include(object):
    """Helper class to determine the pybind11 include path

    The purpose of this class is to postpone importing pybind11
    until it is actually installed, so that the ``get_include()``
    method can be invoked. """

    def __init__(self, user=False):
        self.user = user

    def __str__(self):
        import pybind11
        return pybind11.get_include(self.user)


class get_numpy_include(object):
    """Helper class to determine the numpy include path

    The purpose of this class is to postpone importing numpy
    until it is actually installed, so that the ``get_include()``
    method can be invoked. """

    def __init__(self):
        pass

    def __str__(self):
        import numpy as np
        return np.get_include()

EXTENSIONS_TO_BUILD = [
    Extension("MeshAdaptPUMI.MeshAdapt",
              sources = ['proteus/MeshAdaptPUMI/MeshAdapt.pyx', 'proteus/MeshAdaptPUMI/cMeshAdaptPUMI.cpp',
                         'proteus/MeshAdaptPUMI/MeshConverter.cpp', 'proteus/MeshAdaptPUMI/ParallelMeshConverter.cpp',
                         'proteus/MeshAdaptPUMI/MeshFields.cpp', 'proteus/MeshAdaptPUMI/SizeField.cpp',
                         'proteus/MeshAdaptPUMI/DumpMesh.cpp',
                         'proteus/MeshAdaptPUMI/ErrorResidualMethod.cpp','proteus/MeshAdaptPUMI/VMS.cpp','proteus/MeshAdaptPUMI/createAnalyticGeometry.cpp'],
              depends=["proteus/partitioning.h",
                       "proteus/partitioning.cpp",
                       "proteus/cpartitioning.pyx",
                       "proteus/cmeshTools.pxd",
                       "proteus/mesh.h",
                       'proteus/mesh.cpp',
                       'proteus/meshio.cpp'],
              define_macros=[('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H)],
              language='c++',
              include_dirs=[numpy.get_include(),'include',
                            'proteus','proteus/MeshAdaptPUMI']+
              PROTEUS_SCOREC_INCLUDE_DIRS,
              library_dirs=PROTEUS_SCOREC_LIB_DIRS,
              libraries=PROTEUS_SCOREC_LIBS,
              extra_compile_args=['-std=c++17']+PROTEUS_SCOREC_EXTRA_COMPILE_ARGS+PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_SCOREC_EXTRA_LINK_ARGS+PROTEUS_EXTRA_LINK_ARGS),
    Extension(
        'mprans.cArgumentsDict',
        sources = ['proteus/mprans/ArgumentsDict.cpp'],
        depends=['proteus/mprans/ArgumentsDict.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cPres',
        sources = ['proteus/mprans/Pres.cpp'],
        depends=['proteus/mprans/Pres.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cPresInit',
        sources = ['proteus/mprans/PresInit.cpp'],
        depends=['proteus/mprans/PresInit.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cPresInc',
        sources = ['proteus/mprans/PresInc.cpp'],
        depends = ['proteus/mprans/PresInc.h', 'proteus/mprans/PresInc.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension('mprans.cAddedMass',
              sources = ['proteus/mprans/AddedMass.cpp'],
              depends=['proteus/mprans/AddedMass.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
              language='c++',
              include_dirs=get_xtensor_include(),
              extra_compile_args=PROTEUS_OPT+['-std=c++14']),
    Extension('mprans.SedClosure',
              sources = ['proteus/mprans/SedClosure.cpp'],
              depends = ['proteus/mprans/SedClosure.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
              language='c++',
              include_dirs=get_xtensor_include(),
              extra_compile_args=PROTEUS_OPT+['-std=c++14']),
    Extension('mprans.cVOF3P',
              sources = ['proteus/mprans/VOF3P.cpp'],
              depends = ['proteus/mprans/VOF3P.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
              language='c++',
              include_dirs=get_xtensor_include(),
              extra_compile_args=PROTEUS_OPT+['-std=c++14']),
    Extension(
        'mprans.cVOS3P',
        sources = ['proteus/mprans/VOS3P.cpp'],
        depends = ['proteus/mprans/VOS3P.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension('mprans.cNCLS3P',
              sources=['proteus/mprans/NCLS3P.cpp'],
              depends=['proteus/mprans/NCLS3P.h', 'proteus/mprans/ArgumentsDict.h' , 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
              language='c++',
              include_dirs=get_xtensor_include(),
              extra_compile_args=PROTEUS_OPT+['-std=c++14']),
    Extension('mprans.cMCorr3P',
              sources=['proteus/mprans/MCorr3P.cpp'],
              depends=['proteus/mprans/MCorr3P.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
              language='c++',
              include_dirs=get_xtensor_include(),
              extra_compile_args=PROTEUS_OPT+['-std=c++14'],
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS,
              define_macros=[('PROTEUS_LAPACK_H',
                              PROTEUS_LAPACK_H),
                             ('PROTEUS_LAPACK_INTEGER',
                              PROTEUS_LAPACK_INTEGER),
                             ('PROTEUS_BLAS_H',
                              PROTEUS_BLAS_H)],
              library_dirs=[PROTEUS_LAPACK_LIB_DIR,
                            PROTEUS_BLAS_LIB_DIR],
              libraries=['m',PROTEUS_LAPACK_LIB,
                         PROTEUS_BLAS_LIB],
              ),
    Extension(
        'mprans.cRANS3PSed',
        sources=['proteus/mprans/RANS3PSed.cpp'],
        depends=['proteus/mprans/RANS3PSed.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cRANS3PSed2D',
        sources=['proteus/mprans/RANS3PSed2D.cpp'],
        depends=['proteus/mprans/RANS3PSed2D.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'richards.cRichards',
        sources=['proteus/richards/cRichards.cpp'],
        depends=['proteus/richards/Richards.h', 'proteus/mprans/ArgumentsDict.h' ,'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        language='c++',
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
    ),
    Extension(
        'elastoplastic.cElastoPlastic',
        sources=['proteus/elastoplastic/cElastoPlastic.cpp'],
        define_macros=[('PROTEUS_LAPACK_H',
                        PROTEUS_LAPACK_H),
                       ('PROTEUS_LAPACK_INTEGER',
                        PROTEUS_LAPACK_INTEGER),
                       ('PROTEUS_BLAS_H',
                        PROTEUS_BLAS_H)],
        depends=['proteus/elastoplastic/ElastoPlastic.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        language='c++',
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        library_dirs=[PROTEUS_LAPACK_LIB_DIR,
                      PROTEUS_BLAS_LIB_DIR],
        libraries=['m',PROTEUS_LAPACK_LIB,
                   PROTEUS_BLAS_LIB]
    ),
    Extension(
        'mprans.cRANS3PF',
        sources=['proteus/mprans/RANS3PF.cpp'],
        depends=['proteus/mprans/RANS3PF.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cRANS3PF2D',
        sources=['proteus/mprans/RANS3PF2D.cpp'],
        depends=['proteus/mprans/RANS3PF2D.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension("Isosurface",
              sources=['proteus/Isosurface.pyx'],
              language='c',
              extra_compile_args=PROTEUS_OPT,
              include_dirs=[numpy.get_include(),'proteus'],
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension("BoundaryConditions",
              sources=['proteus/BoundaryConditions.py'],
              depends=['proteus/BoundaryConditions.pxd'],
              language='c++',
              extra_compile_args=PROTEUS_OPT,
              include_dirs=[numpy.get_include(),'proteus']),
    Extension("mprans.BoundaryConditions",
              sources=['proteus/mprans/BoundaryConditions.py'],
              depends=['proteus/mprans/BoundaryConditions.pxd'],
              language='c++',
              extra_compile_args=PROTEUS_OPT,
              include_dirs=[numpy.get_include(),'proteus']),
    Extension("mprans.MeshSmoothing",
              sources=['proteus/mprans/MeshSmoothing.pyx'],
              language='c++',
              include_dirs=[numpy.get_include(),'proteus',PROTEUS_INCLUDE_DIR],
              libraries=['stdc++','m'],
              extra_compile_args=["-std=c++11","-mavx"]+PROTEUS_OPT),
    Extension("mprans.cMoveMeshMonitor",
              sources=['proteus/mprans/cMoveMeshMonitor.pyx'],
              language='c++',
              include_dirs=[numpy.get_include(),'proteus',PROTEUS_INCLUDE_DIR],
              libraries=['stdc++','m'],
              extra_compile_args=["-std=c++11","-mavx"]+PROTEUS_OPT),
    Extension("mbd.CouplingFSI",
              sources=['proteus/mbd/CouplingFSI.pyx',
                       'proteus/mbd/ChVariablesBodyAddedMass.cpp',
                       'proteus/mbd/ChBodyAddedMass.cpp'],
              depends=['proteus/mbd/CouplingFSI.pxd',
                       'proteus/mbd/ChronoHeaders.pxd',
                       'proteus/mbd/ProtChBody.h',
                       'proteus/mbd/ProtChMoorings.h'],
              language='c++',
              include_dirs=[numpy.get_include(),
                            'proteus',
                            'proteus/mbd',
                            PROTEUS_INCLUDE_DIR,
                            PROTEUS_INCLUDE_DIR+'/eigen3',
                            PROTEUS_CHRONO_INCLUDE_DIR,
                            PROTEUS_CHRONO_INCLUDE_DIR+'/chrono',
                            PROTEUS_CHRONO_INCLUDE_DIR+'/chrono/collision/bullet',],
              library_dirs=[PROTEUS_CHRONO_LIB_DIR],
              libraries=['ChronoEngine',
                         'stdc++',
                         'm'],
              extra_compile_args=["-std=c++17"]+PROTEUS_CHRONO_CXX_FLAGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension("WaveTools",
              sources=['proteus/WaveTools.py'],
              depends=['proteus/WaveTools.h'],
              language='c++',
              extra_compile_args=PROTEUS_OPT,
              include_dirs=[numpy.get_include(),'proteus']),
    Extension("fenton.Fenton",
              sources=['proteus/fenton/Fenton.pyx',
                       'proteus/fenton/Solve.cpp',
                       'proteus/fenton/Dpythag.cpp',
                       'proteus/fenton/Dsvbksb.cpp',
                       'proteus/fenton/Dsvdcmp.cpp',
                       'proteus/fenton/Inout.cpp',
                       'proteus/fenton/Subroutines.cpp',
                       'proteus/fenton/Util.cpp',],
              language='c++',
              include_dirs=[numpy.get_include(),
                            'proteus',
                            PROTEUS_INCLUDE_DIR,
                            PROTEUS_NCURSES_INCLUDE_DIR,],
              library_dirs=[PROTEUS_NCURSES_LIB_DIR,],
              libraries=['ncurses','stdc++','m'],
              extra_compile_args=["-std=c++11"]+PROTEUS_OPT),
    Extension(
        'cADR',
        sources=['proteus/ADR.cpp'],
        depends=['proteus/ADR.h', 'proteus/mprans/ArgumentsDict.h', 'proteus/ModelFactory.h', 'proteus/CompKernel.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'
    ),
    Extension("subsurfaceTransportFunctions",
              sources=['proteus/subsurfaceTransportFunctions.pyx'],
              include_dirs=[numpy.get_include(),'proteus'],
              extra_compile_args=PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension("equivalent_polynomials",
              sources=['proteus/equivalent_polynomials.pyx'],
              depends=['proteus/equivalent_polynomials.pxd',
                       'proteus/equivalent_polynomials.h',
                       'proteus/equivalent_polynomials_utils.h',
                       'proteus/equivalent_polynomials_coefficients.h',
                       'proteus/equivalent_polynomials_coefficients_quad.h'],
              language='c++',
              extra_compile_args=PROTEUS_OPT,
              include_dirs=[numpy.get_include(),'proteus'],),
    Extension('cfemIntegrals',
              sources=['proteus/cfemIntegrals.pyx',
                       'proteus/femIntegrals.c',
                       'proteus/postprocessing.c'],
              depends=['proteus/femIntegrals.h'],
              define_macros=[('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('PROTEUS_LAPACK_H',PROTEUS_LAPACK_H),
                             ('PROTEUS_LAPACK_INTEGER',PROTEUS_LAPACK_INTEGER),
                             ('PROTEUS_BLAS_H',PROTEUS_BLAS_H)],
              include_dirs=[numpy.get_include(),'proteus',
                            PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_LAPACK_INCLUDE_DIR,
                            PROTEUS_BLAS_INCLUDE_DIR],
              library_dirs=[PROTEUS_LAPACK_LIB_DIR,
                            PROTEUS_BLAS_LIB_DIR],
              libraries=['m',PROTEUS_LAPACK_LIB,PROTEUS_BLAS_LIB],
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension("csparsity",
              sources=['proteus/csparsity.pyx', 'proteus/sparsity.cpp'],
              depends=['proteus/sparsity.h'],
              language='c++',
              extra_compile_args=PROTEUS_OPT,
              include_dirs=[numpy.get_include(),'proteus'],),
    Extension("cmeshTools",
              sources=['proteus/cmeshTools.pyx', 'proteus/mesh.cpp', 'proteus/meshio.cpp'],
              language='c++',
              define_macros=[('PROTEUS_TRIANGLE_H',PROTEUS_TRIANGLE_H),
                             ('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('CMRVEC_BOUNDS_CHECK',1),
                             ('MV_VECTOR_BOUNDS_CHECK',1),
                             ('PETSCVEC_BOUNDS_CHECK',1),
                             ('F77_POST_UNDERSCORE',1),
                             ('USE_BLAS',1)],
              include_dirs=['proteus',
                            numpy.get_include(),
                            PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_TRIANGLE_INCLUDE_DIR,
                            PROTEUS_HDF5_INCLUDE_DIR] + \
              PROTEUS_PETSC_INCLUDE_DIRS + \
              PROTEUS_MPI_INCLUDE_DIRS,
              library_dirs=PROTEUS_PETSC_LIB_DIRS+PROTEUS_MPI_LIB_DIRS+PROTEUS_HDF5_LIB_DIRS,
              libraries=['hdf5','stdc++','m']+PROTEUS_PETSC_LIBS+PROTEUS_MPI_LIBS+PROTEUS_HDF5_LIBS,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS + PROTEUS_PETSC_EXTRA_LINK_ARGS,
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS + PROTEUS_PETSC_EXTRA_COMPILE_ARGS+PROTEUS_OPT),
    Extension('ctransportCoefficients',
              sources=['proteus/ctransportCoefficients.pyx','proteus/transportCoefficients.c'],
              include_dirs=[numpy.get_include(),'proteus'],
              depends=["proteus/transportCoefficients.h"],
              language="c",
              libraries=['m'],
              extra_compile_args=PROTEUS_OPT),
    Extension('csubgridError',
              sources=['proteus/csubgridError.pyx','proteus/subgridError.c'],
              depends=["proteus/subgridError.h"],
              language="c",
              include_dirs=[numpy.get_include(),'proteus'],
              libraries=['m'],
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension('cshockCapturing',
              sources=['proteus/cshockCapturing.pyx','proteus/shockCapturing.c'],
              depends=["proteus/shockCapturing.h"],
              language="c",
              include_dirs=[numpy.get_include(),'proteus'],
              libraries=['m'],
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension('superluWrappers',
              sources=['proteus/superluWrappers.pyx'],
              define_macros=[('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('PROTEUS_BLAS_H',PROTEUS_BLAS_H)],
              language="c",
              include_dirs=[numpy.get_include(),
                            'proteus',
                            PROTEUS_SUPERLU_INCLUDE_DIR],
              library_dirs=[PROTEUS_SUPERLU_LIB_DIR,
                            PROTEUS_LAPACK_LIB_DIR,
                            PROTEUS_BLAS_LIB_DIR],
              libraries=['m',
                         PROTEUS_SUPERLU_LIB,
                         PROTEUS_LAPACK_LIB,PROTEUS_BLAS_LIB],
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension("csmoothers",
              sources=["proteus/csmoothers.pyx", "proteus/smoothers.c"],
              define_macros=[('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('PROTEUS_LAPACK_H',PROTEUS_LAPACK_H),
                             ('PROTEUS_LAPACK_INTEGER',PROTEUS_LAPACK_INTEGER),
                             ('PROTEUS_BLAS_H',PROTEUS_BLAS_H)],
              language="c",
              include_dirs=['proteus',
                            numpy.get_include(),
                            PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_LAPACK_INCLUDE_DIR,
                            PROTEUS_BLAS_INCLUDE_DIR,
              ],
              library_dirs=[PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_SUPERLU_LIB_DIR,
                            PROTEUS_LAPACK_LIB_DIR,
                            PROTEUS_BLAS_LIB_DIR],
              libraries=['m',
                         PROTEUS_SUPERLU_LIB,
                         PROTEUS_LAPACK_LIB,
                         PROTEUS_BLAS_LIB],
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS),
    Extension("canalyticalSolutions",
              sources=["proteus/canalyticalSolutions.pyx", "proteus/analyticalSolutions.c"],
              depends=["proteus/analyticalSolutions.h"],
              extra_compile_args=PROTEUS_OPT,
              language="c", include_dirs=[numpy.get_include(), 'proteus']),
    Extension("clapack",
              sources=["proteus/clapack.pyx"],
              depends=["proteus/proteus_lapack.h","proteus/proteus_blas.h"],
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS,
              language="c",
              include_dirs=[numpy.get_include(), 'proteus',
                            PROTEUS_LAPACK_INCLUDE_DIR,
                            PROTEUS_BLAS_INCLUDE_DIR],
              library_dirs=[PROTEUS_LAPACK_LIB_DIR,PROTEUS_BLAS_LIB_DIR],
              libraries=['m',
                         PROTEUS_LAPACK_LIB,
                         PROTEUS_BLAS_LIB]),
    Extension("cpostprocessing",
              sources=["proteus/cpostprocessing.pyx","proteus/postprocessing.c"],
              depends=["proteus/postprocessing.h","proteus/postprocessing.pxd"],
              define_macros=[('PROTEUS_LAPACK_H',PROTEUS_LAPACK_H),
                             ('PROTEUS_LAPACK_INTEGER',PROTEUS_LAPACK_INTEGER),
                             ('PROTEUS_BLAS_H',PROTEUS_BLAS_H)],
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS,
              language="c",
              include_dirs=[numpy.get_include(), 'proteus',
                            PROTEUS_LAPACK_INCLUDE_DIR,
                            PROTEUS_BLAS_INCLUDE_DIR],
              library_dirs=[PROTEUS_LAPACK_LIB_DIR,PROTEUS_BLAS_LIB_DIR],
              libraries=['m',
                         PROTEUS_LAPACK_LIB,
                         PROTEUS_BLAS_LIB]),
    Extension('cnumericalFlux',
              sources=['proteus/cnumericalFlux.pyx','proteus/numericalFlux.c'],
              depends=["proteus/numericalFlux.h"],
              extra_compile_args=PROTEUS_OPT,
              language="c", include_dirs=[numpy.get_include(), 'proteus']),
    Extension('ctimeIntegration',
              sources=['proteus/ctimeIntegration.pyx','proteus/timeIntegration.c'],
              depends=["proteus/timeIntegration.h"],
              extra_compile_args=PROTEUS_OPT,
              language="c", include_dirs=[numpy.get_include(), 'proteus']),
    Extension("cTwophaseDarcyCoefficients",
              sources=["proteus/cTwophaseDarcyCoefficients.pyx",
               "proteus/SubsurfaceTransportCoefficients.cpp"],
              depends=["proteus/SubsurfaceTransportCoefficients.h",
                       "proteus/pskRelations.h",
                       "proteus/pskRelations.pxd",
                       "proteus/densityRelations.h",
                       "proteus/twophaseDarcyCoefficients.pxd",
                       "proteus/twophaseDarcyCoefficients.h"],
              define_macros=[('PROTEUS_TRIANGLE_H',PROTEUS_TRIANGLE_H),
                             ('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('CMRVEC_BOUNDS_CHECK',1),
                             ('MV_VECTOR_BOUNDS_CHECK',1),
                             ('PETSCVEC_BOUNDS_CHECK',1),
                             ('F77_POST_UNDERSCORE',1),
                             ('USE_BLAS',1)],
              include_dirs=['proteus',
                            numpy.get_include(),
                            PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_TRIANGLE_INCLUDE_DIR,
                            PROTEUS_HDF5_INCLUDE_DIR] + \
              PROTEUS_PETSC_INCLUDE_DIRS + \
              PROTEUS_MPI_INCLUDE_DIRS,
              language="c++",
              library_dirs=PROTEUS_PETSC_LIB_DIRS+PROTEUS_MPI_LIB_DIRS+PROTEUS_HDF5_LIB_DIRS,
              libraries=['hdf5','stdc++','m']+PROTEUS_PETSC_LIBS+PROTEUS_MPI_LIBS+PROTEUS_HDF5_LIBS,
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS + PROTEUS_PETSC_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS + PROTEUS_PETSC_EXTRA_LINK_ARGS,
    ),
    Extension("cSubsurfaceTransportCoefficients",
              sources=["proteus/cSubsurfaceTransportCoefficients.pyx","proteus/SubsurfaceTransportCoefficients.cpp"],
              depends=["proteus/SubsurfaceTransportCoefficients.pxd",
                       "proteus/SubsurfaceTransportCoefficients.h"],
              define_macros=[('PROTEUS_TRIANGLE_H',PROTEUS_TRIANGLE_H),
                             ('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('CMRVEC_BOUNDS_CHECK',1),
                             ('MV_VECTOR_BOUNDS_CHECK',1),
                             ('PETSCVEC_BOUNDS_CHECK',1),
                             ('F77_POST_UNDERSCORE',1),
                             ('USE_BLAS',1)],
              include_dirs=['proteus',
                            numpy.get_include(),
                            PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_TRIANGLE_INCLUDE_DIR,
                            PROTEUS_HDF5_INCLUDE_DIR] + \
              PROTEUS_PETSC_INCLUDE_DIRS + \
              PROTEUS_MPI_INCLUDE_DIRS,
              language="c++",
              library_dirs=PROTEUS_PETSC_LIB_DIRS+PROTEUS_MPI_LIB_DIRS+PROTEUS_HDF5_LIB_DIRS,
              libraries=['hdf5','stdc++','m']+PROTEUS_PETSC_LIBS+PROTEUS_MPI_LIBS+PROTEUS_HDF5_LIBS,
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS + PROTEUS_PETSC_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS + PROTEUS_PETSC_EXTRA_LINK_ARGS,
    ),
    Extension("cpskRelations",
              sources=["proteus/cpskRelations.pyx"],
              depends=["proteus/pskRelations.pxd",
                       "proteus/pskRelations.h"],
              define_macros=[('PROTEUS_TRIANGLE_H',PROTEUS_TRIANGLE_H),
                             ('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('CMRVEC_BOUNDS_CHECK',1),
                             ('MV_VECTOR_BOUNDS_CHECK',1),
                             ('PETSCVEC_BOUNDS_CHECK',1),
                             ('F77_POST_UNDERSCORE',1),
                             ('USE_BLAS',1)],
              include_dirs=['proteus',
                            numpy.get_include(),
                            PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_TRIANGLE_INCLUDE_DIR,
                            PROTEUS_HDF5_INCLUDE_DIR] + \
              PROTEUS_PETSC_INCLUDE_DIRS + \
              PROTEUS_MPI_INCLUDE_DIRS,
              language="c++",
              library_dirs=PROTEUS_PETSC_LIB_DIRS+PROTEUS_MPI_LIB_DIRS+PROTEUS_HDF5_LIB_DIRS,
              libraries=['hdf5','stdc++','m']+PROTEUS_PETSC_LIBS+PROTEUS_MPI_LIBS+PROTEUS_HDF5_LIBS,
              extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS + PROTEUS_PETSC_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS + PROTEUS_PETSC_EXTRA_LINK_ARGS,
    ),
    Extension("cpartitioning",
              sources=["proteus/cpartitioning.pyx",
                       "proteus/partitioning.cpp",
                       'proteus/mesh.cpp',
                       'proteus/meshio.cpp',],
              depends=["proteus/partitioning.h",
                       "proteus/partitioning.cpp",
                       "proteus/cpartitioning.pyx",
                       "proteus/cmeshTools.pxd",
                       "proteus/mesh.h",
                       'proteus/mesh.cpp',
                       'proteus/meshio.cpp'],
              define_macros=[('PROTEUS_TRIANGLE_H',PROTEUS_TRIANGLE_H),
                             ('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
                             ('CMRVEC_BOUNDS_CHECK',1),
                             ('MV_VECTOR_BOUNDS_CHECK',1),
                             ('PETSCVEC_BOUNDS_CHECK',1),
                             ('F77_POST_UNDERSCORE',1),
                             ('USE_BLAS',1)],
              include_dirs=['proteus',
                            numpy.get_include(),
                            PROTEUS_SUPERLU_INCLUDE_DIR,
                            PROTEUS_TRIANGLE_INCLUDE_DIR,
                            PROTEUS_HDF5_INCLUDE_DIR] +
              PROTEUS_PETSC_INCLUDE_DIRS + PROTEUS_MPI_INCLUDE_DIRS,
              language="c++",
              library_dirs=PROTEUS_PETSC_LIB_DIRS+PROTEUS_MPI_LIB_DIRS+PROTEUS_HDF5_LIB_DIRS,
              libraries=['hdf5','stdc++','m']+PROTEUS_PETSC_LIBS+PROTEUS_MPI_LIBS+PROTEUS_HDF5_LIBS,
              extra_compile_args=['-std=c++17']+PROTEUS_EXTRA_COMPILE_ARGS + PROTEUS_PETSC_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
              extra_link_args=PROTEUS_EXTRA_LINK_ARGS + PROTEUS_PETSC_EXTRA_LINK_ARGS,
    ),
    # Extension("flcbdfWrappers",["proteus/flcbdfWrappers.pyx"],
    #           language="c++",
    #           depends=["proteus/flcbdfWrappers.pxd"],
    #           define_macros=[('PROTEUS_TRIANGLE_H',PROTEUS_TRIANGLE_H),
    #                          ('PROTEUS_SUPERLU_H',PROTEUS_SUPERLU_H),
    #                          ('CMRVEC_BOUNDS_CHECK',1),
    #                          ('MV_VECTOR_BOUNDS_CHECK',1),
    #                          ('PETSCVEC_BOUNDS_CHECK',1),
    #                          ('F77_POST_UNDERSCORE',1),
    #                          ('USE_BLAS',1)],
    #           include_dirs=['proteus',
    #                         numpy.get_include(),
    #                         PROTEUS_SUPERLU_INCLUDE_DIR,
    #                         PROTEUS_TRIANGLE_INCLUDE_DIR,
    #                         PROTEUS_DAETK_INCLUDE_DIR,
    #                         PROTEUS_HDF5_INCLUDE_DIR] + \
    #           PROTEUS_PETSC_INCLUDE_DIRS + \
    #           PROTEUS_MPI_INCLUDE_DIRS,
    #           library_dirs=[PROTEUS_DAETK_LIB_DIR]+PROTEUS_PETSC_LIB_DIRS+PROTEUS_MPI_LIB_DIRS+PROTEUS_HDF5_LIB_DIRS,
    #           libraries=['hdf5','stdc++','m',PROTEUS_DAETK_LIB]+PROTEUS_PETSC_LIBS+PROTEUS_MPI_LIBS+PROTEUS_HDF5_LIBS,
    #           extra_link_args=PROTEUS_EXTRA_LINK_ARGS + PROTEUS_PETSC_EXTRA_LINK_ARGS,
    #           extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS + PROTEUS_PETSC_EXTRA_COMPILE_ARGS+PROTEUS_OPT,
    # ),
    Extension(
        'mprans.cCLSVOF',
        sources=['proteus/mprans/CLSVOF.cpp'],
        depends=["proteus/mprans/CLSVOF.h", "proteus/mprans/CLSVOF.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cNCLS',
        sources=['proteus/mprans/NCLS.cpp'],
        depends=["proteus/mprans/NCLS.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cMCorr',
        sources=['proteus/mprans/MCorr.cpp'],
        depends=["proteus/mprans/MCorr.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"] + [
            "proteus/equivalent_polynomials.h",
            "proteus/equivalent_polynomials_utils.h",
            "proteus/equivalent_polynomials_coefficients.h",
            'proteus/equivalent_polynomials_coefficients_quad.h'],
        define_macros=[('PROTEUS_LAPACK_H',PROTEUS_LAPACK_H),
                       ('PROTEUS_LAPACK_INTEGER',PROTEUS_LAPACK_INTEGER),
                       ('PROTEUS_BLAS_H',PROTEUS_BLAS_H)],
        include_dirs=get_xtensor_include(),
        library_dirs=[PROTEUS_LAPACK_LIB_DIR,
                      PROTEUS_BLAS_LIB_DIR],
        libraries=['m',PROTEUS_LAPACK_LIB,PROTEUS_BLAS_LIB],
        extra_compile_args=PROTEUS_EXTRA_COMPILE_ARGS+PROTEUS_OPT+['-std=c++14'],
        extra_link_args=PROTEUS_EXTRA_LINK_ARGS,
        language='c++'),
    Extension(
        'mprans.cRANS2P',
        sources=['proteus/mprans/RANS2P.cpp'],
        depends=["proteus/mprans/RANS2P.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/MixedModelFactory.h","proteus/CompKernel.h"] + [
            "proteus/equivalent_polynomials.h",
            "proteus/equivalent_polynomials_utils.h",
            "proteus/equivalent_polynomials_coefficients.h",
            'proteus/equivalent_polynomials_coefficients_quad.h'],
        include_dirs=get_xtensor_include() + PROTEUS_MPI_INCLUDE_DIRS,
        extra_compile_args=PROTEUS_OPT+PROTEUS_MPI_LIB_DIRS+['-std=c++14'],#,'-fopenmp'],#,'-DXTENSOR_USE_OPENMP'],
        library_dirs=PROTEUS_MPI_LIB_DIRS+[PROTEUS_LAPACK_LIB_DIR,
                      PROTEUS_BLAS_LIB_DIR],
        libraries=PROTEUS_MPI_LIBS+['m',
                                    PROTEUS_LAPACK_LIB,
                                    PROTEUS_BLAS_LIB],
        extra_link_args=PROTEUS_SCOREC_EXTRA_LINK_ARGS+PROTEUS_EXTRA_LINK_ARGS,#+['-fopenmp'],
        language='c++'),
    Extension(
        'mprans.cRANS2P_IB',
        sources=['proteus/mprans/RANS2P_IB.cpp'],
        depends=["proteus/mprans/RANS2P_IB.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/MixedModelFactory.h","proteus/CompKernel.h"] + [
            "proteus/equivalent_polynomials.h",
            "proteus/equivalent_polynomials_utils.h",
            "proteus/equivalent_polynomials_coefficients.h",
            'proteus/equivalent_polynomials_coefficients_quad.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cRANS2P2D',
        sources=['proteus/mprans/RANS2P2D.cpp'],
        depends=["proteus/mprans/RANS2P2D.h"] + ["proteus/MixedModelFactory.h","proteus/CompKernel.h"] + [
            "proteus/equivalent_polynomials.h",
            "proteus/equivalent_polynomials_utils.h",
            "proteus/equivalent_polynomials_coefficients.h",
            'proteus/equivalent_polynomials_coefficients_quad.h'],
        include_dirs=get_xtensor_include() + PROTEUS_MPI_INCLUDE_DIRS,
        extra_compile_args=PROTEUS_OPT+PROTEUS_MPI_LIB_DIRS+['-std=c++14'],#,'-fopenmp'],#,'-DXTENSOR_USE_OPENMP'],
        library_dirs=PROTEUS_MPI_LIB_DIRS+[PROTEUS_LAPACK_LIB_DIR,
                      PROTEUS_BLAS_LIB_DIR],
        libraries=PROTEUS_MPI_LIBS+['m',
                                    PROTEUS_LAPACK_LIB,
                                    PROTEUS_BLAS_LIB],
        extra_link_args=PROTEUS_SCOREC_EXTRA_LINK_ARGS+PROTEUS_EXTRA_LINK_ARGS,#+['-fopenmp'],
        language='c++'),
    Extension(
        'mprans.cRDLS',
        sources=['proteus/mprans/RDLS.cpp'],
        depends=["proteus/mprans/RDLS.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"] + [
            "proteus/equivalent_polynomials.h",
            "proteus/equivalent_polynomials_utils.h",
            "proteus/equivalent_polynomials_coefficients.h",
            'proteus/equivalent_polynomials_coefficients_quad.h'],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cVOF',
        sources=['proteus/mprans/VOF.cpp'],
        depends=["proteus/mprans/VOF.h", "proteus/mprans/ArgumentsDict.h", "proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cTADR',
        sources=['proteus/mprans/TADR.cpp'],
        depends=["proteus/mprans/TADR.h", "proteus/mprans/ArgumentsDict.h", "proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cMoveMesh',
        ['proteus/mprans/MoveMesh.cpp'],
        depends=["proteus/mprans/MoveMesh.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cMoveMesh2D',
        sources=['proteus/mprans/MoveMesh2D.cpp'],
        depends=["proteus/mprans/MoveMesh2D.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cSW2D',
        sources=['proteus/mprans/SW2D.cpp'],
        depends=["proteus/mprans/SW2D.h", "proteus/mprans/SW2D.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cSW2DCV',
        sources=['proteus/mprans/SW2DCV.cpp'],
        depends=["proteus/mprans/SW2DCV.h", "proteus/mprans/ArgumentsDict.h", "proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cGN_SW2DCV',
        sources=['proteus/mprans/GN_SW2DCV.cpp'],
        depends=["proteus/mprans/GN_SW2DCV.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cKappa',
        sources=['proteus/mprans/Kappa.cpp'],
        depends=["proteus/mprans/Kappa.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cKappa2D',
        sources=['proteus/mprans/Kappa2D.cpp'],
        depends=["proteus/mprans/Kappa2D.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cDissipation',
        sources=['proteus/mprans/Dissipation.cpp'],
        depends=["proteus/mprans/Dissipation.h", "proteus/mprans/ArgumentsDict.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
    Extension(
        'mprans.cDissipation2D',
        sources=['proteus/mprans/Dissipation2D.cpp'],
        depends=["proteus/mprans/Dissipation2D.h"] + ["proteus/ModelFactory.h","proteus/CompKernel.h"],
        include_dirs=get_xtensor_include(),
        extra_compile_args=PROTEUS_OPT+['-std=c++14'],
        language='c++'),
]

def setup_given_extensions(extensions):
    setup(name='proteus',
          version='1.8.3',
          classifiers=[
              'Development Status :: 4 - Beta',
              'Environment :: Console',
              'Environment :: Web Environment',
              'Intended Audience :: End Users/Desktop',
              'Intended Audience :: Developers',
              'Intended Audience :: Science/Research',
              'License :: OSI Approved :: MIT License',
              'Programming Language :: Python :: 3.7'
              'Programming Language :: Python :: 3 :: Only',
              'Programming Language :: Python :: Implementation :: CPython',
              'Topic :: Scientific/Engineering :: Mathematics',
              'Topic :: Scientific/Engineering :: Physics',
              'Operating System :: MacOS :: MacOS X',
              'Operating System :: POSIX',
          ],
          description='Python tools for multiphysics modeling',
          author='The Proteus Developers',
          author_email='proteus-dev@googlegroups.com',
          url='http://proteustoolkit.org',
          packages = ['proteus',
                      'proteus.fenton',
                      'proteus.mprans',
                      'proteus.richards',
                      'proteus.elastoplastic',
                      'proteus.mbd',
                      'proteus.test_utils',
                      'proteus.config',
                      'proteus.TwoPhaseFlow',
                      'proteus.TwoPhaseFlow.utils',
                      'proteus.SWFlow',
                      'proteus.SWFlow.utils',
                      'proteus.SWFlow.models',
                      'proteus.MeshAdaptPUMI',
                      'proteus.MeshAdaptPUMI',
          ],
          cmdclass = {'build_ext':custom_build_ext},
          ext_package='proteus',
          ext_modules=extensions,
          data_files=[(proteus_install_path,
                       ['proteus/proteus_blas.h',
                        'proteus/proteus_lapack.h',
                        'proteus/proteus_superlu.h',
                        'proteus/ModelFactory.h',
                        'proteus/CompKernel.h'
                       ]),
         ],
          scripts = ['scripts/parun','scripts/gf2poly','scripts/gatherArchives.py','scripts/qtm','scripts/waves2xmf','scripts/povgen.py',
                     'scripts/velocity2xmf','scripts/run_script_garnet','scripts/run_script_diamond',

                     'scripts/run_script_lonestar','scripts/run_script_ranger','scripts/run_script_mpiexec','scripts/gatherTimes','scripts/clearh5.py',
                     'scripts/runSWEs.py']
    )

def setup_extensions_in_sequential():
    setup_given_extensions(EXTENSIONS_TO_BUILD)

def setup_extensions_in_parallel():
    import multiprocessing, logging
    mp = multiprocessing.get_context('fork')
    logger = mp.log_to_stderr()
    logger.setLevel(logging.INFO)
    pool = mp.Pool(processes=int(os.getenv('N')))
    EXTENSIONS=[[e] for e in EXTENSIONS_TO_BUILD]
    pool.imap(setup_given_extensions, EXTENSIONS)
    pool.close()
    pool.join()

import logging, multiprocessing
logging.basicConfig(force=True,level=logging.INFO)
mp = multiprocessing.get_context('fork')
logger = mp.log_to_stderr()
logger.setLevel(logging.INFO)

if "build_ext" in sys.argv:
    try:
        setup_extensions_in_parallel()
    except:
        setup_extensions_in_sequential()
else:
    setup_extensions_in_sequential()