main.yml

name: Linux-Build
on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
    types: [opened, synchronize, reopened, ready_for_review]

env:
  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
  BUILD_TYPE: Release
  BUILD_FLAG: "\"-fprofile-arcs -ftest-coverage\""
  ACCOUNT: chengcli

jobs:
  style-checker:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    steps:
      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
      - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by ${{runner.name}}"
      - run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
      - run: echo "🖥️ The workspace, ${{ github.workspace }}, is now ready to test your code on the runner."

      - name: Install cpplint
        run: sudo pip install cpplint

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: Run cpplint
        run: ./tools/check_style.sh

  build-non-hydrostatic:
    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
    # You can convert this to a matrix build if you need cross-platform coverage.
    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: style-checker

    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y lcov libeigen3-dev

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS=${{ env.BUILD_FLAG }} -DCMAKE_C_FLAGS=${{ env.BUILD_FLAG }}

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config Debug -- -j2

      - name: Test
        working-directory: ${{github.workspace}}/build/tests
        # Execute tests defined by the CMake configuration.
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: ctest -C ${{env.BUILD_TYPE}}

      - name: Generate coverage report
        working-directory: ${{github.workspace}}/build/tests
        run: |
          lcov --capture --directory . --output-file coverage.info
          lcov --remove coverage.info '/usr/*' --output-file coverage.info  # filter out system files
          lcov --remove coverage.info '*/_deps/*' --output-file coverage.info  # filter out dependent library files
          lcov --list coverage.info

      - uses: codecov/codecov-action@v3
        env:
          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
        with:
          files: ${{github.workspace}}/build/tests/coverage.info
          fail_ci_if_error: true
          functionalities: fix

  build-hydrostatic:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: style-checker
    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y lcov libeigen3-dev

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: install python modules
        run: sudo pip install -r requirements.txt

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS=${{ env.BUILD_FLAG }} -DCMAKE_C_FLAGS=${{ env.BUILD_FLAG }} -DHYDROSTATIC=ON

      - name: build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j2

      - name: Test
        working-directory: ${{github.workspace}}/build/tests
        # Execute tests defined by the CMake configuration.
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: ctest -C ${{env.BUILD_TYPE}}

      - name: Generate coverage report
        working-directory: ${{github.workspace}}/build/tests
        run: |
          lcov --capture --directory . --output-file coverage.info
          lcov --remove coverage.info '/usr/*' --output-file coverage.info  # filter out system files
          lcov --remove coverage.info '*/_deps/*' --output-file coverage.info  # filter out dependent library files
          lcov --list coverage.info

      - uses: codecov/codecov-action@v3
        env:
          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
        with:
          files: ${{github.workspace}}/build/tests/coverage.info
          fail_ci_if_error: true
          functionalities: fix

  build-vapor2-cloud4:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: style-checker

    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y lcov libeigen3-dev

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Debug -DNVAPOR=2 -DNCLOUD=4
          -DCMAKE_CXX_FLAGS=${{ env.BUILD_FLAG }} -DCMAKE_C_FLAGS=${{ env.BUILD_FLAG }}

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j2

      - name: Test
        working-directory: ${{github.workspace}}/build/tests
        # Execute tests defined by the CMake configuration.
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: ctest -C ${{env.BUILD_TYPE}}

      - name: Generate coverage report
        working-directory: ${{github.workspace}}/build/tests
        run: |
          lcov --capture --directory . --output-file coverage.info
          lcov --remove coverage.info '/usr/*' --output-file coverage.info  # filter out system files
          lcov --remove coverage.info '*/_deps/*' --output-file coverage.info  # filter out dependent library files
          lcov --list coverage.info

      - uses: codecov/codecov-action@v3
        env:
          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
        with:
          files: ${{github.workspace}}/build/tests/coverage.info
          fail_ci_if_error: true
          functionalities: fix

  build-vapor2-cloud5:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: style-checker

    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y lcov libeigen3-dev

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Debug -DNVAPOR=2 -DNCLOUD=5
          -DCMAKE_CXX_FLAGS=${{ env.BUILD_FLAG }} -DCMAKE_C_FLAGS=${{ env.BUILD_FLAG }}

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j2

      - name: Test
        working-directory: ${{github.workspace}}/build/tests
        # Execute tests defined by the CMake configuration.
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: ctest -C ${{env.BUILD_TYPE}}

      - name: Generate coverage report
        working-directory: ${{github.workspace}}/build/tests
        run: |
          lcov --capture --directory . --output-file coverage.info
          lcov --remove coverage.info '/usr/*' --output-file coverage.info  # filter out system files
          lcov --remove coverage.info '*/_deps/*' --output-file coverage.info  # filter out dependent library files
          lcov --list coverage.info

      - uses: codecov/codecov-action@v3
        env:
          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
        with:
          files: ${{github.workspace}}/build/tests/coverage.info
          fail_ci_if_error: true
          functionalities: fix

  build-vapor1-cloud1-legacy:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: style-checker

    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y lcov libeigen3-dev

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Debug -DNVAPOR=1 -DNCLOUD=1 -DNPHASE_LEGACY=2
          -DCMAKE_CXX_FLAGS=${{ env.BUILD_FLAG }} -DCMAKE_C_FLAGS=${{ env.BUILD_FLAG }}

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j2

      - name: Test
        working-directory: ${{github.workspace}}/build/tests
        # Execute tests defined by the CMake configuration.
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: ctest -C ${{env.BUILD_TYPE}}

      - name: Generate coverage report
        working-directory: ${{github.workspace}}/build/tests
        run: |
          lcov --capture --directory . --output-file coverage.info
          lcov --remove coverage.info '/usr/*' --output-file coverage.info  # filter out system files
          lcov --remove coverage.info '*/_deps/*' --output-file coverage.info  # filter out dependent library files
          lcov --list coverage.info

      - uses: codecov/codecov-action@v3
        env:
          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
        with:
          files: ${{github.workspace}}/build/tests/coverage.info
          fail_ci_if_error: true
          functionalities: fix

  generate-ktable-with-netcdf:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: style-checker
    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y libnetcdf-dev libeigen3-dev

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: install python modules
        run: sudo pip install -r requirements.txt

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -DTASK=ktable_test -DACCOUNT=${{env.ACCOUNT}} -DTOKEN=${{secrets.ACCESS_TOKEN}} -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -B ${{github.workspace}}/build-netcdf

      - name: build
        # Build your program with the given configuration
        run: |
          cmake --build ${{github.workspace}}/build-netcdf --config ${{env.BUILD_TYPE}} -- -j2

      - name: test generating ktable
        working-directory: ${{github.workspace}}/build-netcdf
        # Execute tests defined by the CMake configuration.
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: |
          cp ./bin/example_giants_ir.yaml .
          python ./bin/run_ktable.py -i ./bin/example_giants_ir.inp

      - name: test jupiter heating/cooling
        working-directory: ${{github.workspace}}/build-netcdf
        run: echo "Cheers!"

  straka-2d:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: build-non-hydrostatic
    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y lcov libnetcdf-dev libeigen3-dev nco

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: check if artifact exists
        run: echo "ARTIFACT_EXISTS=$(./tools/check_artifact.sh robert_output.nc)" >> $GITHUB_ENV

      - uses: actions/download-artifact@v3
        if: env.ARTIFACT_EXISTS == 'true'
        with:
          name: straka_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/

      - name: fetch the needed lfs file if the artifact does not exist
        if: env.ARTIFACT_EXISTS == 'false'
        run: git lfs pull -I examples/2019-Li-snap/straka_output.nc

      - name: set up python libraries
        run: pip3 install -r requirements.txt

      - name: create build directory
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTASK=straka

      - name: Build
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j4

      - name: run simulation
        working-directory: ${{github.workspace}}/build/bin
        run: ./straka.release -i straka.inp

      - name: combile outputs
        working-directory: ${{github.workspace}}/build/bin
        run: ./combine.py -o test

      - name: compare result
        run: >
          python3 ${{github.workspace}}/examples/2019-Li-snap/test_straka.py
          ${{github.workspace}}/build/bin/straka-test-main.nc
          ${{github.workspace}}/examples/2019-Li-snap/straka_output.nc

      - uses: actions/upload-artifact@v3
        if: env.ARTIFACT_EXISTS == 'false'
        with:
          name: straka_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/straka_output.nc

  robert-2d:
    if: github.event.pull_request.draft == false
    runs-on: [self-hosted, Linux, 8core]
    needs: build-non-hydrostatic
    steps:
      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: check if artifact exists
        run: echo "ARTIFACT_EXISTS=$(./tools/check_artifact.sh robert_output.nc)" >> $GITHUB_ENV

      - uses: actions/download-artifact@v3
        if: env.ARTIFACT_EXISTS == 'true'
        with:
          name: robert_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/

      - name: fetch the needed lfs file
        if: env.ARTIFACT_EXISTS == 'false'
        run: git lfs pull -I examples/2019-Li-snap/robert_output.nc

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTASK=robert

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j8

      - name: run simulation
        env:
          PATH: $PATH:/usr/lib64/mpich/bin
        working-directory: ${{github.workspace}}/build/bin
        run: mpiexec -n 8 ./robert.release -i robert2d.inp

      - name: combile outputs
        working-directory: ${{github.workspace}}/build/bin
        run: ./combine.py -o test

      - name: compare result
        run: >
          python3 ${{github.workspace}}/examples/2019-Li-snap/test_robert.py
          ${{github.workspace}}/build/bin/robert-test-main.nc
          ${{github.workspace}}/examples/2019-Li-snap/robert_output.nc

      - uses: actions/upload-artifact@v3
        if: env.ARTIFACT_EXISTS == 'false'
        with:
          name: robert_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/robert_output.nc

  robert-3d:
    if: github.event.pull_request.draft == false
    runs-on: [self-hosted, Linux, 16core]
    needs: build-non-hydrostatic
    steps:
      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: check if artifact exists
        run: echo "ARTIFACT_EXISTS=$(./tools/check_artifact.sh robert3d_output.nc)" >> $GITHUB_ENV

      - uses: actions/download-artifact@v3
        if: env.ARTIFACT_EXISTS == 'true'
        with:
          name: robert3d_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/

      - name: fetch the needed lfs file
        if: env.ARTIFACT_EXISTS == 'false'
        run: git lfs pull -I examples/2019-Li-snap/robert3d_output.nc

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTASK=robert3d

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j8

      - name: run simulation
        env:
          PATH: $PATH:/usr/lib64/mpich/bin
        working-directory: ${{github.workspace}}/build/bin
        run: mpiexec -n 8 ./robert.release -i robert3d.inp

      - name: combile outputs
        working-directory: ${{github.workspace}}/build/bin
        run: ./combine.py -o test

      - name: compare result
        run: >
          python3 ${{github.workspace}}/examples/2019-Li-snap/test_robert.py
          ${{github.workspace}}/build/bin/robert-test-main.nc
          ${{github.workspace}}/examples/2019-Li-snap/robert3d_output.nc

      - uses: actions/upload-artifact@v3
        if: env.ARTIFACT_EXISTS == 'false'
        with:
          name: robert3d_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/robert3d_output.nc

  bryan-2d:
    if: github.event.pull_request.draft == false
    runs-on: [self-hosted, Linux, 4core]
    needs: [straka-2d]
    steps:
      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: check if artifact exists
        run: echo "ARTIFACT_EXISTS=$(./tools/check_artifact.sh bryan_output.nc)" >> $GITHUB_ENV

      - uses: actions/download-artifact@v3
        if: env.ARTIFACT_EXISTS == 'true'
        with:
          name: bryan_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/

      - name: fetch the needed lfs file
        if: env.ARTIFACT_EXISTS == 'false'
        run: git lfs pull -I examples/2019-Li-snap/bryan_output.nc

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTASK=bryan

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j4

      - name: run simulation
        working-directory: ${{github.workspace}}/build/bin
        run: mpiexec -n 4 ./bryan.release -i bryan.inp

      - name: combile outputs
        working-directory: ${{github.workspace}}/build/bin
        run: ./combine.py -o test

      - name: compare result
        run: >
          ${{github.workspace}}/examples/2019-Li-snap/test_bryan.py
          ${{github.workspace}}/build/bin/bryan-test-main.nc
          ${{github.workspace}}/examples/2019-Li-snap/bryan_output.nc

      - uses: actions/upload-artifact@v3
        if: env.ARTIFACT_EXISTS == 'false'
        with:
          name: bryan_output.nc
          path: ${{github.workspace}}/examples/2019-Li-snap/bryan_output.nc

  shallow-xy:
    if: github.event.pull_request.draft == false
    runs-on: [self-hosted, Linux, 4core]
    needs: build-non-hydrostatic
    steps:
      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: check if artifact exists
        run: echo "ARTIFACT_EXISTS=$(./tools/check_artifact.sh swxy_output.nc)" >> $GITHUB_ENV

      - uses: actions/download-artifact@v3
        if: env.ARTIFACT_EXISTS == 'true'
        with:
          name: swxy_output.nc
          path: ${{github.workspace}}/examples/2020-Li-polar-vortex/

      - name: fetch the needed lfs file
        if: env.ARTIFACT_EXISTS == 'false'
        run: git lfs pull -I examples/2020-Li-polar-vortex/swxy_output.nc

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DEOS=shallow_xy -DNETCDF=ON -DMPI=ON -DNUMBER_GHOST_CELLS=3

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j4

      - name: run simulation
        working-directory: ${{github.workspace}}/build/bin
        run: mpiexec -n 4 ./shallow_xy.release -i shallow_water.inp

      - name: combile outputs
        working-directory: ${{github.workspace}}/build/bin
        run: ./combine.py -o test

      - name: compare result
        run: >
          python3 ${{github.workspace}}/examples/2020-Li-polar-vortex/test_shallow_xy.py
          ${{github.workspace}}/build/bin/sw-test-main.nc
          ${{github.workspace}}/examples/2020-Li-polar-vortex/swxy_output.nc

      - uses: actions/upload-artifact@v3
        if: env.ARTIFACT_EXISTS == 'false'
        with:
          name: swxy_output.nc
          path: ${{github.workspace}}/examples/2020-Li-polar-vortex/swxy_output.nc

  polar-vortex:
    if: github.event.pull_request.draft == false
    runs-on: [self-hosted, Linux, 16core]
    needs: build-non-hydrostatic
    steps:
      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: check if artifact exists
        run: echo "ARTIFACT_EXISTS=$(./tools/check_artifact.sh intruder_output.nc)" >> $GITHUB_ENV

      - uses: actions/download-artifact@v3
        if: env.ARTIFACT_EXISTS == 'true'
        with:
          name: intruder_output.nc
          path: ${{github.workspace}}/examples/2020-Li-polar-vortex/

      - name: fetch the needed lfs file
        if: env.ARTIFACT_EXISTS == 'false'
        run: git lfs pull -I examples/2020-Li-polar-vortex/intruder_output.nc

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTASK=vortex

      - name: Build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j8

      - name: run simulation
        env:
          PATH: $PATH:/usr/lib64/mpich/bin
        working-directory: ${{github.workspace}}/build/bin
        run: mpiexec -n 12 ./polar_vortex.release -i fig_g_intruder.inp

      - name: combile outputs
        working-directory: ${{github.workspace}}/build/bin
        run: ./combine.py -o test

      - name: compare result
        run: >
          python3 ${{github.workspace}}/examples/2020-Li-polar-vortex/test_polar_vortex.py
          ${{github.workspace}}/build/bin/intruder-test-main.nc
          ${{github.workspace}}/examples/2020-Li-polar-vortex/intruder_output.nc

      - uses: actions/upload-artifact@v3
        if: env.ARTIFACT_EXISTS == 'false'
        with:
          name: intruder_output.nc
          path: ${{github.workspace}}/examples/2020-Li-polar-vortex/intruder_output.nc

  juno-mwr:
    if: github.event.pull_request.draft == false
    runs-on: ubuntu-latest
    needs: build-hydrostatic
    steps:
      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y libnetcdf-dev libeigen3-dev libcfitsio-dev nco

      - uses: actions/checkout@v3
        with:
          lfs: false

      - name: install python modules
        run: sudo pip install -r requirements.txt

      - name: create build directory
        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTASK=juno

      - name: build
        # Build your program with the given configuration
        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -- -j2

      - name: run simulation
        working-directory: ${{github.workspace}}/build/bin
        run: ./juno_mwr.release -i juno_mwr.inp

      - name: combile outputs
        working-directory: ${{github.workspace}}/build/bin
        run: ./combine.py -o test

      - name: Test
        working-directory: ${{github.workspace}}/examples/2023-jupiter-mwr-eq
        run: echo "cheers"