gs

gs (Gerchberg-Saxton 法) は, 振動子側と焦点側の振幅制約を交互に課しながら順伝搬と逆伝搬を反復するアルゴリズム. naive より焦点間の干渉を抑えられるが, 反復回数に応じて計算量が増える. アルゴリズムは Marzo らの論文 (Marzo & Drinkwater, 2019) に基づく.

API

Rust

gs(
    &NalgebraBackend,
    &geometry,
    &foci,
    wavelength,
    &option,
    &mut phases,
    &mut intensities,
)?;

Python

gs(geometry, foci, wavelength, option, phases, intensities)

C#

Holo.Gs(geometry, foci, wavelength, option, phases, intensities);

引数	型	説明
geometry	&Geometry	デバイス配置
foci	&[AmplitudeTarget]	焦点列 (位置と目標振幅)
wavelength	Length	波長
option	&GsOption	追加オプション (下記参照)
phases	&mut [Vec<Phase>]	位相の出力バッファ
intensities	&mut [Vec<Intensity>]	振幅の出力バッファ

GsOption

Rust

GsOption {
    repeat,
    constraint,
    directivity,
    mask,
}

Python

GsOption(
    repeat,
    constraint,
    directivity,
    mask,
)

C#

new GsOption
{
    Repeat = repeat,
    Constraint = constraint,
    Directivity = directivity,
    Mask = mask,
}

フィールド	型	デフォルト
repeat	NonZeroUsize	100
constraint	IntensityConstraint	Clamp(MIN, MAX)
directivity	Directivity	Sphere
mask	TransducerMask	AllEnabled

repeat は反復回数. 大きくするほど品質は向上するが計算時間も増える.

Example

Rust

use std::num::NonZeroUsize;

use autd3_rs::geometry::{Autd3, Geometry, TransducerMask, offset};
use autd3_rs::units::{m, mm, s};
use autd3_rs::value::Intensity;
use autd3_rs_pattern::wavelength;
use autd3_rs_pattern_holo::{
    AmplitudeTarget, Directivity, IntensityConstraint, GsOption, NalgebraBackend, Pa, gs,
};

let geometry = Geometry::new(vec![Autd3::default()]);

let mut phases = geometry.phase_buffer();
let mut intensities = geometry.intensity_buffer();

gs(
    &NalgebraBackend,
    &geometry,
    &[
        AmplitudeTarget {
            point: geometry.center() + offset(-30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude: 2.5e3 * Pa,
        },
        AmplitudeTarget {
            point: geometry.center() + offset(30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude: 2.5e3 * Pa,
        },
    ],
    wavelength(340.0 * m / s),
    &GsOption {
        repeat: NonZeroUsize::new(100).unwrap(),
        constraint: IntensityConstraint::Clamp(Intensity::MIN, Intensity::MAX),
        directivity: Directivity::Sphere,
        mask: TransducerMask::AllEnabled,
    },
    &mut phases,
    &mut intensities,
)?;

Python

from autd3.geometry import Autd3, Geometry, offset
from autd3.units import m, mm, s
from autd3.value import Intensity
from autd3_pattern import TransducerMask, wavelength
from autd3_pattern_holo import (
    AmplitudeTarget,
    Directivity,
    IntensityConstraint,
    GsOption,
    Pa,
    gs,
)

geometry = Geometry([Autd3()])

phases = geometry.phase_buffer()
intensities = geometry.intensity_buffer()

gs(
    geometry,
    [
        AmplitudeTarget(
            point=geometry.center() + offset(-30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude=2.5e3 * Pa,
        ),
        AmplitudeTarget(
            point=geometry.center() + offset(30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude=2.5e3 * Pa,
        ),
    ],
    wavelength(340 * m / s),
    GsOption(
        repeat=100,
        constraint=IntensityConstraint.Clamp(Intensity.MIN, Intensity.MAX),
        directivity=Directivity.Sphere,
        mask=TransducerMask.AllEnabled,
    ),
    phases,
    intensities,
)

C#

using AUTD3;
using AUTD3.Holo;
using static AUTD3.Units;
using static AUTD3.Holo.HoloUnits;

var geometry = new Geometry(new[] { new Autd3() });

var phases = geometry.PhaseBuffer();
var intensities = geometry.IntensityBuffer();

Holo.Gs(
    geometry,
    new[]
    {
        new AmplitudeTarget(geometry.Center + Offset(-30.0f * mm, 0.0f * mm, 150.0f * mm), 2.5e3f * Pa),
        new AmplitudeTarget(geometry.Center + Offset(30.0f * mm, 0.0f * mm, 150.0f * mm), 2.5e3f * Pa),
    },
    Pattern.Wavelength(340.0f * m / s),
    new GsOption
    {
        Repeat = 100,
        Constraint = IntensityConstraint.Clamp(Intensity.Min, Intensity.Max),
        Directivity = Directivity.Sphere,
        Mask = TransducerMask.AllEnabled,
    },
    phases,
    intensities
);