Struct DeviceConfig 

pub struct DeviceConfig {
    pub qubit_frequencies: HashMap<usize, f64>,
    pub coupling_strengths: HashMap<(usize, usize), f64>,
    pub drive_amplitudes: HashMap<usize, f64>,
    pub meas_frequencies: HashMap<usize, f64>,
    pub sample_rate: f64,
}

Device configuration for pulse control

Fields

qubit_frequencies: HashMap<usize, f64>

Qubit frequencies (GHz)

coupling_strengths: HashMap<(usize, usize), f64>

Coupling strengths (MHz)

drive_amplitudes: HashMap<usize, f64>

Drive amplitudes

meas_frequencies: HashMap<usize, f64>

Measurement frequencies

sample_rate: f64

Sample rate (GS/s)

Implementations

impl DeviceConfig

pub fn default_config(num_qubits: usize) -> Self

Create a default configuration

Examples found in repository

examples/pulse_demo.rs (line 162)

fn demo_pulse_compilation() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Circuit to Pulse Compilation ---");

    // Create device configuration
    let device_config = DeviceConfig::default_config(4);
    println!("Device configuration:");
    println!("  Qubits: 4");
    println!("  Qubit frequencies: ~5 GHz");
    println!("  Sample rate: {} GS/s", device_config.sample_rate);

    // Create compiler
    let compiler = PulseCompiler::new(device_config);

    // Create a simple circuit
    let mut circuit = Circuit::<4>::new();
    circuit.add_gate(Hadamard { target: QubitId(0) })?;
    circuit.add_gate(CNOT {
        control: QubitId(0),
        target: QubitId(1),
    })?;
    circuit.add_gate(RotationZ {
        target: QubitId(1),
        theta: PI / 4.0,
    })?;

    println!("\nCompiling circuit:");
    for (i, gate) in circuit.gates().iter().enumerate() {
        println!("  {}: {}", i, gate.name());
    }

    // Compile to pulses
    let pulse_schedule = compiler.compile(&circuit)?;

    println!("\nCompiled pulse schedule:");
    println!("  Duration: {} ns", pulse_schedule.duration);
    println!("  Instructions: {}", pulse_schedule.instructions.len());

    // Show channel usage
    let mut channel_usage = std::collections::HashMap::new();
    for (_, instruction) in &pulse_schedule.instructions {
        match instruction {
            PulseInstruction::Play { channel, .. } => {
                *channel_usage.entry(format!("{:?}", channel)).or_insert(0) += 1;
            }
            _ => {}
        }
    }

    println!("\nChannel usage:");
    for (channel, count) in channel_usage {
        println!("  {}: {} pulses", channel, count);
    }

    println!();
    Ok(())
}

Trait Implementations

impl Clone for DeviceConfig

fn clone(&self) -> DeviceConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DeviceConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.