k-Wave

http://www.k-wave.org/documentation/
Admin
k-Wave is a MATLAB toolbox for the time-domain simulation of acoustic, photoacoustic, and ultrasound...
Tokens:377,710
Snippets:1,464
Trust Score:3.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### k-Wave MATLAB Toolbox: Getting Started and Examples

This section provides introductory guides and practical examples for using the k-Wave MATLAB toolbox. It covers fundamental concepts and demonstrates various simulation capabilities.

```MATLAB
% This is a placeholder for actual MATLAB code examples.
% The k-Wave toolbox typically involves defining a k-space grid,
% setting up sources, sensors, and medium properties, and then running simulations.

% Example: Initializing a k-Wave grid
k = kWaveGrid([128, 128], [0.1, 0.1]);

% Example: Defining a homogeneous medium
medium.sound_speed = 1500;
medium.density = 1000;
medium.alpha_coeff = 0.1;

% Example: Defining a source
source.p_mask = zeros(k.Nx, k.Ny);
source.p_mask(25:35, 25:35) = 1;
source.p = gaussian(k.t_grid, 10e6, 50e3);

% Example: Defining a sensor
sensor.mask = zeros(k.Nx, k.Ny);
sensor.mask(100, :) = 1;

% Running the simulation
input_args = {'Data', true, 'Plot', true};
[output_args] = kspaceFirstOrder2D(k, medium, source, sensor, input_args{:});

```

--------------------------------

### C++ Simulation Output Example

This is an example of the status and computational information printed to the command line by the k-wave C++ simulation code during execution. It includes details about the simulation setup, resource usage, and progress.

```text
+---------------------------------------------------------------+ 
|                   kspaceFirstOrder-OMP v1.3                   | 
+---------------------------------------------------------------+ 
| Reading simulation configuration:                        Done | 
| Number of CPU threads:                                     16 | 
| Processor name:     Intel(R) Xeon(R) CPU E5-1660 v3 @ 3.00GHz | 
+---------------------------------------------------------------+ 
|                      Simulation details                       | 
+---------------------------------------------------------------+ 
| Domain dimensions:                             256 x 128 x 64 | 
| Medium type:                                               3D | 
| Simulation time steps:                                   1200 | 
+---------------------------------------------------------------+ 
|                        Initialization                         | 
+---------------------------------------------------------------+ 
| Memory allocation:                                       Done | 
| Data loading:                                            Done | 
| Elapsed time:                                           0.04s | 
+---------------------------------------------------------------+ 
| FFT plans creation:                                      Done | 
| Pre-processing phase:                                    Done | 
| Elapsed time:                                           0.02s | 
+---------------------------------------------------------------+ 
|                    Computational resources                    | 
+---------------------------------------------------------------+ 
| Current host memory in use:                             212MB | 

```

--------------------------------

### New Example: Automatic Sound Speed Selection

Version B.0.5 provides a new example showcasing automatic sound speed selection, simplifying simulation setup.

```MATLAB
// Example script for automatic sound speed selection
```

--------------------------------

### MATLAB: k-Wave Toolbox - Getting Started

This section provides introductory guidance for users new to the k-Wave MATLAB toolbox. It covers essential steps for setting up and running initial simulations of acoustic wave fields.

```MATLAB
% k-Wave Toolbox - Getting Started
% This section guides users through the initial steps of using the k-Wave toolbox.
% It typically involves setting up the environment, defining a computational grid,
% specifying medium properties, and defining sources and sensors.

% Example: Basic setup
% Define grid size and spacing
kgrid = kWaveGrid(grid_size, grid_spacing);

% Define medium properties (e.g., sound speed, density)
medium.sound_speed = 1500; % m/s
medium.density = 1000; % kg/m^3

% Define a source (e.g., a Gaussian pulse)
source.p_mask = zeros(grid_size);
source.p_mask(grid_size(1)/2, grid_size(2)/2) = 1;
source.p = gaussianPulse(dt, t_end, freq);

% Define sensor positions
sensor.mask = zeros(grid_size);
sensor.mask(grid_size(1)/2, :) = 1;

% Run the simulation
input_args = {'DataCast', 'single', 'SimMethod', 'FDTD', 'PlotSim', true};
[output_data, ~] = kspaceFirstOrder2D(kgrid, medium, source, sensor, input_args{:});

```

