Merge pull request #3 from tqsd/fix_id_issue

removed all id occurances by q_id or similar, since of collision with…

Author: benjione

eqsn/gates.py

@@ -18,19 +18,19 @@ def __init__(self):
         self.manager = multiprocessing.Manager()
         self.shared_dict = SharedDict.get_instance()
 
-    def new_qubit(self, id):
+    def new_qubit(self, q_id):
         """
         Creates a new qubit with an id.
 
         Args:
             id (String): Id of the new qubit.
         """
         q = multiprocessing.Queue()
-        thread = QubitThread(id, q)
+        thread = QubitThread(q_id, q)
         p = multiprocessing.Process(target=thread.run, args=())
-        self.shared_dict.set_thread_with_id(id, p, q)
+        self.shared_dict.set_thread_with_id(q_id, p, q)
         p.start()
-        logging.debug("Created new qubit with id %s.", id)
+        logging.debug("Created new qubit with id %s.", q_id)
 
     def stop_all(self):
         """
@@ -176,7 +176,7 @@ def cphase_gate(self, q_id1, q_id2):
         q = self.shared_dict.get_queues_for_ids([q_id1])[0]
         q.put([CONTROLLED_GATE, x, q_id1, q_id2])
 
-    def measure(self, id, non_destructive=False):
+    def measure(self, q_id, non_destructive=False):
         """
         Measures a qubit with an id. If non_destructive is False, the qubit
         is removed from the system, otherwise, the qubit stays in the system
@@ -188,14 +188,14 @@ def measure(self, id, non_destructive=False):
                                     system after measurement.
         """
         ret = self.manager.Queue()
-        q = self.shared_dict.get_queues_for_ids([id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         if non_destructive:
-            q.put([MEASURE_NON_DESTRUCTIVE, id, ret])
+            q.put([MEASURE_NON_DESTRUCTIVE, q_id, ret])
         else:
-            q.put([MEASURE, id, ret])
+            q.put([MEASURE, q_id, ret])
         res = ret.get()
         if not non_destructive:
-            self.shared_dict.delete_id_and_check_to_join_thread(id)
+            self.shared_dict.delete_id_and_check_to_join_thread(q_id)
         logging.debug(
-            "Qubit with id %s has been measured with outcome %d.", id, res)
+            "Qubit with id %s has been measured with outcome %d.", q_id, res)
         return res

eqsn/qubit_thread.py

@@ -39,7 +39,7 @@ def __init__(self, q_id, queue):
 
         logging.debug("Qubit thread with qubit %s has been created.", q_id)
 
-    def apply_single_gate(self, mat, id):
+    def apply_single_gate(self, mat, q_id):
         """
         Applys a single gate to a qubit.
 
@@ -48,7 +48,7 @@ def apply_single_gate(self, mat, id):
             id (String): Qubit on which the gate should be applied to.
         """
         apply_mat = mat
-        nr = self.qubits.index(id)
+        nr = self.qubits.index(q_id)
         total_amount = len(self.qubits)
         before = nr
         after = total_amount - nr - 1
@@ -58,14 +58,14 @@ def apply_single_gate(self, mat, id):
             apply_mat = np.kron(apply_mat, np.eye(2 ** after))
         self.qubit = np.dot(apply_mat, self.qubit)
 
-    def apply_controlled_gate(self, mat, id1, id2):
+    def apply_controlled_gate(self, mat, q_id1, q_id2):
         """
         Apply a controlled gate to
         """
         first_mat = 1
         second_mat = 1
-        nr1 = self.qubits.index(id1)
-        nr2 = self.qubits.index(id2)
+        nr1 = self.qubits.index(q_id1)
+        nr2 = self.qubits.index(q_id2)
         min_nr = min(nr1, nr2)
         max_nr = max(nr1, nr2)
         if min_nr == nr1:
@@ -128,13 +128,13 @@ def send_qubits(self, channel):
         channel.put(dp(self.qubits))
         return
 
-    def measure_non_destructive(self, id, ret_channel):
+    def measure_non_destructive(self, q_id, ret_channel):
         """
         Perform a non destructive measurement on qubit with the id.
         """
         # determine probability for |1>
         measure_vec = np.array([1, 0], dtype=np.csingle)
-        nr = self.qubits.index(id)
+        nr = self.qubits.index(q_id)
         total_amount = len(self.qubits)
         before = nr
         after = total_amount - nr - 1
@@ -166,13 +166,13 @@ def measure_non_destructive(self, id, ret_channel):
         norm = np.linalg.norm(self.qubit)
         self.qubit = self.qubit / norm
 
-    def measure(self, id, ret_channel):
+    def measure(self, q_id, ret_channel):
         """
         Perform a destructive measurement on qubit with the id.
         """
         # determine probability for |1>
         measure_vec = np.array([1, 0], dtype=np.csingle)
-        nr = self.qubits.index(id)
+        nr = self.qubits.index(q_id)
         total_amount = len(self.qubits)
         before = nr
         after = total_amount - nr - 1
@@ -198,7 +198,7 @@ def measure(self, id, ret_channel):
         if after > 0:
             reduction_mat = np.kron(
                 reduction_mat, np.eye(2 ** after, dtype=np.csingle))
-        self.qubits.remove(id)
+        self.qubits.remove(q_id)
         if total_amount == 1:
             # it was the last qubit, just terminate this process
             return

eqsn/shared_dict.py

@@ -57,7 +57,7 @@ def acquire_write(self):
             self._writerList.append(threading.get_ident())
             while self._readers > 0:
                 if self._promote and threading.get_ident() in self._readerList and set(self._readerList).issubset(
-                set(self._writerList)):
+                        set(self._writerList)):
                     break
                 else:
                     self._read_ready.wait()
@@ -93,8 +93,8 @@ def __init__(self):
     def get_queues_for_ids(self, q_id_list):
         ret = []
         self.lock.acquire_read()
-        for id in q_id_list:
-            res = self.id_to_queue[id]
+        for q_id in q_id_list:
+            res = self.id_to_queue[q_id]
             if res not in ret:
                 ret.append(res)
         self.lock.release_read()