updated to add time dependence of steps

__main__.py

@@ -4,15 +4,20 @@ import matplotlib.pyplot as plt
 import elements
 import graphics
 import matrices
+from math import sqrt
 
 print("Hi World!")
 
 ## Tests
-print("###------ Portes anticommutantes ------")
-source = elements.Source(initial_vector = np.array([1. + 0j, 0.]))
+'''print("###------ Portes anticommutantes ------")
+source = elements.Source(initial_vector = np.array([(3/4)*(1. + 0j), (4/5)*(1. + 0j)]))
+
+elements.Screen(previous = (source, "left")).show()
 
 BS1 = elements.BeamSplitter(previous = {"left": None, "right": (source, "left")}, matrix=matrices.HALF_MIRROR_LEFT_ACTIVE)
 
+elements.Screen(previous = (BS1, "left")).show("left")
+elements.Screen(previous = (BS1, "right")).show("right")
 
 X_left_1 = elements.Plate(previous = (BS1, "left"), jones_matrix=matrices.X)
 Z_left_2 = elements.Plate(previous = (X_left_1, "left"), jones_matrix = matrices.Z)
@@ -21,20 +26,23 @@ Z_left_2 = elements.Plate(previous = (X_left_1, "left"), jones_matrix = matrices
 Z_right_1 = elements.Plate(previous = (BS1, "right"), jones_matrix = matrices.Z)
 X_right_2 = elements.Plate(previous = (Z_right_1, "left"), jones_matrix = matrices.X)
 
-BS2 = elements.BeamSplitter(previous = {"left": (Z_left_2, "left"), "right": (X_right_2, "left")}, matrix = matrices.HALF_MIRROR_RIGHT_ACTIVE)
+BS2 = elements.BeamSplitter(previous = {"left": (X_right_2, "left"), "right": (Z_left_2, "left")}, matrix = matrices.HALF_MIRROR_RIGHT_ACTIVE)
 
 screen_right = elements.Screen(previous = (BS2, "right"))
 screen_left = elements.Screen(previous = (BS2, "left"))
 
 screen_left.show("left")
-screen_right.show("right")
+screen_right.show("right")'''
 