--------------------------------

### Simulate Heterogeneous Propagation Medium with k-Wave

This example demonstrates simulating wave propagation in a heterogeneous medium using k-Wave. It covers the setup for media with spatially varying properties.

```matlab
Example: Heterogeneous Propagation Medium
```

--------------------------------

### Simulate Equivalent Source Holography with k-Wave

This example illustrates simulating equivalent source holography using the k-Wave toolbox. It covers the setup for reconstructing acoustic sources from measured fields.

```matlab
Example: Equivalent Source Holography
```

--------------------------------

### Simulate Dipole Point Source in k-Wave

Provides a basic example of simulating a time-varying pressure dipole source in a 2D homogeneous medium using the k-Wave toolbox. This example builds upon the monopole source example and demonstrates the setup and execution of such a simulation.

```MATLAB
% Example MATLAB code for simulating a dipole point source
% This would involve defining the grid, medium properties, and the dipole source.
% For instance:
% k.set_source('dipole_pressure', source_data, 'times', time_vector);
```

--------------------------------

### Example: Running C++ Simulations

Provides guidance and examples on how to run k-wave simulations using the C++ implementation.

```C++
Example: Running C++ Simulations
```

--------------------------------

### New Example: Equivalent Source Holography

Added a new example demonstrating equivalent source holography.

```MATLAB
Equivalent Source Holography
```

--------------------------------

### k-Wave MATLAB Toolbox: Simulations in Three Dimensions Example

This example demonstrates how to perform k-Wave simulations in three spatial dimensions. It covers the setup for 3D wave propagation problems.

```MATLAB
%% Example: Simulations In Three Dimensions
% This example demonstrates performing k-Wave simulations in three spatial dimensions.

% Define grid size
kx = 64;
ky = 64;
kz = 64;

% Create the k-Wave grid
k = kWaveGrid(kx, ky, kz, 0.1);

% Define the medium properties
medium.sound_speed = 1500 * ones(kx, ky, kz);

% Define the source
source.p_mask = zeros(kx, ky, kz);
source.p_mask(kx/2, ky/2, kz/2) = 1;
source.p = gaussian(50, 10);

% Define the sensor
sensor.mask = zeros(kx, ky, kz);
sensor.mask(kx/2, ky/2, kz/2 + 10) = 1;

% Run the simulation
input_args = {
    'PMLInside', false,
    'Plot', true};

[output_args, settings] = kspaceFirstOrder3D(k, medium, source, sensor, input_args{:});

```

--------------------------------

### k-Wave MATLAB Toolbox: Simulations in One Dimension Example

This example demonstrates how to perform k-Wave simulations in one spatial dimension. It simplifies the setup for 1D wave propagation problems.

```MATLAB
%% Example: Simulations In One Dimension
% This example demonstrates performing k-Wave simulations in one spatial dimension.

% Define grid size
kx = 256;

% Create the k-Wave grid
k = kWaveGrid(kx, 0.1);

% Define the medium properties
medium.sound_speed = 1500 * ones(kx, 1);

% Define the source
source.p_mask = zeros(kx, 1);
source.p_mask(kx/2) = 1;
source.p = gaussian(50, 10);

% Define the sensor
sensor.mask = zeros(kx, 1);
sensor.mask(kx/2 + 50) = 1;

% Run the simulation
input_args = {
    'PMLInside', false,
    'Plot', true};

[output_args, settings] = kspaceFirstOrder1D(k, medium, source, sensor, input_args{:});

```

--------------------------------

### Run C++ Simulations with k-Wave

Demonstrates how to run k-Wave simulations using the C++ interface. This involves setting up input files and executing the simulation from the command line.

```bash
k-wave-sim --input-file input.h5 --output-file output.h5
```

--------------------------------

### Compare kspaceFirstOrder2D and kspaceSecondOrder

This example compares the simulation functions `kspaceFirstOrder2D` and `kspaceSecondOrder` for acoustic wave field simulations. It builds upon previous examples and provides a numerical comparison between the two modelling functions.

