nsqdriver 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

nsqdriver/__init__.py

@@ -3,7 +3,7 @@ from .NS_QSYNC import Driver as QSYNCDriver
 from .NS_CST import Driver as CSTDriver
 from .compiler.ns_wave import InsChannel
 
-version_pack = (0, 3, 0)
+version_pack = (0, 3, 1)
 
 __version__ = '.'.join(str(_) for _ in version_pack)
 __all__ = ['MCIDriver', 'QSYNCDriver', 'CSTDriver', 'InsChannel', '__version__']

nsqdriver/setup.py

@@ -1,14 +1,9 @@
 from setuptools import setup
-from setuptools.extension import Extension
 from Cython.Build import cythonize
 import numpy as np
 
-
-extension = [Extension("*", ["nsqdriver/wrapper/*.py"], language='c++'),
-             Extension("*", ["nsqdriver/*.py"], language='c++')]
-
 setup(
-    name='nsqdriver',
-    ext_modules=cythonize(extension, language_level=3),
+    name='compiler',
+    ext_modules=cythonize([r'nsqdriver/compiler/ns_wave.py', r'nsqdriver/compiler/py_wave_asm.py'], language_level=3),
     include_path=[np.get_include()]
 )

nsqdriver-0.3.1.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.1
+Name: nsqdriver
+Version: 0.3.1
+Summary: Naishu Q series quantum measurement and control equipment driver interface
+Home-page: https://g2hoyqcmh4.feishu.cn/wiki/wikcnzvyMd82DLZUe2NsI6HxsFc
+Author: Naishu Technology
+Author-email: jilianyi@naishu.tech
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy (>=1.18)
+Requires-Dist: waveforms
+
+```
+  _   _   ____     ___    ____           _                       
+ | \ | | / ___|   / _ \  |  _ \   _ __  (_) __   __   ___   _ __ 
+ |  \| | \___ \  | | | | | | | | | '__| | | \ \ / /  / _ \ | '__|
+ | |\  |  ___) | | |_| | | |_| | | |    | |  \ V /  |  __/ | |   
+ |_| \_| |____/   \__\_\ |____/  |_|    |_|   \_/    \___| |_|   
+```
+
+[![Tests](https://github.com/mianyan-echo/UltraMCI/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/mianyan-echo/UltraMCI/)
+***
+
+### 简介
+NSQDriver为一套耐数®量子测控系列设备的Python通用驱动接口。可使用Python作为编程语言，基于此驱动接口可以实现对本公司测控设备的控制，进而完成各种超导量子芯片的表征实验和高保真门操作。
+
+```
+                              +------------------------+
+                              |          Python        |
+                              |     +------------------+
+                              |     |      NSQDriver   |
+                              +------------------------+
+                                     :     :         :
+                           +----------     :         -----+
+                           :               :              :
+                           V               V              V
+                     +-----------+   +-----------+   +-----------+   
+                     |  Device A |   |  Device B |   |   QSYNC   |    
+                     +-----------+   +-----------+   +-----------+   
+```
+
+NSQDriver接口可用于统一控制耐数®生产的Q100、MC、QSYNC等一系列量子测控仪器，可详细控制每台仪器每个OUT、IN通道的播放与采集行为，以及查看设备的运行状态等。在一个多台测控设备组成的多量子比特测控系统中，可以有效的在软件层面实现对系统中每台设备的详细控制。
+
+耐数®量子测控系列设备详细信息参考: [耐数](http://naishu.tech)
+
+***
+### 快速开始
+- 驱动接口的通用流程如下
+```python
+from nsqdriver import MCIDriver, QSYNCDriver
+
+# 实例化设备驱动接口
+driver = MCIDriver('127.0.0.1')
+qsync = QSYNCDriver('127.0.0.1')
+
+# 连接设备
+qsync.open()
+driver.open()
+
+# 初始化系统
+qsync.sync_system()
+
+
+# 相关参数，参数细节相关参考 8.可用参数列表
+driver.set('Shot', 1024)
+```
+
+- NSWave接口
+  - NSWave是一种对于耐数®参数化波形技术的控制接口，参数化波形将量子测控所需的各种门的编辑由主控计算机直接生成波形转化成了设备实时计算
+  - 提供了一套直观的时序编辑接口
+```python
+from nsqdriver import InsChannel
+import numpy as np
+
+ch = InsChannel()                        # 生成参数化波形通道实例
+
+frame_65e9 = ch.ins_frame(6.5e9)         # 生成一个frame
+frame_67e9 = ch.ins_frame(6.7e9)         # 生成一个frame
+
+gaussian = ch.evlp_gaussian(4500e-9)     # 生成一个高斯包络
+square = ch.evlp_square(2500e-9)         # 生成一个方波包络
+
+wave1 = gaussian * frame_67e9            # 生成一段高斯包络的波形
+wave2 = square * frame_65e9              # 生成一段方波包络的波形
+
+ch.ins_reset_frame('phase', frame_65e9)
+ch.ins_reset_frame('phase', frame_67e9)
+ch.wait_for_trigger()                    # 等待触发到来
+# 循环播放200次 3μs延迟+ 7μs波形
+with ch.ins_loop(times=200) as _loop:
+    _loop.play_zero(3000e-9)
+    _loop.inc_phase(frame_65e9, np.pi / 2)
+    _loop.play_wave(wave2)
+    _loop.play_wave(wave1)
+```

{nsqdriver-0.3.0.dist-info → nsqdriver-0.3.1.dist-info}/RECORD

@@ -1,17 +1,17 @@
 nsqdriver/NS_CST.py,sha256=_QYCjg1YglIJ4YVmxvISqvy5rExWGlMhyrK9zYIRbRY,7877
 nsqdriver/NS_MCI.py,sha256=ZRf_waF7Q3VnClZnvjogfhVkqW7ltmwZaXXCRU8qA0o,19542
 nsqdriver/NS_QSYNC.py,sha256=68qFZ04KVXb0MSaeKIZVZYqR0UV_tkJYWz7KSz4Dvg0,23281
-nsqdriver/__init__.py,sha256=BMKtTehGZlv0CgT1vJAbyZW1KF670NZwQJ9wWQBYzC0,326
+nsqdriver/__init__.py,sha256=BXs30hyT5ovY79xD1SYbTce9c1CPM7q0siC1EjyzGwk,326
 nsqdriver/common.py,sha256=IHfShqgNN3THbe7KD7ICdfFY7JKC_kQj0_KJk-449gQ,499
-nsqdriver/setup.py,sha256=4ajKQtY4hr2240f5sA81f66_92Yp_wG6gPM-zsOWq9M,390
+nsqdriver/setup.py,sha256=qLy-jDmc3nxnXVoJo4g2cnTvFL3lOiYu_t-vaJ8Z_8o,269
 nsqdriver/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsqdriver/compiler/ns_wave.py,sha256=Z-O--9OtmLiILGx-4imSJuAcdgjP1PNknQlDrSo2CIw,15411
-nsqdriver/compiler/py_wave_asm.py,sha256=aXMr3CqMC0vDP4mtTdyVfnwpvlrE14hGgdthWAF5S6g,17407
+nsqdriver/compiler/ns_wave.cpython-310-darwin.so,sha256=WBh_NOyU4e6G6xBitLFXLkkFvKqCn9ptf3cGTEkjEaE,410360
+nsqdriver/compiler/py_wave_asm.cpython-310-darwin.so,sha256=noQ3HaHLl1NUsT29eU_XA3j5Nlp4_egB-nQqjYiy8p8,432200
 nsqdriver/wrapper/AWG_ADC.py,sha256=8K5xLEa_3CKnStWcoJeTj8ufEQfrx6o4l4XGNuOP3Ug,19211
 nsqdriver/wrapper/BD_NSMCI.py,sha256=SMnDbS6iXDiPBhoR9QVJB_lJXhIXRQIVLJRSBEihLzw,12245
 nsqdriver/wrapper/ND_NSMCI.py,sha256=gTyrDObhbggl35V_q-kpDoPsfttIEnDFc6f0-pk_P0k,6288
 nsqdriver/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsqdriver-0.3.0.dist-info/METADATA,sha256=htBmUOmmEPWvuvX1fmTGsoFlXiZPqysgxrwFnjDDwp0,497
-nsqdriver-0.3.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-nsqdriver-0.3.0.dist-info/top_level.txt,sha256=o7EbQoFO6BoaG3KGbS9Lg_aRheZSY5KYzoYuI9vx-AI,10
-nsqdriver-0.3.0.dist-info/RECORD,,
+nsqdriver-0.3.1.dist-info/METADATA,sha256=qGCBFfF-7sVIK42k9E5AqUPxEWrawBmI1fSMhoNDOJU,4091
+nsqdriver-0.3.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+nsqdriver-0.3.1.dist-info/top_level.txt,sha256=o7EbQoFO6BoaG3KGbS9Lg_aRheZSY5KYzoYuI9vx-AI,10
+nsqdriver-0.3.1.dist-info/RECORD,,

{nsqdriver-0.3.0.dist-info → nsqdriver-0.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.40.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nsqdriver/compiler/ns_wave.py

@@ -1,483 +0,0 @@
-import copy
-from typing import Union, List, Dict
-from itertools import chain, repeat
-from enum import IntEnum
-from collections import namedtuple
-
-import numpy as np
-import waveforms as wf
-
-from .py_wave_asm import *
-
-
-class QInsPlaceholder(NSQCommand):
-    ...
-
-
-class Wave(GenTagMixin):
-    Identity = namedtuple('Relation', ['frame', 'envelop'])
-
-    class Tag(IntEnum):
-        none = 0
-        frame = 1
-        envelope = 2
-        signal = 3
-
-    def __init__(self, ins_obj: "InstructionQ", ins_id: dict):
-        cls = self.__class__
-        self.instruction = ins_obj
-        self.id = cls.Identity(**ins_id)
-        if ins_id['frame'] != -1 and ins_id['envelop'] != -1:
-            self.wtag = cls.Tag.signal
-        elif ins_id['frame'] != -1:
-            self.wtag = cls.Tag.envelope
-        elif ins_id['envelop'] != -1:
-            self.wtag = cls.Tag.frame
-        else:
-            self.wtag = cls.Tag.none
-
-    def __repr__(self):
-        return f'<{self.__class__}::{self.id}::{self.wtag}>'
-
-
-class Frame(Wave):
-    def __init__(self, ins_obj: "InstructionQ", ins_id: int, freq: float):
-        super().__init__(ins_obj, {'frame': ins_id, 'envelop': -1})
-        self.tag = self.generate_tag
-        self.freq = freq
-
-    @property
-    def freq(self):
-        return self._freq
-
-    @freq.setter
-    def freq(self, value):
-        self._freq = value
-        self._ins = QInsFrame(freq=value, tag=self.tag)
-
-    def __mul__(self, other: Wave):
-        if isinstance(other, Envelope) or isinstance(other, Signal):
-            if other.instruction is not self.instruction:
-                raise ValueError(f'隶属于的instruction不同，不能直接相乘')
-            res = Signal(self.instruction, {'frame': self.id.frame, 'envelop': other.id.envelop})
-            res.frame = self
-            res.envelope = other
-            return res
-        else:
-            raise ValueError(f'{self.__class__}不能与{other.__class__}做乘法运算')
-
-    def format(self):
-        return self._ins
-
-
-class Envelope(Wave):
-    def __init__(self, ins_obj: "InstructionQ", ins_id: int, content):
-        super().__init__(ins_obj, {'frame': -1, 'envelop': ins_id})
-        self.tag = self.generate_tag
-        self.content = content
-
-    @property
-    def content(self):
-        return self._content
-
-    @content.setter
-    def content(self, value):
-        self._content = value
-        self._ins = QInsEnvelop(envelop=self.content, tag=self.tag)
-
-    def __mul__(self, other: Wave):
-        if isinstance(other, Frame) or isinstance(other, Signal):
-            if other.instruction is not self.instruction:
-                raise ValueError(f'They belong to different instructions and cannot be directly multiplied')
-            res = Signal(self.instruction, {'frame': other.id.frame, 'envelop': self.id.envelop})
-            res.frame = other
-            res.envelope = self
-            return res
-        else:
-            raise ValueError(f'{self.__class__}不能与{other.__class__}做乘法运算')
-
-    def format(self):
-        return self._ins
-
-
-class Signal(Wave):
-    def __init__(self, ins_obj: "InstructionQ", ins_id: dict):
-        super().__init__(ins_obj, ins_id)
-        self.frame = None
-        self.envelope = None
-
-
-class InstructionQ(GenTagMixin):
-    """!
-    包含各种具体的指令
-    """
-
-    def __init__(self, freqs=None, envelopes=None):
-        """!
-
-        @param freqs:
-        @param envelopes:
-        """
-        if freqs is None:
-            freqs = []
-        if envelopes is None:
-            envelopes = []
-        self.i_set: "List[Union[NSQCommand, InstructionQ]]" = []
-        self.f_set: "Dict[int, Frame]" = {}
-        self.e_set: "Dict[int, Envelope]" = {}
-        self.symbol_set: Dict[str, int] = {}
-        self.symbol_idx = -1
-        self.is_first_trig = True
-        self.last_ins = None
-
-        for i, f in enumerate(freqs):
-            self.ins_frame(f)
-        for i, e in enumerate(envelopes):
-            self.ins_envelope(e)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        ...
-
-    def clear(self):
-        self.i_set.clear()
-        self.symbol_set: Dict[str, int] = {}
-        self.symbol_idx = -1
-        self.is_first_trig = True
-
-    @property
-    def length(self):
-        return len(self.i_set)
-
-    def ins_frame(self, freq, idx=None) -> Frame:
-        raise RuntimeError(f'Cannot create a new frame in the branch')
-
-    def ins_envelope(self, envelope: "Union[np.ndarray, wf.Waveform, str]", idx=None) -> Envelope:
-        raise RuntimeError(f'Cannot create a new envelope in the branch')
-
-    def evlp_gaussian(self, width) -> Envelope:
-        wave = wf.gaussian(width) >> (width/2)
-        wave.start = 0
-        wave.stop = width
-        return self.ins_envelope(wave)
-
-    def evlp_cospulse(self, width) -> Envelope:
-        wave = wf.cosPulse(width) >> (width / 2)
-        wave.start = 0
-        wave.stop = width
-        return self.ins_envelope(wave)
-
-    def evlp_square(self, width) -> Envelope:
-        wave = wf.square(width) >> (width / 2)
-        wave.start = 0
-        wave.stop = width
-        return self.ins_envelope(wave)
-
-    def _append_ins(self, cmd: "Union[NSQCommand, InstructionQ]"):
-        self.last_ins = cmd
-        self.i_set.append(cmd)
-
-    def _map_var(self, var):
-        if var in self.symbol_set:
-            return self.symbol_set[var]
-        self.symbol_idx += 1
-        if self.symbol_idx >= 16:
-            raise RuntimeError(f'Up to 16 variables can be configured')
-        self.symbol_set[var] = self.symbol_idx
-        return self.symbol_set[var]
-
-    def wait_for_trigger(self):
-        if not self.is_first_trig:
-            self.wait()
-        cmd = QInsWaitTrig(tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def ins_variable(self, reg: str, value: int):
-        cmd = QInsMov(self._map_var(reg), value, type='=', tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def ins_add(self, reg: str, value: int):
-        cmd = QInsMov(self._map_var(reg), value, type='+', tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def ins_reset_frame(self, flag, frame=''):
-        cmd = QInsResetF(flag, frame, tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def inc_phase(self, frame, phase):
-        cmd = QInsIncPhase(phase, frame.tag, tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def play_wave(self, wave: Signal, amp=1, freq=0, phase=0):
-        if not isinstance(wave, Signal):
-            raise RuntimeError(f'The parameter wave should be Signal, not {type(wave)}')
-        cmd = QInsPlayWave(wave.frame.tag, wave.envelope.tag, amp, freq, phase, tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def play_zero(self, width):
-        cmd = QInsPlayZero(width, tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def wait(self):
-        cmd = QInsWait(tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def end(self):
-        cmd = QInsEnd(tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def capture(self, width, delay=0):
-        cmd = QInsCapture(width=width, probe_delay=delay, tag=self.generate_tag)
-        self._append_ins(cmd)
-        return cmd
-
-    def _compile(self) -> "List[NSQCommand]":
-        res = []
-        for ins in self.i_set:
-            if isinstance(ins, InstructionQ):
-                res.extend(ins._compile())
-            else:
-                res.append(copy.copy(ins))
-        return res
-
-    def compile(self) -> "List[NSQCommand]":
-        queue = []
-        for idx in sorted(self.f_set.keys()):
-            ins = self.f_set[idx]
-            queue.append(ins.format())
-        for idx in sorted(self.e_set.keys()):
-            ins = self.e_set[idx]
-            queue.append(ins.format())
-
-        queue.extend(self._compile())
-        # 向指令队列中添加End指令
-        if not isinstance(queue[-1], QInsEnd):
-            queue.append(self.end())
-
-        res = []
-        for idx, ins in enumerate(queue):
-            if isinstance(ins, QInsPlaceholder):
-                f_tag = ins.tag
-                t_tag = queue[idx+1].tag
-                for _ins in queue:
-                    if getattr(_ins, 'target', '') == f_tag:
-                        _ins.target = t_tag
-                continue
-            res.append(ins)
-        return res
-
-    def lookup(self):
-        import json
-        ins_list = [str(ins) for ins in self.compile()]
-        print(json.dumps(ins_list, indent=4))
-
-
-class InsChannel(InstructionQ):
-    def __init__(self, freqs=None, envelopes=None):
-        super(InsChannel, self).__init__(freqs, envelopes)
-        self.if_stack: "List[InsIF]" = []
-        self.looping = False
-
-    def clear(self):
-        super().clear()
-        self.looping = False
-
-    def ins_frame(self, freq, idx=None) -> Frame:
-        if idx is None:
-            idx = sorted(self.f_set)[-1]+1 if len(self.f_set) != 0 else 0
-        if not isinstance(idx, int):
-            raise ValueError(f'frame的idx应为整数，而不是{type(idx)}')
-        frame = Frame(self, idx, freq)
-        self.f_set[idx] = frame
-        return frame
-
-    def ins_envelope(self, envelope: "Union[np.ndarray, wf.Waveform, str]", idx=None) -> Envelope:
-        if idx is None:
-            idx = sorted(self.e_set)[-1] + 1 if len(self.e_set) != 0 else 0
-        if not isinstance(idx, int):
-            raise ValueError(f'envelop的idx应为整数，而不是{type(idx)}')
-        obj = Envelope(self, idx, envelope)
-        self.e_set[idx] = obj
-        return obj
-
-    def ins_if(self, formula) -> "InsIF":
-        channel = self if self.__class__ is InsChannel else self.channel
-        if_ins = InsIF.from_channel(channel)
-        if_ins.formula = formula
-        self._append_ins(if_ins)
-        self.if_stack.append(if_ins)
-        return if_ins
-
-    def ins_else(self) -> "InsElse":
-        # if与else之间不能间隔其它指令
-        if not isinstance(self.last_ins, InsIF):
-            raise RuntimeError(f'The last call of ins_else must be ins_if, not {type(self.last_ins)}')
-        # 不能没有if直接调用else
-        if len(self.if_stack) == 0:
-            raise RuntimeError(f'Please call if before calling else')
-        channel = self if self.__class__ is InsChannel else self.channel
-        _if = self.if_stack.pop()
-        _else = InsElse.from_channel(channel)
-        _else._if = _if
-        _if.ins_else = _else
-        return _else
-
-    def ins_loop(self, times) -> "InsLoop":
-        if self.looping:
-            raise RuntimeError(f'The current object is already in the loop')
-        channel = self if self.__class__ is InsChannel else self.channel
-        loop_ins = InsLoop.from_channel(channel)
-        loop_ins.times = times
-        self._append_ins(loop_ins)
-        return loop_ins
-
-
-class InsIF(InsChannel):
-    ch_judge_name = {f'FREQ_{i}': 1<<i for i in range(6)}
-
-    def __init__(self, freqs=None, envelopes=None):
-        """!
-
-        @param freqs:
-        @param envelopes:
-        """
-        super().__init__(freqs, envelopes)
-        self.channel: "InsChannel" = None
-        self.key_ins = None
-        self.ins_else = None
-
-    @classmethod
-    def from_channel(cls, channel):
-        self = cls()
-        self.channel = channel
-        return self
-
-    @property
-    def formula(self):
-        raise RuntimeError(f'{self.__class__.__name__}.formula is a static property')
-
-    @formula.setter
-    def formula(self, formula: str):
-        formula = formula.replace(' ', '')
-        ast = formula.split('==')
-        if len(ast) != 2:
-            raise RuntimeError(f'The format of formula should be [name] == [value]')
-        name, value = ast
-        if name in self.channel.symbol_set:
-            self.key_ins = QInsJumpWithReg(self.channel.symbol_set[name], int(value), None, tag=self.generate_tag)
-        elif name in self.ch_judge_name:
-            self.key_ins = QInsJumpWithJudge(int(value), self.ch_judge_name[name], None, tag=self.generate_tag)
-        else:
-            raise RuntimeError(f'The specified variable {name} does not exist')
-
-    def _compile(self) -> "List[NSQCommand]":
-        """!
-        递归生成分支结构，支持结构嵌套
-        @return:
-        """
-        res = []
-        if_group = super()._compile()
-        else_group = self.ins_else._compile() if isinstance(self.ins_else, InsElse) else []
-        while len(else_group) < 3:
-            else_group.append(QInsWait(tag=self.generate_tag))
-        if_group.append(QInsPlaceholder(tag=self.generate_tag))
-        jump = QInsJump(None, tag=self.generate_tag)
-        self.key_ins.target = if_group[0].tag
-        jump.target = if_group[-1].tag
-
-        res.append(self.key_ins)
-        res.extend(else_group)
-        res.append(jump)
-        res.extend(if_group)
-        return res
-
-    def capture(self, width, delay=0):
-        raise RuntimeError(f'Capture is not allowed to call in a branch structure')
-
-
-class InsElse(InsChannel):
-    def __init__(self, freqs=None, envelopes=None):
-        """!
-
-        @param freqs:
-        @param envelopes:
-        """
-        super().__init__(freqs, envelopes)
-        self.channel = None
-        self._if = None
-
-    @classmethod
-    def from_channel(cls, channel):
-        self = cls()
-        self.channel = channel
-        return self
-
-    def capture(self, width, delay=0):
-        raise RuntimeError(f'Capture is not allowed to call in a branch structure')
-
-
-class InsLoop(InsChannel):
-    def __init__(self, freqs=None, envelopes=None):
-        """!
-
-        @param freqs:
-        @param envelopes:
-        """
-        super().__init__(freqs, envelopes)
-        self.channel: "InsChannel" = None
-        self.times = None
-        self.var = self.generate_tag
-
-    def __enter__(self):
-        self.channel.looping = True
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.looping = False
-
-    @classmethod
-    def from_channel(cls, channel):
-        self = cls()
-        self.channel = channel
-        return self
-
-    def capture(self, width, delay=0):
-        raise RuntimeError(f'Calling capture in a loop construct is not allowed')
-
-    def _compile(self) -> "List[NSQCommand]":
-        body = super()._compile()
-        res = []
-        set_cmd = QInsMov(self.channel._map_var(self.var), 0, type='=', tag=self.generate_tag)
-        body.append(QInsMov(self.channel._map_var(self.var), 1, type='+', tag=self.generate_tag))
-        placeholder = QInsPlaceholder(tag=self.generate_tag)
-        jump = [
-            QInsJumpWithReg(self.channel._map_var(self.var), self.times, placeholder.tag, tag=self.generate_tag),
-            QInsWait(tag=self.generate_tag),
-            QInsWait(tag=self.generate_tag),
-            QInsJump(body[0].tag, tag=self.generate_tag),
-            placeholder
-        ]
-        res.append(set_cmd)
-        res.extend(body)
-        res.extend(jump)
-        return res
-
-    # def _compile(self) -> "List[NSQCommand]":
-    #     ins_list = super()._compile()
-    #     res = []
-    #     for ins in chain.from_iterable(repeat(ins_list, self.times)):
-    #         _ins: "NSQCommand" = copy.copy(ins)
-    #         _ins.tag = self.generate_tag
-    #         res.append(_ins)
-    #     return res

nsqdriver/compiler/py_wave_asm.py

@@ -1,538 +0,0 @@
-import struct
-import copy
-import uuid
-from typing import Union, List, Tuple, Dict
-from enum import IntEnum
-from dataclasses import dataclass, field
-from itertools import chain
-from collections import ChainMap
-
-import numpy as np
-import waveforms as wf
-
-__all__ = [
-    'AssemblyError', 'GenTagMixin', 'Assembler', 'NSQCommand',
-    'QInsWait', 'QInsWaitTrig', 'QInsEnd', 'QInsFrame', 'QInsEnvelop',
-    'QInsJumpWithJudge', 'QInsJump', 'QInsJumpWithReg', 'QInsCapture',
-    'QInsMov', 'QInsIncPhase', 'QInsPlayZero', 'QInsPlayWave', 'QInsResetF',
-]
-
-global_config = {
-    'play_zero_step': 4e-9,
-    'OUTSrate': 8e9,
-    'envelope_dtype': np.int16,  # 描述包络每个点的数据类型
-    'envelope_step': 64,  # 包络步进粒度，单位为bytes
-    'envelope_quant': 16383,  # 包络量化范围
-    'envelope_cache': 204800,  # 包络缓存大小，单位bytes
-    'envelope_head': np.array([2, 0, 0, 512, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.int16),   # 包络更新包头
-}
-
-
-class AssemblyError(RuntimeError):
-    ...
-
-
-class GenTagMixin:
-    @property
-    def generate_tag(self):
-        return uuid.uuid4().hex[:10]
-
-
-@dataclass
-class NSQCommand:
-    """!
-    所有参数化波形指令队列的基类
-    """
-    tag: str = field(kw_only=True)
-
-    def _check_attr(self):
-        ...
-
-    def __bytes__(self):
-        self._check_attr()
-        cmd = self._pack_cmd()
-        return self.list2bytes(cmd)
-
-    def _pack_cmd(self) -> list:
-        return [0x00, 0, 0, 0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-    @property
-    def overhead(self):
-        return 16e-9
-
-    @staticmethod
-    def list2bytes(cmd: list):
-        cmd += [0x00] * 8
-        cmd_raw = struct.pack('=BBIIHHHII' + 'B' * 8, *cmd)
-        return cmd_raw
-
-    @staticmethod
-    def frequency_normalization32(freq) -> np.uint32:
-        return np.uint32(round(freq / global_config['OUTSrate'] * (1 << 32)))
-
-    @staticmethod
-    def phase_normalization32(phase) -> np.uint32:
-        return np.uint32(round(np.fmod(np.fmod(phase / np.pi / 2, 1) + 1, 1) * (1 << 32)))
-
-
-@dataclass
-class _ProbeCommand:
-    tag: str = field(kw_only=True)
-
-    def _check_attr(self):
-        ...
-
-    def __bytes__(self):
-        self._check_attr()
-        cmd = self._pack_cmd()
-        return self.list2bytes(cmd)
-
-    def _pack_cmd(self) -> list:
-        return [0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000]
-
-    @property
-    def overhead(self):
-        return 16e-9
-
-    @staticmethod
-    def list2bytes(cmd: list):
-        cmd_raw = struct.pack('=HHHHHHHH', *cmd[::-1])
-        return cmd_raw
-
-
-@dataclass
-class QInsEnvelop(NSQCommand):
-    envelop: Union[np.ndarray, wf.Waveform]
-
-    def __post_init__(self):
-        self.envelop_slice = slice(0, None, 1)
-
-    def __bytes__(self):
-        if isinstance(self.envelop, wf.Waveform):
-            if self.envelop.start is None or self.envelop.stop is None:
-                raise AssemblyError(f'When the type of {self.__class__.__name__}.envelop is wf.Waveform, '
-                                    f'it must have start and stop attributes')
-            wave = self.envelop.sample(global_config['OUTSrate'])
-        elif isinstance(self.envelop, np.ndarray):
-            wave = self.envelop
-        else:
-            raise AssemblyError(f'The type of {self.__class__.__name__}.envelop must be one of np.ndarray or wf.Waveform')
-        wave *= global_config['envelope_quant']
-        return wave.astype(global_config['envelope_dtype']).tobytes()
-
-
-@dataclass
-class QInsFrame(NSQCommand):
-    freq: float
-
-    def __post_init__(self):
-        self.frame_idx = 0
-
-    def _pack_cmd(self) -> list:
-        return [0x11, self.frame_idx * 4 + 0, self.frequency_normalization32(self.freq),
-                0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-
-@dataclass
-class QInsResetF(NSQCommand):
-    type: str
-    frame: str = ''
-
-    def __post_init__(self):
-        self.frame_idx = 0
-        self.type2head = {'all': 0x51, 'single': 0x41, 'phase': 0x31}
-
-    def _pack_cmd(self) -> list:
-        head = self.type2head.get(self.type.lower(), None)
-        if head is None:
-            raise AssemblyError(f'{self.__class__.__name__}.type can only be one of {self.type2head.keys()}')
-        return [head, self.frame_idx * 4, 0, 0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-
-@dataclass
-class QInsMov(NSQCommand):
-    reg: int
-    value: int
-    type: str = '='
-
-    def __post_init__(self):
-        self.type2head = {'=': 0x38, '+': 0x48}
-
-    def _pack_cmd(self) -> list:
-        head = self.type2head.get(self.type, None)
-        if head is None:
-            raise AssemblyError(f'{self.__class__.__name__}.type can only be one of {self.type2head.keys()}')
-        return [head, self.reg, self.value, 0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-
-@dataclass
-class QInsWaitTrig(NSQCommand):
-    def _pack_cmd(self) -> list:
-        return [0xF4, 0, 0, 0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-
-@dataclass
-class QInsIncPhase(NSQCommand):
-    phase: float
-    frame: str
-
-    def __post_init__(self):
-        self.frame_idx = 0
-
-    def _pack_cmd(self) -> list:
-        return [0x21, self.frame_idx * 4 + 1, self.phase_normalization32(self.phase),
-                0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-
-@dataclass
-class QInsPlayZero(NSQCommand):
-    width: float
-
-    @property
-    def overhead(self):
-        return self.width
-
-    def _pack_cmd(self) -> list:
-        frames = round(self.width / global_config['play_zero_step'])
-        return [0x44, 0, 0, frames, 0, 0x0000, 0x0000, 0, 0]
-
-
-@dataclass
-class QInsPlayWave(NSQCommand):
-    frame: str
-    envelop: str
-    amp: float
-    attach_freq: float
-    attach_phase: float
-
-    @property
-    def overhead(self):
-        return self.envelop_slice.step/global_config['OUTSrate']
-
-    def __post_init__(self):
-        self.frame_idx = 0
-        self.envelop_slice = slice(0, None, 1)
-
-    def _pack_cmd(self) -> list:
-        return [
-            0x04, self.frame_idx * 4,
-            np.uint32(self.envelop_slice.start / global_config['envelope_step']),
-            np.uint32(self.envelop_slice.step / global_config['envelope_step']),
-            np.int32(self.amp * (1 << 15)), 0x0000, 0x0000,
-            self.frequency_normalization32(self.attach_freq),
-            self.phase_normalization32(self.attach_phase)
-        ]
-
-
-@dataclass
-class QInsWait(NSQCommand):
-    def _pack_cmd(self) -> list:
-        return [0x00, 0, 0, 0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-
-@dataclass
-class QInsJump(NSQCommand):
-    target: str
-
-    def __post_init__(self):
-        self.ins_idx = 0
-
-    def _pack_cmd(self) -> list:
-        return [0x18, 0, 0, self.ins_idx, 0, 0x0000, 0x0000, 0, 0]
-
-
-@dataclass
-class QInsJumpWithReg(NSQCommand):
-    reg: int
-    value: int
-    target: str
-
-    def __post_init__(self):
-        self.ins_idx = 0
-
-    def _pack_cmd(self) -> list:
-        return [0x28, self.reg, self.value, self.ins_idx, 0, 0x0000, 0x0000, 0, 0]
-
-
-@dataclass
-class QInsJumpWithJudge(NSQCommand):
-    value: int
-    mask: int
-    target: str
-
-    def __post_init__(self):
-        self.ins_idx = 0
-
-    def _pack_cmd(self) -> list:
-        return [0x28, 0x10, self.mask << 16 | self.value, self.ins_idx, 0, 0x0000, 0x0000, 0, 0]
-
-
-@dataclass
-class QInsEnd(NSQCommand):
-    def _pack_cmd(self) -> list:
-        return [0xF8, 0, 0, 0x00000000, 0x0000, 0x0000, 0x0000, 0x00000000, 0x00000000]
-
-
-@dataclass
-class QInsCapture(NSQCommand):
-    width: float
-    probe_delay: float = 0
-
-    def __post_init__(self):
-        self.ch_flag = {'all': 3, 'ad': 2, 'da': 1}
-
-    def __bytes__(self):
-        delay_length = int(round(self.probe_delay/16e-9))
-        length = int(round(self.width/16e-9))
-        cmds = [
-            [0x0002, self.ch_flag['da'], 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, delay_length],
-            [0x0002, self.ch_flag['all'], 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, length],
-        ]
-        return b''.join(self.list2bytes(cmd) for cmd in cmds)
-
-    @staticmethod
-    def list2bytes(cmd: list):
-        cmd_raw = struct.pack('=HHHHHHHH', *cmd[::-1])
-        return cmd_raw
-
-
-@dataclass
-class _QInsPTrigDelay(_ProbeCommand):
-    tag: str = field(kw_only=True)
-    delay: float
-
-    def __post_init__(self):
-        self.ch_flag = {'all': 3, 'ad': 2, 'da': 1}
-
-    def _pack_cmd(self) -> list:
-        length = int(round(self.delay / 16e-9))
-        return [0x0002, self.ch_flag['all'], 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, length]
-
-
-@dataclass
-class _QInsPWaitTrig(_ProbeCommand):
-    def _pack_cmd(self) -> list:
-        return [0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000]
-
-
-@dataclass
-class _QInsPJump(_ProbeCommand):
-    target: str
-
-    def __post_init__(self):
-        self.ins_idx = 0
-
-    def _pack_cmd(self) -> list:
-        return [0x0003, 0x0000, 0x0000, self.ins_idx, 0x0000, 0x0000, 0x0000, 0x0000]
-
-
-class Assembler(GenTagMixin):
-    def __init__(self, ch_map=None):
-        if ch_map is None:
-            ch_map = {
-                1: [3, 4, 5, 6, 7, 8],
-                2: [11, 12, 13, 14, 15, 16]
-            }
-        self.ch_map = ch_map
-        self.drive2probe = {j: i for i in ch_map.keys() for j in ch_map[i]}
-        self.raw_cmdq = {j: [] for i in ch_map.values() for j in i}
-        self.probe_cmdq = {i: [] for i in ch_map.keys()}
-        self.drive_cmdq = {j: [] for i in ch_map.values() for j in i}
-
-        self.envelop_cache = {
-            j: np.zeros((global_config['envelope_cache'] // 2,), dtype=np.int16) for i in ch_map.values() for j in i
-        }
-
-        self.frame_symbol = {j: {} for i in ch_map.values() for j in i}
-        self.envelop_symbol = {j: {} for i in ch_map.values() for j in i}
-        self.drive_symbol = {j: {} for i in ch_map.values() for j in i}
-        self.probe_symbol = {i: {} for i in ch_map.keys()}
-
-    def set_chnl_cmdq(self, ch_id, cmdq):
-        if ch_id not in self.drive2probe:
-            raise AssemblyError(f'OUT channel {ch_id} does not exist')
-        self.raw_cmdq[ch_id] = cmdq
-        self.envelop_symbol[ch_id], cmdq = self.extract_envelop(ch_id, cmdq)
-        self.frame_symbol[ch_id] = self.extract_frame(cmdq)
-        (self.drive_cmdq[ch_id], self.probe_cmdq[self.drive2probe[ch_id]],
-         self.drive_symbol[ch_id], self.probe_symbol[self.drive2probe[ch_id]]) = self.divide_cmd(ch_id, cmdq)
-
-    def extract_envelop(self, ch_id, cmdq: List[NSQCommand]) -> "Tuple[dict, List[NSQCommand]]":
-        """!
-        在指令队列中提取包络指令，并建立符号表
-
-        @param ch_id:
-        @param cmdq:
-        @return:
-        """
-        res_cmdq, envelops = [], []
-        for cmd in cmdq:
-            if not isinstance(cmd, QInsEnvelop):
-                res_cmdq.append(copy.copy(cmd))
-            else:
-                envelops.append(cmd)
-
-        cache = self.envelop_cache[ch_id]
-        # 给cache头部打上包络更新指令包头
-        cache[:16] = global_config['envelope_head']
-        data_cache = cache[16:]
-        data_cache[:] = 0
-
-        start = 0
-        symbol_map = {}
-        for env in envelops:
-            wave = bytes(env)
-            length = len(wave)
-            end = start + length
-            data_cache[start//2:end//2] = np.frombuffer(wave, dtype=global_config['envelope_dtype'])
-            env.envelop_slice = slice(start, end, length)
-            start += length
-            symbol_map[env.tag] = env
-        return symbol_map, res_cmdq
-
-    @staticmethod
-    def extract_frame(cmdq: List[NSQCommand]) -> "dict":
-        """!
-        在指令队列中提取包络配置指令，并且建立包络符号表
-
-        @param cmdq:
-        @return:
-        """
-        frames = []
-        for cmd in cmdq:
-            if not isinstance(cmd, QInsFrame):
-                continue
-            frames.append(cmd)
-
-        symbol_map = {}
-        for idx, frame in enumerate(frames):
-            frame.frame_idx = idx
-            symbol_map[frame.tag] = frame
-        return symbol_map
-
-    def divide_cmd(self, ch_id, cmdq) -> "Tuple[list, list, dict, dict]":
-        """!
-
-        @param ch_id:
-        @param cmdq:
-        @return:
-        """
-        drive_queue, probe_queue, drive_symbol, probe_symbol = self._link_wave(ch_id, cmdq)
-        drive_queue, drive_symbol = self._optimize_drive_q(drive_queue, drive_symbol)
-        probe_queue, probe_symbol = self._optimize_probe_q(probe_queue)
-        drive_queue, probe_queue = self._link_jump(drive_queue, probe_queue, drive_symbol, probe_symbol)
-        return drive_queue, probe_queue, drive_symbol, probe_symbol
-
-    def _link_wave(self, ch_id, cmdq):
-        """!
-        建立frame和envelop到指令的关联，并生成基础的指令符号表，初步分割drive与probe的指令
-
-        @param ch_id:
-        @param cmdq:
-        @return:
-        """
-        symbols = ChainMap(self.frame_symbol[ch_id], self.envelop_symbol[ch_id])
-        drive_queue, probe_queue, drive_symbol, probe_symbol = [], [], {}, {}
-        probe_queue.append(_QInsPWaitTrig(tag=self.generate_tag))
-        probe_symbol[probe_queue[-1].tag] = 0
-
-        for cmd in cmdq:
-            if hasattr(cmd, 'frame_idx') and hasattr(cmd, 'frame'):
-                frame: QInsFrame = symbols.get(cmd.frame, None)
-                if frame is None:
-                    raise AssemblyError(f'The frame tag required by instruction {cmd} '
-                                        f'does not exist in the instruction queue of channel {ch_id}')
-                cmd.frame_idx = frame.frame_idx
-            if hasattr(cmd, 'envelop_slice') and hasattr(cmd, 'envelop'):
-                envelop: QInsEnvelop = symbols.get(cmd.envelop, None)
-                if envelop is None:
-                    raise AssemblyError(f'The envelop tag required by instruction {cmd} '
-                                        f'does not exist in the instruction queue of channel {ch_id}')
-                cmd.envelop_slice = envelop.envelop_slice
-            if isinstance(cmd, QInsCapture):
-                # 这里要保证占capture位置的playzero指令依然能被跳转
-                wait = QInsPlayZero(tag=cmd.tag, width=cmd.width + cmd.probe_delay)
-                cmd.tag = self.generate_tag
-                drive_queue.append(wait)
-                probe_queue.append(cmd)
-            else:
-                wait = _QInsPTrigDelay(tag=self.generate_tag, delay=cmd.overhead)
-                drive_queue.append(cmd)
-                probe_queue.append(wait)
-            drive_symbol[drive_queue[-1].tag] = len(drive_queue)-1
-            probe_symbol[probe_queue[-1].tag] = len(probe_queue)-1
-        probe_queue.append(_QInsPJump(target=probe_queue[0].tag, tag=self.generate_tag))
-        probe_symbol[probe_queue[-1].tag] = len(probe_queue)-1
-        return drive_queue, probe_queue, drive_symbol, probe_symbol
-
-    def _link_jump(self, drive_queue: List[NSQCommand], probe_queue, drive_symbol, probe_symbol):
-        """!
-        连接指令队列中的跳转指令
-
-        @param drive_queue:
-        @param probe_queue:
-        @return:
-        """
-        for cmd in drive_queue:
-            if hasattr(cmd, 'ins_idx') and hasattr(cmd, 'target'):
-                cmd.ins_idx = drive_symbol[cmd.target]
-
-        for cmd in probe_queue:
-            if hasattr(cmd, 'ins_idx') and hasattr(cmd, 'target'):
-                cmd.ins_idx = probe_symbol[cmd.target]
-        return drive_queue, probe_queue
-
-    def _optimize_probe_q(self, queue):
-        """!
-        优化probe指令队列
-
-        @param queue:
-        @param symbol:
-        @return:
-        """
-        symbol, idx = {}, 0
-        cache = []
-        res_q = []
-        # 合并所有相邻的_QInsProbeDelay，减少指令队列长度
-        for cmd in queue:
-            if isinstance(cmd, _QInsPTrigDelay):
-                cache.append(cmd)
-            else:
-                delay = _QInsPTrigDelay(tag=self.generate_tag, delay=sum(i.delay for i in cache))
-                if delay.delay != 0:
-                    res_q.append(delay)
-                    symbol[delay.tag] = idx
-                    idx += 1
-                res_q.append(cmd)
-                symbol[cmd.tag] = idx
-                idx += 1
-                cache = []
-        return res_q, symbol
-
-    def _optimize_drive_q(self, queue, symbol):
-        """!
-        优化drive指令队列
-
-        @param queue:
-        @param symbol:
-        @return:
-        """
-        return queue, symbol
-
-    def assemble(self) -> "Tuple[dict, dict, dict]":
-        envelop_cache = {}
-        drive_cache = {}
-        for pch, dch_list in self.ch_map.items():
-            memory = np.zeros((10240 * 8 * len(dch_list), ), dtype=np.uint32).reshape((len(dch_list), 8*10240))
-            for idx, ch in enumerate(dch_list):
-                _data = np.frombuffer(b''.join(bytes(i) for i in self.drive_cmdq[ch]), dtype=np.int32)
-                memory[idx, :_data.size] = _data
-            drive_cache[pch] = memory
-            envelop_cache[pch] = np.array([self.envelop_cache[ch] for ch in dch_list], dtype=np.int16)
-
-        probe_cache = {}
-        for pch, queue in self.probe_cmdq.items():
-            memory = np.frombuffer(b''.join(bytes(i) for i in queue), dtype=np.int32)
-            probe_cache[pch] = memory
-
-        return envelop_cache, drive_cache, probe_cache

nsqdriver-0.3.0.dist-info/METADATA

@@ -1,14 +0,0 @@
-Metadata-Version: 2.1
-Name: nsqdriver
-Version: 0.3.0
-Summary: Naishu Q series quantum measurement and control equipment driver interface
-Home-page: https://g2hoyqcmh4.feishu.cn/wiki/wikcnzvyMd82DLZUe2NsI6HxsFc
-Author: Naishu Technology
-Author-email: jilianyi@naishu.tech
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.10
-Requires-Dist: numpy (>=1.18)
-Requires-Dist: waveforms
-