FociSTM

The maximum number of sound field patterns is $8192$
- In extended mode, it is $16384$
The sampling rate is $40 kHz / N$ , where $N$ is a 16-bit unsigned integer greater than 0

The usage of FociSTM is as follows. This is a sample that rotates a focus on the circumference of a circle with a radius of $30 mm$ centered at a point $150 mm$ directly above the center of the array. The circumference is sampled at 200 points, rotating at $1 Hz$ . (That is, the sampling frequency is $200 Hz$ .)

Rust C++ C# Python

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
FociSTM {
    foci: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            center + p
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<Point3> foci;
std::ranges::copy(iota(0) | take(points_num) | transform([&](auto i) {
                    const auto theta = 2.0f * pi * static_cast<float>(i) /
                                       static_cast<float>(points_num);
                    Point3 p = center + radius * Vector3(std::cos(theta),
                                                         std::sin(theta), 0);
                    return p;
                  }),
                  std::back_inserter(foci));
FociSTM(foci, 1.0f * Hz);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new FociSTM(
    foci: Enumerable.Range(0, pointNum).Select(i =>
    {
        var theta = 2.0f * MathF.PI * i / pointNum;
        return center + radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0);
    }),
    config: 1.0f * Hz
);

import numpy as np
from pyautd3 import FociSTM, Hz
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
FociSTM(
    foci=(
        center + radius * np.array([np.cos(theta), np.sin(theta), 0])
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
)

In config, you can specify the frequency, period, and sampling settings.

Due to constraints on the number of sampling points and the sampling period, it may not be possible to output at the specified frequency. For example, in the above example, to rotate 200 points at $1 Hz$ , the sampling frequency should be $200 Hz = 40 kHz /200$ . However, if point_num=199, the sampling frequency must be $199 Hz$ , but there is no integer $N$ that satisfies $199 Hz = 40 kHz / N$ , resulting in an error.

Using FociSTM::into_nearest, the nearest $N$ is selected, but note that the actual frequency may differ from the specified frequency.

Multiple Foci

FociSTM can output up to 8 foci simultaneously.

Below is an example with 2 foci.

Rust C++ C# Python

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
FociSTM {
    foci: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            ControlPoints {
                points: [
                    ControlPoint {
                        point: center + p,
                        phase_offset: Phase::ZERO,
                    },
                    ControlPoint {
                        point: center - p,
                        phase_offset: Phase::ZERO,
                    },
                ],
                intensity: EmitIntensity::MAX,
            }
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<ControlPoints<2>> foci;
std::ranges::copy(
    iota(0) | take(points_num) | transform([&](auto i) {
      const auto theta =
          2.0f * pi * static_cast<float>(i) / static_cast<float>(points_num);
      Vector3 p = radius * Vector3(std::cos(theta), std::sin(theta), 0);
      return ControlPoints<2>{
          .points = std::array{ControlPoint{.point = center + p,
                                            .phase_offset = Phase::zero()},
                               ControlPoint{.point = center - p,
                                            .phase_offset = Phase::zero()}},
          .intensity = std::numeric_limits<EmitIntensity>::max()};
    }),
    std::back_inserter(foci));
FociSTM stm(foci, 1.0f * Hz);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new FociSTM(
    foci: Enumerable.Range(0, pointNum).Select(i =>
        {
            var theta = 2.0f * MathF.PI * i / pointNum;
            var p = radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0);
            return new ControlPoints(
                points: [
                    new ControlPoint { Point = center + p, PhaseOffset = Phase.Zero},
                    new ControlPoint { Point = center - p, PhaseOffset = Phase.Zero}
                ],
                intensity: EmitIntensity.Max
            );
        }),
    config: 1.0f * Hz
);

import numpy as np
from pyautd3 import ControlPoint, ControlPoints, EmitIntensity, FociSTM, Hz, Phase
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
FociSTM(
    foci=(
        ControlPoints(
            points=[
                ControlPoint(
                    point=center + radius * np.array([np.cos(theta), np.sin(theta), 0]),
                    phase_offset=Phase.ZERO,
                ),
                ControlPoint(
                    point=center - radius * np.array([np.cos(theta), np.sin(theta), 0]),
                    phase_offset=Phase.ZERO,
                ),
            ],
            intensity=EmitIntensity.MAX,
        )
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
)

The multi-focus sound field of FociSTM is a simple superposition of single-focus sound fields. That is, for the position of the transducer $x_{t}$ , each focus position $x_{i}$ , ultrasonic frequency $f$ , and speed of sound $c$ , the phase $θ$ is calculated as follows. $θ = ∠ i \sum e^{2 π j \frac{f}{c} ∥ x_{i} - x_{t} ∥ + j ϕ_{i}}$ Here, $ϕ_{i}$ is the phase offset of each focus. For amplitude, the specified value from the software is used instead of $i \sum e^{2 π j \frac{f}{c} ∥ x_{i} - x_{t} ∥ + j ϕ_{i}}$ .

Constraints

To reduce data volume, FociSTM encodes the focus position coordinates as $18 bit$ signed fixed-point numbers with a unit of $0.025 mm$ . Therefore, for each axis direction, only foci within the range of $[- 3276.8 mm, 3276.775 mm]$ from all transducers can be output.

Also, since internal calculations are performed with fixed-point numbers, the phase may differ from that of gain::Focus.

AUTD3 Developers Manual v32.0.1

FociSTM

Multiple Foci

Constraints