```MATLAB
%% Comparison Of Modelling Functions Example
% This example provides a short comparison between the simulation functions `kspaceFirstOrder2D` and `kspaceSecondOrder`.
% It builds on the Homogeneous Propagation Medium and Using A Binary Sensor Mask examples.

% For a more detailed discussion of the second order model used in k-Wave, see Treeby, B. E. and Cox, B. T., "A k-space Green's function solution for acoustic initial value problems in homogeneous media with power law absorption," _J. Acoust. Soc. Am._ , vol. 129, no. 6, pp. 3652-3660, 2011.

%% Contents
%   * About the modelling functions
%   * Running the simulation
%   * Numerical comparison
```

--------------------------------

### Example: Saving Input Files in Parts

Demonstrates techniques for saving input files in parts, potentially for managing large datasets.

```MATLAB
Example: Saving Input Files in Parts
```

--------------------------------

### Simulate Homogeneous Propagation Medium with k-Wave

This example demonstrates simulating acoustic wave propagation in a homogeneous medium using the k-Wave toolbox. It serves as a foundational example for understanding basic simulation setup.

```matlab
% Example: Homogeneous Propagation Medium

% Define grid size and properties
k.dim = [256, 256]; % Grid size
k.dx = 0.5e-3; % Grid spacing in meters
k.dy = 0.5e-3; % Grid spacing in meters

% Define medium properties (e.g., sound speed)
k.sound_speed = 1500; % Sound speed in m/s

% Define time steps
k.dt = 0.25 * k.dx / k.sound_speed; % Time step based on Courant number
k.t_end = 100e-6; % End time in seconds

% Define a source
k.source.p_initial = zeros(k.dim);
k.source.p_initial(k.dim(1)/2, k.dim(2)/2) = 1;

% Run the simulation
k.simulate(k);

% Display the results (e.g., pressure field at a specific time)
figure;
imagesc(k.sensor.recording);
title('Pressure field at end time');
xlabel('x position');
ylabel('y position');
```

--------------------------------

### PHP Example (Placeholder)

This is a placeholder for a PHP code example related to the k-Wave project. The actual functionality is not specified in the provided text.

```PHP
<.php>
```

--------------------------------

### k-Wave MATLAB Toolbox: Dipole Point Source Example

This example demonstrates simulating a dipole point source in a homogeneous propagation medium using the k-Wave MATLAB toolbox. It covers the setup for simulating sources with directional properties.

```MATLAB
%% Example: Dipole Point Source In A Homogeneous Propagation Medium
% This example demonstrates simulating a dipole point source.

% Define grid size
kx = 128;
ky = 128;

% Create the k-Wave grid
k = kWaveGrid(kx, ky, 0.1);

% Define the medium properties
medium.sound_speed = 1500 * ones(kx, ky);

% Define the dipole point source
source.p_mask = zeros(kx, ky);
source.p_mask(kx/2, ky/2) = 1;
source.p = kWaveGaussian(50, 10);
% For a dipole, you might need to define velocity or use a specific source type
% This example uses a Gaussian pulse as a placeholder.

% Define the sensor
sensor.mask = zeros(kx, ky);
sensor.mask(kx/2, ky/2 + 50) = 1;

% Run the simulation
input_args = {
    'PMLInside', false,
    'Plot', true};

[output_args, settings] = kspaceFirstOrder2D(k, medium, source, sensor, input_args{:});

```

--------------------------------

### PHP Example for K-Wave Simulation Extension

This is a placeholder for a PHP code example related to extending K-Wave simulations. Further details on specific PHP functionalities for this purpose would be needed.

```php
<.php>
// PHP code for extending K-Wave simulations would go here.
// This is a placeholder and requires specific implementation details.

```

--------------------------------

### k-Wave MATLAB Toolbox: Monopole Point Source Example

This example demonstrates simulating a monopole point source in a homogeneous propagation medium using the k-Wave MATLAB toolbox. It covers the basic setup for time-domain acoustic simulations.

