naive

The Naive method is an algorithm that applies back-propagation to the target sound pressure vector. It does not iterate and is fast, but it does not correct for interference between focal points, so a weak sound field may be generated.

API

Rust

naive(
    &NalgebraBackend,
    &geometry,
    &foci,
    wavelength,
    &option,
    &mut dst,
)?;

Python

naive(geometry, foci, wavelength, option, dst)

C#

Holo.Naive(geometry, foci, wavelength, option, dst);

Parameter	Type	Description
geometry	&Geometry	Device layout
foci	&[AmplitudeTarget]	Sequence of focal points (position and target amplitude)
wavelength	Length	Wavelength
option	&NaiveOption	Additional options (see below)
dst	&mut [[Emission; _]]	Output buffer

For the common elements (AmplitudeTarget / TransducerMask / LinAlgBackend, etc.), see the Holo overview.

NaiveOption

Rust

NaiveOption {
    constraint,
    directivity,
    mask,
    parallel,
}

Python

NaiveOption(
    constraint,
    directivity,
    mask,
    parallel,
)

C#

new NaiveOption(
    constraint,
    directivity,
    mask,
    parallel
)

Field	Type	Default
constraint	EmissionConstraint	Clamp(MIN, MAX)
directivity	Directivity	Sphere
mask	TransducerMask	AllEnabled
parallel	bool	true

For the meaning of each field, see the Holo overview.

parallel decides whether the quantization of the result is spread over several host threads (a GPU backend ignores it).

Example

Rust

use autd3_rs::geometry::{Autd3, Geometry, 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, EmissionConstraint, NaiveOption, NalgebraBackend, Pa,
    TransducerMask, naive,
};

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

let mut dst = geometry.pattern_buffer();

naive(
    &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),
    &NaiveOption {
        constraint: EmissionConstraint::Clamp(Intensity::MIN, Intensity::MAX),
        directivity: Directivity::Sphere,
        mask: TransducerMask::AllEnabled,
        parallel: true,
    },
    &mut dst,
)?;

Python

import numpy as np
from autd3.geometry import Autd3, Geometry
from autd3.units import m, s
from autd3_pattern import wavelength
from autd3_pattern_holo import (
    AmplitudeTarget,
    Directivity,
    EmissionConstraint,
    NaiveOption,
    Pa,
    TransducerMask,
    naive,
)

geometry = Geometry([Autd3([0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0])])

dst = geometry.pattern_buffer()

naive(
    geometry,
    [
        AmplitudeTarget(
            point=geometry.center() + np.array([-30.0, 0.0, 150.0]),
            amplitude=2.5e3 * Pa,
        ),
        AmplitudeTarget(
            point=geometry.center() + np.array([30.0, 0.0, 150.0]),
            amplitude=2.5e3 * Pa,
        ),
    ],
    wavelength(340 * m / s),
    NaiveOption(
        constraint=EmissionConstraint.Clamp(0x00, 0xFF),
        directivity=Directivity.Sphere,
        mask=TransducerMask.AllEnabled,
    ),
    dst,
)

C#

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

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

var dst = geometry.PatternBuffer();

Holo.Naive(
    geometry,
    new[]
    {
        new AmplitudeTarget(geometry.Center + new Vector3(-30.0f, 0.0f, 150.0f), 2.5e3f * Pa),
        new AmplitudeTarget(geometry.Center + new Vector3(30.0f, 0.0f, 150.0f), 2.5e3f * Pa),
    },
    Pattern.Wavelength(340.0f * m / s),
    new NaiveOption(
        constraint: EmissionConstraint.Clamp(Intensity.Min, Intensity.Max),
        directivity: Directivity.Sphere,
        mask: TransducerMask.AllEnabled
    ),
    dst
);