cmake.yml

name: Build

on: [push, pull_request]

jobs:
  build_repo:
    strategy:
      fail-fast: false
      matrix:
        build_type : [ Release, Debug ]
        os : [ macos-latest, ubuntu-20.04 ]
        include:
          - os: ubuntu-20.04
            cxx: g++-10
          - os: macos-latest
            cxx: clang++

    name: "Repo • ${{ matrix.os }}: ${{ matrix.cxx }} ${{ matrix.build_type }}"
    runs-on: ${{ matrix.os }}
    env:
      CXX : ${{ matrix.cxx }}
      CCACHE_DIR : ${{github.workspace}}/build/.ccache
      CCACHE_COMPRESS : true
      CCACHE_COMPRESSLEVEL : 6
      BUILD_CONFIG : >
        -G Ninja
        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
        -DCMAKE_PREFIX_PATH=/usr/local/Cellar/eigen/3.3.9;/usr/local/opt/bison
        -DBUILD_SHARED_LIBS=OFF
        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
        -DMPIEXEC_PREFLAGS='--bind-to;none;--allow-run-as-root'
        -DENABLE_FORTRAN=ON
        -DCMAKE_INSTALL_PREFIX=${{github.workspace}}/build/library/install
    outputs:
      should_skip: ${{ steps.skip_check.outputs.should_skip }}

    steps:
    - uses: actions/checkout@v3

    - id: skip_check
      name: Check if can skip
      uses: fkirc/skip-duplicate-actions@v5
      with:
        cancel_others: 'true'

    - name: Create Build Environment
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      # Some projects don't allow in-source building, so create a separate build directory
      # We'll use this as our working directory for all subsequent commands
      run: |
        cmake -E make_directory ${{github.workspace}}/build/compiler
        cmake -E make_directory ${{github.workspace}}/build/library
        cmake -E make_directory ${{github.workspace}}/build/library_test

    - name: Install prerequisite MacOS packages
      if: ${{ steps.skip_check.outputs.should_skip != 'true' && matrix.os == 'macos-latest' }}
      run: |
        brew install ninja gcc@10 boost eigen bison ccache automake python3 numpy scipy
        echo "FC=/usr/local/bin/gfortran-10" >> $GITHUB_ENV
        echo "EIGEN3_INCLUDE_DIR=/usr/local/include/eigen3" >> $GITHUB_ENV

    - name: Install prerequisites Ubuntu packages
      if: ${{ steps.skip_check.outputs.should_skip != 'true' && matrix.os == 'ubuntu-20.04' }}
      run: |
        sudo apt-get update
        sudo apt-get install ninja-build g++-10 gfortran-10 liblapack-dev libboost-dev libeigen3-dev ccache python3-numpy python3-scipy
        echo "FC=/usr/bin/gfortran-10" >> $GITHUB_ENV
        echo "EIGEN3_INCLUDE_DIR=/usr/include/eigen3" >> $GITHUB_ENV

    - name: Prepare ccache timestamp
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      id: ccache_cache_timestamp
      shell: cmake -P {0}
      run: |
        string(TIMESTAMP current_date "%Y-%m-%d-%H;%M;%S" UTC)
        message("\"timestamp=${current_date}\" >> $GITHUB_OUTPUT")

    - name: Setup ccache cache files
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      uses: actions/cache@v3
      with:
        path: ${{github.workspace}}/build/.ccache
        key: ${{ matrix.config.name }}-ccache-${{ steps.ccache_cache_timestamp.outputs.timestamp }}
        restore-keys: |
          ${{ matrix.config.name }}-ccache-

    - name: Generate configure script
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      shell: bash
      working-directory: ${{github.workspace}}
      run: ./autogen.sh && ls -l ${{github.workspace}}/configure

    - name: Generate Libint library
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      # Use a bash shell so we can use the same syntax for environment variable
      # access regardless of the host operating system
      shell: bash
      working-directory: ${{github.workspace}}/build/compiler
      run: |
        CPPFLAGS="-I$EIGEN3_INCLUDE_DIR" CXXFLAGS="-std=c++11 -Wno-enum-compare" ${{github.workspace}}/configure --with-max-am=2,2 --with-eri-max-am=2,2 --with-eri3-max-am=3,2 --enable-eri=1 --enable-eri3=1 --enable-1body=1 --disable-1body-property-derivs --with-multipole-max-order=2
        make -j3
        make check
        cd src/bin/test_eri && ./stdtests.pl && cd ../../..
        make export
        echo "ARTIFACT=`ls -1 libint*tgz`" >> $GITHUB_ENV

    - name: Archive Library Tarball
      if: ${{ steps.skip_check.outputs.should_skip != 'true' && matrix.build_type == 'Release'}}
      uses: actions/upload-artifact@v3
      with:
        if-no-files-found: error
        name: ${{ runner.os }}-${{ matrix.cxx }}
        path: ${{github.workspace}}/build/compiler/${{ env.ARTIFACT }}
        retention-days: 1

    - name: Build+test+install Libint library
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      shell: bash
      working-directory: ${{github.workspace}}/build/library
      run: |
        tar -xzf ../compiler/libint-2*.tgz
        cd libint-2*
        echo "LIBINT_EXPORTED_DIR=`pwd`" >> $GITHUB_ENV
        cmake -S . -B build -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_CONFIG
        cmake --build build --target check
        cmake --build build --target install

    - name: Test installed Libint library
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      shell: bash
      working-directory: ${{github.workspace}}/build/library_test
      run: |
        cat > CMakeLists.txt <<EOF
        cmake_minimum_required(VERSION 3.8)
        project(hf++)
        find_package(Libint2 2.8.0 REQUIRED)
        find_package(Threads)  # clang does not autolink threads even though we are using std::thread
        add_executable(hf++ EXCLUDE_FROM_ALL $LIBINT_EXPORTED_DIR/tests/hartree-fock/hartree-fock++.cc)
        target_link_libraries(hf++ Libint2::cxx Threads::Threads)
        EOF
        cmake . -DCMAKE_PREFIX_PATH=${{github.workspace}}/build/library/install -DCMAKE_BUILD_TYPE=$BUILD_TYPE
        cmake --build . --target hf++
        ./hf++ $LIBINT_EXPORTED_DIR/tests/hartree-fock/h2o_rotated.xyz | python $LIBINT_EXPORTED_DIR/tests/hartree-fock/hartree-fock++-validate.py $LIBINT_EXPORTED_DIR/MakeVars.features

    - name: Build Python bindings
      if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
      shell: bash
      working-directory: ${{github.workspace}}/build/library
      run: |
        cd libint-2*
        cd build
        cmake . -DLIBINT2_PYTHON=ON
        cmake --build . --target libint2-python
        cmake --build . --target libint2-python-test

  build_export:
    # to debug the second stage, it is handy to short-circuit the first stage down to ~6 minutes:
    # * run only the Linux/Release (remove items from matrix.build_type and matrix.os)
    # * don't generate any derivative ints (edit CPPFLAGS)
    # * turn off generator testing (comment out "make check" and "stdtests.pl" lines)
    # * suppress last two (test library and bindings) steps ("if: false")
    needs: build_repo
    if: always() && (needs.build_repo.outputs.should_skip != 'true')
    strategy:
      fail-fast: false
      matrix:
        cfg:
          - runs-on: ubuntu-latest
            lane: ubuntu-gnu
            libargs: >
              -DBUILD_SHARED_LIBS=ON
            testargs: ""
            # note full paths depend on setup-miniconda:
            # * Miniforge is miniconda3 vs. Miniconda is miniconda

          - runs-on: windows-latest
            lane: windows-clang-cl
            libargs: >
              -GNinja
              -DCMAKE_BUILD_TYPE=Release
              -DBUILD_SHARED_LIBS=OFF
              -DCMAKE_CXX_COMPILER=clang-cl
              -DCMAKE_C_COMPILER=clang-cl
            testargs: >
              -GNinja
              -DCMAKE_BUILD_TYPE=Release
              -DCMAKE_CXX_COMPILER=clang-cl
              -DCMAKE_C_COMPILER=clang-cl

          - runs-on: macos-latest
            lane: macos-clang
            libargs: >
              -DBUILD_SHARED_LIBS=ON
            testargs: ""

          - runs-on: ubuntu-latest
            lane: ubuntu-intel
            libargs: >
              -DCMAKE_CXX_COMPILER=icpx
              -DCMAKE_CXX_FLAGS="--gcc-toolchain=${CONDA_PREFIX} --sysroot=${CONDA_PREFIX}/${HOST}/sysroot -target ${HOST}"
            testargs: >
              -DCMAKE_CXX_COMPILER=icpx
              -DCMAKE_CXX_FLAGS="--gcc-toolchain=${CONDA_PREFIX} --sysroot=${CONDA_PREFIX}/${HOST}/sysroot -target ${HOST}"

    name: "Export • ${{ matrix.cfg.lane }}"
    runs-on: ${{ matrix.cfg.runs-on }}

    steps:
    # Note we're not checking out the repo. All src from Linux tarball generated above.

    - name: Write a Conda Env File
      shell: bash -l {0}
      run: |
        cat > export.yaml <<EOF
        name: test
        channels:
          - conda-forge
        dependencies:
          - cmake
          - ninja
          - cxx-compiler
          - python
          - boost
          - eigen
          - numpy
          - scipy
          - pybind11
          #- dpcpp_linux-64
        EOF
        if [[ "${{ runner.os }}" == "Windows" ]]; then
          sed -i "s/- cxx/#- cxx/g" export.yaml
        fi
        if [[ "${{ matrix.cfg.lane }}" == "ubuntu-intel" ]]; then
          sed -i "s/#- dpcpp_linux-64/- dpcpp_linux-64/g" export.yaml
        fi
        cat export.yaml

    - name: Create Conda Environment
      uses: conda-incubator/setup-miniconda@v2
      with:
        miniforge-variant: Mambaforge
        use-mamba: true
        python-version: "3.9"
        activate-environment: test
        channels: conda-forge
        environment-file: export.yaml
        show-channel-urls: true

    - name: Environment Information
      shell: bash -l {0}
      run: |
        conda info
        conda list

    - name: Prepare compiler environment for Windows
      if: ${{ runner.os == 'Windows' }}
      uses: ilammy/msvc-dev-cmd@v1
      with:
        arch: x64

    - uses: actions/download-artifact@v3
      with:
        name: Linux-g++-10

    - name: Extract, Build, Install Libint Library
      shell: bash -l {0}
      run: |
        tar -zxf libint*tgz
        mkdir libint && mv libint-2*/* libint/ && cd libint/
        cmake \
          -S. \
          -Bbuild \
          -GNinja \
          -DCMAKE_INSTALL_PREFIX="${{github.workspace}}/installed" \
          -DCMAKE_CXX_COMPILER=${CXX} \
          -DLIBINT2_PYTHON=ON \
          -DCMAKE_PREFIX_PATH="${CONDA_PREFIX}" \
          ${{ matrix.cfg.libargs }}
        cmake --build build --target install libint2-python-test

    - name: Test Libint library - unit tests
      shell: bash -l {0}
      working-directory: ${{github.workspace}}/libint/build
      run: |
        cmake --build . --target check

    - name: Test Libint library - consume installation for SCF
      shell: bash -l {0}
      run: |
        mkdir test_installed_library && cd test_installed_library
        cat > CMakeLists.txt <<EOF
        cmake_minimum_required(VERSION 3.8)
        project(hf++)
        find_package(Libint2 2.8.0 REQUIRED)
        get_target_property(_l2_maxam Libint2::int2 Libint2_MAX_AM_ERI)
        message("Libint2_MAX_AM_ERI \${_l2_maxam}")
        find_package(Threads)  # clang does not autolink threads even though we are using std::thread
        add_executable(hf++ EXCLUDE_FROM_ALL "../libint/tests/hartree-fock/hartree-fock++.cc")
        target_link_libraries(hf++ Libint2::cxx Threads::Threads)
        EOF
        cmake -S . -B build -DCMAKE_PREFIX_PATH="${{github.workspace}}/installed" ${{ matrix.cfg.testargs }}
        cmake --build build --target hf++
        ./build/hf++ ../libint/tests/hartree-fock/h2o_rotated.xyz | python ../libint/tests/hartree-fock/hartree-fock++-validate.py ../libint/MakeVars.features

    - name: Build & Test Python bindings (again, independently)
      shell: bash -l {0}
      working-directory: ${{github.workspace}}/libint/python
      run: |
        cmake . -D CMAKE_PREFIX_PATH="${{github.workspace}}/installed" ${{ matrix.cfg.testargs }}
        cmake --build . --target libint2-python
        cmake --build . --target libint2-python-test