```MATLAB
%% Example: Monopole Point Source In A Homogeneous Propagation Medium
% This example demonstrates simulating a monopole point source.

% Define grid size
kx = 128;
ky = 128;

% Create the k-Wave grid
k = kWaveGrid(kx, ky, 0.1);

% Define the medium properties
medium.sound_speed = 1500 * ones(kx, ky);

% Define the monopole point source
source.p_mask = zeros(kx, ky);
source.p_mask(kx/2, ky/2) = 1;
source.p = gaussian(50, 10);

% Define the sensor
sensor.mask = zeros(kx, ky);
sensor.mask(kx/2, ky/2 + 50) = 1;

% Run the simulation
input_args = {
    'PMLInside', false,
    'Plot', true};

[output_args, settings] = kspaceFirstOrder2D(k, medium, source, sensor, input_args{:});

```

--------------------------------

### Get Computer and k-Wave Version Information

Retrieves and returns detailed information about the computer system and the installed k-Wave toolbox version. Helpful for debugging and environment checks.

```Python
getComputerInfo()
```

--------------------------------

### Simulate Homogeneous Propagation Medium with k-Wave

This example demonstrates setting up and running a simulation in a homogeneous propagation medium using the k-Wave toolbox. It covers the basic parameters for homogeneous media.

```matlab
Example: Homogenous Propagation Medium
```

--------------------------------

### Setup and Run 3D Simulation (MATLAB)

Sets up and executes a 3D photoacoustic simulation. This includes creating a 3D computational grid, defining the initial pressure distribution as a sphere using `makeBall`, and specifying a single sensor point in 3D. The simulation is performed using `kspaceFirstOrder3D`.

```MATLAB
% create the computational grid
kgrid = kWaveGrid(Nx, dx, Nx, dx, Nx, dx);

% create initial pressure distribution
source.p0 = makeBall(Nx, Nx, Nx, Nx/2, Nx/2, Nx/2, source_radius);

% define a single sensor point
sensor.mask = zeros(Nx, Nx, Nx);
sensor.mask(Nx/2 - source_sensor_distance, Nx/2, Nx/2) = 1;

% run the simulation
sensor_data_3D = kspaceFirstOrder3D(kgrid, medium, source, sensor, input_args{:});
```

--------------------------------

### Simulate Diffraction Through Slit with k-Wave

This example demonstrates simulating wave diffraction through a slit using the k-Wave toolbox. It covers the setup for modeling wave interference patterns.

```matlab
Example: Diffraction Through A Slit
```

--------------------------------

### Simulate B-mode Ultrasound Images with k-Wave

This example shows how to simulate B-mode ultrasound images using the k-Wave toolbox. It covers the setup for generating cross-sectional ultrasound images.

```matlab
Example: Simulating B-mode Ultrasound Images
```

--------------------------------

### Model Absorption and Dispersion with kspaceSecondOrder

Illustrates the absorption and dispersion characteristics of the k-Wave model using `kspaceSecondOrder`. It compares numerical results with theoretical curves calculated using `powerLawKramersKronig` for various power absorption parameters.

```matlab
kspaceSecondOrder(k, medium, x, y, z, dt, t_end, input_signal, 'Plot', true, 'ExampleNumber', 1);
```

--------------------------------

### Run C++ Simulations with k-Wave

This example demonstrates how to execute k-Wave simulations using the C++ versions of the kspaceFirstOrder3D functions. It requires downloading the C++ code from the k-Wave website and placing it in the 'binaries' folder. The process involves running simulations via C++, reloading output data into MATLAB, and potentially using CUDA code for GPU acceleration.

```MATLAB
%% Running C++ Simulations
% This section details how to run k-Wave simulations using the C++ executables.
% Ensure the C++ binaries are compiled and placed in the 'binaries' directory.
% Example: Running a 3D simulation
% kspaceFirstOrder3D_wrapper(kgrid, medium, sources, detectors, input_args);

%% Reloading Output Data
% After running the C++ simulation, the output data can be loaded back into MATLAB.
% output_data = kread('output.h5');

%% Running GPU Simulations (CUDA)
% For accelerated simulations, use the CUDA-enabled C++ code.
% Ensure you have a compatible NVIDIA GPU and CUDA toolkit installed.
% kspaceFirstOrder3DCUDA_wrapper(kgrid, medium, sources, detectors, input_args);
```

--------------------------------

