NeutralAtomQuantumDevice

quantrs2_device::neutral_atom

Trait NeutralAtomQuantumDevice 

Source 
pub trait NeutralAtomQuantumDevice: QuantumDevice + CircuitExecutor {

Show 17 methods    // Required methods
    fn system_type<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<NeutralAtomSystemType>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn atom_count<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<usize>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn atom_spacing<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn state_encoding<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<AtomStateEncoding>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn blockade_radius<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<Option<f64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn supports_rydberg_gates<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn supports_tweezer_manipulation<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn loading_efficiency<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn gate_fidelity<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn execute_neutral_atom_circuit<'life0, 'life1, 'async_trait, const N: usize>(
        &'life0 self,
        circuit: &'life1 Circuit<N>,
        shots: usize,
        config: Option<NeutralAtomDeviceConfig>,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<NeutralAtomCircuitResult>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_atoms<'life0, 'life1, 'async_trait>(
        &'life0 self,
        positions: &'life1 [(f64, f64, f64)],
    ) -> Pin<Box<dyn Future<Output = DeviceResult<Vec<bool>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn move_atoms<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        atom_indices: &'life1 [usize],
        new_positions: &'life2 [(f64, f64, f64)],
    ) -> Pin<Box<dyn Future<Output = DeviceResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn rydberg_excitation<'life0, 'life1, 'async_trait>(
        &'life0 self,
        atom_indices: &'life1 [usize],
        excitation_time: Duration,
        laser_power: f64,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<Vec<bool>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn global_rydberg_operation<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        operation: &'life1 str,
        parameters: &'life2 HashMap<String, f64>,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn measure_atom_states<'life0, 'life1, 'async_trait>(
        &'life0 self,
        atom_indices: &'life1 [usize],
    ) -> Pin<Box<dyn Future<Output = DeviceResult<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn calculate_atom_correlations<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        atom_pairs: &'life1 [(usize, usize)],
        correlation_type: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<HashMap<String, f64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn estimate_fidelity<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        target_state: &'life1 str,
        measurement_data: &'life2 NeutralAtomMeasurementData,
    ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;

}
Expand description

Trait for neutral atom quantum devices

Required Methods§

Source

fn system_type<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<NeutralAtomSystemType>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the neutral atom system type

Source

fn atom_count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the number of atoms in the array

Source

fn atom_spacing<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the atom spacing

Source

fn state_encoding<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<AtomStateEncoding>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the state encoding scheme

Source

fn blockade_radius<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<Option<f64>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the Rydberg blockade radius

Source

fn supports_rydberg_gates<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check if Rydberg gates are supported

Source

fn supports_tweezer_manipulation<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check if optical tweezer manipulation is supported

Source

fn loading_efficiency<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get loading efficiency

Source

fn gate_fidelity<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get gate fidelity

Source

fn execute_neutral_atom_circuit<'life0, 'life1, 'async_trait, const N: usize>( &'life0 self, circuit: &'life1 Circuit<N>, shots: usize, config: Option<NeutralAtomDeviceConfig>, ) -> Pin<Box<dyn Future<Output = DeviceResult<NeutralAtomCircuitResult>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a neutral atom circuit with detailed results

Source

fn load_atoms<'life0, 'life1, 'async_trait>( &'life0 self, positions: &'life1 [(f64, f64, f64)], ) -> Pin<Box<dyn Future<Output = DeviceResult<Vec<bool>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load atoms into the trap array

Source

fn move_atoms<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, atom_indices: &'life1 [usize], new_positions: &'life2 [(f64, f64, f64)], ) -> Pin<Box<dyn Future<Output = DeviceResult<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Move atoms using optical tweezers

Source

fn rydberg_excitation<'life0, 'life1, 'async_trait>( &'life0 self, atom_indices: &'life1 [usize], excitation_time: Duration, laser_power: f64, ) -> Pin<Box<dyn Future<Output = DeviceResult<Vec<bool>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Perform Rydberg excitation

Source

fn global_rydberg_operation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, operation: &'life1 str, parameters: &'life2 HashMap<String, f64>, ) -> Pin<Box<dyn Future<Output = DeviceResult<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Perform global Rydberg operations

Source

fn measure_atom_states<'life0, 'life1, 'async_trait>( &'life0 self, atom_indices: &'life1 [usize], ) -> Pin<Box<dyn Future<Output = DeviceResult<Vec<String>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Measure atom states

Source

fn calculate_atom_correlations<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, atom_pairs: &'life1 [(usize, usize)], correlation_type: &'life2 str, ) -> Pin<Box<dyn Future<Output = DeviceResult<HashMap<String, f64>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Calculate atom correlations

Source

fn estimate_fidelity<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target_state: &'life1 str, measurement_data: &'life2 NeutralAtomMeasurementData, ) -> Pin<Box<dyn Future<Output = DeviceResult<f64>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Estimate state fidelity

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§