Struct DynamicalDecoupling 

pub struct DynamicalDecoupling {
    pub min_idle_time: f64,
    pub sequence_type: DecouplingSequence,
    /* private fields */
}

Optimization pass that inserts dynamical decoupling sequences

Fields

min_idle_time: f64

Minimum idle time to insert decoupling (nanoseconds)

sequence_type: DecouplingSequence

Decoupling sequence type

Implementations

impl DynamicalDecoupling

pub fn new(noise_model: NoiseModel) -> Self

Create a new dynamical decoupling pass

Examples found in repository

examples/noise_optimization_demo.rs (line 174)

fn demo_noise_optimization_passes(
    circuit: &Circuit<4>,
) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Individual Optimization Passes ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);

    // Test coherence optimization
    let coherence_opt = CoherenceOptimization::new(noise_model.clone());
    let cost_model = NoiseAwareCostModel::new(noise_model.clone());

    if coherence_opt.should_apply() {
        let coherence_result = coherence_opt.apply(circuit, &cost_model)?;
        println!("✓ Coherence optimization applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After coherence opt: {}", coherence_result.num_gates());
    }

    // Test noise-aware mapping
    let mapping_opt = NoiseAwareMapping::new(noise_model.clone(), coupling_map.clone());
    if mapping_opt.should_apply() {
        let mapping_result = mapping_opt.apply(circuit, &cost_model)?;
        println!("✓ Noise-aware mapping applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After mapping opt: {}", mapping_result.num_gates());
    }

    // Test dynamical decoupling
    let dd_opt = DynamicalDecoupling::new(noise_model.clone());
    if dd_opt.should_apply() {
        let dd_result = dd_opt.apply(circuit, &cost_model)?;
        println!("✓ Dynamical decoupling applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After DD insertion: {}", dd_result.num_gates());
    }

    println!();
    Ok(())
}

Trait Implementations

impl Clone for DynamicalDecoupling

fn clone(&self) -> DynamicalDecoupling

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicalDecoupling

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

Formats the value using the given formatter.

impl OptimizationPass for DynamicalDecoupling

fn name(&self) -> &str

Name of the optimization pass

fn apply_to_gates( &self, gates: Vec<Box<dyn GateOp>>, _cost_model: &dyn CostModel, ) -> QuantRS2Result<Vec<Box<dyn GateOp>>>

Apply the optimization pass to a gate list

fn should_apply(&self) -> bool

Check if this pass should be applied