### Use Ultrasound Transducer as Sensor with k-Wave

This example demonstrates using an ultrasound transducer as a sensor in k-Wave simulations. It covers the setup for receiving and processing acoustic signals with transducers.

```matlab
Example: Using An Ultrasound Transducer As A Sensor
```

--------------------------------

### Simulate k-Wave in Axisymmetric Coordinate System

This example demonstrates simulating wave propagation in an axisymmetric coordinate system using k-Wave. It covers the setup for simulations with rotational symmetry.

```matlab
Example: Simulations In An Axisymmetric Coordinate System
```

--------------------------------

### Compare k-Wave Modelling Functions

This example provides a comparison of different modeling functions available within the k-Wave toolbox, helping users choose the most appropriate method for their simulations.

```matlab
Example: Comparison Of Modelling Functions
```

--------------------------------

### Example: Simulations in Three Dimensions

Provides examples of running simulations in three dimensions.

```MATLAB
Example: Simulations In Three Dimensions
```

--------------------------------

### Simulate Heat Diffusion in Homogeneous Medium with k-Wave

This example demonstrates the simulation of heat diffusion in a homogeneous medium using k-Wave. It covers the setup for thermal diffusion problems.

```matlab
Example: Heat Diffusion In A Homogeneous Medium
```

--------------------------------

### Simulate Homogeneous Propagation Medium with k-Wave

This example demonstrates setting up and running simulations in a homogeneous propagation medium using the k-Wave toolbox.

```MATLAB
Example: Homogenous Propagation Medium
```

--------------------------------

### MATLAB: Simulate in Three Dimensions

This example demonstrates k-Wave simulations in three dimensions. It covers the setup and execution of acoustic wave propagation problems in full 3D space.

```MATLAB
kWaveExample('Initial Value Problems', 'Example: Simulations In Three Dimensions');
```

--------------------------------

### Compare k-Wave Modelling Functions

This example provides a comparison of different modeling functions available within the k-Wave toolbox. It helps users understand the performance and applicability of various simulation methods.

```matlab
Example: Comparison Of Modelling Functions
```

--------------------------------

### MATLAB: Simulate in One Dimension

This example demonstrates k-Wave simulations in one dimension. It covers the setup and execution of acoustic wave propagation problems in a single spatial dimension.

```MATLAB
kWaveExample('Initial Value Problems', 'Example: Simulations In One Dimension');
```

--------------------------------

### Simulate Focused Detector in 2D with k-Wave

This example demonstrates simulating a focused detector in two dimensions using the k-Wave toolbox. It covers the setup for modeling directional acoustic sensing.

```matlab
Example: Focussed Detector In 2D
```

--------------------------------

### Setup and Run 2D Simulation (MATLAB)

Configures and runs a 2D photoacoustic simulation. It involves creating a 2D computational grid, defining the initial pressure distribution as a disc using `makeDisc`, and setting a single sensor point in 2D. The simulation is executed using `kspaceFirstOrder2D`.

```MATLAB
% create the computational grid
kgrid = kWaveGrid(Nx, dx, Nx, dx);

% create initial pressure distribution
source.p0 = makeDisc(Nx, Nx, Nx/2, Nx/2, source_radius);

% define a single sensor point
sensor.mask = zeros(Nx, Nx);
sensor.mask(Nx/2 - source_sensor_distance, Nx/2) = 1;

% run the simulation
sensor_data_2D = kspaceFirstOrder2D(kgrid, medium, source, sensor, input_args{:});
```

--------------------------------

### MATLAB: Using The C++ Code

Examples demonstrating how to use the C++ code associated with the k-Wave toolbox, including running C++ simulations and saving input files.

```MATLAB
%% Example: Running C++ Simulations
% Execute k-Wave simulations using the C++ backend.
% Requires k-Wave toolbox and C++ compilation.

% Compile C++ code (if not already done)
% mex kspaceFirstOrder2D.cpp

% Run simulation using C++ executable
input_file = 'input.h5';
output_file = 'output.h5';
system(sprintf('kspaceFirstOrder2D -i %s -o %s', input_file, output_file));

```

