Scientific Computing

Environment variables that start with DYLD_ are restricted by macOS, and are not passed to child processes by default for security reasons. A workaround for this is to use a dummy environment variable that does not start with DYLD_, and then use a wrapper script to read that variable and set the DYLD_LIBRARY_PATH environment variable accordingly. This is necessary because DYLD_LIBRARY_PATH is read at program startup, and setting it within a program will not have any effect on the dynamic linker used by that program. The wrapper script can be used to set the DYLD_LIBRARY_PATH environment variable before executing the desired program, allowing it to find the necessary libraries without being blocked by macOS security restrictions.

There are several ways to reboot a computer from the terminal. For Linux or macOS the “reboot” command (or shutdown -r) is commonly used. For Windows, the PowerShell command Restart-Computer is a standard way to reboot the system from Terminal.

Within Windows Subsystem for Linux (WSL), the “reboot” command is only for the particular WSL instance and actually results in a shutdown of the WSL instance, not the entire Windows system. One can verify this by before and after the standard 8 second WSL shutdown time, running in Windows Terminal:

wsl.exe --list --running

The Anytone AT-5000 radio has three modes: Ham, HF, and CB. 99 memories are available in each of Ham mode and HF mode. 16 memories are available in CB mode (even after moving the jumper that enables Ham and HF modes). MEM channels are not shared between frequency modes, so there are 99 Ham and 99 HF channels and 16 CB MEM channels.

Anytone AT-5000 quirks:

• “Dual watch” does not work in VFO mode, even from MEM channels. VFO is only available in Ham or HF profiles, and is how one would normally use the radio in HF or Ham mode.
• If a MEM channel is deleted from the scan list, it’s still scanned when scanning MEM channels. This seems like a firmware bug, present in a radio with LCD version 1.00, RF version 1.00, and radio data version 1.00. The “workaround” is to delete the channel from MEM, which is not so desirable but the only way we know how at this time.

CPS programming

Anytone (Qixiang Electronics) provides a programming cable for the Anytone AT-5000 radio, which connects via the 8P8C modular microphone jack to USB. This is a USB to serial adapter. If the comm port does not appear in the AT-5000 CPS software or in Device Manager under “Ports (COM & LPT)” as “USB-SERIAL CH340 (COMx)”, check Windows Device Manager under “Other devices” for “USB Serial” with a yellow warning icon.

The driver necessary is the GD USB Virtual Comm Port driver, which can be downloaded as part of the Anytone D878 programming software package if not seen as part of the Anytone AT-5000 CPS install package. Don’t install the D878 CPS software, just extract the Zip archive folder titled like “Virtual GD USB Com Drivers (Only If Needed)” and extract the “GD_VirtualComDriver v2.0.2.4944.rar” file to get the driver installer under the “x64” folder. After installing the driver, unplug and replug the programming cable. If it’s still showing a yellow warning icon, right-click on the “USB Serial” entry, select “Update driver”, and choose to browse for drivers on the computer by “let me pick from a list of available drivers on my computer”. Under USB Devices look for “USB-SERIAL CH340” and select it to install the driver. It might be necessary to unplug and replug the programming cable again after installing the driver for it to be recognized properly. There should no longer be a yellow warning icon, and the comm port should appear in the AT-5000 CPS software as “USB-SERIAL CH340 (COMx)” under the “Port” dropdown menu.

Workaround for CPS bugs

These bugs were present in the first release of the AT-5000 CPS software.

• Can’t add or edit memory channels: set the band and working band near the top of the Channel editing window to MEM. Each time a channel is edited, this may need to be done again
• Can’t delete memory channels: channels appear to be deleted, but appear again upon programming the radio. Simply delete them from the radio front panel instead

For CMake, the export of compile commands comes by setting the CMAKE_EXPORT_COMPILE_COMMANDS variable to ON. This generates <build_dir>/compile_commands.json file that contains the compile commands for each source file. However, this does not include the link commands used to link the final executable or library. To show the link commands in Ninja for a specific target, use:

ninja -t compdb-targets mytarg

This command has to be issued directly to Ninja, not using “cmake –build”.

Matlab preferences are stored in <prefdir>/matlab.mlsettings since Matlab R2020a. To reset Matlab preferences, one can rename / move this file–keep it for a backup. The location of <prefdir> can be found by running the following command in Matlab:

prefdir

After moving the matlab.mlsettings file, restart Matlab. Matlab will create a new matlab.mlsettings file with default preferences.

This is particularly helpful if Python is setup with a “bad” distribution that crashes Matlab upon Python py. commands in Matlab, and there isn’t another Python distribution available to switch to in Matlab’s preferences.

The matlab.mlsettings file is a ZIP file of XML and JSON files and folders.

These one-line Unix-like shell commands help find the directories consuming the most hard drive space. This command lists the top 10 largest directories in the specified path. This is useful to HPC where disk quota as seen by quota -s or similar indicates it’s time to clean up some files.

du -hd1 /path/to/check 2>/dev/null | sort -rh | head

While disk size quota is often the main concern, there is often also a quota on the number of files (inodes) that can be owned by a user. To find the directories with the most files, use this command:

find /path/to/check -type f -printf '%h\n' 2>/dev/null | sort | uniq -c | sort -rn | head

Graphical terminal disk usage program “ncdu” is a widely-available Ncurses based program showing the largest files. NCDU is more user-friendly than the plain text method above. NCDU allows deleting files interactively. When using on WSL, specify the desired drive like (for C: in this example):

ncdu /mnt/c

When using CMake’s add_custom_command and add_custom_target on Windows, if the CMAKE_EXECUTABLE_SUFFIX (which is typically .exe) is not included as part of the command or target, it can lead to the custom target is rebuilt every time the project is rebuilt, even if the command is up to date. This happens because CMake does not exactly match the output file of the custom command, since the .exe suffix was missing on Windows, and therefore CMake does not properly track the existence of a target’s dependencies. As a result, CMake assumes that the target is always out of date and needs to be rebuilt. To avoid this issue, ensure that the output of your custom command includes the CMAKE_EXECUTABLE_SUFFIX. For example, if generating an executable with add_custom_command, specify the output file with the correct suffix:

set(myexe ${CMAKE_CURRENT_BINARY_DIR}/my_executable${CMAKE_EXECUTABLE_SUFFIX})

add_custom_command(
    OUTPUT ${myexe}
    COMMAND ...
)

add_custom_target(MyTarget ALL
    DEPENDS ${myexe}
)

By including the CMAKE_EXECUTABLE_SUFFIX in both the OUTPUT and DEPENDS sections, CMake will correctly recognize the target as an executable and will only rebuild it when necessary, thus avoiding unnecessary rebuilds.

Check the desired website’s SSL certificate with a service like Qualys SSL Labs to see if the certificate is valid and properly configured. If the certificate is valid but you still encounter SSL errors, it’s possible that the public WiFi network is interfering with the SSL connection. Also try using command line web programs to see if there are any SSL errors or warnings in the output. Examples:

curl -v https://www.scivision.dev

python -c "import requests; print(requests.get('https://www.scivision.dev').status_code)"

If these fail, try without SSL

curl -v http://www.neverssl.com

python -c "import requests; print(requests.get('http://www.neverssl.com').status_code)"

An example of the curl output when even HTTP connections are interfered with:

curl -v http://neverssl.com
* Host neverssl.com:80 was resolved.
* IPv6: (none)
* IPv4: x.x.x.x
*   Trying x.x.x.x:80...
* connect to x.x.x.x port 80 from 0.0.0.0 port 58197 failed: Timed out
* Failed to connect to neverssl.com port 80 after 21104 ms: Could not connect to server
* closing connection #0
curl: (28) Failed to connect to neverssl.com port 80 after 21104 ms: Could not connect to server

