[BUG] Axis-symmetric simulation not supported on Darwin

[waltsims]

Describe the bug
When running the example examples/at_focused_bowl_AS/at_focused_bowl_AS.py, Users are presented with the following binary error message:

┌───────────────────────────────────────────────────────────────┐
│                   kspaceFirstOrder-OMP v1.3                   │
├───────────────────────────────────────────────────────────────┤
│ Reading simulation configuration:                        Done │
│ File format version:                                      1.2 │
│ Number of CPU threads:                                     10 │
│ Processor name:                                               │
├───────────────────────────────────────────────────────────────┤
│                      Simulation details                       │
├───────────────────────────────────────────────────────────────┤
│ Domain dimensions:                                  144 x 109 │
│ Medium type:                                               AS │
│ Simulation time steps:                                   2400 │
├───────────────────────────────────────────────────────────────┤
│ Input file:  /var/folders/_t/rb3njlf11tgf4_0f57j62dk80000gq/  │
│              T/18-Sep-2024-14-09-02_kwave_input.h5            │
│ Input file:  /var/folders/_t/rb3njlf11tgf4_0f57j62dk80000gq/  │
│              T/18-Sep-2024-14-09-02_kwave_output.h5           │
├───────────────────────────────────────────────────────────────┤
│ Compression level:                                          0 │
│ Print progress interval:                                   5% │
├───────────────────────────────────────────────────────────────┤
│                        Medium details                         │
├───────────────────────────────────────────────────────────────┤
│ Wave propagation:                                      Linear │
│ Absorption type:                                     Lossless │
│ Medium parameters:                                Homogeneous │
├───────────────────────────────────────────────────────────────┤
│                        Source details                         │
├───────────────────────────────────────────────────────────────┤
│ Pressure source:                                              │
│ + Source type:                                           Many │
│ + Source condition:                                  Additive │
│ + Memory usage:                                       19.47MB │
├───────────────────────────────────────────────────────────────┤
│                        Sensor details                         │
├───────────────────────────────────────────────────────────────┤
│ Sensor mask type:                                       Index │
│ Sampling begins at time step:                            2341 │
├───────────────────────────────────────────────────────────────┤
│ Pressure sensor p_raw                                         │
│ + File usage:                                          2.04MB │
├───────────────────────────────────────────────────────────────┤
│                        Initialization                         │
├───────────────────────────────────────────────────────────────┤
│ Memory allocation:                                       Done │
│ Data loading:                                                 │
│ + Reading input file:                                    Done │
│ + Creating output file:                                  Done │
│ Elapsed time:                                           0.02s │
├───────────────────────────────────────────────────────────────┤
│ FFT plans creation:                                    Failed │
└───────────────────────────────────────────────────────────────┘


Errors:
WARNING:root:Highest prime factors in each dimension are [  3 109]
WARNING:root:Use dimension sizes with lower prime factors to improve speed

libgomp: Affinity not supported on this configuration
┌───────────────────────────────────────────────────────────────┐
│            !!! K-Wave experienced a fatal error !!!           │
├───────────────────────────────────────────────────────────────┤
│ Error: Cannot create plan 1D real-to-real FFT of kind 5 in y  │
│        direction.                                             │
├───────────────────────────────────────────────────────────────┤
│                      Execution terminated                     │
└───────────────────────────────────────────────────────────────┘

Expected behavior
This example should run without issue.

Desktop (please complete the following information):

• OS: MacOS
• Version v0.3.4

[tjjlemaire]

Hi,

Thanks so much for your work adapting k-wave in python.

I ran into the same issue as above while trying to run the at_circular_piston_AS.ipynb example. Here's my configuration:

• OS: MacOS 15.5 (Apple M1 chip)
• Python version: 3.10.18 (installed via Anaconda)
• package version: 0.4.0

Do you have any idea if this can be circumvented?

Thanks very much in advance!

[waltsims]

Hi @tjjlemaire, not at the moment. We are missing this feature for the time being. You could always try running the example in a Google colab instance for now.

Hope this helps,

Walter

[elma16]

Hi @waltsims, I was wondering if this bug also relates to the inclusion of absorption in k-Wave when using a mac or similar. In particular, I have this minimal failing example.

from copy import deepcopy

import matplotlib.pyplot as plt
import numpy as np
from kwave.data import Vector
from kwave.kgrid import kWaveGrid
from kwave.kmedium import kWaveMedium
from kwave.ksensor import kSensor
from kwave.ksource import kSource
from kwave.kspaceFirstOrder2D import kspaceFirstOrder2D
from kwave.options.simulation_execution_options import SimulationExecutionOptions
from kwave.options.simulation_options import SimulationOptions
from kwave.utils.filters import smooth
from kwave.utils.mapgen import make_disc

PML_size = 0  # size of the PML in grid points
N = Vector([128, 256]) - 2 * PML_size  # number of grid points
d = Vector([0.1e-3, 0.1e-3])  # grid point spacing [m]
kgrid = kWaveGrid(N, d)

medium_lossless = kWaveMedium(sound_speed=1540, density=1000)
medium_absorbing = kWaveMedium(
    sound_speed=1540, density=1000, alpha_coeff=10.75, alpha_power=1.5
)

# create initial pressure distribution using makeDisc
disc_magnitude = 5  # [Pa]
disc_pos = Vector([60, 140])  # [grid points]
disc_radius = 5  # [grid points]
disc_2 = disc_magnitude * make_disc(N, disc_pos, disc_radius)

disc_pos = Vector([30, 110])  # [grid points]
disc_radius = 8  # [grid points]
disc_1 = disc_magnitude * make_disc(N, disc_pos, disc_radius)

# smooth the initial pressure distribution and restore the magnitude
p0 = smooth(disc_1 + disc_2, restore_max=True)

# assign to the source structure
source = kSource()
source.p0 = p0

sensor = kSensor()
sensor.mask = np.zeros(N)
sensor.mask[0] = 1

kgrid.makeTime(medium_lossless.sound_speed)

simulation_options = SimulationOptions(
    pml_inside=False,
    pml_size=PML_size,
    smooth_p0=False,
    save_to_disk=True,
    data_cast="single",
)
execution_options = SimulationExecutionOptions(
    is_gpu_simulation=False, verbose_level=2, show_sim_log=True
)

print("Computing Lossless")
sensor_data_lossless = kspaceFirstOrder2D(
    kgrid,
    source,
    deepcopy(sensor),
    medium_lossless,
    simulation_options,
    execution_options,
)["p"]

print("Computing Absorbing")
sensor_data_absorbing = kspaceFirstOrder2D(
    kgrid,
    source,
    deepcopy(sensor),
    medium_absorbing,
    simulation_options,
    execution_options,
)["p"]

assert not np.isclose(sensor_data_lossless, sensor_data_absorbing).all()

This does not pass the assert statement, as the two arrays are identical. On a linux machine, this is not a problem.

[waltsims]

Tracked by #612 (Update Makefile for Darwin), which targets the axisymmetric build on macOS. Will close when that PR merges.