Draft support trappedions

* Add netsquid-trappedions snippet as a requirement
* Register IonTrapIndividualAddressing as a qdevice model with the key "trapped-ion"
* Add TrappedIonIndividualFlavour as flavour when using "trapped-ion" in handler
* Add TISubroutineTranspiler as transpiler when using "trapped-ion" in host
* Create TIProcessor class
* Add TIProcessor as processor when using "trapped-ion" in qnos

Author: mkvanhooft

setup.cfg

@@ -22,6 +22,7 @@ install_requires =
     pydynaa >=0.3, <2.0
     netsquid >=1.1.8, <2.0
     netsquid-magic >= 16.0.0, <17.0.0
+    netsquid-trappedions >= 4.0.0, <5.0.0
     bitarray >=2.8.0, <3.0.0
     netqasm >=1.0.0, <=2.0.0
     pytest >=7.1, <8.0

squidasm/run/stack/build.py

@@ -5,6 +5,7 @@
 from netsquid_netbuilder.builder.network_builder import NetworkBuilder, NodeBuilder
 from netsquid_netbuilder.network_config import NetworkConfig
 from netsquid_netbuilder.run import get_default_builder
+from netsquid_trappedions.ion_trap import IonTrapIndividualAddressingBuilder
 
 from squidasm.sim.stack.stack import StackNode
 
@@ -36,6 +37,7 @@ def build(self, config: NetworkConfig) -> Dict[str, StackNode]:
 
 def create_stack_network_builder() -> NetworkBuilder:
     builder = get_default_builder()
+    builder.register_qdevice("trapped-ion", IonTrapIndividualAddressingBuilder)
     original_node_builder = builder.node_builder
 
     # replace the original node builder with new StackNodeBuilder

squidasm/sim/stack/handler.py

@@ -148,6 +148,10 @@ def __init__(
             self._flavour: Optional[flavour.Flavour] = flavour.NVFlavour()
         elif qdevice_type == "generic":
             self._flavour: Optional[flavour.Flavour] = flavour.VanillaFlavour()
+        elif qdevice_type == "trapped-ion":
+            self._flavour: Optional[
+                flavour.Flavour
+            ] = flavour.TrappedIonIndividualFlavour()
         else:
             raise ValueError
 

squidasm/sim/stack/host.py

@@ -9,7 +9,11 @@
     StopAppMessage,
 )
 from netqasm.sdk.epr_socket import EPRSocket
-from netqasm.sdk.transpile import NVSubroutineTranspiler, SubroutineTranspiler
+from netqasm.sdk.transpile import (
+    NVSubroutineTranspiler,
+    SubroutineTranspiler,
+    TISubroutineTranspiler,
+)
 from netsquid.components.component import Component, Port
 from netsquid.nodes import Node
 
@@ -67,6 +71,8 @@ def __init__(self, comp: HostComponent, qdevice_type: Optional[str] = "nv") -> N
             ] = NVSubroutineTranspiler
         elif qdevice_type == "generic":
             self._compiler: Optional[Type[SubroutineTranspiler]] = None
+        elif qdevice_type == "trapped-ion":
+            self._compiler = TISubroutineTranspiler
         else:
             raise ValueError
 

squidasm/sim/stack/processor.py

@@ -4,7 +4,13 @@
 from typing import TYPE_CHECKING, Dict, Generator, Optional, Union
 
 import netsquid as ns
-from netqasm.lang.instr import NetQASMInstruction, core, nv, vanilla
+from netqasm.lang.instr import (
+    NetQASMInstruction,
+    core,
+    nv,
+    trapped_ion_individual,
+    vanilla,
+)
 from netqasm.lang.operand import Register
 from netqasm.lang.subroutine import Subroutine
 from netsquid.components import QuantumProcessor
@@ -31,6 +37,7 @@
 from netsquid.components.qprogram import QuantumProgram
 from netsquid.nodes import Node
 from netsquid.qubits import qubitapi