```MATLAB
%% Example: Saving Input Files in Parts
% Save k-Wave simulation input files in multiple parts.
% Requires k-Wave toolbox.

k = kWavePropagator(...);
input_args = {...};

% Save input in parts
k.saveInput('filename_part1.h5', 'Part', 1);
k.saveInput('filename_part2.h5', 'Part', 2);

```

--------------------------------

### MATLAB: k-Wave Toolbox - Using The C++ Code

This section covers examples related to using the C++ interface of the k-Wave toolbox, including running C++ simulations and saving input files in parts.

```MATLAB
%% Example: Running C++ Simulations
% Demonstrates how to compile and run k-Wave simulations using the provided C++ interface.
% Requires a C++ compiler and k-Wave C++ library.

% Prepare input parameters for C++ simulation.
% Compile C++ code.
% Execute the compiled C++ program.

%% Example: Saving Input Files in Parts
% Shows how to save large k-Wave input files in multiple parts to manage memory
% and facilitate transfer.
% Requires k-Wave toolbox.

% Define simulation parameters.
% Save input data in segmented files.
% Load segmented files for simulation.

```

--------------------------------

### Simulate Doppler Effect with k-Wave

This example illustrates the simulation of the Doppler effect using the k-Wave toolbox. It covers the setup for modeling frequency shifts due to moving sources or reflectors.

```matlab
Example: The Doppler Effect
```

--------------------------------

### MATLAB: Focussed Detector in 2D

This example demonstrates the use of a focused detector in 2D simulations with the k-Wave MATLAB toolbox. It covers the setup and application of directional sensors for acoustic measurements.

```MATLAB
kWaveExample('Sensor Directivity', 'Example: Focussed Detector In 2D');
```

--------------------------------

### MATLAB: Simulate in Axisymmetric Coordinate System

This example illustrates k-Wave simulations in an axisymmetric coordinate system. It covers the setup and execution of acoustic wave propagation problems with rotational symmetry.

```MATLAB
kWaveExample('Initial Value Problems', 'Example: Simulations In An Axisymmetric Coordinate System');
```

--------------------------------

### Compare k-Wave Modelling Functions

This example provides a comparison between different modelling functions or approaches within k-Wave. It helps in understanding the trade-offs and applicability of various simulation methods.

```matlab
% Example: Comparison Of Modelling Functions

% Define simulation parameters
k.dim = [128, 128];
k.dx = 1e-3;
k.sound_speed = 1500;
k.dt = 0.25 * k.dx / k.sound_speed;
k.t_end = 50e-6;

% Define source
k.source.p_initial = zeros(k.dim);
k.source.p_initial(k.dim(1)/2, k.dim(2)/2) = 1;

% --- Method 1: Standard FDTD ---
% k_fdtd = k;
k.simulation_method = 'fdtd';
k.simulate(k_fdtd);
pressure_fdtd = k_fdtd.sensor.recording;

% --- Method 2: Angular Spectrum (if available/applicable) ---
% k_as = k;
% k_as.simulation_method = 'angular_spectrum';
% k_as.simulate(k_as);
% pressure_as = k_as.sensor.recording;

% Compare results (e.g., plot difference or visualize side-by-side)
figure;
subplot(1, 2, 1);
imagesc(pressure_fdtd);
title('FDTD Simulation');
xlabel('x position');
ylabel('y position');

% subplot(1, 2, 2);
% imagesc(pressure_as);
% title('Angular Spectrum Simulation');
% xlabel('x position');
% ylabel('y position');
```

--------------------------------

### Load External Image Maps for k-Wave Simulation

This example demonstrates how to load external image files (e.g., .png, .jpg) to define properties like sound speed or density within the k-Wave simulation domain. This allows for simulating complex, heterogeneous media.