-print("### ------ Portes commutantes ------")
+'''print("### ------ Portes commutantes ------")
 
 source2 = elements.Source(initial_vector = np.array([1.+0j, 0.]))
 
 BS12 = elements.BeamSplitter(previous = {"left": (source2, "left"), "right": None}, matrix=matrices.SYM_BS_INACTIVE)
 
+elements.Screen(previous = (BS12, "left")).show()
+elements.Screen(previous = (BS12, "right")).show()
+
 Phase_left_12 = elements.Plate(previous = (BS12, "left"), jones_matrix=matrices.PHASE(np.pi/5))
 Z_left_22 = elements.Plate(previous = (Phase_left_12, "left"), jones_matrix = matrices.Z)
 
@@ -48,4 +56,80 @@ screen_right2 = elements.Screen(previous = (BS22, "right"))
 screen_left2 = elements.Screen(previous = (BS22, "left"))
 
 screen_left2.show("left")
-screen_right2.show("right")
+screen_right2.show("right")'''
+
+
+'''print("###------ Tests BeamSplitters ------")
+source = elements.Source(initial_vector = np.array([(3/5)*(1. + 0j), (4/5)*(1. + 0j)]))
+
+elements.Screen(previous = (source, "left")).show()
+
+BS1 = elements.BeamSplitter(previous = {"left": None, "right": (source, "left")}, matrix=matrices.HALF_MIRROR_LEFT_ACTIVE)
+
+elements.Screen(previous = (BS1, "left")).show("left")
+elements.Screen(previous = (BS1, "right")).show("right")'''
+
+'''print("###------ Portes classiques ------")
+source = elements.Source(initial_vector = np.array([1. + 0j, 0.]))
+
+elements.Screen(previous = (source, "left")).show()
+
+Nom =   {str(matrices.X) : "X",
+        str(matrices.Y) : "Y",
+        str(matrices.Z) : "Z",
+        str(matrices.H) : "H",
+        str(matrices.S) : "S",
+        str(matrices.T) : "T",}
+
+Portes =    [matrices.X,
+            matrices.Y,
+            matrices.Z,
+            matrices.H,
+            matrices.S,
+            matrices.T]
+
+for porte1 in Portes:
+    P1 = elements.Plate(previous = (source, "left"), jones_matrix=porte1)
+    elements.Screen(previous = (P1, "left")).show( Nom[str(porte1)] + "|ψ⟩")
+    for porte2 in Portes:
+        P2 = elements.Plate(previous = (P1, "left"), jones_matrix=porte2)
+        elements.Screen(previous = (P2, "left")).show(Nom[str(porte2)] + Nom[str(porte1)] + "|ψ⟩")'''
+
+print("###------ Tentative marche aléatoire ------")
+
+
+def marche(n):
+    Photons = [elements.Source(initial_vector = np.array([0., 1.+0j]))]
+    for i in range(n):
+        New_Photons = []
+        new_photons = dict()
+        for source in Photons:
+            PH = elements.Plate(previous = (source, "left"), jones_matrix=matrices.H)
+            BS = elements.BeamSplitter(previous = {"left": (PH, "left"), "right": None}, matrix=matrices.POLARISER_BS)
+            LEFT = elements.Path(previous = (BS, "left"), time = -1)
+            RIGHT = elements.Path(previous = (BS, "right"), time = 1)
+            Screen_left = elements.Screen(previous = (LEFT, "left"))
+            Screen_right = elements.Screen(previous = (RIGHT, "right"))
+            if Screen_left.temporality() in new_photons.keys():
+                new_photons[Screen_left.temporality()][0] += Screen_left.out()[0]
+                new_photons[Screen_left.temporality()][1] += Screen_left.out()[1]
+            else:
+                new_photons[Screen_left.temporality()] = np.array([Screen_left.out()[0], Screen_left.out()[1]])
+            if Screen_right.temporality() in new_photons.keys():
+                new_photons[Screen_right.temporality()][0] += Screen_right.out()[0] 
+                new_photons[Screen_right.temporality()][1] += Screen_right.out()[1]
+            else:
+                new_photons[Screen_right.temporality()] = np.array([Screen_right.out()[0], Screen_right.out()[1]])
+        Photons = [elements.Source(initial_vector = list(new_photons.values())[k] ,time = list(new_photons.keys())[k] ) for k in range(len(new_photons))]
+    repartition = dict()
+    for photon in Photons:
+        if photon.temporality('left') in repartition.keys():
+            repartition[photon.temporality('left')] += photon.out('left')[0]**2 + photon.out('left')[1]**2
+        else:
+            repartition[photon.temporality('left')] = photon.out('left')[0]**2 + photon.out('left')[1]**2
+    plt.plot(list(repartition.keys()),list(repartition.values()))
+    plt.title("Distribution de densité de probabilité")
+    plt.xlabel("Position")
+    plt.ylabel("Probabilité de présence")
+    plt.show()
+marche(100)
\ No newline at end of file

elements.py

@@ -2,12 +2,16 @@ import numpy as np
 
 ### ------ Special elements ------
 class Source:
-    def __init__(self, initial_vector=np.array([1., 0.+0j])): ## if no input state given, starts a |0>
+    def __init__(self, initial_vector=np.array([1., 0.+0j]), time = 0): ## if no input state given, starts a |0>
         self.photon = initial_vector
         self.next = None
+        self.time = time
 
     def out(self, side):
         return self.photon
+    
+    def temporality(self, side):
+        return self.time
 
 
 class Screen:
@@ -17,14 +21,18 @@ class Screen:
     def show(self, name = 'ψ'):
         previous_component, previous_component_output_side = self.previous
         ket = previous_component.out(previous_component_output_side)
-        alpha = round(ket[0])
-        beta = round(ket[1])
+        alpha = round(ket[0],3)
+        beta = round(ket[1],3)
         print(f"|{name}⟩ = {alpha}|0⟩ + {beta}|1⟩")
 
     def out(self):
         previous_component, previous_component_output_side = self.previous
         return previous_component.out(previous_component_output_side)
 
+    def temporality(self):
+        previous_component, previous_component_output_side = self.previous
+        return previous_component.temporality(previous_component_output_side) 
+
 
 
 ### ------ Classic Elements ------
@@ -33,6 +41,19 @@ class Element:
         self.previous = previous  ## (as in {"left": (Object 1, "label of chosen output of object 1"), "right": (obj2, "label2")})
         self.next = None
 
+class Path(Element):
+    def __init__(self, previous, time):
+        Element.__init__(self, previous)
+        self.time = time
+
+    def out(self, side):
+        previous_component, previous_component_output_side = self.previous
+        return previous_component.out(previous_component_output_side)
+    
+    def temporality(self, side):
+        previous_component, previous_component_output_side = self.previous
+        return previous_component.temporality(previous_component_output_side) + self.time
+
 class Plate(Element):
     def __init__(self, previous, jones_matrix = np.eye(2, dtype='complex')):
         Element.__init__(self, previous)
@@ -44,6 +65,10 @@ class Plate(Element):
         previous_element_output_side = self.previous[1]
         self.output_vector = self.jones_matrix @ previous_element.out(previous_element_output_side) # matrix-vector product : jones matrix times state vector given by the out(side) method of the previous component
         return self.output_vector
+    
+    def temporality(self, side):
+        previous_component, previous_component_output_side = self.previous
+        return previous_component.temporality(previous_component_output_side)
 
 class BeamSplitter(Element):
     """matrix is a 4x4 complex ndarray, two first dimensions regard left input, two next are right. So it's blockwise defined."""
@@ -77,3 +102,30 @@ class BeamSplitter(Element):
             _, ans = np.split(self.output_vector, 2)
 
         return ans
+
+    def temporality(self, side):
+        if self.previous["left"] is None and self.previous["right"] is None:
+            return 0
+
+        elif self.previous["left"] is None:
+            right_previous_component = self.previous["right"][0]
+            right_previous_component_output_side = self.previous["right"][1]
+            right_time = right_previous_component.temporality(right_previous_component_output_side)
+            return right_time
+
+        elif self.previous["right"] is None:
+            left_previous_component = self.previous["left"][0]
+            left_previous_component_output_side = self.previous["left"][1]
+            left_time = left_previous_component.temporality(left_previous_component_output_side)
+            return left_time
+        else:
+            right_previous_component = self.previous["right"][0]
+            right_previous_component_output_side = self.previous["right"][1]
+            right_time = right_previous_component.temporality(right_previous_component_output_side)
+            left_previous_component = self.previous["left"][0]
+            left_previous_component_output_side = self.previous["left"][1]
+            left_time = left_previous_component.temporality(left_previous_component_output_side)
+            if side == "left":
+                return left_time
+            elif side == "right":
+                return right_time
\ No newline at end of file

graphics.py

+import matplotlib.pyplot as plt 

matrices.py

@@ -73,3 +73,8 @@ HALF_MIRROR_RIGHT_ACTIVE = (1/np.sqrt(2))*np.array([[1,   0,   1,   0],
                                                     [0,  -1,   0,   1],
                                                     [1,   0,  -1,   0],
                                                     [0,   1,   0,   1]], dtype='complex')
+
+POLARISER_BS = np.array([[1,   0,   0,   0],
+                        [0,  0,   1,   0],
+                        [0,   0,  0,   1],
+                        [0,   1,   0,   0]], dtype='complex')