+from netsquid_trappedions.instructions import INSTR_MS_INDIVIDUAL
 
 from pydynaa import EventExpression
 from squidasm.sim.stack.common import (
@@ -883,3 +890,78 @@ def _interpret_controlled_rotation_instr(
             yield from self._do_controlled_rotation(app_id, instr, INSTR_CYDIR)
         else:
             raise RuntimeError(f"Unsupported instruction {instr}")
+
+
+class TIProcessor(Processor):
+    """A `Processor` for nodes with a TI hardware."""
+
+    def _interpret_qalloc(self, app_id: int, instr: core.QAllocInstruction) -> None:
+        app_mem = self.app_memories[app_id]
+
+        virt_id = app_mem.get_reg_value(instr.reg)
+        if virt_id is None:
+            raise RuntimeError(f"qubit address in register {instr.reg} is not defined")
+        self._logger.debug(f"Allocating qubit with virtual ID {virt_id}")
+
+        # All qubits are communication qubits in TI
+        phys_id = self.physical_memory.allocate_comm()
+        app_mem.map_virt_id(virt_id, phys_id)
+
+    def _interpret_init(
+        self, app_id: int, instr: core.InitInstruction
+    ) -> Generator[EventExpression, None, None]:
+        app_mem = self.app_memories[app_id]
+        virt_id = app_mem.get_reg_value(instr.reg)
+        phys_id = app_mem.phys_id_for(virt_id)
+        self._logger.debug(
+            f"Performing {instr} on virtual qubit "
+            f"{virt_id} (physical ID: {phys_id})"
+        )
+        prog = QuantumProgram()
+        prog.apply(INSTR_INIT, qubit_indices=[phys_id])
+        yield self.qdevice.execute_program(prog)
+
+    def _interpret_meas(
+        self, app_id: int, instr: core.MeasInstruction
+    ) -> Generator[EventExpression, None, None]:
+        app_mem = self.app_memories[app_id]
+        virt_id = app_mem.get_reg_value(instr.qreg)
+        phys_id = app_mem.phys_id_for(virt_id)
+
+        self._logger.debug(
+            f"Measuring qubit {virt_id} (physical ID: {phys_id}), "
+            f"placing the outcome in register {instr.creg}"
+        )
+
+        prog = QuantumProgram()
+        prog.apply(INSTR_MEASURE, qubit_indices=[phys_id])
+        yield self.qdevice.execute_program(prog)
+        outcome: int = prog.output["last"][0]
+        app_mem.set_reg_value(instr.creg, outcome)
+
+    def _interpret_single_rotation_instr(
+        self, app_id: int, instr: trapped_ion_individual.RotXInstruction
+    ) -> Generator[EventExpression, None, None]:
+        if isinstance(instr, trapped_ion_individual.RotXInstruction):
+            yield from self._do_single_rotation(app_id, instr, INSTR_ROT_X)
+        elif isinstance(instr, trapped_ion_individual.RotYInstruction):
+            yield from self._do_single_rotation(app_id, instr, INSTR_ROT_Y)
+        elif isinstance(instr, trapped_ion_individual.RotZInstruction):
+            yield from self._do_single_rotation(app_id, instr, INSTR_ROT_Z)
+        else:
+            raise RuntimeError(f"Unsupported instruction {instr}")
+
+    def _interpret_two_qubit_instr(
+        self, app_id: int, instr: core.TwoQubitRotationInstruction
+    ) -> Generator[EventExpression, None, None]:
+        assert isinstance(instr, trapped_ion_individual.MSGateInstruction)
+
+        app_mem = self.app_memories[app_id]
+        virt_id0 = app_mem.get_reg_value(instr.reg0)
+        phys_id0 = app_mem.phys_id_for(virt_id0)
+        virt_id1 = app_mem.get_reg_value(instr.reg1)
+        phys_id1 = app_mem.phys_id_for(virt_id1)
+
+        prog = QuantumProgram()
+        prog.apply(INSTR_MS_INDIVIDUAL, qubit_indices=[phys_id0, phys_id1])
+        yield self.qdevice.execute_program(prog)

squidasm/sim/stack/qnos.py

@@ -20,6 +20,7 @@
     NVProcessor,
     Processor,
     ProcessorComponent,
+    TIProcessor,
 )
 
 # TODO: make this a parameter
@@ -135,6 +136,10 @@ def __init__(self, comp: QnosComponent, qdevice_type: Optional[str] = "nv") -> N
         elif qdevice_type == "nv":
             self.processor = NVProcessor(comp.processor_comp, self)
             self._physical_memory = NVPhysicalQuantumMemory(comp.qdevice.num_positions)
+        elif qdevice_type == "trapped-ion":
+            self.processor = TIProcessor(comp.processor_comp, self)
+            # We can use Generic PhysicalQuantumMemory for TI
+            self._physical_memory = PhysicalQuantumMemory(comp.qdevice.num_positions)
         else:
             raise ValueError