First simulations

quasi/_math/fock/ops.py

@@ -209,7 +209,7 @@ def fock_probability(n, state):
     return np.abs(state[tuple(n)]) ** 2
 
 
-def mean_photon(state, mode,):
+def mean_photon_number(state, mode,):
     # pylint: disable=unused-argument
     n = np.arange(state._cutoff)
     probs = np.diagonal(state.reduced_dm(mode))
@@ -547,4 +547,4 @@ def mix(state, n):
     right_str = [indices[i] for i in range(1, 2 * n, 2)]
     out_str = [indices[: 2 * n]]
     einstr = "".join(left_str + [","] + right_str + ["->"] + out_str)
-    return np.einsum(einstr, state, state.conj())
+    return np.einsum(einstr, state, state.conj())

quasi/devices/__init__.py

@@ -4,7 +4,7 @@
 from .generic_device import GenericDevice
 from .generic_device import wait_input_compute
 from .generic_device import ensure_output_compute
-from .port import connect_ports
+#from .port import connect_ports
 from .port import Port
 from .beam_splitter import BeamSplitter
 from .generic_device import DeviceInformation

quasi/devices/beam_splitters/ideal_beam_splitter.py

@@ -19,11 +19,11 @@ class IdealBeamSplitter(GenericDevice):
     ports = {
         "A": Port(label="A", direction="input", signal=None,
                   signal_type=GenericSignal, device=None),
-        "B": Port(label="A", direction="output", signal=None,
+        "B": Port(label="B", direction="output", signal=None,
                   signal_type=GenericQuantumSignal, device=None),
-        "C": Port(label="A", direction="input", signal=None,
+        "C": Port(label="C", direction="input", signal=None,
                   signal_type=GenericSignal, device=None),
-        "D": Port(label="A", direction="output", signal=None,
+        "D": Port(label="D", direction="output", signal=None,
                   signal_type=GenericQuantumSignal, device=None),
     }
 
@@ -32,7 +32,6 @@ class IdealBeamSplitter(GenericDevice):
     gui_tags = ["ideal"]
     gui_name = "Ideal Beam Splitter"
 
-    @ensure_output_compute
     @wait_input_compute
     def compute_outputs(self):
-        pass
+        print("TEST")

quasi/devices/control/simple_trigger.py

@@ -29,8 +29,15 @@ class SimpleTrigger(GenericDevice):
     gui_icon = icon_list.SIMPLE_TRIGGER
     gui_tags = ["control"]
     gui_name = "Simple Trigger"
+    power = 0
+    power_average = 0
+    power_peak = 0
+    reference = None
 
     @ensure_output_compute
     @wait_input_compute
-    def compute_outputs(self):
-        pass
+    def compute_outputs(self, *args, **kwargs):
+        print("TRIGGERING")
+        self.ports["T"].data = True
+        self.ports["T"].signal.set_computed()
+

quasi/devices/generic_device.py

@@ -3,7 +3,7 @@
 """
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import Dict
+from typing import Dict, Type
 from copy import deepcopy
 
 from quasi.simulation import Simulation, DeviceInformation
@@ -14,12 +14,14 @@ def wait_input_compute(method):
     Wrapper function, makes sure that the inputs are
     computed before computing outputs.
     """
-
     def wrapper(self, *args, **kwargs):
+        print(args)
+        print(kwargs)
         for port in self.ports.keys():
             port = self.ports[port]
             if port.direction == "input":
-                port.signal.wait_till_compute()
+                if port.signal is not None:
+                    port.signal.wait_till_compute()
         return method(self, *args, **kwargs)
 
     return wrapper
@@ -33,8 +35,9 @@ def ensure_output_compute(method):
     """
 
     def wrapper(self, *args, **kwargs):
+        print(args)
+        print(kwargs)
         return method(self, *args, **kwargs)
-
     return wrapper
 
 
@@ -58,15 +61,9 @@ def __init__(self, name=None):
         simulation.register_device(ref)
 
 
-<<<<<<< HEAD
-
-    def register_signal(self, signal,port_label:str,
-                        override:bool=False):
-=======
     def register_signal(
         self, signal: GenericSignal, port_label: str, override: bool = False
     ):
->>>>>>> origin/beam_splitter
         """
         Register a signal to port
         """
@@ -105,11 +102,7 @@ def compute_outputs(self):
 
     @property
     @abstractmethod
-<<<<<<< HEAD
-    def ports(self):
-=======
-    def ports(self) -> Dict[str, Port]:
->>>>>>> origin/beam_splitter
+    def ports(self) -> Dict[str, Type["Port"]]:
         """Average Power Draw"""
         raise NotImplementedError("power must be defined")
 

quasi/devices/investigation_devices/__init__.py

@@ -1 +1,2 @@
 from .wigner_control import WignerControl
+from .photon_distribution import PhotonDistribution

quasi/devices/investigation_devices/photon_distribution.py

@@ -0,0 +1,61 @@
+"""
+Photon Distribution
+"""
+import plotly.express as px
+import numpy as np
+
+from quasi.devices import (GenericDevice,
+                           wait_input_compute,
+                           ensure_output_compute)
+from quasi.devices.port import Port
+from quasi.signals import (GenericSignal,
+                           GenericQuantumSignal)
+
+from quasi.gui.icons import icon_list
+from quasi.simulation import ModeManager
+
+
+class PhotonDistribution(GenericDevice):
+    """
+    Implements Photon Distribution Grapphing device
+    """
+    ports = {
+        "IN": Port(
+            label="IN",
+            direction="input",
+            signal=None,
+            signal_type=GenericQuantumSignal, device=None),
+    }
+
+    # Gui Configuration
+    gui_icon = icon_list.HISTOGRAM
+    gui_tags = ["investigate"]
+    gui_name = "Photon Distribution"
+
+    power_average = 0
+    power_peak = 0
+    reference = 0
+
+
+
+    @wait_input_compute
+    def compute_outputs(self, *args, **kwargs):
+        mm = ModeManager()
+        m_id = self.ports["IN"].signal.mode_id
+        mode = mm.get_mode(m_id)
+        print(mode)
+        probabilities = np.real(np.diag(mode))
+
+        histogram_data = {
+            'State': [str(i) for i in range(len(probabilities))],
+            'Probability': probabilities}
+
+        # Create a histogram using Plotly Express
+        fig = px.bar(histogram_data, x='State', y='Probability',
+                    labels={'Probability': 'Probability Amplitude', 'State': 'Fock State'},
+                    title='Fock State Density Matrix Histogram')
+
+        # Show the plot
+        fig.show()
+
+

quasi/devices/investigation_devices/wigner_control.py

@@ -1,5 +1,5 @@
 """
-Ideal Single Photon Source implementation
+Create wigner distribution plots
 """
 
 from quasi.devices import (GenericDevice,

quasi/devices/sources/ideal_single_photon_source.py

@@ -1,34 +1,62 @@
 """
 Ideal Single Photon Source implementation
 """
+import numpy as np
 
 from quasi.devices import (GenericDevice,
                            wait_input_compute,
                            ensure_output_compute)
 from quasi.devices.port import Port
 from quasi.signals import (GenericSignal,
+                           QuantumContentType,
+                           GenericBoolSignal,
                            GenericQuantumSignal)
 
 from quasi.gui.icons import icon_list
+from quasi.simulation import ModeManager
 
+from quasi._math.fock.ops import adagger, a
 
 class IdealSinglePhotonSource(GenericDevice):
     """
     Implements Ideal Single Photon Source
     """
     ports = {
-        "control": Port(label="A", direction="input", signal=None,
-                        signal_type=GenericSignal, device=None),
-        "output": Port(label="A", direction="output", signal=None,
-                       signal_type=GenericQuantumSignal, device=None),
+        "control": Port(
+            label="control",
+            direction="input",
+            signal=None,
+            signal_type=GenericBoolSignal,
+            device=None),
+        "output": Port(
+            label="output",
+            direction="output",
+            signal=None,
+            signal_type=GenericQuantumSignal,
+            device=None),
     }
 
     # Gui Configuration
     gui_icon = icon_list.SINGLE_PHOTON_SOURCE
     gui_tags = ["ideal"]
     gui_name = "Ideal Single Photon Source"
 
+    power_peak = 0
+    power_average = 0
+
+    reference = None
+
     @ensure_output_compute
     @wait_input_compute
-    def compute_outputs(self):
-        pass
+    def compute_outputs(self, *args, **kwargs):
+        mm = ModeManager()
+        m_id = mm.create_new_mode()
+        AD = adagger(mm.simulation.dimensions)
+        A = a(mm.simulation.dimensions)
+        mode = mm.get_mode(m_id)
+        mm.modes[m_id] =  np.matmul(AD, np.matmul(mode, A))
+        self.ports["output"].signal.set_contents(
+            content_type=QuantumContentType.FOCK,
+            mode_id=m_id)
+        self.ports["output"].signal.set_computed()
+

quasi/experiment/__init__.py

@@ -0,0 +1 @@
+from .experiment_manager import Experiment

quasi/experiement/experiement_manager.py → quasi/experiment/experiment_manager.py

@@ -4,7 +4,7 @@
 import numpy as np
 
 
-class Experiement:
+class Experiment:
     """Singleton object"""
 
     def __init__(self, num_modes, hbar=2, cutoff=10):