Docker images are useful for reproducibility and ease of setup and for software binary distribution on platforms not natively available on GitHub Actions runner images. While one can setup a custom Docker image, it’s often possible to simply use an existing official image from Docker Hub.

Example: Ubuntu 20.04

This example GitHub Actions workflow uses the Ubuntu 20.04 image to build a C++ binary with the GNU C++ compiler. For APT operations, the “-y” option is necessary. Environment variable DEBIAN_FRONTEND is set to “noninteractive” to avoid interactive prompts for certain operations despite “-y”. Don’t use “sudo” as the container user is root and the “sudo” package is not installed.

A special feature of this example is using Kitware’s CMake APT repo to install the latest version of CMake on an EOL Ubuntu distro.

name: ubuntu-20.04

on: [push]

# avoid wasted runs
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  ubuntu-20.04:
    runs-on: ubuntu-latest
    container:
      image: ubuntu:20.04
      env:
        DEBIAN_FRONTEND: noninteractive

    strategy:
      fail-fast: false
      matrix:
        gcc-version: [7, 8]

    env:
      CC: gcc-${{ matrix.gcc-version }}
      CXX: g++-${{ matrix.gcc-version }}
      FC: gfortran-${{ matrix.gcc-version }}

    steps:

    - name: install compilers
      run: |
        apt update -y
        apt install -y --no-install-recommends ca-certificates gpg curl ninja-build ${{ env.CC }} ${{ env.CXX }} ${{ env.FC }}

    - name: install CMake
      run: |
        curl -s https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
        echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ focal main' | tee /etc/apt/sources.list.d/kitware.list >/dev/null
        apt-get update
        test -f /usr/share/doc/kitware-archive-keyring/copyright || rm /usr/share/keyrings/kitware-archive-keyring.gpg
        apt-get install --no-install-recommends -y kitware-archive-keyring
        apt-get install --no-install-recommends -y cmake

    - uses: actions/checkout

    - name: CMake configure
      run: cmake -B build

    - name: CMake build
      run: cmake --build build

    - name: CMake test
      run: ctest --test-dir build

Example: Alpine Linux

This example GitHub Actions workflow uses the Alpine Linux image with the MUSL C library to build a statically-linked binary.

name: alpine-musl

on: [push]

jobs:
  musl:
    runs-on: ubuntu-latest
    container:
      image: alpine

    steps:
    - uses: actions/checkout

    - name: install build tools
      run: apk add --no-cache ninja-build cmake make gfortran openmpi-dev

    - name: print MUSL version
      continue-on-error: true
      run: ldd --version

    - name: CMake configure
      run: cmake -B build

    - name: CMake build
      run: cmake --build build

# Good idea to ensure self-tests pass before packaging
    - name: CMake test
      run: ctest --test-dir build

(Optional) If a CPack archive is desired add step:

    - name: CMake package
      if: success()
      run: cpack --config build/CPackConfig.cmake

The binary artifact or CPack archive can be uploaded by step upload-artifact:

    - name: .exe for release
      uses: actions/upload-artifact@v7
      archive: false
      if: success()
      with:
        name: my.exe
        path: build/my.exe

When CMake fails on the configure or generate steps in a CI workflow, having CMakeConfigureLog.yaml uploaded a as a file can help debug the issue. Add this step to the GitHub Actions workflow YAML file:

  - name: Configure CMake
    run: cmake -B build

# other steps ...

  - name: upload CMakeConfigureLog.yaml
    if: failure() && hashFiles('build/CMakeFiles/CMakeConfigureLog.yaml') != ''
    uses: actions/upload-artifact@v7
    archive: false
    with:
      name: ${{ runner.os }}-${{ env.CC }}-CMakeConfigureLog.yaml
      path: build/CMakeFiles/CMakeConfigureLog.yaml
      retention-days: 5

The “retention-days” parameter is optional. Ensure the “name” parameter is unique to avoid conflicts with other jobs in the workflow. Here we assume that the OS and C compiler are unique between jobs.