```matlab
% Example: Loading External Image Maps

% Define grid properties
k.dim = [256, 256];
k.dx = 0.5e-3;

% Load an image file (e.g., a grayscale image representing sound speed variations)
image_data = imread('sound_speed_map.png');

% Ensure the image data is compatible with the grid size
% Resize if necessary (e.g., using imresize)
if ~isequal(size(image_data(:,:,1)), k.dim)
    image_data = imresize(image_data(:,:,1), k.dim);
end

% Normalize the image data to represent sound speed values
% Assuming the image is grayscale (0-255) and maps to sound speeds between 1400 and 1600 m/s
min_speed = 1400;
max_speed = 1600;
k.sound_speed = min_speed + (double(image_data) / 255) * (max_speed - min_speed);

% Define other simulation parameters (dt, t_end, source)
k.dt = 0.25 * k.dx / max(k.sound_speed(:));
k.t_end = 100e-6;
k.source.p_initial = zeros(k.dim);
k.source.p_initial(k.dim(1)/2, k.dim(2)/2) = 1;

% Run the simulation
k.simulate(k);

% Display the sound speed map and the resulting pressure field
figure;
subplot(1,2,1);
imagesc(k.sound_speed);
title('Sound Speed Map');
xlabel('x position');
ylabel('y position');

subplot(1,2,2);
imagesc(k.sensor.recording);
title('Pressure field');
xlabel('x position');
ylabel('y position');
```

--------------------------------

### Simulate Monopole Point Source in k-Wave

This example demonstrates simulating the acoustic field generated by a monopole point source in a homogeneous medium. It covers the setup for a basic time-varying source.

```matlab
% Example: Monopole Point Source In A Homogeneous Propagation Medium

% Define grid and medium properties
k.dim = [256, 256];
k.dx = 0.5e-3;
k.sound_speed = 1500;
k.dt = 0.25 * k.dx / k.sound_speed;
k.t_end = 100e-6;

% Define a monopole point source (e.g., a Gaussian pulse)
fs = 1 / k.dt;
t = k.t_grid;
center_freq = 1e6; % 1 MHz
bandwidth = 0.5e6;  % 0.5 MHz

k.source.p_single_freq = sin(2 * pi * center_freq * t) .* exp(-((t - 50e-6) .^ 2) / (2 * (1 / (2 * bandwidth)) ^ 2));

% Position the source
k.source.position = [k.dim(1)/2, k.dim(2)/2];

% Run the simulation
k.simulate(k);

% Display the pressure field
figure;
imagesc(k.sensor.recording);
title('Pressure field from monopole source');
xlabel('x position');
ylabel('y position');
```

--------------------------------

### Define Source Properties with makeDisc

This PHP code snippet demonstrates how to define initial source properties for wave simulations using the `makeDisc` function. It sets up initial pressure (`p0`) and its temporal gradient (`dp0dt`) for two discs of different sizes, visualizing the pressure field with `MeshPlot`.

```php
<?php
// Define source properties
$source = [];

// Create initial source distribution with two discs
$disc1_radius = 10;
$disc2_radius = 5;
$disc1_center = [50, 50];
$disc2_center = [70, 70];

// Assign to p0 field
$source['p0'] = makeDisc(grid, $disc1_center, $disc1_radius, $disc2_center, $disc2_radius);

// Assign to dp0dt field
$source['dp0dt'] = makeDisc(grid, $disc1_center, $disc1_radius, $disc2_center, $disc2_radius);

// Assign to both fields
$source['p0'] = makeDisc(grid, $disc1_center, $disc1_radius, $disc2_center, $disc2_radius);
$source['dp0dt'] = makeDisc(grid, $disc1_center, $disc1_radius, $disc2_center, $disc2_radius);

// Visualize the pressure field
kspaceSecondOrder(grid, kgrid, $source, 'MeshPlot', true, 'PlotFrames', true);
?>

```

--------------------------------

### Model Power Law Absorption in k-Wave

This example illustrates modeling power-law absorption in acoustic wave propagation using the k-Wave toolbox. It covers the setup for simulating media with frequency-dependent attenuation.

```matlab
Example: Modelling Power Law Absorption
```

--------------------------------

### Compare k-Wave Modelling Functions

This example provides a comparison between different modelling functions available within the k-Wave toolbox for acoustic simulations.

```MATLAB
Example: Comparison Of Modelling Functions
```

--------------------------------

### Control Absorbing Boundary Layer in k-Wave

This example demonstrates controlling the absorbing boundary layer (ABL) parameters in k-Wave simulations. It covers the setup for minimizing reflections from the simulation domain boundaries.

```matlab
Example: Controlling The Absorbing Boundary Layer
```

--------------------------------

