New branch 6 5

INSTALL.md

@@ -0,0 +1,31 @@
+# Installation Instructions  
+
+## General Dependencies
+Silospin requires Python 3.7 or newer. Python can be installed from the Python webpage (https://www.python.org/downloads/) or through Anaconda (https://www.anaconda.com/products/distribution). The package also requries NumPy (https://numpy.org/), SciPy (https://scipy.org/), and Matplotlib (https://matplotlib.org/). Install these as,
+
+```bash
+$ pip install numpy
+$ pip install scipy
+$ pip install matplotlib   
+```
+### Zurich Instrument Modules  
+
+Silospin interfaces with physical instruments from Zurich Instruments and therefore requires software used by Zurich including zhinst and zhinst-toolkit. These can be installed as,
+
+```bash
+$ pip install zhinst
+$ pip install zhinst-toolkit  
+```
+
+## Silospin  
+
+```bash
+$ git clone git@github.com:nimalec/Silospin.git  
+$ cd silospin/
+$ pip install -e .
+```
+
+If an old branch is being used (e.g. branch 'new_branch_6_5')
+```bash
+$ git switch new_branch_6_5  
+```

README.md

@@ -1,2 +1,23 @@
 # Silospin
-Silospin is a package responsible for the calibration, control , and benchmarking of quantum dot processors. This is the primary codebase used by the Sigillito Group at the University of Pennsylvania. 
+Silospin is a package responsible for the calibration, control , and benchmarking of quantum dot processors. This is the primary codebase used by the Sigillito Group at the University of Pennsylvania. Check out our group's latest work here:
+[Sigillito Group Page](https://pennqubit.com/).   
+
+
+
+Silospin interfaces with the following hardware for quantum control experiments.
+
+![](https://github.com/nimalec/Silospin/blob/new_branch_6_5/images/waveform.png)
+![](https://github.com/nimalec/Silospin/blob/new_branch_6_5/images/pulses.png)For details on installation instructions, please click [INSTALL.md](https://github.com/nimalec/Silospin/blob/new_branch_6_5/INSTALL.md).  
+
+## Citing
+```
+@software{silospin,
+  author       = {Nima Leclerc, Dr. Anthony Sigillito},
+  title        = {Silospin: silospin},
+  month        = aug,
+  year         = 2022,
+  version      = {0.0.1},
+  doi          = {10.5281/zenodo.6459381},
+  url          = {https://github.com/nimalec/Silospin}
+}
+```

silospin/experiment/example_gst.py

@@ -0,0 +1,2 @@
+from silospin.experiment import setup_experiment
+awg = setup_experiment.awg_driver

silospin/experiment/main.py

@@ -0,0 +1,6 @@
+from silospin.experiment import setup_experiment
+
+setup_experiment.init()
+print(setup_experiment.awg_driver)
+print(setup_experiment.mfli_driver)
+print(setup_experiment.qubit_parameters)

silospin/experiment/setup_experiment.py

@@ -0,0 +1,14 @@
+from silospin.drivers.zi_hdawg_driver import HdawgDriver
+from silospin.drivers.zi_mfli2 import MfliDriver
+
+def init(awg_id="dev8446", mfli_id="dev5759"):
+    global awg_driver
+    global mfli_driver
+    global qubit_parameters
+    awg_driver = HdawgDriver(awg_id)
+    mfli_driver = MfliDriver(mfli_id)
+    qubit_parameters =  {
+        0: {"i_amp_pi": 1.0, "q_amp_pi": 1.0 , "i_amp_pi_2": 1.0, "q_amp_pi_2": 1.0, "tau_pi" : 100e-9,  "tau_pi_2" :  50e-9,  "delta_iq" : 0 , "mod_freq": 60e6},
+        1: {"i_amp_pi": 1.0, "q_amp_pi": 1.0 , "i_amp_pi_2": 1.0, "q_amp_pi_2": 1.0, "tau_pi" : 100e-9,  "tau_pi_2" :  50e-9,  "delta_iq" : 0 , "mod_freq": 60e6},
+        2: {"i_amp_pi": 1.0, "q_amp_pi": 1.0 , "i_amp_pi_2": 1.0, "q_amp_pi_2": 1.0, "tau_pi" : 120e-9,  "tau_pi_2" :  60e-9,  "delta_iq" : 0 , "mod_freq": 60e6},
+        3: {"i_amp_pi": 1.0, "q_amp_pi": 1.0 , "i_amp_pi_2": 1.0, "q_amp_pi_2": 1.0, "tau_pi" : 160e-9,  "tau_pi_2" :  80e-9,  "delta_iq" : 0 , "mod_freq": 60e6}}

silospin/io/qc_io.py

@@ -0,0 +1,250 @@
+import pandas as pd
+import re
+
+def read_qubit_paramater_file(file_path):
+    qubit_parameters = pd.read_csv(file_path)
+    return qubit_parameters.to_dict
+
+def write_qubit_parameter_file(qubit_parameters, file_path):
+    param_df = pd.DataFrame.from_dict(qubit_parameters)
+    param_df.to_csv(file_path)
+
+def quantum_protocol_parser(file_path, qubit_lengths, qubit_set = {1,2,3,4}):
+    sequence_table = {}
+    gates = {"x": "pi_2", "y": "pi_2", "xxx": "pi_2", "yyy": "pi_2",  "xx": "pi", "yy":  "pi", "mxxm": "pi", "myym": "pi"}
+    df = pd.read_csv(file_path, header = None, skiprows=1)
+    df = df[0:100]
+
+    for idx in range(len(df)):
+        line = df.values[idx][0].split(";")[0:len(df.values[idx][0].split(";"))-1]
+        seq_line = {"0": [], "1": [], "2": [] , "3":[]} ##refer as seq_line[idx].append(new_gate)
+        for elem in line:
+            element = re.split('\(| \)', elem)
+            idx_set = set()
+            length_set = []
+            for item in element:
+                if len(item)>2:
+                    seq_line[str(int(item[0])-1)].append(item[2:len(item)])
+                    #sequence_line[int(item[0])-1] = item[2:len(item)]
+                    idx_set.add(int(item[0]))
+                    if item[2] == "t":
+                        length_set.append(int(item[2:len(item)]))
+                    else:
+                        qubit_length = qubit_lengths[int(item[0])][gates[item[2:len(item)]]]
+                        length_set.append(qubit_length)
+                else:
+                    pass
+            max_gt_len = max(length_set)
+            diff_set = qubit_set.difference(idx_set)
+            for item in diff_set:
+                #sequence_line[item-1] = "t"+str(max_gt_len)
+                seq_line[str(item-1)].append("t"+str(max_gt_len) )
+
+        #sequence_table[idx] = sequence_line
+        sequence_table[idx] = seq_line
+    return sequence_table
+
+def quantum_protocol_parser_csv_v2(file_path, qubit_lengths, qubit_cores, plunger_channels):
+    qubit_sequence_table = {} ## qubit_sequence_table[line][qubit_core] w/ qubit_core = {0,1,2,3}
+    plunger_sequence_table = {}  ## plunger_sequence_table[line][plunger_channel] w/ qubit_core = {0,1,2,3,4,5,6,7}
+    q_seq_line = {} ##qubit sequence line
+    p_seq_line = {}  ##qubit sequence line
+    ##Possible non-Z/non-plunger gates
+    gates = {"x": "pi_2", "y": "pi_2", "xxx": "pi_2", "yyy": "pi_2",  "xx": "pi", "yy":  "pi", "mxxm": "pi", "myym": "pi"}
+    ## Read through CSV file ==> convert to data frame
+    df = pd.read_csv(file_path, header = None, skiprows=1)
+
+    ##Loop through qubit cores
+    for q_idx in qubit_cores:
+        #q_seq_line[q_idx-1] = []
+        q_seq_line[q_idx] = []
+    ##Loop through plunger channels
+    # for p_idx in plunger_channels:
+    #     p_seq_line[p_idx] = []
+
+    for idx in range(len(df)):
+        ##Single line obtained from Pandas data frame
+        line = df.values[idx][0].split(";")[0:len(df.values[idx][0].split(";"))-1]
+        ##Each gate in line
+        for elem in line:
+            element = re.split('\(| \)', elem)
+            p_idx_set = set()
+            q_idx_set = set()
+            length_set = []
+
+            for item in element:
+                if len(item)>2:
+                    if item[2] == "p":
+                        p_seq_line[int(item[0])].append(item[2:len(item)])
+                        p_idx_set.add(int(item[0]))
+                        #pulse_length = plunger_lengths[item[2:len(item)]]
+                        #length_set.append(pulse_length)
+                    else:
+                        q_seq_line[int(item[0])-1].append(item[2:len(item)])
+                        #q_seq_line[int(item[0])].append(item[2:len(item)])
+                        if item[2] == "t":
+                            length_set.append(int(item[2:len(item)]))
+                            q_idx_set.add(int(item[0]))
+                        elif item[2] == "z":
+                            pass
+                        else:
+                            qubit_length = qubit_lengths[int(item[0])][gates[item[2:len(item)]]]
+                            length_set.append(qubit_length)
+                            q_idx_set.add(int(item[0])-1)
+                else:
+                    pass
+
+            if len(length_set) == 0:
+                pass
+            else:
+                max_gt_len = max(length_set)
+                q_diff_set = qubit_cores.difference(q_idx_set)
+                p_diff_set = plunger_channels.difference(p_idx_set)
+                for item in q_diff_set:
+                    q_seq_line[item].append("t"+str(max_gt_len))
+                    #q_seq_line[item].append("t"+str(max_gt_len))
+                # for item in p_diff_set:
+                #     p_seq_line[item].append("t"+str(max_gt_len))
+        # qubit_line = {}
+        # for q in q_seq_line:
+        #     qubit_line[q] = q_seq_line[q][0:len(q_seq_line[q])/2]
+        # qubit_sequence_table[idx] = qubit_line
+        qubit_sequence_table[idx] = q_seq_line
+        print(qubit_sequence_table[idx])
+
+        #plunger_sequence_table[idx] = p_seq_line
+    return qubit_sequence_table, plunger_sequence_table
+
+def quantum_protocol_parser_Zarb(file_path, qubit_lengths, qubit_set = {1,2,3,4}):
+    sequence_table = {}
+    gates = {"x": "pi_2", "y": "pi_2", "xxx": "pi_2", "yyy": "pi_2",  "xx": "pi", "yy":  "pi", "mxxm": "pi", "myym": "pi"}
+    df = pd.read_csv(file_path, header = None, skiprows=1)
+    for idx in range(len(df)):
+        line = df.values[idx][0].split(";")[0:len(df.values[idx][0].split(";"))-1]
+        seq_line = {"0": [], "1": [], "2": [] , "3":[]}
+        for elem in line:
+            element = re.split('\(| \)', elem)
+            idx_set = set()
+            length_set = []
+            for item in element:
+                if len(item)>2:
+                    seq_line[str(int(item[0])-1)].append(item[2:len(item)])
+                    idx_set.add(int(item[0]))
+                    if item[2] == "t":
+                        length_set.append(int(item[3:len(item)]))
+                    elif item[2] == "z":
+                        length_set.append(32)
+                        pass
+                    else:
+                        qubit_length = qubit_lengths[int(item[0])][gates[item[2:len(item)]]]
+                        length_set.append(qubit_length)
+                else:
+                    pass
+            max_gt_len = max(length_set)
+            diff_set = qubit_set.difference(idx_set)
+            for item in diff_set:
+                seq_line[str(item-1)].append("t"+str(max_gt_len) )
+        sequence_table[idx] = seq_line
+    return sequence_table
+
+
+def quantum_protocol_parser_Zarb_v2(file_path, qubit_lengths, qubit_set = {1,2,3,4}):
+    sequence_table = {}
+    gates = {"x": "pi_2", "y": "pi_2", "xxx": "pi_2", "yyy": "pi_2",  "xx": "pi", "yy":  "pi", "mxxm": "pi", "myym": "pi"}
+    df = pd.read_csv(file_path, header = None, skiprows=1)
+    for idx in range(len(df)):
+        line = df.values[idx][0].split(";")[0:len(df.values[idx][0].split(";"))-1]
+        seq_line = {"0": [], "1": [], "2": [] , "3":[]}
+        for elem in line:
+            element = re.split('\(| \)', elem)
+            idx_set = set()
+            length_set = []
+            for item in element:
+                if len(item)>2:
+                    seq_line[str(int(item[0])-1)].append(item[2:len(item)])
+                    idx_set.add(int(item[0]))
+                    if item[2] == "t":
+                        length_set.append(int(item[3:len(item)]))
+                    elif item[2] == "z":
+                        channel_set = {"0", "1", "2", "3"}
+                        z_idx = {str(int(item[0])-1)}
+                        diff_set_z = channel_set.difference(z_idx)
+                        for itm in diff_set_z:
+                            seq_line[itm].append("z0z")
+                    else:
+                        qubit_length = qubit_lengths[int(item[0])][gates[item[2:len(item)]]]
+                        length_set.append(qubit_length)
+                else:
+                    pass
+            if len(length_set) == 0:
+                pass
+            else:
+                max_gt_len = max(length_set)
+                diff_set = qubit_set.difference(idx_set)
+                for item in diff_set:
+                    seq_line[str(item-1)].append("t"+str(max_gt_len))
+        sequence_table[idx] = seq_line
+    return sequence_table
+
+def quantum_protocol_parser_str(file_path, qubit_lengths, qubit_set = {1,2,3,4}):
+    sequence_table = {}
+    gates = {"x": "pi_2", "y": "pi_2", "xxx": "pi_2", "yyy": "pi_2",  "xx": "pi", "yy":  "pi", "mxxm": "pi", "myym": "pi"}
+    df = pd.read_csv(file_path, header = None, skiprows=1)
+    df = df[0:100]
+
+    for idx in range(len(df)):
+        line = df.values[idx][0].split(";")[0:len(df.values[idx][0].split(";"))-1]
+        seq_line = {"0": [], "1": [], "2": [] , "3":[]} ##refer as seq_line[idx].append(new_gate)
+        for elem in line:
+            element = re.split('\(| \)', elem)
+            idx_set = set()
+            length_set = []
+            for item in element:
+                if len(item)>2:
+                    seq_line[str(int(item[0])-1)].append(item[2:len(item)])
+                    #sequence_line[int(item[0])-1] = item[2:len(item)]
+                    idx_set.add(int(item[0]))
+                    if item[2] == "t":
+                        length_set.append(int(item[2:len(item)]))
+                    else:
+                        qubit_length = qubit_lengths[int(item[0])][gates[item[2:len(item)]]]
+                        length_set.append(qubit_length)
+                else:
+                    pass
+            max_gt_len = max(length_set)
+            diff_set = qubit_set.difference(idx_set)
+            for item in diff_set:
+                #sequence_line[item-1] = "t"+str(max_gt_len)
+                seq_line[str(item-1)].append("t"+str(max_gt_len) )
+
+        #sequence_table[idx] = sequence_line
+        sequence_table[idx] = seq_line
+    return sequence_table
+
+
+def gst_parser(file_path, qubit_lengths, qubit_set = {0,1,2,3}):
+    sequence_table = {}
+    gates = {"x": "pi_2", "y": "pi_2", "xxx": "pi_2", "yyy": "pi_2",  "xx": "pi", "yy":  "pi", "mxxm": "pi", "myym": "pi"}
+    df = pd.read_csv(file_path, header = None, skiprows=1)
+
+    for idx in range(len(df)):
+        line = df.values[idx][0].split(";")[0:len(df.values[idx][0].split(";"))-1]
+        seq_line = {0: [], 1: [], 2: [] , 3: []}
+
+        for elem in line:
+            element = re.split('\(| \)', elem)
+            idx_set = set()
+            length_set = []
+            for item in element:
+                if len(item)>2:
+                    seq_line[int(item[0])].append(item[2:len(item)])
+                    qubit_length = qubit_lengths[int(item[0])][gates[item[2:len(item)]]]
+                    length_set.append(qubit_length)
+                else:
+                    pass
+            max_gt_len = max(length_set)
+            diff_set = qubit_set.difference(idx_set)
+            for item in diff_set:
+                seq_line[item].append("t"+str(max_gt_len) )
+        sequence_table[idx] = seq_line
+    return sequence_table

silospin/math/math_helpers.py

@@ -2,14 +2,28 @@
 def gauss(x, amp, mu, sig):
     return amp*np.exp(-(x-mu)**2/(2*sig**2))
 
-def rectangular(npoints, amp):
+def rectangular(npoints, amp, min_points = 48):
     array = amp*np.ones(npoints)
-    array[0] = 0
-    array[1] = 0
-    array[npoints-1] = 0
-    array[npoints-2] = 0
-    return array 
+    if npoints < min_points:
+        npoints_pad = min_points - npoints
+        if npoints_pad%2 == 0:
+            zero_pad_l = np.zeros(int(npoints_pad/2))
+            zero_pad_r = np.zeros(int(npoints_pad/2))
+        elif 2*int(npoints_pad/2) + npoints < min_points:
+            zero_pad_l = np.zeros(int(npoints_pad/2))
+            zero_pad_r = np.zeros(int(npoints_pad/2) + 1)
+        else:
+            zero_pad_l = np.zeros(int(npoints_pad/2))
+            zero_pad_r = np.zeros(int(npoints_pad/2)-1)
+        array = np.concatenate((zero_pad_l, array,zero_pad_r), axis=None)
+    else:
+        array = amp*np.ones(npoints)
 
+    return array
 
-##def chirped():
-##def adiabatic():
+def compute_accumulated_phase(gt, phi_l):
+    phi_d_gt = {"x":  0, "y": 90, "xx":  0, "yy": 90 , "xxx":  180, "yyy": -90, "mxxm": 180, "myym": -90}
+    phi_d = phi_d_gt[gt]
+    phi_a = phi_d - phi_l
+    phi_l = phi_l + phi_a
+    return phi_l, phi_a