### Example: Plane Wave Absorption

Illustrates the simulation of plane wave absorption.

```MATLAB
Example: Plane Wave Absorption
```

--------------------------------

### Simulate Ultrasound Beam Patterns with k-Wave

This example illustrates simulating ultrasound beam patterns using the k-Wave toolbox. It covers the setup for visualizing and analyzing the spatial distribution of ultrasound beams.

```matlab
Example: Simulating Ultrasound Beam Patterns
```

--------------------------------

### Run C++ Simulations with k-Wave

This example demonstrates how to run k-Wave simulations using the C++ interface. It covers the basic steps for compiling and executing C++ code that interfaces with the k-Wave toolbox for acoustic wave field simulations.

```bash
# Example: Running C++ simulations
# This would typically involve compiling C++ code that uses the k-Wave C++ API
# and then executing the compiled binary.
# Example compilation command (may vary based on system and compiler):
g++ your_simulation.cpp -o simulation_executable -I/path/to/k-wave/cpp/include -L/path/to/k-wave/cpp/lib -lk_wave

# Example execution:
./simulation_executable
```

--------------------------------

### Image Reconstruction with Bandlimited Sensors using k-Wave

This example illustrates image reconstruction using bandlimited sensors with the k-Wave toolbox. It covers the setup for incorporating frequency-limited sensor responses into reconstruction.

```matlab
Example: Image Reconstruction With Bandlimited Sensors
```

--------------------------------

### Image Reconstruction with Directional Sensors using k-Wave

This example demonstrates image reconstruction using directional sensors with the k-Wave toolbox. It covers the setup for incorporating sensor directivity into the reconstruction process.

```matlab
Example: Image Reconstruction With Directional Sensors
```

--------------------------------

### PHP Example - Basic Usage

A basic example demonstrating how to use PHP within the k-Wave project context. This snippet might be used for web-based interactions or data processing.

```PHP
<?php
// Example PHP code
echo "Hello from k-Wave PHP integration!";
?>
```

--------------------------------

### Model Sensor Directivity in 2D with k-Wave

This example demonstrates modeling sensor directivity in two dimensions using the k-Wave toolbox. It covers the setup for defining and simulating the directional response of sensors.

```matlab
Example: Modelling Sensor Directivity In 2D
```

--------------------------------

### k-Wave MATLAB Toolbox: Setting Initial Pressure Gradient Example

This example demonstrates how to set an initial pressure gradient for a simulation using the k-Wave MATLAB toolbox. This can be used to simulate pre-stressed media or specific initial conditions.

```MATLAB
%% Example: Setting An Initial Pressure Gradient
% This example demonstrates setting an initial pressure gradient.

% Define grid size
kx = 128;
ky = 128;

% Create the k-Wave grid
k = kWaveGrid(kx, ky, 0.1);

% Define the medium properties
medium.sound_speed = 1500 * ones(kx, ky);

% Define the source
source.p_mask = zeros(kx, ky);
source.p_mask(kx/2, ky/2) = 1;
source.p = gaussian(50, 10);

% Define the sensor
sensor.mask = zeros(kx, ky);
sensor.mask(kx/2, ky/2 + 50) = 1;

% Set an initial pressure gradient
initial_pressure_gradient = zeros(kx, ky);
initial_pressure_gradient(kx/2, :) = 1e6; % Example: Gradient along y-axis

% Run the simulation
input_args = {
    'PMLInside', false,
    'Plot', true,
    'InitialPressure', initial_pressure_gradient};

[output_args, settings] = kspaceFirstOrder2D(k, medium, source, sensor, input_args{:});

```

--------------------------------

### Simulate Focused Detector in 3D with k-Wave

This example illustrates simulating a focused detector in three dimensions using the k-Wave toolbox. It covers the setup for modeling directional acoustic sensing in 3D.

```matlab
Example: Focussed Detector In 3D
```

--------------------------------

### Simulate Transducer Field Patterns with k-Wave

This example demonstrates simulating the acoustic field patterns generated by transducers using the k-Wave toolbox. It covers the setup for modeling transducer directivity and beamforming.

```matlab
Example: Simulating Transducer Field Patterns
```
Tokens:
Raw