Initial release

104 files changed, 15822 insertions, 0 deletions

diff --git a/src/devices/alldevices.h b/src/devices/alldevices.h
new file mode 100644
index 0000000..daa7ee1
--- /dev/null
+++ b/src/devices/alldevices.h
@@ -0,0 +1,44 @@
+#pragma once
+
+/** ******************************************* **/
+/**       Elementary passive devices            **/
+/** ******************************************* **/
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <merger.h>
+#include <splitter.h>
+#include <crossing.h>
+#include <pcm_device.h>
+
+/** ******************************************* **/
+/**            Active devices                   **/
+/** ******************************************* **/
+#include <detector.h>
+#include <phaseshifter.h>
+#include <mzi_active.h>
+#include <mzi.h>
+
+/** ******************************************* **/
+/**            Sources                          **/
+/** ******************************************* **/
+//#include <bitstream_source.h>
+#include <cw_source.h>
+#include <value_list_source.h>
+#include <electrical_value_list_source.h>
+
+/** ******************************************* **/
+/**              Utilities                      **/
+/** ******************************************* **/
+#include <probe.h>
+//#include <ring.h>
+#include <time_monitor.h>
+
+/** ******************************************* **/
+/**           Circuits                          **/
+/** ******************************************* **/
+#include <crow.h>
+#include <octane_cell.h>
+#include <octane_segment.h>
+#include <octane_matrix.h>
+#include <mesh_col.h>
+#include <clements.h>
diff --git a/src/devices/bitstream_source.cpp b/src/devices/bitstream_source.cpp
new file mode 100644
index 0000000..f2e38a6
--- /dev/null
+++ b/src/devices/bitstream_source.cpp
@@ -0,0 +1,76 @@
+#include <bitstream_source.h>
+
+#include <random>
+#include <cstdlib>
+
+using std::cout;
+using std::endl;
+
+unsigned int BitstreamSource::m_bits_per_value = 8;
+//double BitstreamSource::m_output_jitter = 0.0;
+
+void BitstreamSource::runner()
+{
+    // Initialize random number generator
+    //mt19937 gen(m_seed);
+    //uniform_int_distribution<> dis(1, m_max_value); // uniform in [1, max]
+    //int operation_mode = 0; // 0: modulated source , 1: independent pulses
+
+    auto max_val = pow(2.0, m_bits_per_value) - 1;
+
+    cout << name() << ":" << endl;
+    cout << "signal on: " << m_signal_on << endl;
+    cout << "signal off: " << m_signal_off << endl;
+    cout << "bits: ";
+    cout << endl;
+
+    for(const auto &val : m_values) {
+        auto val_saturated = val;
+        if (m_current_value > max_val)
+            val_saturated = max_val;
+
+        for (unsigned int iBit = 0; iBit < m_bits_per_value; ++iBit) {
+            bool bit = val_saturated & (1 << iBit);
+            cout << bit;
+        }
+    }
+    cout << " --> " << (dynamic_cast<sc_signal<OpticalSignal> *>(p_out.get_interface()))->name();
+    cout << endl;
+    cout << endl;
+
+    // Loop over all values
+    for (unsigned int iVal = 0; iVal < m_values.size(); ++iVal) {
+        m_current_value = m_values[iVal];
+
+        if (m_current_value > max_val)
+            m_current_value = max_val;
+
+        for (unsigned int iBit = 0; iBit < m_bits_per_value; ++iBit) {
+            // Wait at least one clk cycle, and for enable to be high
+            do {
+                // Wait next clk edge
+                wait();
+                cout << "CLK tick (" << this->name() << ")" << endl;
+            } while (!p_enable->read());
+            
+            // Deduce bit "value" from binary representation
+            // iBit = 0 represents LSB
+            bool bit = m_current_value & (1 << iBit);
+
+            // Initialize corresponding signal
+            auto s = (bit ? OpticalSignal(m_signal_on) :
+                            OpticalSignal(m_signal_off));
+
+            s.getNewId(); // New Id is necessary to notify signal change
+
+            // Send signal to output with no delay
+            m_out_writer.delayedWrite(s, SC_ZERO_TIME);
+        }
+    }
+
+    // Wait for end of simulation
+    while (true) {
+        // Do nothing
+        wait();
+    }
+}
diff --git a/src/devices/bitstream_source.h b/src/devices/bitstream_source.h
new file mode 100644
index 0000000..a7c8715
--- /dev/null
+++ b/src/devices/bitstream_source.h
@@ -0,0 +1,105 @@
+#pragma once
+
+#include <systemc.h>
+#include <fstream>
+
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+using namespace std;
+
+class BitstreamSource : public sc_module {
+public:
+    // Set it as typedef for now (we may very well never need to change it)
+    typedef unsigned long operand_type;
+
+public:
+    // Ports
+    sc_port<sc_signal_in_if<bool>> p_enable;
+    sc_in<bool> p_clk;
+    sc_port<sc_signal_out_if<OpticalSignal>> p_out;
+
+    // Timed ports writers
+    OpticalOutputPort m_out_writer;
+
+    // Member variables
+    static unsigned int m_bits_per_value;
+
+    vector<operand_type> m_values;
+    operand_type m_current_value = 0;
+
+    OpticalSignal m_signal_on;
+    OpticalSignal m_signal_off;
+
+    // Processes
+    void runner();
+
+    // 
+    inline void setWavelength(const double &wl)
+    { 
+        m_signal_on.m_wavelength_id = m_signal_on.getIDFromWavelength(wl);
+        m_signal_off.m_wavelength_id = m_signal_off.getIDFromWavelength(wl);
+    }
+    
+    // 
+    inline void setPower(const double &on, const double &off = 0.0)
+    { 
+        m_signal_on.m_field = sqrt(on);
+        m_signal_off.m_field = sqrt(off);
+    }
+
+    // Constructor
+    BitstreamSource(sc_module_name name)
+        : sc_module(name)
+        , m_out_writer("out_delayed_writer", p_out)
+    {
+        SC_HAS_PROCESS(BitstreamSource);
+
+        SC_THREAD(runner);
+        sensitive << p_clk.pos() << p_clk.neg();
+    }
+
+    BitstreamSource(sc_module_name name,
+                     const vector<operand_type> &values,
+                     const OpticalSignal &signal_on,
+                     const OpticalSignal &signal_off = OpticalSignal(0))
+        : sc_module(name)
+        , m_out_writer("out_delayed_writer", p_out)
+        , m_values(values)
+        , m_current_value(values.empty() ? 0 : values[0])
+        , m_signal_on(signal_on)
+        , m_signal_off(signal_off)
+    {
+        SC_HAS_PROCESS(BitstreamSource);
+
+        SC_THREAD(runner);
+        sensitive << p_clk.pos() << p_clk.neg();
+    }
+
+    BitstreamSource(sc_module_name name,
+                     const std::string &values_file,
+                     const OpticalSignal &signal_on,
+                     const OpticalSignal &signal_off = OpticalSignal(0))
+        : sc_module(name)
+        , m_out_writer("out_delayed_writer", p_out)
+        , m_signal_on(signal_on)
+        , m_signal_off(signal_off)
+    {
+        // Read values from file
+        std::ifstream i(values_file);
+        
+        int value;
+        m_values.clear();
+        while ( i.good() ) {
+            i >> value;
+            m_values.push_back(value);
+        }
+
+        m_current_value = (m_values.empty() ? 0 : m_values[0]);
+
+        SC_HAS_PROCESS(BitstreamSource);
+        
+        SC_THREAD(runner);
+        sensitive << p_clk.pos() << p_clk.neg();
+    }
+};
diff --git a/src/devices/clements.cpp b/src/devices/clements.cpp
new file mode 100644
index 0000000..a99bfb3
--- /dev/null
+++ b/src/devices/clements.cpp
@@ -0,0 +1,137 @@
+#include "clements.h"
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX)).c_str())
+
+void Clements::init_ports()
+{
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing optical ports
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    p_in.clear();
+    p_out.clear();
+    for(size_t i = 0; i < m_N; i++)
+    {
+        p_in.push_back(make_unique<spx::oa_port_in_type>(__modname("IN_", i)));
+        p_out.push_back(make_unique<spx::oa_port_out_type>(__modname("OUT_", i)));
+    }
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing electrical input ports
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    p_vphi.clear();
+    p_vtheta.clear();
+
+    size_t num_of_electrical_ports = (m_N * (m_N - 1) / 2);
+    for(size_t i = 0; i < num_of_electrical_ports; i++)
+    {
+        p_vphi.push_back(make_unique<sc_in<double>>(__modname("VPHI_", i)));
+        p_vtheta.push_back(make_unique<sc_in<double>>(__modname("VTHETA_", i)));
+    }    
+}
+
+void Clements::init()
+{
+    m_optical_connect.clear();
+    m_mesh_cols.clear();
+
+    size_t num_cols = (m_N != 2) ? m_N : 1;
+    size_t num_wires = m_N * (num_cols - 1);
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Instantiating submodules
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    for(size_t j = 0; j < num_cols; j++)
+    {
+        m_mesh_cols.push_back(make_unique<MeshCol>(__modname("COL_", j),
+                            m_N, j, m_length_cm, m_attenuation_wg_dB_cm,
+                            m_attenuation_coupler_dB, m_attenuation_ps_dB,
+                            m_neff, m_ng));
+        m_mesh_cols[j]->init();
+    }
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Instantiating optical wires
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    for(size_t i = 0; i < num_wires; i++)
+        m_optical_connect.push_back(make_unique<spx::oa_signal_type>(__modname("W_", i)));
+    
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Connecting modules (optical)
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    if (m_N == 2)
+    {
+        m_mesh_cols[0]->p_in[0]->bind(*p_in[0]);
+        m_mesh_cols[0]->p_in[1]->bind(*p_in[1]);
+        m_mesh_cols[0]->p_out[0]->bind(*p_out[0]);
+        m_mesh_cols[0]->p_out[1]->bind(*p_out[1]);
+    }
+    else
+    {
+        // first col has inputs that go to ports,
+        // and outputs going to the first m_N wires
+        for(size_t i = 0; i < m_N; i++)
+        {
+            m_mesh_cols[0]->p_in[i]->bind(*p_in[i]);
+            m_mesh_cols[0]->p_out[i]->bind(*m_optical_connect[i]);
+        }
+
+        size_t in_index;
+        size_t out_index;
+        for(size_t j = 1; j < num_cols - 1; j++)
+        {
+            in_index = (j - 1) * m_N;
+            out_index = j * m_N;
+            for(size_t i = 0; i < m_N; i++)
+            {
+                m_mesh_cols[j]->p_in[i]->bind(*m_optical_connect[in_index + i]);
+                m_mesh_cols[j]->p_out[i]->bind(*m_optical_connect[out_index + i]);            
+            }
+        }
+
+        // last col has outputs that go to ports,
+        // and inputs coming from the last m_N wires
+        in_index = (num_cols - 2) * m_N;
+        for(size_t i = 0; i < m_N; i++)
+        {
+            m_mesh_cols[num_cols - 1]->p_in[i]->bind(*m_optical_connect[in_index + i]);
+            m_mesh_cols[num_cols - 1]->p_out[i]->bind(*p_out[i]);            
+        }
+    }
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Connecting modules (electrical)
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    // The index of the electrical port advances top to bottom, and
+    // then moves to the next column
+
+    size_t ports_in_col;
+    size_t cur_port = 0;
+    for(size_t j = 0; j < num_cols; j++)
+    {
+        ports_in_col = m_N/2;
+        if ((m_N % 2 == 0) && !(j % 2 == 0)) // if even-odd, there is one less MZI
+            ports_in_col = m_N/2 - 1;
+            
+        for(size_t i = 0; i < ports_in_col; i++)
+        {
+            m_mesh_cols[j]->p_vphi[i]->bind(*p_vphi[cur_port]);
+            m_mesh_cols[j]->p_vtheta[i]->bind(*p_vtheta[cur_port]);   
+            
+            cur_port ++;         
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/devices/clements.h b/src/devices/clements.h
new file mode 100644
index 0000000..78de99f
--- /dev/null
+++ b/src/devices/clements.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <specs.h>
+#include <spx_module.h>
+#include <mesh_col.h>
+
+/* Clements MZI Mesh
+
+The mesh has a total of N(N-1)/2 MZIs, as specified in
+Optimal design for universal multiport interferometers by Clements et al. (2016).
+
+Connection guide (above the X is electrical address of phi/theta):
+           0             3
+        0__| __ ______ __| __ ______0
+           \/     2      \/     5
+        1__/\__ __| __ __/\__ __| __1
+           1      \/     4      \/
+        2__| __ __/\__ __| __ __/\__2
+           \/            \/     
+        3__/\__ ______ __/\__ ______3
+*/
+
+class Clements : public spx_module{
+public:
+    vector<unique_ptr<spx::oa_port_in_type>> p_in;
+    vector<unique_ptr<spx::oa_port_out_type>> p_out;
+    vector<unique_ptr<sc_in<double>>> p_vphi;
+    vector<unique_ptr<sc_in<double>>> p_vtheta;
+
+    // Member variables
+    size_t m_N; // represents the number of inputs of the mesh (rows)
+
+    // Parameters for the internal MZIs
+    double m_length_cm;
+    double m_attenuation_wg_dB_cm;
+    double m_attenuation_coupler_dB;
+    double m_attenuation_ps_dB;
+    double m_neff;
+    double m_ng;
+
+    // Submodules and wires
+    vector<unique_ptr<spx::oa_signal_type>> m_optical_connect;
+    vector<unique_ptr<MeshCol>> m_mesh_cols;
+
+    // Initialization functions
+    void init_ports();
+    void init();
+
+    Clements(sc_module_name name, const size_t &N,
+            const double &length_cm = 1e-2,
+            const double &attenuation_wg_dB_cm = 0, const double &attenuation_coupler_dB = 0,
+            const double &attenuation_ps_dB = 0,
+            const double &neff = 2.2111, const double &ng = 2.2637)
+        : spx_module(name)
+        , m_N(N)
+        , m_length_cm(length_cm)
+        , m_attenuation_wg_dB_cm(attenuation_wg_dB_cm)
+        , m_attenuation_coupler_dB(attenuation_coupler_dB)
+        , m_attenuation_ps_dB(attenuation_ps_dB)
+        , m_neff(neff)
+        , m_ng(ng)
+    {
+        assert(N > 1);
+        init_ports();
+    }
+};
\ No newline at end of file
diff --git a/src/devices/crossing.cpp b/src/devices/crossing.cpp
new file mode 100644
index 0000000..f8c8f5e
--- /dev/null
+++ b/src/devices/crossing.cpp
@@ -0,0 +1,129 @@
+#include "specs.h"
+#include "crossing.h"
+
+using namespace std;
+
+void CrossingUni::on_input_changed()
+{
+    // If it's NAN, it's because it was not specified and thus the linear should be zero (-inf dB)
+    const double crosstalk_field_lin = (isnan(m_crosstalk_power_dB)) ? 0 : pow(10.0, m_crosstalk_power_dB / 20);
+    const double transmission_field_lin = pow(10.0, -m_attenuation_power_dB / 20); // due to attenuations
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type S13, S14, S23, S24;
+    // the second part relates to power that is crossed over (not transmitted)
+    S13 = polar(transmission_field_lin, 0.0); // From in1 to out1
+    S24 = polar(transmission_field_lin, 0.0); // From in2 to out2
+    S14 = polar(crosstalk_field_lin, 0.0);   // From in1 to out2 (crosstalk)
+    S23 = polar(crosstalk_field_lin, 0.0);   // From in2 to out1 (crosstalk)
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "transmission_power = " << norm(S13) << " W/W" << endl;
+        cout << "crosstalk_power = " << norm(S14)<< " W/W" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in1.get_interface()))->name();
+        cout << " ---   ---> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_out1.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in2.get_interface()))->name();
+        cout << " ---   ---> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_out2.get_interface()))->name();
+        cout << endl;
+
+        cout << endl;
+    }
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        auto s1 = p_in1->read();
+        auto s2 = p_in2->read();
+
+        // Apply S-parameters
+        auto s3 = s1 * S13 + s2 * S23;
+        auto s4 = s1 * S14 + s2 * S24;
+
+        // Get new IDs for signal
+        s3.getNewId();
+        s4.getNewId();
+
+        // Write to ouput port after delay
+        m_out1_writer.delayedWrite(s3, sc_time(0, SC_NS));
+        m_out2_writer.delayedWrite(s4, sc_time(0, SC_NS));
+    }
+}
+
+void CrossingBi::on_input_changed()
+{
+    // If it's NAN, it's because it was not specified and thus the linear should be zero (-inf dB)
+    const double crosstalk_field_lin = (isnan(m_crosstalk_power_dB)) ? 0 : pow(10.0, m_crosstalk_power_dB / 20);
+    const double transmission_field_lin = pow(10.0, -m_attenuation_power_dB / 20); // due to attenuations
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type through = polar(transmission_field_lin, 0.0);
+    OpticalSignal::field_type cross = polar(crosstalk_field_lin, 0.0);
+
+    OpticalSignal::field_type S02, S03, S12, S13;
+    // the second part relates to power that is crossed over (not transmitted)
+    S02 = through; // From in1 to out1
+    S13 = through; // From in2 to out2
+    S03 = cross;   // From in1 to out2 (crosstalk)
+    S12 = cross;   // From in2 to out1 (crosstalk)
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "transmission_power = " << norm(through) << " W/W" << endl;
+        cout << "crosstalk_power = " << norm(cross)<< " W/W" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_in.get_interface()))->name();
+        cout << " ---   ---> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p2_out.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_in.get_interface()))->name();
+        cout << " ---   ---> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p3_out.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p2_in.get_interface()))->name();
+        cout << " ---   ---> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_out.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p3_in.get_interface()))->name();
+        cout << " ---   ---> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_out.get_interface()))->name();
+        cout << endl;
+
+        cout << endl;
+    }
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        auto s0_in = p0_in->read();
+        auto s1_in = p1_in->read();
+        auto s2_in = p2_in->read();
+        auto s3_in = p3_in->read();
+
+        // Apply S-parameters
+        auto s0_out = s2_in * S02 + s3_in * S03;
+        auto s1_out = s2_in * S12 + s3_in * S13;
+        auto s2_out = s0_in * S02 + s1_in * S12;
+        auto s3_out = s0_in * S03 + s1_in * S13;
+
+        // Get new IDs for signal
+        s0_out.getNewId();
+        s1_out.getNewId();
+        s2_out.getNewId();
+        s3_out.getNewId();
+
+        // Write to ouput port after delay
+        m_p0_out_writer.delayedWrite(s0_out, sc_time(0, SC_NS));
+        m_p1_out_writer.delayedWrite(s1_out, sc_time(0, SC_NS));
+        m_p2_out_writer.delayedWrite(s2_out, sc_time(0, SC_NS));
+        m_p3_out_writer.delayedWrite(s3_out, sc_time(0, SC_NS));
+    }
+}
\ No newline at end of file
diff --git a/src/devices/crossing.h b/src/devices/crossing.h
new file mode 100644
index 0000000..8631ba4
--- /dev/null
+++ b/src/devices/crossing.h
@@ -0,0 +1,113 @@
+#pragma once
+
+#include <systemc.h>
+
+#include <spx_module.h>
+
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+
+/* A waveguide crossing that accounts for */
+/* loss and interchannel crosstalk        */
+/*                                        */
+/*           (2)p_in2                     */
+/*                |                       */
+/*    (1)p_in1----+---->p_out1(3)         */
+/*                |                       */
+/*                v                       */
+/*              p_out2(4)                 */
+/*                                        */
+/* ---------------------------------------*/
+class CrossingBase : public spx_module {
+public:
+    // Member variables
+    double m_attenuation_power_dB;
+    double m_crosstalk_power_dB;
+
+    // Constructor with crosstalk
+    // Attenuation relates to out1/in1 when there's nothing in in2
+    // Crosstalk relates to out2/in1 when there's nothing in in1
+    CrossingBase(sc_module_name name,
+                       double attenuation_power_dB = 0,
+                       double crosstalk_power_dB = NAN)
+        : spx_module(name)
+        , m_attenuation_power_dB(attenuation_power_dB)
+        , m_crosstalk_power_dB(crosstalk_power_dB)
+    {
+    }
+};
+
+class CrossingUni : public CrossingBase {
+public:
+    // Ports
+    spx::oa_port_in_type p_in1;
+    spx::oa_port_in_type p_in2;
+    spx::oa_port_out_type p_out1;
+    spx::oa_port_out_type p_out2;
+
+    // Timed ports writers
+    OpticalOutputPort m_out1_writer;
+    OpticalOutputPort m_out2_writer;
+
+    // Processes
+    void on_input_changed();
+
+    // Constructor with crosstalk
+    // Attenuation relates to out1/in1 when there's nothing in in2
+    // Crosstalk relates to out2/in1 when there's nothing in in1
+    CrossingUni(sc_module_name name,
+                       double attenuation_power_dB = 0,
+                       double crosstalk_power_dB = NAN)
+        : CrossingBase(name, attenuation_power_dB, crosstalk_power_dB)
+        , m_out1_writer("out1_delayed_writer", p_out1)
+        , m_out2_writer("out2_delayed_writer", p_out2)
+    {
+        SC_HAS_PROCESS(CrossingUni);
+
+        SC_THREAD(on_input_changed);
+        sensitive << p_in1 << p_in2;
+    }
+};
+
+typedef CrossingUni Crossing;
+
+class CrossingBi : public CrossingBase {
+public:
+    // Ports
+    spx::oa_port_in_type p0_in;
+    spx::oa_port_in_type p1_in;
+    spx::oa_port_in_type p2_in;
+    spx::oa_port_in_type p3_in;
+    spx::oa_port_out_type p0_out;
+    spx::oa_port_out_type p1_out;
+    spx::oa_port_out_type p2_out;
+    spx::oa_port_out_type p3_out;
+
+    // Timed ports writers
+    OpticalOutputPort m_p0_out_writer;
+    OpticalOutputPort m_p1_out_writer;
+    OpticalOutputPort m_p2_out_writer;
+    OpticalOutputPort m_p3_out_writer;
+
+    // Processes
+    void on_input_changed();
+
+    // Constructor with crosstalk
+    // Attenuation relates to out1/in1 when there's nothing in in2
+    // Crosstalk relates to out2/in1 when there's nothing in in1
+    CrossingBi(sc_module_name name,
+                       double attenuation_power_dB = 0,
+                       double crosstalk_power_dB = NAN)
+        : CrossingBase(name, attenuation_power_dB, crosstalk_power_dB)
+        , m_p0_out_writer("p0_out_delayed_writer", p0_out)
+        , m_p1_out_writer("p1_out_delayed_writer", p1_out)
+        , m_p2_out_writer("p2_out_delayed_writer", p2_out)
+        , m_p3_out_writer("p3_out_delayed_writer", p3_out)
+    {
+        SC_HAS_PROCESS(CrossingBi);
+
+        SC_THREAD(on_input_changed);
+        sensitive << p0_in << p1_in << p2_in << p3_in;
+    }
+};
\ No newline at end of file
diff --git a/src/devices/crow.cpp b/src/devices/crow.cpp
new file mode 100644
index 0000000..d411aa2
--- /dev/null
+++ b/src/devices/crow.cpp
@@ -0,0 +1,97 @@
+#include <crow.h>
+
+using namespace std;
+
+void CROW::connect_submodules()
+{
+    // Physical parameters of the components
+    // double neff = 2.6391; //2.2;
+    // double ng = 4.3416; //neff;
+    // double loss_db_cm = 2; //1;
+    // double coupling_through = (1 - pow(0.83645, 2.0));//0.85;
+    // double coupling_through = 1 - pow(0.83645, 2.0);//0.85;
+    // double coupling_through = 1 - pow(0.83645, 2.0);//0.85;
+    // coupling_through = 1 - 0.83645;//0.85;
+    //double pi_length = 1.55e-6/2/neff;
+    //double internal_length = 200*pi_length;
+    //double internal_length = 1001*pi_length;
+    // double internal_length = 2.0*((2.0 * M_PI * 3.2544e-6) + 10e-6); // 2pi*R+10um (R = 3.2544um)
+    // double internal_length = 2.0 * M_PI * (3.2544e-6 + 10e-6/(2.0*M_PI)); // 2pi*R+10um (R = 3.2544um)
+    //double var_factor = 1.01*pi_length;
+    // double var_factor = 0;
+
+    // -- Parameterizing components -- //
+    for (size_t i = 0; i < N; i++)
+    {
+        // here is where variation is disabled (0 and uncomment)
+        // double _wg_length_variation = var_factor*i;
+        double _wg_length = m_ring_length / 2.0;
+        // double _wg_length = M_PI * 3.2544e-6 + 10e-6;
+        //double _wg_length = 200*100.0*(1550e-9 + 0.1e-9 * i)/(2.0*neff);
+        
+        //cout << _wg_length_variation << endl;
+        cout << wg_top.at(i)->name() << endl;
+        wg_top.at(i)->m_length_cm = _wg_length * 100.0;
+        wg_top.at(i)->m_neff = m_neff;
+        wg_top.at(i)->m_ng = m_ng;
+        wg_top.at(i)->m_attenuation_dB_cm = m_loss_db_cm;
+
+        cout << wg_bot.at(i)->name() << endl;
+        wg_bot.at(i)->m_length_cm = _wg_length * 100.0;
+        wg_bot.at(i)->m_neff = m_neff;
+        wg_bot.at(i)->m_ng = m_ng;
+        wg_bot.at(i)->m_attenuation_dB_cm = m_loss_db_cm;
+
+        cout << dc.at(i)->name() << endl;
+        dc.at(i)->m_dc_through_coupling_power = m_coupling_through;
+    }
+    dc.at(N)->m_dc_through_coupling_power = m_coupling_through;
+
+    // -- Connecting components -- //
+    // Before loop, outer connections on left
+    dc.at(0)->p_in1(p_in);
+    dc.at(0)->p_out1(p_out_t);
+    //p_through.p_in(OUT_THROUGH);
+
+    // Loop, inner connections
+    for (size_t i = 0; i < N; i++)
+    {
+        // Need to take care if odd or even, 
+        // as inputs come from different directions
+        if (i%2 == 0)
+        {
+            // If i even, DC(i) input at bottom
+            dc.at(i)->p_in2(*S_BL.at(i));
+            dc.at(i)->p_out2(*S_TL.at(i));
+            // If i even, DC(i+1) input at the top
+            dc.at(i+1)->p_in1(*S_TR.at(i));
+            dc.at(i+1)->p_out1(*S_BR.at(i));
+            // If even, top waveguide(i) is L->R
+            wg_top.at(i)->p_in(*S_TL.at(i));
+            wg_top.at(i)->p_out(*S_TR.at(i));
+            // If even, bottom waveguide(i) is R->L
+            wg_bot.at(i)->p_in(*S_BR.at(i));
+            wg_bot.at(i)->p_out(*S_BL.at(i));
+        }
+        else{
+            // If i odd, DC(i) input at top
+            dc.at(i)->p_in2(*S_TL.at(i));
+            dc.at(i)->p_out2(*S_BL.at(i));
+            // If i odd, DC(i+1) input at the bottom
+            dc.at(i+1)->p_in1(*S_BR.at(i));
+            dc.at(i+1)->p_out1(*S_TR.at(i));
+            // If odd, top waveguide(i) is R->L
+            wg_top.at(i)->p_in(*S_TR.at(i));
+            wg_top.at(i)->p_out(*S_TL.at(i));
+            // If odd, bottom waveguide(i) is L->R
+            wg_bot.at(i)->p_in(*S_BL.at(i));
+            wg_bot.at(i)->p_out(*S_BR.at(i));
+        }
+    }    
+    // After loop, outer connections on right
+    //pd1.p_readout(PD_OUT);
+    dc.at(N)->p_in2(p_add);
+    dc.at(N)->p_out2(p_out_d);
+
+    dc.at(0)->m_out1_writer.m_converger = false;
+}
\ No newline at end of file
diff --git a/src/devices/crow.h b/src/devices/crow.h
new file mode 100644
index 0000000..d0e6ed2
--- /dev/null
+++ b/src/devices/crow.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <systemc.h>
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <detector.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include <pcm_device.h>
+#include <directional_coupler.h>
+#include <merger.h>
+
+#include <cassert>
+
+class CROW : public sc_module {
+public:
+    // Ports
+    /** The optical input ports. */
+    sc_port<sc_signal_in_if<OpticalSignal>> p_in;
+    sc_port<sc_signal_in_if<OpticalSignal>> p_add;
+    /** The electrical output port. */
+    sc_port<sc_signal_out_if<OpticalSignal>> p_out_t;
+    sc_port<sc_signal_out_if<OpticalSignal>> p_out_d;
+
+    // Member variables
+    size_t N;
+    double m_ring_length;
+    double m_neff = 2.2;
+    double m_ng = 4.3;
+    double m_loss_db_cm = 2;
+    double m_coupling_through = 0.85;
+
+    // Wires
+    vector<shared_ptr<sc_signal<OpticalSignal>>> S_TL;
+    vector<shared_ptr<sc_signal<OpticalSignal>>> S_BL;
+    vector<shared_ptr<sc_signal<OpticalSignal>>> S_TR;
+    vector<shared_ptr<sc_signal<OpticalSignal>>> S_BR;
+    //sc_signal<OpticalSignal> terminator;
+
+    // Member submodules
+    vector<shared_ptr<Waveguide>> wg_top;
+    vector<shared_ptr<Waveguide>> wg_bot;
+    vector<shared_ptr<DirectionalCoupler>> dc;
+
+    
+    virtual void init()
+    {
+        assert(N > 0);
+        S_TL.clear();
+        S_BL.clear();
+        S_TR.clear();
+        S_BR.clear();
+        wg_bot.clear();
+        wg_top.clear();
+        dc.clear();
+        stringstream ss;
+        string _i;
+        for (size_t i = 0; i < N; ++i)
+        {
+            ss.str(std::string());
+            ss << i;
+            _i = ss.str();
+            cout << _i << endl;
+            S_TL.push_back(make_shared<sc_signal<OpticalSignal>>((string("S_TL") + "_" + _i).c_str()));
+            S_BL.push_back(make_shared<sc_signal<OpticalSignal>>((string("S_BL") + "_" + _i).c_str()));
+            S_TR.push_back(make_shared<sc_signal<OpticalSignal>>((string("S_TR") + "_" + _i).c_str()));
+            S_BR.push_back(make_shared<sc_signal<OpticalSignal>>((string("S_BR") + "_" + _i).c_str()));
+            wg_bot.push_back(make_shared<Waveguide>((string("wg_bot") + "_" + _i).c_str()));
+            wg_top.push_back(make_shared<Waveguide>((string("wg_top") + "_" + _i).c_str()));
+            dc.push_back(make_shared<DirectionalCoupler>((string("dc") + "_" + _i).c_str()));
+        }
+        ss.str(std::string());
+        ss << N;
+        _i = ss.str();
+        cout << _i << endl;
+        dc.push_back(make_shared<DirectionalCoupler>((string("dc") + "_" + _i).c_str()));
+        connect_submodules();
+    }
+
+    void connect_submodules();
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * */
+    CROW(sc_module_name name, const size_t &nrings = 3, const double &ring_length = 0.0)
+        : sc_module(name)
+        , N(nrings)
+        , m_ring_length(ring_length)
+    {
+    }
+
+    void setRingLength(const double &ring_length)
+    {
+        assert(ring_length >= 0);
+        m_ring_length = ring_length;
+    }
+};
diff --git a/src/devices/cw_source.cpp b/src/devices/cw_source.cpp
new file mode 100644
index 0000000..4be5934
--- /dev/null
+++ b/src/devices/cw_source.cpp
@@ -0,0 +1,45 @@
+#include "specs.h"
+#include <cw_source.h>
+
+using std::cout;
+using std::endl;
+
+void CWSource::runner()
+{
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "signal on: " << m_signal_on << endl;
+        cout << "--> " <<
+            (dynamic_cast<spx::oa_signal_type *>(p_out.get_interface()))->name() << endl;
+        cout << endl;
+    }
+
+    bool first_run = true;
+
+    while (true) {
+        // Wait for enable signal
+        if (! enable.read().to_bool())
+        {
+            // cout << name() << " waiting for enable" << endl;
+            wait(enable.posedge_event());
+        }
+        // cout << name() << " was enabled" << endl;
+        auto s = m_signal_on;
+        s.getNewId();
+
+        // Write value to output
+        m_out_writer.delayedWrite(s, SC_ZERO_TIME);
+        cout << name() << " emitted: " << s << endl;
+
+        // Wait for reset
+        if ( !first_run || !reset.read().to_bool())
+        {
+            // cout << name() << " waiting for reset" << endl;
+            wait(reset.posedge_event());
+            reset.write(sc_logic(0));
+            wait(reset.negedge_event());
+        }
+        // cout << name() << " was reset" << endl;
+    }
+}
diff --git a/src/devices/cw_source.h b/src/devices/cw_source.h
new file mode 100644
index 0000000..487177c
--- /dev/null
+++ b/src/devices/cw_source.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <systemc.h>
+#include <fstream>
+
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include "specs.h"
+#include "spx_module.h"
+
+class CWSource : public spx_module {
+public:
+    // Ports
+    spx::oa_port_out_type p_out;
+
+    // Timed ports writers
+    OpticalOutputPort m_out_writer;
+
+    // Signal characteristic
+    spx::oa_value_type m_signal_on;
+    double m_source_wavelength;
+
+    // Source emission control
+    spx::ed_signal_type enable;
+    spx::ed_signal_type reset;
+
+    // Processes
+    void runner();
+
+    inline void setWavelength(const double &wl)
+    {
+        m_source_wavelength = wl;
+        m_signal_on.m_wavelength_id = m_signal_on.getIDFromWavelength(wl);
+    }
+    inline void setFrequency(const double &f)
+    {
+        setWavelength(299792458.0 / f);
+    }
+    inline void setAmplitudePhase (const double &amplitude, const double &phase)
+    {
+        m_signal_on.m_field = polar(amplitude, phase);
+    }
+    inline void setPhase (const double &phase)
+    {
+        if (m_signal_on.modulus() == 0)
+            cerr << "Warning: setting phase has no effect on 0" << endl;
+        m_signal_on.m_field = polar(m_signal_on.modulus(), phase);
+    }
+    inline void setPower (const double &power)
+    {
+        m_signal_on.m_field = polar(sqrt(power), m_signal_on.phase());
+    }
+    inline void setPower(const double &power, double phase)
+    {
+        setAmplitudePhase(sqrt(power), phase);
+    }
+
+    // Constructor
+    CWSource(sc_module_name name)
+        : spx_module(name)
+        , m_out_writer("out_delayed_writer", p_out)
+    {
+        SC_HAS_PROCESS(CWSource);
+
+        SC_THREAD(runner);
+
+        enable = sc_logic(0);
+        reset = sc_logic(0);
+    }
+
+    CWSource(sc_module_name name, const OpticalSignal& signal_on)
+        : CWSource(name)
+    {
+        m_signal_on = signal_on;
+    }
+};
diff --git a/src/devices/detector.cpp b/src/devices/detector.cpp
new file mode 100644
index 0000000..b93a5de
--- /dev/null
+++ b/src/devices/detector.cpp
@@ -0,0 +1,136 @@
+#include "specs.h"
+#include <detector.h>
+#include <cstdlib> // system()
+#include <random>
+#include <complex>
+
+using namespace std;
+
+void Detector::on_port_in_changed()
+{
+    // always initialize memory
+    m_memory_in[0] = 0;
+
+    // rng seed
+    init();
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        const auto &p_in_read = p_in->read();
+
+        auto cur_wavelength_id = p_in_read.m_wavelength_id;
+        // Updating the field memory
+        m_memory_in[cur_wavelength_id] = p_in_read.m_field;
+        m_event_manual_trigger.notify();
+    }
+}
+
+void Detector::on_time_tick()
+{
+    sc_time sampling_time = sc_time(m_sampling_time, SC_SEC);
+    if (sampling_time.value() == 0)
+        sampling_time = sc_time::from_value(1);
+
+    OpticalSignal::field_type total_field;
+    OpticalSignal::field_type::value_type total_power;
+    double photocurrent;
+
+    // Wait for enable signal
+    if (! enable.read().to_bool())
+    {
+        // cout << name() << " waiting for enable" << endl;
+        wait(enable.posedge_event());
+        cout << name() << " was enabled" << endl;
+    }
+
+    while(true)
+    {
+        if (sc_pending_activity()) {
+            wait(sampling_time, m_event_manual_trigger);
+            //wait(m_event_manual_trigger); // if only time-averaged signal is of interest
+        } else {
+            /* wait for reset */
+            //TODO (see CWSource code)
+            wait(); // effectively wait until the end of the simulation
+        }
+
+        /* Get current time tk*/
+        double tk = sc_time_stamp().to_seconds();
+
+        /* Calculate current output value based on present fields */
+        /* Calculate sum of fields at current time*/
+        total_field = 0;
+        total_power = 0;
+        for (auto field : m_memory_in)
+        {
+            double wl = specsGlobalConfig.wavelengths_vector[field.first];
+            double freq = 299792458 / wl;
+            total_field += field.second * exp(complex<double>(0, 2 * M_PI * freq * tk));
+            total_power += norm(field.second);
+        }
+
+        if (norm(total_field) == 0)
+            total_field = 1e-20*m_rngDist(m_rngGen);
+
+        photocurrent = norm(total_field) * m_responsivity_A_W;
+        m_cur_readout = photocurrent + (!m_noiseBypass)*noise_gen(photocurrent) + m_darkCurrent_A;
+        m_cur_readout_no_interf = total_power * m_responsivity_A_W + (!m_noiseBypass)*noise_gen(photocurrent) + m_darkCurrent_A;
+
+
+        //m_cur_readout = total_field.real();
+        // Write to output port
+        //p_readout->write(m_cur_readout);
+    }
+}
+
+/*
+Generates a current noise to be applied to the noiseless_readout,
+calculated from the responsivity.
+
+Considers: TIA input referred, shot, and thermal
+*/
+double Detector::noise_gen(const double &noiseless_readout)
+{
+    // elementary charge
+    const double q = 1.60217e-19;
+
+    // Boltzmann constant
+    const double K = 1.38064e-23;
+
+    double inoise_tia_2 = m_opFreq_Hz*pow(m_iTIA,2);
+    double inoise_shot_2 = m_opFreq_Hz*2*q*(noiseless_readout+m_darkCurrent_A);
+    double inoise_therm_2 = m_opFreq_Hz*4*K*m_temp_K/m_equivR_Ohm;
+
+    // the RMS value is also the variance of the random variable
+    double inoise_rms = inoise_tia_2 + inoise_shot_2 + inoise_therm_2;
+
+    // mean = noiseless, std = sqrt(variance)
+    // the second element of the product is the gaussian(0,1)
+    return sqrt(inoise_rms) * m_rngDist(m_rngGen);
+}
+
+/*
+To be implemented in the future, user can specify the wavelength response
+of the photodiode
+*/
+double Detector::wavelength_dependent_responsivity(const double &wavelength)
+{
+    (void)wavelength;
+    if(true)
+    {
+        return m_responsivity_A_W;
+    }
+    else
+    {
+        // custom responsivity curve
+        return 0; // should return the new responsivity
+    }
+}
+
+void Detector::init()
+{
+    std::random_device rd;  // Will be used to obtain a seed for the random number engine
+    m_rngGen.seed(rd());
+}
diff --git a/src/devices/detector.h b/src/devices/detector.h
new file mode 100644
index 0000000..d2e5e65
--- /dev/null
+++ b/src/devices/detector.h
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <systemc.h>
+#include <fstream>
+#include <random>
+
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include "specs.h"
+#include "spx_module.h"
+
+// TODO: rename to photodetector
+class Detector : public spx_module {
+public:
+    // Ports
+    spx::oa_port_in_type p_in;
+    spx::ea_port_out_type p_readout; // TODO: divide into cathode and anode
+    double m_cur_readout;
+    double m_cur_readout_no_interf;
+
+    // Input memory for multi-wavelength purposes
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in;
+
+    // Detector enable signal
+    spx::ed_signal_type enable;
+
+    // Member variables
+    double m_responsivity_A_W;
+    double m_darkCurrent_A;
+    double m_opFreq_Hz;
+    double m_temp_K;
+    double m_equivR_Ohm;
+    double m_iTIA; // A/sqrt(Hz)
+    bool m_noiseBypass;
+    double m_sampling_time;
+
+    // if each photodiode has an independent RNG device
+    std::default_random_engine m_rngGen;
+    std::normal_distribution<double> m_rngDist;
+
+    sc_event m_event_manual_trigger;
+
+    // Init all parameters
+    void init();
+
+    // Function that generates the noise applied to the output of this module
+    double noise_gen(const double &noiseless_readout);
+    double wavelength_dependent_responsivity(const double &wavelength);
+
+    // Processes
+    void on_port_in_changed();
+    void on_time_tick();
+
+    virtual void trace(sc_trace_file *Tf) const
+    {
+        sc_trace(Tf, m_cur_readout, (string(name()) + ".readout").c_str());
+        sc_trace(Tf, m_cur_readout_no_interf, (string(name()) + ".readout_no_interference").c_str());
+    }
+
+    // Constructor
+    Detector(sc_module_name name,
+             double responsivity_A_W = 1,
+             double darkCurrent_A = 0, // 100e-12 is an OK value
+             bool noiseBypass = true,
+             double opFreq_Hz = 1e9,
+             double temp_K = 300,
+             double equivR_Ohm = 400,
+             double iTIA = 10e-12,
+             double sampling_time = 1e-12)
+        : spx_module(name)
+        , m_responsivity_A_W(responsivity_A_W)
+        , m_darkCurrent_A(darkCurrent_A)
+        , m_opFreq_Hz(opFreq_Hz)
+        , m_temp_K(temp_K)
+        , m_equivR_Ohm(equivR_Ohm)
+        , m_iTIA(iTIA)
+        , m_noiseBypass(noiseBypass)
+        , m_sampling_time(sampling_time)
+        , m_rngDist(0,1)
+    {
+        SC_HAS_PROCESS(Detector);
+        enable = sc_logic(0);
+
+        SC_THREAD(on_port_in_changed);
+        sensitive << p_in;
+
+        SC_THREAD(on_time_tick);
+    }
+};
diff --git a/src/devices/directional_coupler.cpp b/src/devices/directional_coupler.cpp
new file mode 100644
index 0000000..da0872b
--- /dev/null
+++ b/src/devices/directional_coupler.cpp
@@ -0,0 +1,318 @@
+#include "specs.h"
+#include <directional_coupler.h>
+
+using namespace std;
+
+void DirectionalCouplerUni::on_port_in1_changed()
+{
+    m_through_power_dB = 10*log10(m_dc_through_coupling_power) - m_dc_loss;
+    m_cross_power_dB = 10*log10(1.0 - m_dc_through_coupling_power) - m_dc_loss;
+
+    m_memory_in1[0] = 0; // initializing for nan wavelength
+
+    const double transmission_through = pow(10.0, m_through_power_dB / 20.0);
+    const double transmission_cross = pow(10.0, m_cross_power_dB / 20.0);
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type S13, S14, S23, S24;
+    S13 = polar(transmission_through, m_through_phase_rad);
+    S24 = polar(transmission_through, m_through_phase_rad);
+    S14 = polar(transmission_cross, m_cross_phase_rad);
+    S23 = polar(transmission_cross, m_cross_phase_rad);
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "through_power = " << norm(S13) << " W/W" << endl;
+        cout << "cross_power = " << norm(S14)<< " W/W" << endl;
+        cout << "through_field = " << abs(S13) << "" << endl;
+        cout << "cross_field = " << abs(S14)<< "" << endl;
+        cout << "insertion loss = " << m_dc_loss << "dB" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in1.get_interface()))->name();
+        cout << " --,__,-> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_out1.get_interface()))->name();
+        cout << endl;
+
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in2.get_interface()))->name();
+        cout << " --'  '-> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_out2.get_interface()))->name();
+        cout << endl;
+
+        cout << endl;
+    }
+
+    OpticalSignal p_in1_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        p_in1_read = p_in1->read();
+
+        auto cur_wavelength_id = p_in1_read.m_wavelength_id;
+        // Updating the field memory
+        m_memory_in1[cur_wavelength_id] = p_in1_read.m_field;
+
+        auto s3 = OpticalSignal(m_memory_in1[cur_wavelength_id] * S13 +
+                        m_memory_in2[cur_wavelength_id] * S23
+                        , cur_wavelength_id);
+
+        auto s4 = OpticalSignal(m_memory_in1[cur_wavelength_id] * S14 +
+                                m_memory_in2[cur_wavelength_id] * S24
+                                , cur_wavelength_id);
+
+        m_out1_writer.delayedWrite(s3, sc_time(m_delay_ns, SC_NS));
+        m_out2_writer.delayedWrite(s4, sc_time(m_delay_ns, SC_NS));
+    }
+}
+
+void DirectionalCouplerUni::on_port_in2_changed()
+{
+    m_through_power_dB = 10*log10(m_dc_through_coupling_power) - m_dc_loss;
+    m_cross_power_dB = 10*log10(1.0 - m_dc_through_coupling_power) - m_dc_loss;
+
+    m_memory_in2[0] = 0; // initializing for nan wavelength
+
+    const double transmission_through = pow(10.0, m_through_power_dB / 20.0);
+    const double transmission_cross = pow(10.0, m_cross_power_dB / 20.0);
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type S13, S14, S23, S24;
+    S13 = polar(transmission_through, m_through_phase_rad);
+    S24 = polar(transmission_through, m_through_phase_rad);
+    S14 = polar(transmission_cross, m_cross_phase_rad);
+    S23 = polar(transmission_cross, m_cross_phase_rad);
+
+    OpticalSignal p_in2_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        p_in2_read = p_in2->read();
+
+        auto cur_wavelength_id = p_in2_read.m_wavelength_id;
+        // Updating the field memory
+        m_memory_in2[cur_wavelength_id] = p_in2_read.m_field;
+
+        auto s3 = OpticalSignal(m_memory_in1[cur_wavelength_id] * S13 +
+                                m_memory_in2[cur_wavelength_id] * S23
+                        , cur_wavelength_id);
+
+        auto s4 = OpticalSignal(m_memory_in1[cur_wavelength_id] * S14 +
+                                m_memory_in2[cur_wavelength_id] * S24
+                                , cur_wavelength_id);
+
+        m_out1_writer.delayedWrite(s3, sc_time(m_delay_ns, SC_NS));
+        m_out2_writer.delayedWrite(s4, sc_time(m_delay_ns, SC_NS));
+    }
+}
+
+
+void DirectionalCouplerBi::on_p0_in_changed()
+{
+    m_through_power_dB = 10*log10(m_dc_through_coupling_power) - m_dc_loss;
+    m_cross_power_dB = 10*log10(1.0 - m_dc_through_coupling_power) - m_dc_loss;
+
+    m_memory_in0[0] = 0; // initializing for nan wavelength
+
+    const double transmission_through = pow(10.0, m_through_power_dB / 20.0);
+    const double transmission_cross = pow(10.0, m_cross_power_dB / 20.0);
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type S02, S13, S03, S12;
+    S02 = polar(transmission_through, m_through_phase_rad);
+    S13 = polar(transmission_through, m_through_phase_rad);
+    S03 = polar(transmission_cross, m_cross_phase_rad);
+    S12 = polar(transmission_cross, m_cross_phase_rad);
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "through_power = " << norm(S02) << " W/W" << endl;
+        cout << "cross_power = " << norm(S03)<< " W/W" << endl;
+        cout << "through_field = " << abs(S02) << "" << endl;
+        cout << "cross_field = " << abs(S03)<< "" << endl;
+        cout << "insertion loss = " << m_dc_loss << "dB" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_in.get_interface()))->name();
+
+        cout << " --,__,-> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p2_out.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_in.get_interface()))->name();
+        cout << " --'  '-> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p3_out.get_interface()))->name();
+        cout << endl;
+
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_out.get_interface()))->name();
+        cout << " <-,__,-- ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p2_in.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_out.get_interface()))->name();
+        cout << " <-'  '-- ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p3_in.get_interface()))->name();
+        cout << endl;
+
+        cout << endl;
+    }
+
+    OpticalSignal p0_in_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        p0_in_read = p0_in->read();
+
+        auto cur_wavelength_id = p0_in_read.m_wavelength_id;
+
+        // Updating the field memory
+        m_memory_in0[cur_wavelength_id] = p0_in_read.m_field;
+
+        auto s2 = OpticalSignal(m_memory_in0[cur_wavelength_id] * S02 +
+                                m_memory_in1[cur_wavelength_id] * S12
+                                , cur_wavelength_id);
+
+        auto s3 = OpticalSignal(m_memory_in0[cur_wavelength_id] * S03 +
+                                m_memory_in1[cur_wavelength_id] * S13
+                                , cur_wavelength_id);
+
+        m_p2_out_writer.delayedWrite(s2, sc_time(m_delay_ns, SC_NS));
+        m_p3_out_writer.delayedWrite(s3, sc_time(m_delay_ns, SC_NS));
+    }
+}
+
+void DirectionalCouplerBi::on_p1_in_changed()
+{
+    m_through_power_dB = 10*log10(m_dc_through_coupling_power) - m_dc_loss;
+    m_cross_power_dB = 10*log10(1.0 - m_dc_through_coupling_power) - m_dc_loss;
+
+    m_memory_in1[0] = 0; // initializing for nan wavelength
+
+    const double transmission_through = pow(10.0, m_through_power_dB / 20.0);
+    const double transmission_cross = pow(10.0, m_cross_power_dB / 20.0);
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type S02, S13, S03, S12;
+    S02 = polar(transmission_through, m_through_phase_rad);
+    S13 = polar(transmission_through, m_through_phase_rad);
+    S03 = polar(transmission_cross, m_cross_phase_rad);
+    S12 = polar(transmission_cross, m_cross_phase_rad);
+
+    OpticalSignal p1_in_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        p1_in_read = p1_in->read();
+
+        auto cur_wavelength_id = p1_in_read.m_wavelength_id;
+
+        // Updating the field memory
+        m_memory_in1[cur_wavelength_id] = p1_in_read.m_field;
+
+        auto s2 = OpticalSignal(m_memory_in0[cur_wavelength_id] * S02 +
+                                m_memory_in1[cur_wavelength_id] * S12
+                                , cur_wavelength_id);
+
+        auto s3 = OpticalSignal(m_memory_in0[cur_wavelength_id] * S03 +
+                                m_memory_in1[cur_wavelength_id] * S13
+                                , cur_wavelength_id);
+
+        m_p2_out_writer.delayedWrite(s2, sc_time(m_delay_ns, SC_NS));
+        m_p3_out_writer.delayedWrite(s3, sc_time(m_delay_ns, SC_NS));
+    }
+}
+
+void DirectionalCouplerBi::on_p2_in_changed()
+{
+    m_through_power_dB = 10*log10(m_dc_through_coupling_power) - m_dc_loss;
+    m_cross_power_dB = 10*log10(1.0 - m_dc_through_coupling_power) - m_dc_loss;
+
+    m_memory_in2[0] = 0; // initializing for nan wavelength
+
+    const double transmission_through = pow(10.0, m_through_power_dB / 20.0);
+    const double transmission_cross = pow(10.0, m_cross_power_dB / 20.0);
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type S02, S13, S03, S12;
+    S02 = polar(transmission_through, m_through_phase_rad);
+    S13 = polar(transmission_through, m_through_phase_rad);
+    S03 = polar(transmission_cross, m_cross_phase_rad);
+    S12 = polar(transmission_cross, m_cross_phase_rad);
+
+    OpticalSignal p2_in_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        p2_in_read = p2_in->read();
+
+        auto cur_wavelength_id = p2_in_read.m_wavelength_id;
+
+        // Updating the field memory
+        m_memory_in2[cur_wavelength_id] = p2_in_read.m_field;
+
+        auto s0 = OpticalSignal(m_memory_in2[cur_wavelength_id] * S02 +
+                                m_memory_in3[cur_wavelength_id] * S03
+                                , cur_wavelength_id);
+
+        auto s1 = OpticalSignal(m_memory_in2[cur_wavelength_id] * S12 +
+                                m_memory_in3[cur_wavelength_id] * S13
+                                , cur_wavelength_id);
+
+        m_p0_out_writer.delayedWrite(s0, sc_time(m_delay_ns, SC_NS));
+        m_p1_out_writer.delayedWrite(s1, sc_time(m_delay_ns, SC_NS));
+    }
+}
+
+void DirectionalCouplerBi::on_p3_in_changed()
+{
+    m_through_power_dB = 10*log10(m_dc_through_coupling_power) - m_dc_loss;
+    m_cross_power_dB = 10*log10(1.0 - m_dc_through_coupling_power) - m_dc_loss;
+
+    m_memory_in3[0] = 0; // initializing for nan wavelength
+
+    const double transmission_through = pow(10.0, m_through_power_dB / 20.0);
+    const double transmission_cross = pow(10.0, m_cross_power_dB / 20.0);
+
+    // Pre-calculate S-parameters
+    OpticalSignal::field_type S02, S13, S03, S12;
+    S02 = polar(transmission_through, m_through_phase_rad);
+    S13 = polar(transmission_through, m_through_phase_rad);
+    S03 = polar(transmission_cross, m_cross_phase_rad);
+    S12 = polar(transmission_cross, m_cross_phase_rad);
+
+    OpticalSignal p3_in_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read current inputs
+        p3_in_read = p3_in->read();
+
+        auto cur_wavelength_id = p3_in_read.m_wavelength_id;
+
+        // Updating the field memory
+        m_memory_in3[cur_wavelength_id] = p3_in_read.m_field;
+
+        auto s0 = OpticalSignal(m_memory_in2[cur_wavelength_id] * S02 +
+                                m_memory_in3[cur_wavelength_id] * S03
+                                , cur_wavelength_id);
+
+        auto s1 = OpticalSignal(m_memory_in2[cur_wavelength_id] * S12 +
+                                m_memory_in3[cur_wavelength_id] * S13
+                                , cur_wavelength_id);
+
+        m_p0_out_writer.delayedWrite(s0, sc_time(m_delay_ns, SC_NS));
+        m_p1_out_writer.delayedWrite(s1, sc_time(m_delay_ns, SC_NS));
+    }
+}
\ No newline at end of file
diff --git a/src/devices/directional_coupler.h b/src/devices/directional_coupler.h
new file mode 100644
index 0000000..1e907a6
--- /dev/null
+++ b/src/devices/directional_coupler.h
@@ -0,0 +1,133 @@
+#pragma once
+
+#include <systemc.h>
+#include <map>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include "spx_module.h"
+
+
+class DirectionalCouplerBase : public spx_module {
+public:
+    // Member variables
+    double m_delay_ns = 0;
+    double m_through_phase_rad = 0;
+    double m_cross_phase_rad = M_PI/2;
+    double m_dc_through_coupling_power;
+
+    double m_through_power_dB;
+    double m_cross_power_dB;
+    double m_dc_loss; // is in dB
+
+    // Constructor
+    DirectionalCouplerBase(sc_module_name name,
+                       double dc_through_coupling_power = 0.5,
+                       double dc_loss = 0)
+        : spx_module(name)
+        , m_dc_through_coupling_power(dc_through_coupling_power)
+        , m_dc_loss(dc_loss)
+    {
+        // nothing to do
+    }
+};
+
+class DirectionalCouplerUni : public DirectionalCouplerBase {
+public:
+    // Ports
+    spx::oa_port_in_type p_in1;
+    spx::oa_port_in_type p_in2;
+    spx::oa_port_out_type p_out1;
+    spx::oa_port_out_type p_out2;
+
+    // Timed ports writers
+    OpticalOutputPort m_out1_writer;
+    OpticalOutputPort m_out2_writer;
+
+    // Memory for multi-wavelength purposes
+    // maybe with vector it has better performance
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in1;
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in2;
+
+    // Processes
+    void on_port_in1_changed();
+    void on_port_in2_changed();
+
+    // Constructor
+    DirectionalCouplerUni(sc_module_name name,
+                       double dc_through_coupling_power = 0.5,
+                       double dc_loss = 0)
+        : DirectionalCouplerBase(name, dc_through_coupling_power, dc_loss)
+        , m_out1_writer("out1_delayed_writer", p_out1)
+        , m_out2_writer("out2_delayed_writer", p_out2)
+    {
+        SC_HAS_PROCESS(DirectionalCouplerUni);
+
+        SC_THREAD(on_port_in1_changed);
+        sensitive << p_in1;
+
+        SC_THREAD(on_port_in2_changed);
+        sensitive << p_in2;
+    }
+};
+
+typedef DirectionalCouplerUni DirectionalCoupler;
+
+class DirectionalCouplerBi : public DirectionalCouplerBase {
+public:
+    // Ports
+    /** The optical input ports. */
+    spx::oa_port_in_type p0_in;
+    spx::oa_port_in_type p1_in;
+    spx::oa_port_in_type p2_in;
+    spx::oa_port_in_type p3_in;
+
+    /** The optical output ports. */
+    spx::oa_port_out_type p0_out;
+    spx::oa_port_out_type p1_out;
+    spx::oa_port_out_type p2_out;
+    spx::oa_port_out_type p3_out;
+
+    // Timed ports writers
+    OpticalOutputPort m_p0_out_writer;
+    OpticalOutputPort m_p1_out_writer;
+    OpticalOutputPort m_p2_out_writer;
+    OpticalOutputPort m_p3_out_writer;
+
+    // Memory for multi-wavelength purposes
+    // maybe with vector it has better performance
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in0;
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in1;
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in2;
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in3;
+
+    // Processes
+    void on_p0_in_changed();
+    void on_p1_in_changed();
+    void on_p2_in_changed();
+    void on_p3_in_changed();
+
+    // Constructor
+    DirectionalCouplerBi(sc_module_name name,
+                       double dc_through_coupling_power = 0.5,
+                       double dc_loss = 0)
+        : DirectionalCouplerBase(name, dc_through_coupling_power, dc_loss)
+        , m_p0_out_writer("p0_out_delayed_writer", p0_out)
+        , m_p1_out_writer("p1_out_delayed_writer", p1_out)
+        , m_p2_out_writer("p2_out_delayed_writer", p2_out)
+        , m_p3_out_writer("p3_out_delayed_writer", p3_out)
+    {
+        SC_HAS_PROCESS(DirectionalCouplerBi);
+
+        SC_THREAD(on_p0_in_changed);
+        sensitive << p0_in;
+
+        SC_THREAD(on_p1_in_changed);
+        sensitive << p1_in;
+
+        SC_THREAD(on_p2_in_changed);
+        sensitive << p2_in;
+
+        SC_THREAD(on_p3_in_changed);
+        sensitive << p3_in;
+    }
+};
diff --git a/src/devices/electrical_value_list_source.cpp b/src/devices/electrical_value_list_source.cpp
new file mode 100644
index 0000000..02b6af5
--- /dev/null
+++ b/src/devices/electrical_value_list_source.cpp
@@ -0,0 +1,67 @@
+#include "specs.h"
+#include "electrical_value_list_source.h"
+
+using std::cout;
+using std::cerr;
+using std::endl;
+
+void EVLSource::runner()
+{
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "value list (" << m_values_queue.size() << " values)";
+        if (false)
+        {
+            cout << ":" << endl;
+            for (const auto& val : m_values_queue)
+                cout << "\t" << "@" << sc_time(val.first, SC_SEC) << ": " << val.second << endl;
+        }
+        cout << endl;
+        cout << "--> " <<
+            (dynamic_cast<spx::ea_signal_type *>(p_out.get_interface()))->name() << endl;
+        cout << endl;
+    }
+
+    // Wait for enable signal
+    if (! enable.read().to_bool())
+    {
+        // cout << name() << " waiting for enable" << endl;
+        wait(enable.posedge_event());
+        cout << name() << " was enabled" << endl;
+    }
+
+    // Emitting 0 at enable (will only go through if there is no value at t=0)
+    if (m_values_queue.cbegin() == m_values_queue.cend()
+        || sc_time(m_values_queue.front().first, SC_SEC).value() > 0)
+    {
+        cout << "@" << sc_time_stamp() << ", " << name() << " emitted: " << spx::ea_value_type(0) << endl;
+        p_out->write(spx::ea_value_type(0));
+    }
+
+    auto it = m_values_queue.cbegin();
+    while (it != m_values_queue.cend())
+    {
+        sc_time now = sc_time_stamp();
+        if (it->first < now.to_seconds())
+        {
+            ++it;
+            continue;
+        }
+        sc_time delay = sc_time(it->first, SC_SEC) - now;
+
+        // Wait until next output time
+        wait(delay);
+
+        auto Vout = it->second;
+
+        // Write value to output
+        p_out->write(Vout);
+        cout << "@" << sc_time_stamp() << ", " << name() << " emitted: " << Vout << endl;
+
+        ++it;
+    }
+
+    // cout << name() << " completed" << endl;
+    while(true) { wait(); }
+}
diff --git a/src/devices/electrical_value_list_source.h b/src/devices/electrical_value_list_source.h
new file mode 100644
index 0000000..0534784
--- /dev/null
+++ b/src/devices/electrical_value_list_source.h
@@ -0,0 +1,128 @@
+#pragma once
+
+#include <systemc.h>
+#include <fstream>
+#include <algorithm>
+#include <vector>
+#include <utility>
+
+#include "strutils.h"
+#include "optical_output_port.h"
+#include "optical_signal.h"
+#include "specs.h"
+#include "spx_module.h"
+
+using std::vector;
+using std::pair;
+
+class EVLSource : public spx_module {
+public:
+    typedef pair<double, spx::ea_value_type> time_value_pair_type;
+
+    // Ports
+    spx::ea_port_out_type p_out;
+
+    // Signal to emit
+    vector<time_value_pair_type> m_values_queue;
+
+    // Source emission control
+    spx::ed_signal_type enable;
+
+    // Processes
+    void runner();
+
+    EVLSource(sc_module_name name, const vector<time_value_pair_type> &values = {})
+    : spx_module(name)
+    , m_values_queue(values)
+    {
+        sortValues();
+        enable = sc_logic(0);
+
+        SC_HAS_PROCESS(EVLSource);
+        SC_THREAD(runner);
+    }
+
+    void setValues(const vector<time_value_pair_type> &values)
+    {
+        m_values_queue = values;
+        sortValues();
+    }
+
+    void setValues(const string &filename)
+        {
+        std::ifstream file(filename);
+
+        if (!file.is_open()) {
+            cerr << "Error: Cannot open the file." << endl;
+            exit(1);
+        }
+
+        string line;
+
+        getline(file, line);
+
+        int lineNumber = 0;
+        while (getline(file, line)) {
+            ++lineNumber;
+            istringstream s(line);
+            string field;
+
+            double t, V;
+
+            // Skip if line is empty or starts with ;
+            if (line.empty())
+            {
+                cout << "Skipping empty line." << endl;
+                continue;
+            }
+            // Skip if line starts with ;
+            if (line[0] == ';')
+            {
+                cout << "Skipping commented line: " << line << endl;
+                continue;
+            }
+
+            // Read first field (time)
+            getline(s, field, ',');
+            strutils::trim(field);
+
+            // Skip header line if it exists
+            if(lineNumber == 1 && field == "time")
+            {
+                cout << "Skipping header line: " << line << endl;
+                continue;
+            }
+
+            try {
+                t = stod(field);
+            } catch (std::invalid_argument const& ex) {
+                cerr << "Invalid value for time: \"" << field << "\"" << endl;
+                exit(1);
+            }
+
+            // Read second field (V)
+            getline(s, field, ',');
+            try {
+                V = stod(field);
+            } catch (std::invalid_argument const& ex) {
+                cerr << "Invalid value for voltage: \"" << field << "\"" << endl;
+                exit(1);
+            }
+
+            cout << t << ": " << V << "V" << endl;
+            m_values_queue.emplace_back(t, V);
+        }
+
+        file.close();
+        sortValues();
+    }
+
+    void sortValues()
+    {
+        auto cmp = [](const time_value_pair_type& p1, const time_value_pair_type& p2) {
+            return p1.first < p2.first;
+        };
+        // Stable sort will keep initial ordering for values with identical time
+        std::stable_sort(m_values_queue.begin(), m_values_queue.end(), cmp);
+    }
+};
diff --git a/src/devices/generic_2x2_coupler.h b/src/devices/generic_2x2_coupler.h
new file mode 100644
index 0000000..6cafc17
--- /dev/null
+++ b/src/devices/generic_2x2_coupler.h
@@ -0,0 +1,86 @@
+#pragma once
+
+#include "devices/generic_transmission_device.h"
+
+class Generic2x2Coupler : public GenericTransmissionDevice {
+public:
+    Generic2x2Coupler(sc_module_name name
+                    , const double &k_power = 0.0
+                    , const double &insertion_loss = 0.0)
+    : GenericTransmissionDevice(name, 4)
+    {
+        setCouplingFactor(k_power);
+        setInsertionLoss(insertion_loss);
+    }
+
+    void setCouplingFactor(const double &k_power)
+    {
+        assert(isfinite(k_power) && k_power >= 0 && k_power <= 1);
+        m_k_power = k_power;
+    }
+
+    void setInsertionLoss(const double &insertion_loss)
+    {
+        assert(isfinite(insertion_loss) && insertion_loss >= 0);
+        m_insertion_loss = insertion_loss;
+    }
+
+private:
+
+    virtual void prepareTM()
+    {
+        TM.clear();
+        TM.resize(nports);
+
+        double lambda0 = 1550e-9;
+        double transmission_cross = sqrt(m_k_power) * pow(10.0, -m_insertion_loss/20.0);
+        transmission_cross = max(0.0, min(1.0, transmission_cross));
+        double transmission_through = sqrt(1 - m_k_power) * pow(10.0, -m_insertion_loss/20.0);
+        transmission_through = max(0.0, min(1.0, transmission_through));
+        double phi_through = 0.0;
+        double phi_cross = M_PI / 2.0;
+        double tau = 0.0;
+        size_t k;
+
+        // cout << transmission_through << endl;
+        // cout << transmission_cross << endl;
+        // cout << m_k_power << endl << endl << endl;
+
+        // (13, 14, 23, 24 are the only active ones)
+
+        // S13
+        k = 0*nports + 2;
+        TM.Mactive[k] = true;
+        TM.Malpha[k] = {transmission_through};
+        TM.Mphi[k] = {phi_through};
+        TM.Mtau[k] = {tau};
+        
+        // S14
+        k = 0*nports + 3;
+        TM.Mactive[k] = true;
+        TM.Malpha[k] = {transmission_cross};
+        TM.Mphi[k] = {phi_cross};
+        TM.Mtau[k] = {tau};
+        
+        // S23
+        k = 1*nports + 2;
+        TM.Mactive[k] = true;
+        TM.Malpha[k] = {transmission_cross};
+        TM.Mphi[k] = {phi_cross};
+        TM.Mtau[k] = {tau};
+        
+        // S24
+        k = 1*nports + 3;
+        TM.Mactive[k] = true;
+        TM.Malpha[k] = {transmission_through};
+        TM.Mphi[k] = {phi_through};
+        TM.Mtau[k] = {tau};
+
+        // cout << TM.Mphi.size() << endl;
+        // cout << TM.Mphi[0].size() << endl;
+        // cout << TM.Mphi[1].size() << endl;
+    }
+
+    double m_insertion_loss;
+    double m_k_power; // power coupling factor (1-k = transmission factor)
+};
\ No newline at end of file
diff --git a/src/devices/generic_transmission_device.cpp b/src/devices/generic_transmission_device.cpp
new file mode 100644
index 0000000..e709109
--- /dev/null
+++ b/src/devices/generic_transmission_device.cpp
@@ -0,0 +1,224 @@
+#include "devices/generic_transmission_device.h"
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + SUFFIX + "_" + to_string(IDX)).c_str())
+
+using std::size_t;
+using std::pow;
+
+TransmissionMatrix::paramset_type TransmissionMatrix::operator()(const size_t &i, const size_t &j
+    , const wavelength_type &lambda, const size_t max_order) const
+{
+    // row/col to index
+    const size_t k = i * N + j;
+
+    if (Mactive[k] == false)
+        return {0,0,0};
+
+    if (max_order == 0)
+        return {Malpha[k][0], Mphi[k][0], Mtau[k][0]};
+
+    // Alias relevant taylor series
+    auto &Malpha_ = Malpha[k];
+    auto &Mphi_ = Mphi[k];
+    auto &Mtau_ = Mtau[k];
+
+    // Get initial parameters (values at lambda0)
+    double alpha = Malpha_[0];
+    double phi = Mphi_[0];
+    double tau = Mtau_[0];
+
+    // Calculate distance to lambda0
+    const wavelength_type dlambda = lambda - lambda0;
+
+    // Perform taylor expansion of alpha
+    double dlambda_n_over_fact_n = 1.0;
+    for (size_t order = 1; order < min(1 + max_order, Malpha_.size()); ++order)
+    {
+        double dalpha_over_dlambda_n = Malpha_[order];
+        dlambda_n_over_fact_n *= dlambda / order;
+        alpha += dalpha_over_dlambda_n * dlambda_n_over_fact_n;
+    }
+
+    // Perform taylor expansion of phi
+    dlambda_n_over_fact_n = 1.0;
+    for (size_t order = 1; order < min(1 + max_order, Mphi_.size()); ++order)
+    {
+        double dphi_over_dlambda_n = Mphi_[order];
+        dlambda_n_over_fact_n *= dlambda / order;
+        phi += dphi_over_dlambda_n * dlambda_n_over_fact_n;
+    }
+
+    // Perform taylor expansion of tau
+    dlambda_n_over_fact_n = 1.0;
+    for (size_t order = 1; order < min(1 + max_order, Mtau_.size()); ++order)
+    {
+        double dtau_over_dlambda_n = Mtau_[order];
+        dlambda_n_over_fact_n *= dlambda / order;
+        tau += dtau_over_dlambda_n * dlambda_n_over_fact_n;
+    }
+
+    //cout << lambda << ": " << alpha << ", " << fmod(phi, 2*M_PI) << ", " << tau << endl;
+    return {alpha,phi,tau};
+}
+
+void GenericTransmissionDevice::pre_init()
+{
+    ports_in.clear();
+    ports_out.clear();
+    ports_out_writers.clear();
+
+    for (size_t i = 0; i < nports; ++i)
+    {
+        ports_in.push_back(make_shared<port_in_type>(__modname("_IN", i)));
+        ports_out.push_back(make_shared<port_out_type>(__modname("_OUT", i)));
+        ports_out_writers.push_back(make_shared<OpticalOutputPort>(__modname("_OOP", i), (*ports_out[i])));
+        ports_out_writers[i]->m_use_deltas = true;
+    }
+}
+
+void GenericTransmissionDevice::init()
+{
+    prepareTM();
+    assert(nports == TM.N);
+    for (size_t i = 0; i < nports; ++i)
+    {
+        for (size_t j = 0; j < nports; ++j)
+        {
+            sc_spawn_options opts;
+            if (TM.isActive(i, j))
+            {
+                opts.set_sensitivity(ports_in[i].get());
+                sc_spawn( sc_bind(&GenericTransmissionDevice::input_on_i_output_on_j, this, i, j), 
+                    (string(name()) + "process_" + to_string(i) + "_" + to_string(j)).c_str(), &opts);
+            }
+        }
+    }
+}
+
+string GenericTransmissionDevice::describe() const
+{
+    return ""s;
+}
+
+void GenericTransmissionDevice::input_on_i(size_t i)
+{
+    auto last_signal = OpticalSignal(0);
+    const auto &p_in = (*ports_in[i]);
+    const bool active = TM.isInputActive(i);
+
+    while(active)
+    {
+        // Wait for new input on i_in
+        wait();
+
+        // Read new input from i_in
+        const auto &s = p_in->read();
+
+        // cout << "received:" << endl << "\t" << s;
+
+        // Compute delta
+        const auto deltaE_in = s - last_signal;
+
+        // Store new input signal for next change
+        last_signal = s;
+
+        // Loop on all device ports
+        for (size_t j = 0; j < nports; ++j)
+        {
+            if (!TM.isActive(i,j))
+                continue;
+            // cout << "(i,j):" << i << ", " << j << endl;
+
+            // Get transmission parameters at this wavelength
+            auto Tij = TM(i, j, s.getWavelength());
+
+            // Apply parameters
+            auto deltaE_out = deltaE_in * polar(Tij.alpha, Tij.phi);
+
+            // cout << Tij.alpha << ", " << Tij.phi << ", " << Tij.tau << endl;
+
+            deltaE_out.getNewId();
+
+            // Schedule writing the change in output port
+            ports_out_writers[j]->delayedWrite(deltaE_out, sc_time(Tij.tau, SC_SEC));
+        }
+    }
+    while (true) { wait(); }
+}
+
+void GenericTransmissionDevice::input_on_i_output_on_j(size_t i, size_t j)
+{
+    auto last_signal = OpticalSignal(0);
+    const auto &p_in = (*ports_in[i]);
+    //auto &p_out = (*ports_out[j]);
+    auto &p_out_writer = (*ports_out_writers[j]);
+    const bool active = TM.isActive(i, j);
+    cout << i << ", " << j << " is active" << endl;
+
+    // Block if non active
+    while (!active) { wait(); }
+
+    complex<double> Sij;
+    double delay;
+    
+    // Wait for first signal to calculate Sij and delay
+    volatile bool init_done = false;
+    while (!init_done)
+    {
+        // Wait for first input on p_in
+        wait();
+
+        // Read new input from i_in
+        const auto &s = p_in->read();
+
+        // cout << "received:" << endl << "\t" << s << endl;
+
+        if (isnan(s.getWavelength()))
+            continue;
+
+        // Find Sij at that wavelength
+        const auto Tij = TM(i, j, s.getWavelength());
+        Sij = polar(Tij.alpha, Tij.phi);
+        delay = Tij.tau;
+        
+        auto deltaE = (s - last_signal) * Sij;
+        last_signal = s;
+        p_out_writer.delayedWrite(deltaE, sc_time(delay, SC_SEC));
+
+        init_done = true;
+
+        // cout << "init done:" << endl << "\t" << norm(Sij) << ", " << arg(Sij) << ", " << delay << endl;
+    }
+
+    while(true)
+    {
+        // Wait for new input on i_in
+        wait();
+
+        // Read new input from i_in
+        const auto &s = p_in->read();
+
+        if (s.getWavelength() != last_signal.getWavelength())
+        {
+            cerr << "Cannot handle different wavelength (" << __FUNCTION__ << ")" << endl;
+            cerr << s << endl;
+            cerr << last_signal << endl;
+            sc_stop();
+        }
+
+        // cout << "received:" << endl << "\t" << s << endl;
+
+        // Compute new delta
+        auto deltaE = (s - last_signal) * Sij;
+
+        // Store new input signal for next change
+        last_signal = s;
+
+        //deltaE_out.getNewId();
+
+        // Schedule writing the change in output port
+        p_out_writer.delayedWrite(deltaE, sc_time(delay, SC_SEC));
+        //wait(SC_ZERO_TIME);
+    }
+}
\ No newline at end of file
diff --git a/src/devices/generic_transmission_device.h b/src/devices/generic_transmission_device.h
new file mode 100644
index 0000000..bfd110b
--- /dev/null
+++ b/src/devices/generic_transmission_device.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#define SC_INCLUDE_DYNAMIC_PROCESSES
+
+#include <systemc.h>
+#include <vector>
+#include <valarray>
+#include "devices/spx_module.h"
+#include "optical_signal.h"
+#include "optical_output_port.h"
+
+using std::vector;
+using std::valarray;
+using std::string;
+using std::cout;
+using std::endl;
+using std::cerr;
+
+class TransmissionMatrix {
+public:
+    typedef TransmissionMatrix this_type;
+    typedef double wavelength_type;
+    typedef double param_type;
+    typedef valarray<param_type> taylor_series_type;
+    typedef valarray<taylor_series_type> matrix_type;
+    typedef struct{ double alpha, phi, tau; } paramset_type;
+
+    size_t N; // Number of ports (= Nrow = Ncol) in the matrix
+    // Arrays of matrices describing alpha, phi and the group delay via their taylor coefficients (starting from alpha0)
+    matrix_type Malpha;
+    matrix_type Mphi;
+    matrix_type Mtau;
+    valarray<bool> Mactive;
+    wavelength_type lambda0; // Wavelength at which the taylor coefficients were calculated
+
+    paramset_type operator()(const size_t &i, const size_t &j, const wavelength_type &lambda, const size_t max_order=2) const;
+    inline bool isActive(const size_t &i, const size_t &j) const
+    { return Mactive[i * N + j]; }
+    inline bool isInputActive(const size_t &i) const
+    { 
+        bool ret = false;
+        for (size_t j = 0; j < N; ++j)
+            ret |= Mactive[i * N + j];
+        return ret;
+    }
+
+    void clear()
+    {
+        N = 0;
+        lambda0 = 0;
+        Malpha.resize(0);
+        Mphi.resize(0);
+        Mtau.resize(0);
+        Mactive.resize(0);
+    }
+
+    void resize(size_t nports)
+    {
+        N = nports;
+        Malpha.resize(nports*nports, {0});
+        Mphi.resize(nports*nports, {0});
+        Mtau.resize(nports*nports, {0});
+        Mactive.resize(nports*nports, false);
+    }
+};
+
+class GenericTransmissionDevice : public spx_module {
+public:
+    typedef GenericTransmissionDevice this_type;
+
+    /* ------------------------ */
+    size_t nports;
+    vector<shared_ptr<port_in_type>> ports_in;
+    vector<shared_ptr<port_out_type>> ports_out;
+    vector<shared_ptr<OpticalOutputPort>> ports_out_writers;
+    TransmissionMatrix TM;
+
+    /* ------------------------ */
+    virtual void pre_init();
+    virtual void init();
+    virtual string describe() const;
+    virtual void prepareTM() = 0;
+
+    // Process input on i
+    void input_on_i(size_t i);
+    void input_on_i_output_on_j(size_t i, size_t j);
+
+    GenericTransmissionDevice(sc_module_name name, size_t N = 1)
+    : spx_module(name)
+    , nports(N)
+    {
+        pre_init();
+    }
+};
\ No newline at end of file
diff --git a/src/devices/generic_waveguide.h b/src/devices/generic_waveguide.h
new file mode 100644
index 0000000..d704678
--- /dev/null
+++ b/src/devices/generic_waveguide.h
@@ -0,0 +1,119 @@
+#pragma once
+
+#include "devices/generic_transmission_device.h"
+
+using std::isfinite;
+
+class GenericWaveguide : public GenericTransmissionDevice {
+public:
+    GenericWaveguide(sc_module_name name
+                    , const double &length = 0
+                    , const double &loss = 0
+                    , const double &neff = 1
+                    , const double &ng = 1
+                    , const double &D = 0
+                    , const double &lambda0 = 1.55e-6)
+    : GenericTransmissionDevice(name, 2)
+    {
+        cerr << "GenericWaveguide is disabled (not working)." << endl;
+        exit(1);
+
+        setLength(length);
+        setLoss(loss);
+        setEffectiveIndex(neff);
+        setGroupIndex(ng);
+        setDispersion(D);
+        setLambda0(lambda0);
+    }
+
+    void setLength(const double &length)
+    {
+        assert(isfinite(length) && length >= 0);
+        m_length = length;
+    }
+
+    void setLoss(const double &loss)
+    {
+        cout << loss << endl;
+        assert(isfinite(loss));
+        m_loss = loss;
+    }
+
+    void setEffectiveIndex(const double &neff)
+    {
+        assert(isfinite(neff) && neff >= 0);
+        m_neff = neff;
+    }
+
+    void setGroupIndex(const double &ng)
+    {
+        assert(isfinite(ng) && ng >= 0);
+        m_ng = ng;
+    }
+
+    void setDispersion(const double &D)
+    {
+        assert(isfinite(D));
+        m_D = D;
+    }
+
+    void setLambda0(const double &lambda0)
+    {
+        assert(isfinite(lambda0) && lambda0 > 0);
+        m_lambda0 = lambda0;
+    }
+
+
+private:
+
+    virtual void prepareTM()
+    {
+        TM.clear();
+        TM.resize(nports);
+
+        const double c = 299792458.0;
+        double lambda0 = m_lambda0;
+        double transmission = pow(10.0, -(m_loss * m_length)/20.0);
+        double two_pi_L = 2 * M_PI * m_length;
+        double dphi_0 = fmod(two_pi_L * m_neff, 2 * M_PI);
+
+        // The following 2 lines are wrong...
+        double dphi_1 = - two_pi_L * m_ng / lambda0 / lambda0; // Here it should be -2pi*L*ng/(lambda*lambda0) (instead of lambda0^2)
+        double dphi_2 = two_pi_L * 2 * m_ng / lambda0 / lambda0 / lambda0;
+
+        double group_delay_0 = m_length * m_ng / c;
+        double group_delay_1 = m_length * m_D;
+
+        TM.lambda0 = lambda0;
+        TM.Mactive = {false, true, true, false};
+        TM.Malpha = {
+            {0},
+            {transmission},
+            {transmission},
+            {0}};
+        TM.Mphi = {
+            {0},
+            {dphi_0, dphi_1, dphi_2},
+            {dphi_0, dphi_1, dphi_2},
+            {0}};
+        TM.Mtau = {
+            {0},
+            {group_delay_0, group_delay_1},
+            {group_delay_0, group_delay_1},
+            {0}};
+
+        // cout << "----------- " << name() << " -----------" << endl;
+        // cout << "- alpha:        " << TM.Malpha[1][0] << " (V/m)/(V/m)" << endl;
+        // cout << "- transmission: " << pow(TM.Malpha[1][0],2.0) << " W/W" << endl;
+        // cout << "- phi:          " << TM.Mphi[1][0] << " rad" << endl;
+        // cout << "- dphi/dlambda: " << TM.Mphi[1][1] << " rad/m" << endl;
+        // cout << "- group delay:  " << TM.Mtau[1][0] << " s" << endl;
+    }
+
+    double m_loss; // loss in dB/m
+    double m_neff; // real part of neff
+    double m_ng; // (real part of) ng
+    double m_D; // dispersion
+    double m_lambda0; // dispersion
+    double m_length; // waveguide length
+};
\ No newline at end of file
diff --git a/src/devices/merger.cpp b/src/devices/merger.cpp
new file mode 100644
index 0000000..2aa3e9f
--- /dev/null
+++ b/src/devices/merger.cpp
@@ -0,0 +1,69 @@
+#include <merger.h>
+#include <specs.h>
+
+using namespace std;
+
+void Merger::on_port_in1_changed()
+{
+    const double transmission = pow(10.0, - m_attenuation_dB / 20) / sqrt(2);
+    m_memory_in1[0] = 0; // initializing for nan wavelength
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "transmission = " << pow(transmission, 2) << " W/W" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in1.get_interface()))->name() << endl;
+        cout << "\t --> \t" << (dynamic_cast<spx::oa_signal_type *>(p_out.get_interface()))->name() << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in2.get_interface()))->name();
+        cout << endl;
+        cout << endl;
+    }
+
+    OpticalSignal p_in1_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+        // Read sum of input signals
+        p_in1_read = p_in1->read();
+
+        auto cur_wavelength_id = p_in1_read.m_wavelength_id;
+        // Updating the field memory
+        m_memory_in1[cur_wavelength_id] = p_in1_read.m_field;
+
+        auto s = OpticalSignal(m_memory_in1[cur_wavelength_id] +
+                                m_memory_in2[cur_wavelength_id]
+                                , cur_wavelength_id);
+
+        s *= transmission;
+
+        m_out_writer.delayedWrite(s,SC_ZERO_TIME);
+    }
+}
+
+void Merger::on_port_in2_changed()
+{
+    const double transmission = pow(10.0, - m_attenuation_dB / 20) / sqrt(2);
+    m_memory_in2[0] = 0; // initializing for nan wavelength
+
+    OpticalSignal p_in2_read;
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+        // Read sum of input signals
+        p_in2_read = p_in2->read();
+
+        auto cur_wavelength_id = p_in2_read.m_wavelength_id;
+        // Updating the field memory
+        m_memory_in2[cur_wavelength_id] = p_in2_read.m_field;
+
+        auto s = OpticalSignal(m_memory_in1[cur_wavelength_id] +
+                                m_memory_in2[cur_wavelength_id]
+                                , cur_wavelength_id);
+
+        s *= transmission;
+
+        m_out_writer.delayedWrite(s,SC_ZERO_TIME);
+    }
+}
\ No newline at end of file
diff --git a/src/devices/merger.h b/src/devices/merger.h
new file mode 100644
index 0000000..a3c0704
--- /dev/null
+++ b/src/devices/merger.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <systemc.h>
+#include <map>
+
+#include <spx_module.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+#include "specs.h"
+#include "spx_module.h"
+
+// A symmetric no-delay merger
+class Merger : public spx_module {
+public:
+    // Ports
+    spx::oa_port_in_type p_in1;
+    spx::oa_port_in_type p_in2;
+    spx::oa_port_out_type p_out;
+
+    // Timed ports writers
+    OpticalOutputPort m_out_writer;
+
+    // Member variables
+    double m_attenuation_dB;
+
+    // Memory for multi-wavelength purposes
+    // maybe with vector it has better performance
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in1;
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in2;
+
+    // Processes
+    void on_port_in1_changed();
+    void on_port_in2_changed();
+
+    // Constructor
+    Merger(sc_module_name name,
+           double attenuation_dB = 0)
+        : spx_module(name)
+        , m_out_writer("out_delayed_writer", p_out)
+        , m_attenuation_dB(attenuation_dB)
+    {
+        SC_HAS_PROCESS(Merger);
+
+        SC_THREAD(on_port_in1_changed);
+        sensitive << p_in1;
+
+        SC_THREAD(on_port_in2_changed);
+        sensitive << p_in2;
+    }
+};
diff --git a/src/devices/mesh_col.cpp b/src/devices/mesh_col.cpp
new file mode 100644
index 0000000..5723b17
--- /dev/null
+++ b/src/devices/mesh_col.cpp
@@ -0,0 +1,243 @@
+#include <mesh_col.h>
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX)).c_str())
+
+void MeshCol::init_ports()
+{
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing optical input ports
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    p_in.clear();
+    for(size_t i = 0; i < m_N; i++)
+    {
+        p_in.push_back(make_unique<spx::oa_port_in_type>(__modname("IN_", i)));
+    }
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing optical output ports
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    p_out.clear();
+    for(size_t i = 0; i < m_N; i++)
+    {
+        p_out.push_back(make_unique<spx::oa_port_out_type>(__modname("OUT_", i)));
+    }
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing electrical input ports
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    p_vphi.clear();
+    p_vtheta.clear();
+
+    size_t num_of_electrical_ports = m_N/2;
+    if ((m_N % 2 == 0) && !(m_j % 2 == 0)) // if even-odd, there is one less MZI
+        num_of_electrical_ports = m_N/2 - 1;
+
+
+    for(size_t i = 0; i < num_of_electrical_ports; i++)
+    {
+        p_vphi.push_back(make_unique<sc_in<double>>(__modname("VPHI_", i)));
+        p_vtheta.push_back(make_unique<sc_in<double>>(__modname("VTHETA_", i)));
+    }
+}
+
+void MeshCol::init()
+{
+    if (m_N % 2 == 0)
+    {
+        if (m_j % 2 == 0)
+            init_N_even_j_even();
+        else
+            init_N_even_j_odd();
+    }
+    else
+    {
+        if (m_j % 2 == 0)
+            init_N_odd_j_even();
+        else
+            init_N_odd_j_odd();
+    }
+}
+
+/* 
+    For N=4 that's how it looks
+        0__  __0
+           \/
+        1__/\__1
+
+        2__  __2
+           \/
+        3__/\__3
+
+    TODO: snap to 2pi phase instead of setting neff = 0
+*/
+void MeshCol::init_N_even_j_even()
+{
+    for(size_t i = 0; i < m_N/2; i++)
+    {
+        m_mzi.push_back(make_unique<MZI>(__modname("MZI_", i),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_attenuation_coupler_dB, m_attenuation_ps_dB,
+                m_neff, m_ng));
+                
+        m_mzi[i]->p_in1(*p_in[2*i]);
+        m_mzi[i]->p_in2(*p_in[2*i+1]);
+        m_mzi[i]->p_out1(*p_out[2*i]);
+        m_mzi[i]->p_out2(*p_out[2*i+1]);
+        m_mzi[i]->p_vphi(*p_vphi[i]);
+        m_mzi[i]->p_vtheta(*p_vtheta[i]);
+        m_mzi[i]->init();
+    }
+}
+
+
+/* For N=4 that's how it looks
+
+        0______0
+
+        1__  __1
+           \/
+        2__/\__2
+
+        3______3
+
+    The empty rows have a waveguide that adds zero phase
+    but can have loss and time delay.
+
+    TODO: snap to 2pi phase instead of setting neff = 0
+
+*/
+void MeshCol::init_N_even_j_odd()
+{
+    assert(m_N >= 4);
+
+    // Zero neff so it doesn't add any phase
+    m_wg.push_back(make_unique<Waveguide>(__modname("WG_", 0),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_neff, m_ng));
+    m_wg[0]->p_in(*p_in[0]);
+    m_wg[0]->p_out(*p_out[0]);
+
+    for(size_t i = 1; i <= m_N/2 - 1; i++)
+    {
+        m_mzi.push_back(make_unique<MZI>(__modname("MZI_", i),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_attenuation_coupler_dB, m_attenuation_ps_dB,
+                m_neff, m_ng));
+                
+        m_mzi[i - 1]->p_in1(*p_in[2 * i - 1]);
+        m_mzi[i - 1]->p_in2(*p_in[2 * i]);
+        m_mzi[i - 1]->p_out1(*p_out[2 * i - 1]);
+        m_mzi[i - 1]->p_out2(*p_out[2 * i]);
+        m_mzi[i - 1]->p_vphi(*p_vphi[i - 1]);
+        m_mzi[i - 1]->p_vtheta(*p_vtheta[i - 1]);
+        m_mzi[i - 1]->init();
+
+    }
+
+    // Zero neff so it doesn't add any phase
+    m_wg.push_back(make_unique<Waveguide>(__modname("WG_", 1),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_neff, m_ng));
+    m_wg[1]->p_in(*p_in[m_N-1]);
+    m_wg[1]->p_out(*p_out[m_N-1]);
+
+}
+
+/* For N=5 that's how it looks
+
+        0__  __0
+           \/
+        1__/\__1
+
+        2__  __2
+           \/
+        3__/\__3
+
+        4______4
+
+    The empty rows have a waveguide that adds zero phase
+    but can have loss and time delay.
+
+    TODO: snap to 2pi phase instead of setting neff = 0
+
+*/
+void MeshCol::init_N_odd_j_even()
+{
+    cout << "odd-even" << endl;
+    for(size_t i = 0; i < m_N/2; i++)
+    {
+        m_mzi.push_back(make_unique<MZI>(__modname("MZI_", i),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_attenuation_coupler_dB, m_attenuation_ps_dB,
+                m_neff, m_ng));
+                
+        m_mzi[i]->p_in1(*p_in[2*i]);
+        m_mzi[i]->p_in2(*p_in[2*i+1]);
+        m_mzi[i]->p_out1(*p_out[2*i]);
+        m_mzi[i]->p_out2(*p_out[2*i+1]);
+        m_mzi[i]->p_vphi(*p_vphi[i]);
+        m_mzi[i]->p_vtheta(*p_vtheta[i]);
+        m_mzi[i]->init();
+    }
+    // Zero neff so it doesn't add any phase
+    m_wg.push_back(make_unique<Waveguide>(__modname("WG_", 0),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_neff, m_ng));
+    m_wg[0]->p_in(*p_in[m_N-1]);
+    m_wg[0]->p_out(*p_out[m_N-1]);
+}
+
+/* For N=5 that's how it looks
+        
+        0______0
+
+        1__  __1
+           \/
+        2__/\__2
+
+        3__  __3
+           \/
+        4__/\__4
+
+    The empty rows have a waveguide that adds zero phase
+    but can have loss and time delay.
+
+    TODO: snap to 2pi phase instead of setting neff = 0
+
+*/
+void MeshCol::init_N_odd_j_odd()
+{
+    cout << "odd-odd" << endl;
+    // Zero neff so it doesn't add any phase
+    m_wg.push_back(make_unique<Waveguide>(__modname("WG_", 0),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_neff, m_ng));
+    m_wg[0]->p_in(*p_in[0]);
+    m_wg[0]->p_out(*p_out[0]);
+
+    for(size_t i = 1; i <= m_N/2; i++)
+    {
+        m_mzi.push_back(make_unique<MZI>(__modname("MZI_", i),
+                m_length_cm, m_attenuation_wg_dB_cm,
+                m_attenuation_coupler_dB, m_attenuation_ps_dB,
+                m_neff, m_ng));
+                
+        m_mzi[i - 1]->p_in1(*p_in[2 * i - 1]);
+        m_mzi[i - 1]->p_in2(*p_in[2 * i]);
+        m_mzi[i - 1]->p_out1(*p_out[2 * i - 1]);
+        m_mzi[i - 1]->p_out2(*p_out[2 * i]);
+        m_mzi[i - 1]->p_vphi(*p_vphi[i - 1]);
+        m_mzi[i - 1]->p_vtheta(*p_vtheta[i - 1]);
+        m_mzi[i - 1]->init();
+    }
+}
\ No newline at end of file
diff --git a/src/devices/mesh_col.h b/src/devices/mesh_col.h
new file mode 100644
index 0000000..e0a6066
--- /dev/null
+++ b/src/devices/mesh_col.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <systemc.h>
+#include <specs.h>
+#include <spx_module.h>
+#include <mzi.h>
+#include <waveguide.h>
+
+/**
+ * This class implements a single column of an MZI mesh
+ * specified in the work: Optimal design for universal multiport interferometers
+ * by Clements et al. (2016).
+*/
+
+class MeshCol : public spx_module{
+public:
+    // Ports
+    vector<unique_ptr<spx::oa_port_in_type>> p_in;
+    vector<unique_ptr<spx::oa_port_out_type>> p_out;
+    vector<unique_ptr<sc_in<double>>> p_vphi;
+    vector<unique_ptr<sc_in<double>>> p_vtheta;
+
+    // Member variables
+    size_t m_N; // represents the number of inputs of the mesh (rows)
+    size_t m_j; // represents the current row being evaluated
+
+    // Parameters for the internal MZIs
+    double m_length_cm;
+    double m_attenuation_wg_dB_cm;
+    double m_attenuation_coupler_dB;
+    double m_attenuation_ps_dB;
+    double m_neff;
+    double m_ng;
+
+    // Submodules
+    vector<unique_ptr<MZI>> m_mzi;
+    vector<unique_ptr<Waveguide>> m_wg;
+
+
+    // Initialization functions
+    void init_ports();
+    void init();
+
+    void init_N_even_j_even();
+    void init_N_even_j_odd();
+
+    void init_N_odd_j_even();
+    void init_N_odd_j_odd();
+
+    /** Constructor for MZI Mesh Column
+     *
+     * @param name name of the module
+     * @param N number of rows contained in the module
+     * @param j current column being created, from 0 to N-1
+     * */
+    MeshCol(sc_module_name name, const size_t &N, const size_t &j,
+            const double &length_cm = 1e-2,
+            const double &attenuation_wg_dB_cm = 0, const double &attenuation_coupler_dB = 0,
+            const double &attenuation_ps_dB = 0,
+            const double &neff = 2.2111, const double &ng = 2.2637)
+        : spx_module(name)
+        , m_N(N)
+        , m_j(j)
+        , m_length_cm(length_cm)
+        , m_attenuation_wg_dB_cm(attenuation_wg_dB_cm)
+        , m_attenuation_coupler_dB(attenuation_coupler_dB)
+        , m_attenuation_ps_dB(attenuation_ps_dB)
+        , m_neff(neff)
+        , m_ng(ng)
+    {
+        assert(N > 1);
+        assert(j < N);
+
+        init_ports();
+    }
+};
\ No newline at end of file
diff --git a/src/devices/mzi.cpp b/src/devices/mzi.cpp
new file mode 100644
index 0000000..6999fd9
--- /dev/null
+++ b/src/devices/mzi.cpp
@@ -0,0 +1,55 @@
+#include <mzi.h>
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX)).c_str())
+
+using namespace std;
+
+void MZI::init()
+{
+    DC1.reset();
+    DC2.reset();
+    PS1.reset();
+    PS2.reset();
+    WG1.reset();
+    WG2.reset();
+
+    // Creating instances
+    WG1 = make_unique<Waveguide>((string(name()) + "/WG1").c_str(),
+            m_length_cm, m_attenuation_dB_cm, m_neff, m_ng);
+    WG2 = make_unique<Waveguide>((string(name()) + "/WG2").c_str(),
+            m_length_cm, m_attenuation_dB_cm, m_neff, m_ng);
+    DC1 = make_unique<DirectionalCoupler>((string(name()) + "/DC1").c_str(), 0.5, m_attenuation_coupler_dB);
+    DC2 = make_unique<DirectionalCoupler>((string(name()) + "/DC2").c_str(), 0.5, m_attenuation_coupler_dB);
+    PS1 = make_unique<PhaseShifter>((string(name()) + "/PS1").c_str(), m_attenuation_ps_dB);
+    PS2 = make_unique<PhaseShifter>((string(name()) + "/PS2").c_str(), m_attenuation_ps_dB);
+
+    // Connecting
+
+    PS1->p_in(p_in1);
+    PS1->p_out(w1);
+    PS1->p_vin(p_vphi);
+
+    DC1->p_in1(w1);
+    DC1->p_in2(p_in2);
+    DC1->p_out1(w2);
+    DC1->p_out2(w5);
+
+    // Upper branch
+    PS2->p_in(w2);
+    PS2->p_out(w3);
+    PS2->p_vin(p_vtheta);
+
+    WG1->p_in(w3);
+    WG1->p_out(w4);
+
+    // Bottom branch
+    WG2->p_in(w5);
+    WG2->p_out(w6);
+
+    // End
+    DC2->p_in1(w4);
+    DC2->p_in2(w6);
+    DC2->p_out1(p_out1);
+    DC2->p_out2(p_out2);
+}
\ No newline at end of file
diff --git a/src/devices/mzi.h b/src/devices/mzi.h
new file mode 100644
index 0000000..95089ad
--- /dev/null
+++ b/src/devices/mzi.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <systemc.h>
+
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include "specs.h"
+#include "spx_module.h"
+
+#include <directional_coupler.h>
+#include <phaseshifter.h>
+#include <waveguide.h>
+
+/** A unidirectional waveguide module. */
+class MZI : public spx_module {
+public:
+    // Ports
+    /** The optical input ports. */
+    spx::oa_port_in_type p_in1, p_in2;
+    /** The optical output ports. */
+    spx::oa_port_out_type p_out1, p_out2;
+    /** The electrical input ports */
+    spx::ea_port_in_type p_vphi, p_vtheta;
+
+    // Member variables
+
+    /** Waveguide-related. */
+    double m_length_cm;
+    double m_attenuation_dB_cm;
+    double m_neff;
+    double m_ng;
+
+    /** DC-related */
+    double m_attenuation_coupler_dB;
+
+    /** PhaseShifter-related */
+    double m_attenuation_ps_dB;
+
+    // Member submodules and wires
+    spx::oa_signal_type w1, w2, w3, w4, w5, w6;
+
+    unique_ptr<PhaseShifter> PS1, PS2;
+    unique_ptr<Waveguide> WG1, WG2, WG3;
+    unique_ptr<DirectionalCoupler> DC1,DC2;
+
+    virtual void init();
+
+    /** Constructor for MZI
+     *
+     * @param name name of the module
+     * @param length_cm internal branch length in cm
+     * */
+    MZI(sc_module_name name, const double &length_cm = 1e-2,
+            const double &attenuation_wg_dB_cm = 0, const double &attenuation_coupler_dB = 0,
+            const double &attenuation_ps_dB = 0,
+            const double &neff = 2.2111, const double &ng = 2.2637)
+        : spx_module(name)
+        , m_length_cm(length_cm)
+        , m_attenuation_dB_cm(attenuation_wg_dB_cm)
+        , m_neff(neff)
+        , m_ng(ng)
+        , m_attenuation_coupler_dB(attenuation_coupler_dB)
+        , m_attenuation_ps_dB(attenuation_ps_dB)
+    {
+
+    }
+};
diff --git a/src/devices/mzi_active.cpp b/src/devices/mzi_active.cpp
new file mode 100644
index 0000000..4a8b8a8
--- /dev/null
+++ b/src/devices/mzi_active.cpp
@@ -0,0 +1,206 @@
+#include <mzi_active.h>
+
+void MZIActiveUni::init()
+{
+    m_dc1_o1 = make_shared<spx::oa_signal_type>((string(name()) + "/DC1_out1").c_str());
+    m_dc1_o2 = make_shared<spx::oa_signal_type>((string(name()) + "/DC1_out2").c_str());
+    m_dc2_i1 = make_shared<spx::oa_signal_type>((string(name()) + "/DC2_in1").c_str());
+    m_dc2_i2 = make_shared<spx::oa_signal_type>((string(name()) + "/DC2_in2").c_str());
+    m_ps_in = make_shared<spx::oa_signal_type>((string(name()) + "/PS1_in").c_str());
+    m_ps_out = make_shared<spx::oa_signal_type>((string(name()) + "/PS1_out").c_str());
+
+    m_wg1 = make_shared<WaveguideUni>((string(name()) + "/WG1").c_str());
+    m_wg2 = make_shared<WaveguideUni>((string(name()) + "/WG2").c_str());
+    m_wg3 = make_shared<WaveguideUni>((string(name()) + "/WG3").c_str());
+    m_dc1 = make_shared<DirectionalCouplerUni>((string(name()) + "/DC1").c_str());
+    m_dc2 = make_shared<DirectionalCouplerUni>((string(name()) + "/DC2").c_str());
+    m_ps = make_shared<PhaseShifterUni>((string(name()) + "/PS1").c_str());
+
+    connect_submodules();
+}
+
+void MZIActiveUni::connect_submodules()
+{
+    // Parametrizing the instances
+
+    // cast as unidirectional devices
+    WaveguideUni * const wg1 = dynamic_cast<WaveguideUni *>(m_wg1.get());
+    WaveguideUni * const wg2 = dynamic_cast<WaveguideUni *>(m_wg2.get());
+    WaveguideUni * const wg3 = dynamic_cast<WaveguideUni *>(m_wg3.get());
+    DirectionalCouplerUni * const dc1 = dynamic_cast<DirectionalCouplerUni *>(m_dc1.get());
+    DirectionalCouplerUni * const dc2 = dynamic_cast<DirectionalCouplerUni *>(m_dc2.get());
+    PhaseShifterUni * const ps = dynamic_cast<PhaseShifterUni *>(m_ps.get());
+
+
+    // Top waveguides are divided by two to preserve
+    // the same length in the arms
+    wg1->m_length_cm = m_length_cm/2;
+    wg1->m_attenuation_dB_cm = m_attenuation_dB_cm;
+    wg1->m_neff = m_neff;
+    wg1->m_ng = m_ng;
+
+    wg2->m_length_cm = m_length_cm/2;
+    wg2->m_attenuation_dB_cm = m_attenuation_dB_cm;
+    wg2->m_neff = m_neff;
+    wg2->m_ng = m_ng;
+
+    wg3->m_length_cm = m_length_ref_cm;
+    wg3->m_attenuation_dB_cm = m_attenuation_dB_cm;
+    wg3->m_neff = m_neff;
+    wg3->m_ng = m_ng;
+
+    dc1->m_dc_loss = m_dc_loss_dB;
+    dc2->m_dc_loss = m_dc_loss_dB;
+
+    ps->m_sensitivity = m_ps_sens_rad_v;
+    ps->m_attenuation_dB = m_ps_loss_dB;
+
+    // Connecting the blocks
+
+    dc1->p_in1(p_in1);
+    dc1->p_in2(p_in2);
+    dc1->p_out1(*m_dc1_o1);
+    dc1->p_out2(*m_dc1_o2);
+
+    // Top arm
+    wg1->p_in(*m_dc1_o1);
+    wg1->p_out(*m_ps_in);
+
+    ps->p_in(*m_ps_in);
+    ps->p_out(*m_ps_out);
+    ps->p_vin(p_vin);
+
+    wg2->p_in(*m_ps_out);
+    wg2->p_out(*m_dc2_i1);
+
+    // Bot arm
+    wg3->p_in(*m_dc1_o2);
+    wg3->p_out(*m_dc2_i2);
+
+    dc2->p_in1(*m_dc2_i1);
+    dc2->p_in2(*m_dc2_i2);
+    dc2->p_out1(p_out1);
+    dc2->p_out2(p_out2);
+}
+
+void MZIActiveBi::init()
+{
+    // forward
+    m_dc1_p2_out = make_shared<spx::oa_signal_type>((string(name()) + "/DC1_out1_0").c_str());
+    m_dc1_p3_out = make_shared<spx::oa_signal_type>((string(name()) + "/DC1_out2_0").c_str());
+    m_dc2_p0_in = make_shared<spx::oa_signal_type>((string(name()) + "/DC2_in1_0").c_str());
+    m_dc2_p1_in = make_shared<spx::oa_signal_type>((string(name()) + "/DC2_in2_0").c_str());
+    m_ps_p0_in = make_shared<spx::oa_signal_type>((string(name()) + "/PS1_in_0").c_str());
+    m_ps_p1_out = make_shared<spx::oa_signal_type>((string(name()) + "/PS1_out_0").c_str());
+
+    // backward
+    m_dc1_p2_in = make_shared<spx::oa_signal_type>((string(name()) + "/DC1_out1_1").c_str());
+    m_dc1_p3_in = make_shared<spx::oa_signal_type>((string(name()) + "/DC1_out2_1").c_str());
+    m_dc2_p0_out = make_shared<spx::oa_signal_type>((string(name()) + "/DC2_in1_1").c_str());
+    m_dc2_p1_out = make_shared<spx::oa_signal_type>((string(name()) + "/DC1_in2_1").c_str());
+    m_ps_p0_out = make_shared<spx::oa_signal_type>((string(name()) + "/PS1_in_1").c_str());
+    m_ps_p1_in = make_shared<spx::oa_signal_type>((string(name()) + "/PS1_out_1").c_str());
+
+    // devices
+    m_wg1 = make_shared<WaveguideBi>((string(name()) + "/WG1").c_str());
+    m_wg2 = make_shared<WaveguideBi>((string(name()) + "/WG2").c_str());
+    m_wg3 = make_shared<WaveguideBi>((string(name()) + "/WG3").c_str());
+    m_dc1 = make_shared<DirectionalCouplerBi>((string(name()) + "/DC1").c_str());
+    m_dc2 = make_shared<DirectionalCouplerBi>((string(name()) + "/DC2").c_str());
+    m_ps = make_shared<PhaseShifterBi>((string(name()) + "/PS1").c_str());
+
+    connect_submodules();
+}
+
+void MZIActiveBi::connect_submodules()
+{
+    // Parametrizing the instances
+
+    // cast as unidirectional devices
+    WaveguideBi * const wg1 = dynamic_cast<WaveguideBi *>(m_wg1.get());
+    WaveguideBi * const wg2 = dynamic_cast<WaveguideBi *>(m_wg2.get());
+    WaveguideBi * const wg3 = dynamic_cast<WaveguideBi *>(m_wg3.get());
+    DirectionalCouplerBi * const dc1 = dynamic_cast<DirectionalCouplerBi *>(m_dc1.get());
+    DirectionalCouplerBi * const dc2 = dynamic_cast<DirectionalCouplerBi *>(m_dc2.get());
+    PhaseShifterBi * const ps = dynamic_cast<PhaseShifterBi *>(m_ps.get());
+
+
+    // Top waveguides are divided by two to preserve
+    // the same length in the arms
+    wg1->m_length_cm = m_length_cm/2;
+    wg1->m_attenuation_dB_cm = m_attenuation_dB_cm;
+    wg1->m_neff = m_neff;
+    wg1->m_ng = m_ng;
+
+    wg2->m_length_cm = m_length_cm/2;
+    wg2->m_attenuation_dB_cm = m_attenuation_dB_cm;
+    wg2->m_neff = m_neff;
+    wg2->m_ng = m_ng;
+
+    wg3->m_length_cm = m_length_ref_cm;
+    wg3->m_attenuation_dB_cm = m_attenuation_dB_cm;
+    wg3->m_neff = m_neff;
+    wg3->m_ng = m_ng;
+
+    dc1->m_dc_loss = m_dc_loss_dB;
+    dc2->m_dc_loss = m_dc_loss_dB;
+
+    ps->m_sensitivity = m_ps_sens_rad_v;
+    ps->m_attenuation_dB = m_ps_loss_dB;
+
+    // Connecting the blocks
+
+    { // forward
+        dc1->p0_in(p0_in);
+        dc1->p1_in(p1_in);
+        dc1->p2_out(*m_dc1_p2_out);
+        dc1->p3_out(*m_dc1_p3_out);
+
+        // Top arm
+        wg1->p0_in(*m_dc1_p2_out);
+        wg1->p1_out(*m_ps_p0_in);
+
+        ps->p0_in(*m_ps_p0_in);
+        ps->p1_out(*m_ps_p1_out);
+        ps->p_vin(p_vin);
+
+        wg2->p0_in(*m_ps_p1_out);
+        wg2->p1_out(*m_dc2_p0_in);
+
+        // Bot arm
+        wg3->p0_in(*m_dc1_p3_out);
+        wg3->p1_out(*m_ps_p1_out);
+
+        dc2->p0_in(*m_dc2_p0_in);
+        dc2->p1_in(*m_ps_p1_out);
+        dc2->p2_out(p2_out);
+        dc2->p3_out(p3_out);
+    }
+
+    { // backward
+        dc1->p0_out(p0_out);
+        dc1->p1_out(p1_out);
+        dc1->p2_in(*m_dc1_p2_in);
+        dc1->p3_in(*m_dc1_p3_in);
+
+        // Top arm
+        wg1->p0_out(*m_dc1_p2_in);
+        wg1->p1_in(*m_ps_p0_out);
+
+        ps->p0_out(*m_ps_p0_out);
+        ps->p1_in(*m_ps_p1_in);
+        ps->p_vin(p_vin);
+
+        wg2->p0_out(*m_ps_p1_in);
+        wg2->p1_in(*m_dc2_p0_out);
+
+        // Bot arm
+        wg3->p0_out(*m_dc1_p3_in);
+        wg3->p1_in(*m_ps_p1_in);
+
+        dc2->p0_out(*m_dc2_p0_out);
+        dc2->p1_out(*m_ps_p1_in);
+        dc2->p2_in(p2_in);
+        dc2->p3_in(p3_in);
+    }
+}
\ No newline at end of file
diff --git a/src/devices/mzi_active.h b/src/devices/mzi_active.h
new file mode 100644
index 0000000..890322e
--- /dev/null
+++ b/src/devices/mzi_active.h
@@ -0,0 +1,179 @@
+#pragma once
+
+#include "specs.h"
+#include <systemc.h>
+#include <waveguide.h>
+#include <phaseshifter.h>
+#include <directional_coupler.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+//TODO: pass element's characteristics as argument, for instance, pass an example of waveguide,
+// or an example of DC such that it copies. Requires: constructors in each element to build
+// by copying.
+
+class MZIActiveBase : public spx_module {
+public:
+    // Member variables
+    double m_ps_sens_rad_v;
+    double m_length_cm;
+    double m_length_ref_cm;
+    double m_attenuation_dB_cm;
+    double m_neff;
+    double m_ng;
+    double m_dc_loss_dB; // loss of the splitter/merger
+    double m_ps_loss_dB; // loss of the phase shifter
+
+    virtual void init() = 0;
+    virtual void connect_submodules() = 0;
+
+    // Member submodules
+    shared_ptr<WaveguideBase> m_wg1, m_wg2, m_wg3;
+    shared_ptr<DirectionalCouplerBase> m_dc1, m_dc2;
+    shared_ptr<PhaseShifterBase> m_ps;
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * @param m_ps_sens_rad_v sensitivity of phase shifter
+     * @param m_length_cm length of the phase-shifter arm
+     * @param m_length_ref_cm length of the reference arm
+     * @param m_attenuation_dB_cm loss per cm of wgs
+     * @param m_neff neff of wgs
+     * @param m_ng ng of wgs
+     * @param m_dc_loss_dB insertion loss of the y-junctions
+     * @param m_ps_loss_dB insertion loss of the phase shifter
+     * */
+    MZIActiveBase(sc_module_name name,
+                double ps_sens_rad_v = 1,
+                double length_cm = 0, double length_ref_cm = 0,
+                double attenuation_dB_cm = 0,
+                double neff = 2.2, double ng = 2.6, double dc_loss_dB = 0,
+                double ps_loss_dB = 0)
+        : spx_module(name)
+        , m_ps_sens_rad_v(ps_sens_rad_v)
+        , m_length_cm(length_cm)
+        , m_length_ref_cm(length_ref_cm)
+        , m_attenuation_dB_cm(attenuation_dB_cm)
+        , m_neff(neff)
+        , m_ng(ng)
+        , m_dc_loss_dB(dc_loss_dB)
+        , m_ps_loss_dB(ps_loss_dB)
+    {
+    }
+};
+
+class MZIActiveUni : public MZIActiveBase {
+public:
+    // Ports
+    /** The optical input ports. */
+    spx::oa_port_in_type p_in1, p_in2;
+    /** The optical output ports. */
+    spx::oa_port_out_type p_out1, p_out2;
+    /** The electrical input ports */
+    spx::ea_port_in_type p_vin;
+
+    // Wires
+    shared_ptr<spx::oa_signal_type> m_dc1_o1, m_dc1_o2, m_dc2_i1, m_dc2_i2;
+    shared_ptr<spx::oa_signal_type> m_ps_in, m_ps_out;
+
+    virtual void init();
+    virtual void connect_submodules();
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * @param m_ps_sens_rad_v sensitivity of phase shifter
+     * @param m_length_cm length of the phase-shifter arm
+     * @param m_length_ref_cm length of the reference arm
+     * @param m_attenuation_dB_cm loss per cm of wgs
+     * @param m_neff neff of wgs
+     * @param m_ng ng of wgs
+     * @param m_dc_loss_dB insertion loss of the y-junctions
+     * @param m_ps_loss_dB insertion loss of the phase shifter
+     * */
+    MZIActiveUni(sc_module_name name,
+                 double ps_sens_rad_v = 1,
+                 double length_cm = 0,
+                 double length_ref_cm = 0,
+                 double attenuation_dB_cm = 0,
+                 double neff = 2.2,
+                 double ng = 2.6,
+                 double dc_loss_dB = 0,
+                 double ps_loss_dB = 0)
+        : MZIActiveBase(name,
+                        ps_sens_rad_v,
+                        length_cm,
+                        length_ref_cm,
+                        attenuation_dB_cm,
+                        neff,
+                        ng,
+                        dc_loss_dB,
+                        ps_loss_dB)
+    {
+
+    }
+};
+
+typedef MZIActiveUni MZIActive;
+
+class MZIActiveBi : public MZIActiveBase {
+public:
+    // Ports
+    /** The optical input ports. */
+    spx::oa_port_in_type p0_in;
+    spx::oa_port_in_type p1_in;
+    spx::oa_port_in_type p2_in;
+    spx::oa_port_in_type p3_in;
+
+    /** The optical output ports. */
+    spx::oa_port_out_type p0_out;
+    spx::oa_port_out_type p1_out;
+    spx::oa_port_out_type p2_out;
+    spx::oa_port_out_type p3_out;
+
+    /** The electrical input ports */
+    spx::ea_port_in_type p_vin;
+
+    // Wires
+    shared_ptr<spx::oa_signal_type> m_dc1_p2_out, m_dc1_p3_out, m_dc2_p0_in, m_dc2_p1_in;
+    shared_ptr<spx::oa_signal_type> m_dc1_p2_in, m_dc1_p3_in, m_dc2_p0_out, m_dc2_p1_out;
+    shared_ptr<spx::oa_signal_type> m_ps_p0_in, m_ps_p1_in, m_ps_p0_out, m_ps_p1_out;
+
+    virtual void init();
+    virtual void connect_submodules();
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * @param m_ps_sens_rad_v sensitivity of phase shifter
+     * @param m_length_cm length of the phase-shifter arm
+     * @param m_length_ref_cm length of the reference arm
+     * @param m_attenuation_dB_cm loss per cm of wgs
+     * @param m_neff neff of wgs
+     * @param m_ng ng of wgs
+     * @param m_dc_loss_dB insertion loss of the y-junctions
+     * @param m_ps_loss_dB insertion loss of the phase shifter
+     * */
+    MZIActiveBi(sc_module_name name,
+                 double ps_sens_rad_v = 1,
+                 double length_cm = 0,
+                 double length_ref_cm = 0,
+                 double attenuation_dB_cm = 0,
+                 double neff = 2.2,
+                 double ng = 2.6,
+                 double dc_loss_dB = 0,
+                 double ps_loss_dB = 0)
+        : MZIActiveBase(name,
+                        ps_sens_rad_v,
+                        length_cm,
+                        length_ref_cm,
+                        attenuation_dB_cm,
+                        neff,
+                        ng,
+                        dc_loss_dB,
+                        ps_loss_dB)
+    {
+
+    }
+};
diff --git a/src/devices/octane_cell.cpp b/src/devices/octane_cell.cpp
new file mode 100644
index 0000000..1b5c59c
--- /dev/null
+++ b/src/devices/octane_cell.cpp
@@ -0,0 +1,91 @@
+#include <octane_cell.h>
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX)).c_str())
+
+void OctaneCell::init()
+{
+    if(m_isCompact)
+        init_compact();
+    else
+        init_full();
+}
+
+void OctaneCell::init_full()
+{
+    // Physical parameters of the components
+    double lambda = 1550e-9; // the wavelength used by the circuit
+    double neff = 2.2;
+    double ng = 2.2;
+    double loss_per_cm = 0; // in waveguide
+    double loss_merger = 0;
+    double length_for_2pi = 100*lambda/(neff);
+
+    // Constructing the instances
+    m_wg1 = make_unique<Waveguide>(__modname("WG_", 0), length_for_2pi, loss_per_cm, neff, ng);
+    m_wg2 = make_unique<Waveguide>(__modname("WG_", 1), length_for_2pi, loss_per_cm, neff, ng);
+    m_wg3 = make_unique<Waveguide>(__modname("WG_", 2), length_for_2pi, loss_per_cm, neff, ng);
+    m_wg4 = make_unique<Waveguide>(__modname("WG_", 3), length_for_2pi, loss_per_cm, neff, ng);
+
+    m_merger = make_unique<Merger>(__modname("Y_", 0), loss_merger);
+
+    m_pcm = make_unique<PCMElement>(__modname("PCM_", 0), m_meltEnergy, m_nStates, 0);
+
+    m_pd = make_unique<Detector>(__modname("PD_", 0));
+
+    // Connecting
+    m_wg1->p_in(p_in_r);
+    m_wg1->p_out(m_merg_in1);
+
+    m_wg2->p_in(p_in_c);
+    m_wg2->p_out(m_merg_in2);
+
+    m_merger->p_in1(m_merg_in1);
+    m_merger->p_in2(m_merg_in2);
+    m_merger->p_out(m_merg_out);
+
+    m_wg3->p_in(m_merg_out);
+    m_wg3->p_out(m_pcm_in);
+
+    m_pcm->p_in(m_pcm_in);
+    m_pcm->p_out(m_pcm_out);
+
+    // m_wg4->p_in(m_pcm_in);
+    m_wg4->p_in(m_pcm_out);
+    m_wg4->p_out(m_pd_in);
+
+    m_pd->p_in(m_pd_in);
+    m_pd->p_readout(p_readout);
+}
+
+void OctaneCell::init_compact()
+{
+    // Physical parameters of the components
+    double lambda = 1550e-9; // the wavelength used by the circuit
+    double neff = 2.2;
+    double ng = 2.2;
+    double loss_per_cm = 0; // in waveguide
+    double loss_merger = 0;
+    double length_for_2pi = 100*lambda/(neff);
+
+    (void)ng;
+    (void)loss_per_cm;
+    (void)length_for_2pi;
+
+    m_merger = make_unique<Merger>(__modname("Y_", 0), loss_merger);
+
+    m_pcm = make_unique<PCMElement>(__modname("PCM_", 0), m_meltEnergy, m_nStates, 0);
+
+    m_pd = make_unique<Detector>(__modname("PD_", 0));
+
+    // Connecting
+    m_merger->p_in1(p_in_r);
+    m_merger->p_in2(p_in_c);
+    m_merger->p_out(m_merg_out);
+
+    m_pcm->p_in(m_merg_out);
+    m_pcm->p_out(m_pcm_out);
+
+    m_pd->p_in(m_pcm_out);
+    m_pd->p_readout(p_readout);
+}
\ No newline at end of file
diff --git a/src/devices/octane_cell.h b/src/devices/octane_cell.h
new file mode 100644
index 0000000..aadcd20
--- /dev/null
+++ b/src/devices/octane_cell.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <systemc.h>
+#include <waveguide.h>
+#include <pcm_device.h>
+#include <merger.h>
+#include <detector.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+/** The minimal octane cell composed of merger, waveguides, PCM and a detector. */
+/** For now, all photonic parameters will be internal and constant. The only */
+/** one that can be changed is the PCM levels.*/
+
+//TODO: pass element's characteristics as argument, for instance, pass an example of waveguide,
+// or an example of DC, PCM such that it copies. Requires: constructors in each element to build
+// by copying.
+
+class OctaneCell : public sc_module {
+public:
+    // Ports
+    /** The optical input ports. */
+    sc_port<sc_signal_in_if<OpticalSignal>> p_in_r, p_in_c;
+    /** The electrical output port. */
+    sc_out<double> p_readout;
+
+    // Member variables
+    double m_meltEnergy;
+    bool m_isCompact;
+    int m_nStates;
+
+    // Wires
+    sc_signal<OpticalSignal> m_merg_in1, m_merg_in2, m_merg_out, m_pcm_in, m_pcm_out, m_pd_in;
+
+    // Member submodules
+    unique_ptr<Waveguide> m_wg1, m_wg2, m_wg3, m_wg4;
+    unique_ptr<Merger> m_merger;
+    unique_ptr<PCMElement> m_pcm;
+    unique_ptr<Detector> m_pd;
+
+    // This function should be called right after
+    // Instantiation (either declaration or make_shared or new)
+    void init();
+    void init_compact();
+    void init_full();
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * @param meltEnergy energy needed to amorphize by one step
+     * @param nStates number of internal states supported by the PCM
+     * */
+    OctaneCell(sc_module_name name, double meltEnergy = 10e-12, int nStates = 63, bool isCompact = false)
+        : sc_module(name)
+        , m_meltEnergy(meltEnergy)
+        , m_isCompact(isCompact)
+        , m_nStates(nStates)
+    {
+    }
+
+};
diff --git a/src/devices/octane_matrix.cpp b/src/devices/octane_matrix.cpp
new file mode 100644
index 0000000..d8126f3
--- /dev/null
+++ b/src/devices/octane_matrix.cpp
@@ -0,0 +1,365 @@
+#include <octane_matrix.h>
+
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX)).c_str())
+
+#define __outname(SUFFIX, IDX, IDY) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX) + "_" + to_string(IDY)).c_str())
+
+using std::size_t;
+using std::pow;
+
+void OctaneMatrix::init_ports()
+{
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing input ports
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    
+    p_in_r.clear();
+    p_in_c.clear();
+
+    // cout << "Initializing input ports of " << name() << endl;
+
+    for(size_t i = 0; i < m_rows; i++)
+        p_in_r.push_back(make_unique<port_in_type>(__modname("IN_R_", i)));
+    
+    for(size_t i = 0; i < m_columns; i++)
+        p_in_c.push_back(make_unique<port_in_type>(__modname("IN_C_", i)));
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing output port matrix
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    
+    p_readout.clear(); // clearing before start
+
+    // cout << "Initializing output ports of " << name() << endl;
+
+    vector<unique_ptr<sc_out<double>>> temp_vector;
+
+    for(size_t i = 0; i < m_rows; i++)
+    {
+        temp_vector.clear(); // moving to new row
+        for(size_t j = 0; j < m_columns; j++)
+        {
+            temp_vector.push_back(make_unique<sc_out<double>>(__outname("PD_", i, j)));
+        } 
+        p_readout.push_back(std::move(temp_vector)); // adding new row
+    }
+
+    // cout << "Successful port initialization of  " << name() << endl;
+
+}
+
+void OctaneMatrix::init()
+{
+
+    double crossing_loss = 0;
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing circuit elements (waveguides, DCs, octanecell)
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    m_optical_connect_horizontal.clear();
+    m_optical_connect_vertical.clear();
+    m_segment.clear();
+    m_cross.clear();
+
+    // cout << "Initializing submodules of " << name() << endl;
+
+    // Optical wires
+    unsigned long num_of_nets_horizontal = 3*m_rows*(m_columns-1);
+    unsigned long num_of_nets_vertical = (m_rows-1)*m_columns;
+
+    for(unsigned long i = 0; i < num_of_nets_horizontal; i++)
+        m_optical_connect_horizontal.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("wh_", i)));
+    for(unsigned long i = 0; i < num_of_nets_vertical; i++)
+        m_optical_connect_vertical.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("wv_", i)));
+
+    // Crossings
+    for(unsigned long i = 0; i < m_rows; i++)
+    {   // Last column doesn't have crossings, thus the -1 in the loop
+        for(unsigned long j = 0; j < (m_columns - 1); j++)
+        {
+            m_cross.push_back(make_unique<Crossing>(__outname("X_", i, j), crossing_loss));
+        } 
+    }
+
+    // Octane segments
+    bool term_row = false;
+    bool term_col = false;
+    double coupling_through_row = 0;
+    double coupling_through_col = 0;
+
+    for(unsigned long i = 0; i < m_rows; i++)
+    {
+        for(unsigned long j = 0; j < m_columns; j++)
+        {
+            if(isLastRow(i) && isLastCol(j))
+            {
+                // Last element
+                term_col = true;
+                term_row = true;
+                coupling_through_row = 0;
+                coupling_through_col = 0;
+            }
+            else if(isLastRow(i))
+            {
+                // Term row
+                term_col = false;
+                term_row = true;
+                coupling_through_row = (1.0 - 1.0/(m_columns - j));
+                coupling_through_col = 0;
+            }
+            else if(isLastCol(j))
+            {
+                // Term col
+                term_col = true;
+                term_row = false;
+                coupling_through_row = 0;
+                coupling_through_col = (1.0 - 1.0/(m_rows - i));
+            }
+            else
+            {
+                // Inner element
+                term_col = false;
+                term_row = false;
+                coupling_through_row = (1.0 - 1.0/(m_columns - j));
+                coupling_through_col = (1.0 - 1.0/(m_rows - i));
+            }
+            auto temp_segment = make_unique<OctaneSegment>
+                    (
+                    __outname("SEG_", i, j),
+                    term_row, term_col,
+                    coupling_through_row, coupling_through_col,
+                    m_meltEnergy, m_nStates, m_isCompact
+                    );
+            temp_segment->init(); // mandatory initialization
+            m_segment.push_back(std::move(temp_segment));
+        }   
+    }
+
+    // cout << "Successful module initialization of " << name() << endl;
+
+    // Modules are constructed in their vectors, time to connect !
+    connect_submodules();
+
+}
+
+void OctaneMatrix::connect_submodules()
+{
+
+    // cout << "Connecting submodules of " << name() << endl;
+
+    // If there is only one element in the matrix
+    // the pins are connected directly
+    if((m_rows == 1) && (m_columns == 1))
+    {
+        // cout << name() << "contains only one element. " << endl;
+
+        m_segment.at(0)->p_in[0]->bind(*p_in_r.at(0));
+        m_segment.at(0)->p_in[1]->bind(*p_in_c.at(0)); 
+        m_segment.at(0)->p_readout->bind(*p_readout[0][0]);
+
+        // cout << "Successful connection of " << name() << endl;
+        return;
+    }
+
+    // Column vector
+    if(m_columns == 1)
+    {
+        // cout << name() << "contains only one column. " << endl;
+
+        for(unsigned long i = 0; i < m_rows; i++)
+        {
+            // in segment, in row is p_in[0]
+            m_segment.at(i)->p_in[0]->bind(*p_in_r.at(i)); 
+
+            if(isFirstRow(i)) // should connect to the port
+                m_segment.at(i)->p_in[1]->bind(*p_in_c.at(0)); 
+            else // connects to intermediate net which is output of the previous block
+                m_segment.at(i)->p_in[1]->bind(*m_optical_connect_vertical.at(i-1)); 
+
+            if(!isLastRow(i)) // there's only one output in vector segment
+                m_segment.at(i)->p_out[0]->bind(*m_optical_connect_vertical.at(i)); 
+            
+            m_segment.at(i)->p_readout->bind(*p_readout[i][0]);
+
+        }
+        // cout << "Successful connection of " << name() << endl;
+        return;
+    }
+
+    // Row vector
+    if(m_rows == 1)
+    {
+        // cout << name() << "contains only one row. " << endl;
+
+        for(unsigned long j = 0; j < m_columns; j++)
+        {
+            if(isFirstCol(j))
+            {
+                // in segment, in row is p_in[0]
+                m_segment.at(j)->p_in[0]->bind(*p_in_r.at(0)); 
+                m_segment.at(j)->p_in[1]->bind(*m_optical_connect_horizontal.at(3*j+1)); 
+                m_segment.at(j)->p_out[0]->bind(*m_optical_connect_horizontal.at(3*j));
+
+                // in1, out1 are horizontal connections
+                m_cross.at(j)->p_in1.bind(*m_optical_connect_horizontal.at(3*j));
+                m_cross.at(j)->p_in2.bind(*p_in_c.at(j));
+                m_cross.at(j)->p_out1.bind(*m_optical_connect_horizontal.at(3*j+2));
+                m_cross.at(j)->p_out2.bind(*m_optical_connect_horizontal.at(3*j+1));
+            }
+            else if(!isLastCol(j))
+            { // middle element
+                m_segment.at(j)->p_in[0]->bind(*m_optical_connect_horizontal.at(3*j-1)); 
+                m_segment.at(j)->p_in[1]->bind(*m_optical_connect_horizontal.at(3*j+1)); 
+                m_segment.at(j)->p_out[0]->bind(*m_optical_connect_horizontal.at(3*j));
+
+                // in1, out1 are horizontal connections
+                m_cross.at(j)->p_in1.bind(*m_optical_connect_horizontal.at(3*j));
+                m_cross.at(j)->p_in2.bind(*p_in_c.at(j));
+                m_cross.at(j)->p_out1.bind(*m_optical_connect_horizontal.at(3*j+2));
+                m_cross.at(j)->p_out2.bind(*m_optical_connect_horizontal.at(3*j+1));
+            }
+            else
+            { // last column here
+                m_segment.at(j)->p_in[0]->bind(*m_optical_connect_horizontal.at(3*j-1)); 
+                m_segment.at(j)->p_in[1]->bind(*p_in_c.at(j));            
+            }
+            m_segment.at(j)->p_readout->bind(*p_readout[0][j]);
+        }
+        // cout << "Successful connection of " << name() << endl;
+        return;
+    }
+
+    // Getting here means it's an actual matrix with more than one element
+    unsigned long cur_pos;
+    unsigned long cur_cross;
+    unsigned long seg_out_h;
+    unsigned long seg_out_v;
+    for(unsigned long i = 0; i < m_rows; i++)
+    {
+        for(unsigned long j = 0; j < m_columns; j++)
+        {
+            cur_pos = m_columns*i + j;
+            cur_cross = (m_columns-1)*i + j;
+            seg_out_h = 3*(m_columns-1)*i+3*j;
+            seg_out_v = m_columns*i+j;
+            // cout << "cur_pos: " << cur_pos << endl;
+            // cout << "cur_cross: " << cur_cross << endl;
+            // cout << "out_h: " << seg_out_h << endl;
+            // cout << "out_v: " << seg_out_v << endl;
+
+            if(isFirstRow(i) && isFirstCol(j))
+            {
+                // cout << "first element" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*p_in_r.at(i));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_horizontal.at(seg_out_h+1)); 
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_segment.at(cur_pos)->p_out[1]->bind(*m_optical_connect_vertical.at(seg_out_v));
+
+                m_cross.at(cur_cross)->p_in1.bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_cross.at(cur_cross)->p_in2.bind(*p_in_c.at(j));
+                m_cross.at(cur_cross)->p_out1.bind(*m_optical_connect_horizontal.at(seg_out_h+2));
+                m_cross.at(cur_cross)->p_out2.bind(*m_optical_connect_horizontal.at(seg_out_h+1));
+            }
+            else if(isFirstRow(i) && !isLastCol(j))
+            {
+                // cout << "first row not last col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*m_optical_connect_horizontal.at(seg_out_h-1));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_horizontal.at(seg_out_h+1)); 
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_segment.at(cur_pos)->p_out[1]->bind(*m_optical_connect_vertical.at(seg_out_v));
+
+                m_cross.at(cur_cross)->p_in1.bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_cross.at(cur_cross)->p_in2.bind(*p_in_c.at(j));
+                m_cross.at(cur_cross)->p_out1.bind(*m_optical_connect_horizontal.at(seg_out_h+2));
+                m_cross.at(cur_cross)->p_out2.bind(*m_optical_connect_horizontal.at(seg_out_h+1));                
+            }
+            else if(isFirstRow(i) && isLastCol(j))
+            {
+                // cout << "first row last col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*m_optical_connect_horizontal.at(seg_out_h-1));
+                m_segment.at(cur_pos)->p_in[1]->bind(*p_in_c.at(j)); 
+                // no row output
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_vertical.at(seg_out_v));
+            }
+            else if(!isFirstRow(i) && !isLastRow(i) && isFirstCol(j))
+            {
+                // cout << "middle row first col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*p_in_r.at(i));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_horizontal.at(seg_out_h+1)); 
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_segment.at(cur_pos)->p_out[1]->bind(*m_optical_connect_vertical.at(seg_out_v));
+
+                m_cross.at(cur_cross)->p_in1.bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_cross.at(cur_cross)->p_in2.bind(*m_optical_connect_vertical.at(seg_out_v-m_columns));
+                m_cross.at(cur_cross)->p_out1.bind(*m_optical_connect_horizontal.at(seg_out_h+2));
+                m_cross.at(cur_cross)->p_out2.bind(*m_optical_connect_horizontal.at(seg_out_h+1));
+            }
+            else if(!isFirstRow(i) && !isLastRow(i) && !isLastCol(j))
+            {
+                // cout << "middle row middle col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*m_optical_connect_horizontal.at(seg_out_h-1));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_horizontal.at(seg_out_h+1)); 
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_segment.at(cur_pos)->p_out[1]->bind(*m_optical_connect_vertical.at(seg_out_v));
+
+                m_cross.at(cur_cross)->p_in1.bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_cross.at(cur_cross)->p_in2.bind(*m_optical_connect_vertical.at(seg_out_v-m_columns));
+                m_cross.at(cur_cross)->p_out1.bind(*m_optical_connect_horizontal.at(seg_out_h+2));
+                m_cross.at(cur_cross)->p_out2.bind(*m_optical_connect_horizontal.at(seg_out_h+1));
+            }
+            else if(!isFirstRow(i) && !isLastRow(i) && isLastCol(j))
+            {
+                // cout << "middle row last col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*m_optical_connect_horizontal.at(seg_out_h-1));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_vertical.at(seg_out_v-m_columns)); 
+                // no row output
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_vertical.at(seg_out_v));
+            }
+            else if(isLastRow(i) && isFirstCol(j))
+            {
+                // cout << "last row first col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*p_in_r.at(i));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_horizontal.at(seg_out_h+1)); 
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_horizontal.at(seg_out_h));
+
+                m_cross.at(cur_cross)->p_in1.bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_cross.at(cur_cross)->p_in2.bind(*m_optical_connect_vertical.at(seg_out_v-m_columns));
+                m_cross.at(cur_cross)->p_out1.bind(*m_optical_connect_horizontal.at(seg_out_h+2));
+                m_cross.at(cur_cross)->p_out2.bind(*m_optical_connect_horizontal.at(seg_out_h+1));
+            }
+            else if(isLastRow(i) && !isLastCol(j))
+            {
+                // cout << "last row middle col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*m_optical_connect_horizontal.at(seg_out_h-1));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_horizontal.at(seg_out_h+1)); 
+                m_segment.at(cur_pos)->p_out[0]->bind(*m_optical_connect_horizontal.at(seg_out_h));
+
+                m_cross.at(cur_cross)->p_in1.bind(*m_optical_connect_horizontal.at(seg_out_h));
+                m_cross.at(cur_cross)->p_in2.bind(*m_optical_connect_vertical.at(seg_out_v-m_columns));
+                m_cross.at(cur_cross)->p_out1.bind(*m_optical_connect_horizontal.at(seg_out_h+2));
+                m_cross.at(cur_cross)->p_out2.bind(*m_optical_connect_horizontal.at(seg_out_h+1));
+            }
+            else if(isLastRow(i) && isLastCol(j))
+            {
+                // cout << "last row last col" << endl;
+                m_segment.at(cur_pos)->p_in[0]->bind(*m_optical_connect_horizontal.at(seg_out_h-1));
+                m_segment.at(cur_pos)->p_in[1]->bind(*m_optical_connect_vertical.at(seg_out_v-m_columns)); 
+            }
+            else
+                cout<< endl << endl << "This condition should not appear" << endl << endl;
+            
+            m_segment.at(cur_pos)->p_readout->bind(*p_readout[i][j]);
+
+        }   
+    }
+}
\ No newline at end of file
diff --git a/src/devices/octane_matrix.h b/src/devices/octane_matrix.h
new file mode 100644
index 0000000..afcf06a
--- /dev/null
+++ b/src/devices/octane_matrix.h
@@ -0,0 +1,99 @@
+#pragma once
+
+#include <systemc.h>
+#include <octane_segment.h>
+#include <crossing.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+// TODO: remove these (are in spx_module.h)
+typedef sc_signal_in_if<OpticalSignal > if_in_type;
+typedef sc_signal_out_if<OpticalSignal > if_out_type;
+typedef sc_port<if_in_type> port_in_type;
+typedef sc_port<if_out_type> port_out_type;
+
+
+/** Building block for the OCTANE circuit
+ * The current implementation includes all
+ * intermediate components allowing modelling of imperfections,
+ * but at the cost of increased module count.
+ *
+ * A simpler way would be to disregard all intermediate waveguides
+ * and model their effects on `octane_cell`
+ *
+ * Maybe I could add an argument to init(bool isCompact), defining
+ * if the model will be compact or not.
+*/
+
+//TODO: pass element's characteristics as argument, for instance, pass an example of waveguide,
+// or an example of DC, PCM such that it copies. Requires: constructors in each element to build
+// by copying.
+
+class OctaneMatrix : public sc_module {
+public:
+    // Ports
+    /** The optical input ports. */
+    vector<unique_ptr<port_in_type>> p_in_r;
+    vector<unique_ptr<port_in_type>> p_in_c;
+
+    /** The optical output ports. */
+    vector<unique_ptr<port_out_type>> p_out;
+
+    /** The electric output ports in matrix format*/
+    // TODO: verify if a matrix library should be used
+    vector<vector<unique_ptr<sc_out<double>>>> p_readout;
+
+    // Define the size of the matrix
+    std::size_t m_rows;
+    std::size_t m_columns;
+
+    bool m_isCompact;
+
+    // For internal octane_cell
+    double m_meltEnergy;
+    int m_nStates;
+
+    // Wires
+    vector<unique_ptr<sc_signal<OpticalSignal>>> m_optical_connect_horizontal;
+    vector<unique_ptr<sc_signal<OpticalSignal>>> m_optical_connect_vertical;
+
+    // Member submodules
+    vector<unique_ptr<Crossing>> m_cross;
+    vector<unique_ptr<OctaneSegment>> m_segment;
+
+    //Init() must be called after declaration
+    void init();
+    void init_ports();
+    void connect_submodules();
+
+    // auxiliar functions for readability
+    // they were written with 0 to N-1 indexing in mind!
+    inline bool isFirstRow(unsigned long i){return (i==0);}
+    bool isFirstCol(unsigned long j){return (j==0);}
+    bool isLastRow(unsigned long i){return (i==m_rows-1);}
+    bool isLastCol(unsigned long j){return (j==m_columns-1);}
+
+    /** Constructor for Octane Matrix
+     *
+     * @param name name of the module
+     * @param meltEnergy energy needed to amorphize by one step
+     * @param nStates number of internal states supported by the PCM
+     * */
+    OctaneMatrix(sc_module_name name, std::size_t rows, std::size_t columns,
+                    double meltEnergy = 10e-12, int nStates = 63, bool isCompact = false)
+        : sc_module(name)
+        , m_rows(rows)
+        , m_columns(columns)
+        , m_isCompact(isCompact)
+        , m_meltEnergy(meltEnergy)
+        , m_nStates(nStates)
+    {
+
+        assert(rows > 0);
+        assert(columns > 0);
+
+        init_ports(); // At least the ports should always be
+        // in the constructor
+    }
+
+};
diff --git a/src/devices/octane_segment.cpp b/src/devices/octane_segment.cpp
new file mode 100644
index 0000000..32dcd84
--- /dev/null
+++ b/src/devices/octane_segment.cpp
@@ -0,0 +1,396 @@
+#include <octane_segment.h>
+
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX)).c_str())
+
+using std::size_t;
+using std::pow;
+
+void OctaneSegment::init_ports()
+{
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing input ports
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    p_in.clear();
+
+    // cout << "Initializing input ports of " << name() << endl;
+    // 0 is row, 1 is column  
+    p_in.push_back(make_unique<port_in_type>("IN_R"));
+    p_in.push_back(make_unique<port_in_type>("IN_C"));
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing output ports based on termination
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    
+    p_out.clear();
+    
+    // cout << "Initializing output ports of " << name() << endl;
+    // If there is only one output, the vector has only one element
+    if (m_term_row && m_term_col)
+    {
+        ; // no optical output
+    }
+    else if(m_term_row)
+    {
+        // Last row, so only has row outputs
+        p_out.push_back(make_unique<port_out_type>("OUT_R"));
+    }
+    else if(m_term_col)
+    {
+        // Last column, so only has only column outputs
+        p_out.push_back(make_unique<port_out_type>("OUT_C"));
+    }
+    else
+    {
+        // Internal elements have both outputs
+        p_out.push_back(make_unique<port_out_type>("OUT_R"));
+        p_out.push_back(make_unique<port_out_type>("OUT_C"));
+    }
+    p_readout = make_unique<sc_out<double>>("OUT_PD");
+
+    // cout << "Successful port initialization of  " << name() << endl;
+
+}
+
+void OctaneSegment::init()
+{
+    if(m_isCompact)
+        init_compact();
+    else
+        init_full();
+
+}
+
+void OctaneSegment::init_full()
+{
+    // Physical parameters of the components
+    double lambda = 1550e-9; // the wavelength used by the circuit
+    double neff = 2.2;
+    double ng = 2.2;
+    double loss_per_cm = 0; // in waveguide
+    double dc_loss = 0;
+    double length_for_2pi = 100*lambda/(neff);
+    double length_for_pi_2 = length_for_2pi/4;
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing circuit elements (waveguides, DCs, octanecell)
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    m_wg.clear();
+    m_dc.clear();
+    m_optical_connect.clear();
+
+    // cout << "Initializing submodules of " << name() << endl;
+    
+    m_oct = make_unique<OctaneCell>(__modname("OCT_", 0), m_meltEnergy, m_nStates, m_isCompact);
+    m_oct->init();
+
+    if (m_term_row && m_term_col)
+    {   
+        // Last element
+        for(size_t i = 0; i < 2; i++)
+        {
+            m_wg.push_back(make_unique<Waveguide>(__modname("WG_", i), length_for_2pi, loss_per_cm, neff, ng));
+            m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", i)));
+        }
+    }
+    else if(m_term_row)
+    {
+        // Last row
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_R_", 0), m_coupling_through_row, dc_loss));
+        for(size_t i = 0; i < 4; i++)
+        {
+            m_wg.push_back(make_unique<Waveguide>(__modname("WG_", i), length_for_2pi, loss_per_cm, neff, ng));
+            m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", i)));
+        }
+        // Adjusting the last waveguide to give pi/2 shift
+        // compensating for the lack of DC
+        m_wg.at(3)->m_length_cm = length_for_2pi + length_for_pi_2;
+        // We have one extra wire with respect to waveguides
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 4)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 0))); // terminator
+    }
+    else if(m_term_col)
+    {
+        // Last column
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_C_", 0), m_coupling_through_col, dc_loss));
+        for(size_t i = 0; i < 4; i++)
+        {
+            m_wg.push_back(make_unique<Waveguide>(__modname("WG_", i), length_for_2pi, loss_per_cm, neff, ng));
+            m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", i)));
+        }
+        // Adjusting the last waveguide to give pi/2 shift
+        // compensating for the lack of DC
+        m_wg.at(3)->m_length_cm = length_for_2pi + length_for_pi_2;
+        // We have one extra wire with respect to waveguides
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 4)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 0))); // terminator
+    }
+    else
+    {
+        // Internal element
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_R_", 0), m_coupling_through_row, dc_loss));
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_C_", 0), m_coupling_through_col, dc_loss));
+        for(size_t i = 0; i < 6; i++)
+        {
+            m_wg.push_back(make_unique<Waveguide>(__modname("WG_", i), length_for_2pi, loss_per_cm, neff, ng));
+            m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", i)));
+        }
+        // We have two extra wires with respect to waveguides
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 6)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 7)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 0))); // terminator
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 1))); // terminator
+    }
+
+    // cout << "Successful module initialization of " << name() << endl;
+
+    // Modules are constructed in their vectors, time to connect !
+    connect_submodules_full();
+
+}
+
+void OctaneSegment::connect_submodules_full()
+{
+
+    // cout << "Connecting submodules of " << name() << endl;
+
+    if (m_term_row && m_term_col)
+    {   
+        // Last element
+        m_wg.at(0)->p_in(*p_in.at(0));     
+        m_wg.at(0)->p_out(*m_optical_connect.at(0));
+
+        m_wg.at(1)->p_in(*p_in.at(1));     
+        m_wg.at(1)->p_out(*m_optical_connect.at(1));  
+
+        m_oct->p_in_r(*m_optical_connect.at(0));
+        m_oct->p_in_c(*m_optical_connect.at(1));
+        
+    }
+    else if(m_term_row)
+    {
+        // Last row
+        m_wg.at(0)->p_in(*p_in.at(0)); // input at row
+        m_wg.at(0)->p_out(*m_optical_connect.at(0));
+
+        m_dc.at(0)->p_in1(*m_optical_connect.at(0));
+        m_dc.at(0)->p_in2(*m_optical_connect.at(5)); // Terminated
+        m_dc.at(0)->p_out1(*m_optical_connect.at(1)); // Through
+        m_dc.at(0)->p_out2(*m_optical_connect.at(2)); // Cross
+
+        m_wg.at(1)->p_in(*m_optical_connect.at(1));     
+        m_wg.at(1)->p_out(*p_out.at(0)); // Out row
+
+        m_wg.at(2)->p_in(*m_optical_connect.at(2));     
+        m_wg.at(2)->p_out(*m_optical_connect.at(3));
+
+        // Side without DC (must be conmpensated with pi/2)
+        m_wg.at(3)->p_in(*p_in.at(1));
+        m_wg.at(3)->p_out(*m_optical_connect.at(4));
+
+        m_oct->p_in_r(*m_optical_connect.at(3));
+        m_oct->p_in_c(*m_optical_connect.at(4));
+    }
+    else if(m_term_col)
+    {
+        // Last column
+        m_wg.at(0)->p_in(*p_in.at(1)); // input at col
+        m_wg.at(0)->p_out(*m_optical_connect.at(0));
+
+        m_dc.at(0)->p_in1(*m_optical_connect.at(0));
+        m_dc.at(0)->p_in2(*m_optical_connect.at(5)); // Terminated
+        m_dc.at(0)->p_out1(*m_optical_connect.at(1)); // Through
+        m_dc.at(0)->p_out2(*m_optical_connect.at(2)); // Cross
+
+        m_wg.at(1)->p_in(*m_optical_connect.at(1));     
+        m_wg.at(1)->p_out(*p_out.at(0)); // Out column
+
+        m_wg.at(2)->p_in(*m_optical_connect.at(2));     
+        m_wg.at(2)->p_out(*m_optical_connect.at(3));
+
+        // Side without DC (must be conmpensated with pi/2)
+        m_wg.at(3)->p_in(*p_in.at(0));     
+        m_wg.at(3)->p_out(*m_optical_connect.at(4));
+
+        m_oct->p_in_r(*m_optical_connect.at(4));
+        m_oct->p_in_c(*m_optical_connect.at(3));
+    }
+    else
+    {
+        // Internal element
+        m_wg.at(0)->p_in(*p_in.at(0)); // input at row
+        m_wg.at(0)->p_out(*m_optical_connect.at(0));
+
+        m_dc.at(0)->p_in1(*m_optical_connect.at(0));
+        m_dc.at(0)->p_in2(*m_optical_connect.at(8)); // Terminated
+        m_dc.at(0)->p_out1(*m_optical_connect.at(1)); // Through
+        m_dc.at(0)->p_out2(*m_optical_connect.at(2)); // Cross
+
+        m_wg.at(1)->p_in(*m_optical_connect.at(1));     
+        m_wg.at(1)->p_out(*p_out.at(0)); // Out row
+
+        m_wg.at(2)->p_in(*m_optical_connect.at(2));     
+        m_wg.at(2)->p_out(*m_optical_connect.at(3));
+
+        m_wg.at(3)->p_in(*p_in.at(1));     
+        m_wg.at(3)->p_out(*m_optical_connect.at(4));
+
+        m_dc.at(1)->p_in1(*m_optical_connect.at(4));
+        m_dc.at(1)->p_in2(*m_optical_connect.at(9)); // Terminated
+        m_dc.at(1)->p_out1(*m_optical_connect.at(5)); // Through
+        m_dc.at(1)->p_out2(*m_optical_connect.at(6)); // Cross
+
+        m_wg.at(4)->p_in(*m_optical_connect.at(5));     
+        m_wg.at(4)->p_out(*p_out.at(1)); // Out col
+
+        m_wg.at(5)->p_in(*m_optical_connect.at(6));     
+        m_wg.at(5)->p_out(*m_optical_connect.at(7));    
+
+        m_oct->p_in_r(*m_optical_connect.at(3));
+        m_oct->p_in_c(*m_optical_connect.at(7));
+    }
+    m_oct->p_readout(*p_readout);
+
+    // cout << "Successful connection of " << name() << endl;
+
+}
+
+void OctaneSegment::init_compact()
+{
+    // Physical parameters of the components
+    double lambda = 1550e-9; // the wavelength used by the circuit
+    double neff = 2.2;
+    double ng = 2.2;
+    double loss_per_cm = 0; // in waveguide
+    double dc_loss = 0;
+    double length_for_2pi = 100*lambda/(neff);
+    double length_for_pi_2 = length_for_2pi/4;
+
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+    // Initializing circuit elements (waveguides, DCs, octanecell)
+    // --------------------------------------------------------------------------//
+    // --------------------------------------------------------------------------//
+
+    m_wg.clear();
+    m_dc.clear();
+    m_optical_connect.clear();
+
+    // cout << "Initializing submodules of " << name() << endl;
+    
+    m_oct = make_unique<OctaneCell>(__modname("OCT_", 0), m_meltEnergy, m_nStates, m_isCompact);
+    m_oct->init();
+
+    if (m_term_row && m_term_col)
+    {   
+        ;
+    }
+    else if(m_term_row)
+    {
+        // Last row
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_R_", 0), m_coupling_through_row, dc_loss));
+        m_wg.push_back(make_unique<Waveguide>(__modname("WG_", 0), length_for_pi_2, loss_per_cm, neff, ng));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 0)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 1)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 0))); // terminator
+    }
+    else if(m_term_col)
+    {
+        // Last column
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_C_", 0), m_coupling_through_col, dc_loss));
+        m_wg.push_back(make_unique<Waveguide>(__modname("WG_", 0), length_for_pi_2, loss_per_cm, neff, ng));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 0)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 1)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 0))); // terminator
+    }
+    else
+    {
+        // Internal element
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_R_", 0), m_coupling_through_row, dc_loss));
+        m_dc.push_back(make_unique<DirectionalCoupler>(__modname("DC_C_", 0), m_coupling_through_col, dc_loss));
+        // We have two extra wires with respect to waveguides
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 0)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("W_", 1)));
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 0))); // terminator
+        m_optical_connect.push_back(make_unique<sc_signal<OpticalSignal>>(__modname("TERM_", 1))); // terminator
+    }
+
+    // cout << "Successful module initialization of " << name() << endl;
+
+    // Modules are constructed in their vectors, time to connect !
+    connect_submodules_compact();
+
+}
+
+void OctaneSegment::connect_submodules_compact()
+{
+
+    // cout << "Connecting submodules of " << name() << endl;
+
+    if (m_term_row && m_term_col)
+    {   
+        // Last element
+        m_oct->p_in_r(*p_in.at(0));
+        m_oct->p_in_c(*p_in.at(1));
+        
+    }
+    else if(m_term_row)
+    {
+        // Last row
+        m_dc.at(0)->p_in1(*p_in.at(0));
+        m_dc.at(0)->p_in2(*m_optical_connect.at(2)); // Terminated
+        m_dc.at(0)->p_out1(*p_out.at(0)); // Through
+        m_dc.at(0)->p_out2(*m_optical_connect.at(0)); // Cross
+
+        // Side without DC (must be conmpensated with pi/2)
+        m_wg.at(0)->p_in(*p_in.at(1));
+        m_wg.at(0)->p_out(*m_optical_connect.at(1));
+
+        m_oct->p_in_r(*m_optical_connect.at(0));
+        m_oct->p_in_c(*m_optical_connect.at(1));
+    }
+    else if(m_term_col)
+    {
+        // Last column
+        m_dc.at(0)->p_in1(*p_in.at(1));
+        m_dc.at(0)->p_in2(*m_optical_connect.at(2)); // Terminated
+        m_dc.at(0)->p_out1(*p_out.at(0)); // Through
+        m_dc.at(0)->p_out2(*m_optical_connect.at(0)); // Cross
+
+        // Side without DC (must be conmpensated with pi/2)
+        m_wg.at(0)->p_in(*p_in.at(0));     
+        m_wg.at(0)->p_out(*m_optical_connect.at(1));
+
+        m_oct->p_in_r(*m_optical_connect.at(1));
+        m_oct->p_in_c(*m_optical_connect.at(0));
+    }
+    else
+    {
+        // Internal element
+        m_dc.at(0)->p_in1(*p_in.at(0));
+        m_dc.at(0)->p_in2(*m_optical_connect.at(2)); // Terminated
+        m_dc.at(0)->p_out1(*p_out.at(0)); // Through
+        m_dc.at(0)->p_out2(*m_optical_connect.at(0)); // Cross
+
+        m_dc.at(1)->p_in1(*p_in.at(1));
+        m_dc.at(1)->p_in2(*m_optical_connect.at(3)); // Terminated
+        m_dc.at(1)->p_out1(*p_out.at(1)); // Through
+        m_dc.at(1)->p_out2(*m_optical_connect.at(1)); // Cross
+
+        m_oct->p_in_r(*m_optical_connect.at(0));
+        m_oct->p_in_c(*m_optical_connect.at(1));
+    }
+    m_oct->p_readout(*p_readout);
+
+    // cout << "Successful connection of " << name() << endl;
+
+}
\ No newline at end of file
diff --git a/src/devices/octane_segment.h b/src/devices/octane_segment.h
new file mode 100644
index 0000000..ea28f03
--- /dev/null
+++ b/src/devices/octane_segment.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <systemc.h>
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <octane_cell.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+// TODO: remove these (are in spx_module.h)
+typedef sc_signal_in_if<OpticalSignal > if_in_type;
+typedef sc_signal_out_if<OpticalSignal > if_out_type;
+typedef sc_port<if_in_type> port_in_type;
+typedef sc_port<if_out_type> port_out_type;
+
+
+/** Building block for the OCTANE circuit
+ * The current implementation includes all
+ * intermediate components allowing modelling of imperfections,
+ * but at the cost of increased module count.
+ *
+ * A simpler way would be to disregard all intermediate waveguides
+ * and model their effects on `octane_cell`
+ *
+ * Maybe I could add an argument to init(bool isCompact), defining
+ * if the model will be compact or not.
+*/
+
+//TODO: pass element's characteristics as argument, for instance, pass an example of waveguide,
+// or an example of DC, PCM such that it copies. Requires: constructors in each element to build
+// by copying.
+
+class OctaneSegment : public sc_module {
+public:
+    // Ports
+    /** The optical input ports. */
+    vector<unique_ptr<port_in_type>> p_in;
+
+    /** The optical output ports. */
+    vector<unique_ptr<port_out_type>> p_out;
+
+    /** The electric output port*/
+    unique_ptr<sc_out<double>> p_readout;
+
+    // Member variables
+    // Defines the number of ports and elements
+    bool m_term_row;
+    bool m_term_col;
+    bool m_isCompact;
+
+    // Defines the coupling in the DCs (should change as more elements are added)
+    double m_coupling_through_row;
+    double m_coupling_through_col;
+
+    // For internal octane_cell
+    double m_meltEnergy;
+    int m_nStates;
+
+
+    // Wires
+    vector<unique_ptr<sc_signal<OpticalSignal>>> m_optical_connect;
+
+    // Member submodules
+    vector<unique_ptr<Waveguide>> m_wg;
+    vector<unique_ptr<DirectionalCoupler>> m_dc;
+    unique_ptr<OctaneCell> m_oct;
+
+    // init() should be called after declaration
+    void init();
+    void init_compact();
+    void init_full();
+    void init_ports();
+    void connect_submodules_full();
+    void connect_submodules_compact();
+
+    /** Constructor for Octane Segment
+     *
+     * @param name name of the module
+     * @param meltEnergy energy needed to amorphize by one step
+     * @param nStates number of internal states supported by the PCM
+     * */
+    OctaneSegment(sc_module_name name, bool term_row, bool term_col,
+                    double coupling_through_row, double coupling_through_col,
+                    double meltEnergy, int nStates, bool isCompact = false)
+        : sc_module(name)
+        , m_term_row(term_row)
+        , m_term_col(term_col)
+        , m_isCompact(isCompact)
+        , m_coupling_through_row(coupling_through_row)
+        , m_coupling_through_col(coupling_through_col)
+        , m_meltEnergy(meltEnergy)
+        , m_nStates(nStates)
+    {
+        init_ports(); // At least the ports should always be
+        // in the constructor
+    }
+
+};
diff --git a/src/devices/pcm_device.cpp b/src/devices/pcm_device.cpp
new file mode 100644
index 0000000..dc018da
--- /dev/null
+++ b/src/devices/pcm_device.cpp
@@ -0,0 +1,150 @@
+#include <algorithm>
+#include <iostream>
+
+#include <pcm_device.h>
+
+#define ZERO_PULSE_THRESHOLD (1e-10)
+
+using namespace std;
+
+void PCMElement::on_input_changed()
+{
+    // setting the transmission for the initial state
+    update_transmission_local();
+
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "Emelt = " << m_meltEnergy*1e9 << " nJ" << endl;
+        cout << "Nstates = " << m_nStates << "" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in.get_interface()))->name();
+        cout << " --> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_out.get_interface()))->name();
+        cout << endl;
+        cout << endl;
+    }
+
+    m_last_pulse_power = 0;
+    bool in_window = false;
+    vector<pulse_sample_t> vector_of_samples;
+    uint32_t cur_wavelength_id;
+    m_memory_in[0] = 0;
+    double total_in_power = 0;
+
+    while (true) {
+        // Wait next input change
+        wait();
+
+        // Read signal and store field in memory for that wavelength
+        auto s = p_in->read();
+        cur_wavelength_id = s.m_wavelength_id;
+        m_memory_in[cur_wavelength_id] = s.m_field;
+
+        // Summing powers of all wavelengths
+        total_in_power = 0;
+        for (auto lambdaID_field : m_memory_in)
+        {
+            total_in_power += norm(lambdaID_field.second);
+        }
+
+        // Storage of optical state on the input
+        const sc_time &now = sc_time_stamp();
+
+        bool last_was_zero = m_last_pulse_power < ZERO_PULSE_THRESHOLD;
+        bool current_is_zero = total_in_power < ZERO_PULSE_THRESHOLD;
+        bool rising_edge = last_was_zero && !current_is_zero;
+        if (!rising_edge)
+        {
+            // Enter here when:
+            //   - a signal is received on top of another one (pulse intersect)
+            //   - a signal ends (power falls to 0)
+
+            // Record the event
+            vector_of_samples.emplace_back(now.to_seconds(), total_in_power);
+        }
+        else
+        {
+            // Enter here when:
+            //   - a signal starts (power rises from 0 to non-0 value)
+            // This case is necessarily the first rise
+
+            // Will unroll events and check if there was a phase change before according to
+            // the vector and advance the state accordingly to get the transmission
+            // cout << "\t\t first rise detected" << endl;
+            in_window = phase_change(vector_of_samples, true);
+            if (!in_window)
+                vector_of_samples.clear();
+
+            // Record the current event
+            vector_of_samples.emplace_back(now.to_seconds(), total_in_power);
+        }
+
+        m_last_pulse_power = total_in_power;
+
+        // Write attenuated signal to output
+        s *= m_transmission;
+        s.getNewId();
+
+        m_out_writer.delayedWrite(s, SC_ZERO_TIME);
+    }
+}
+
+bool PCMElement::phase_change(const vector<pulse_sample_t> &samples, const bool &local)
+{
+    // Here should decide between sending the
+    // sim off to external or resolving inside
+
+    // Should set new values for m_state and m_transmission
+
+    double energy_absorbed = 0;
+    double dur_pulse = 0;
+    // will return true if we shouldn't erase the vector
+    bool in_influence_window = false;
+
+    if (samples.empty())
+        return true;
+
+    if (sc_time_stamp().to_seconds() -  samples.back().first < influence_time_ns*1e-9)
+        return true;
+
+    if (local)
+    {
+        // Integrating power along each duration
+        // pulse 0 stays at pow[0] for tim[1]-tim[0] seconds
+        // the last sample is zero in power, just here to get the final time
+        for (unsigned int i = 0; i < samples.size()-1; i++)
+        {
+            dur_pulse = samples[i+1].first - samples[i].first;
+            energy_absorbed += samples[i].second * dur_pulse;
+        }
+        // if enough energy and not saturated
+        if ((energy_absorbed > m_meltEnergy) && (m_state < m_nStates))
+        {
+            // cout << sc_time_stamp() << ": \n\t" << name() << " phase changed with "
+            //           << energy_absorbed*1e6 << " uJ" << endl;
+            m_state++;
+            // cout << "\tnew state: " << m_state << endl;
+            update_transmission_local();
+        }
+    }
+    else // external phase change simulation
+    {
+        // send the simulation to external software
+        cout << "TODO: implement handles to external sim"
+                << endl;
+    }
+    return in_influence_window;
+}
+
+void PCMElement::update_transmission_local()
+{
+    double sp = 0.85;
+    double ep = 0.95;
+    double speed = 3;
+    m_transmission = sp+(ep-sp)*tanh(speed*m_state/m_nStates);
+    // cout << "\tnew trans_power: " << m_transmission << "- W/W" << endl;
+
+    // For field need to do a square root
+    m_transmission = sqrt(m_transmission);
+}
diff --git a/src/devices/pcm_device.h b/src/devices/pcm_device.h
new file mode 100644
index 0000000..4510591
--- /dev/null
+++ b/src/devices/pcm_device.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <vector>
+
+#include <systemc.h>
+
+#include <spx_module.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+#include "specs.h"
+#include "spx_module.h"
+
+class PCMElement : public spx_module {
+public:
+    // Ports
+    spx::oa_port_in_type p_in;
+    spx::oa_port_out_type p_out;
+
+    // Timed ports writers
+    OpticalOutputPort m_out_writer;
+
+    // Auxiliary struct - stores tuples of value-time
+    typedef pair<double,double> pulse_sample_t;
+
+    // Member variables
+    double m_meltEnergy;
+    int m_state;
+    int m_nStates;
+    double m_transmission = 1;
+    double influence_time_ns = 1;
+
+    /** Current information about the optical input, before any attenuation and phase shift. */
+    double m_last_pulse_power;
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in;
+
+
+    // Processes
+    void on_input_changed();
+    bool phase_change(const vector<pulse_sample_t> &vec, const bool &local);
+    void update_transmission_local();
+
+
+    // Constructor
+    PCMElement(sc_module_name name,
+               double meltEnergy = 0,
+               int nStates = 0,
+               int state = 0)
+        : spx_module(name)
+        , m_out_writer("out_delayed_writer", p_out)
+        , m_meltEnergy(meltEnergy)
+        , m_state(state)
+        , m_nStates(nStates)
+    {
+        SC_HAS_PROCESS(PCMElement);
+
+        SC_THREAD(on_input_changed);
+        sensitive << p_in;
+    }
+};
diff --git a/src/devices/phaseshifter.cpp b/src/devices/phaseshifter.cpp
new file mode 100644
index 0000000..620243d
--- /dev/null
+++ b/src/devices/phaseshifter.cpp
@@ -0,0 +1,198 @@
+#include "specs.h"
+#include <phaseshifter.h>
+
+using namespace std;
+
+void PhaseShifterUni::on_port_in_changed()
+{
+    auto transmission_field = pow(10.0, - m_attenuation_dB / 20);
+    m_memory_in[0] = 0; // initializing for nan wavelength
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "transmission_power = " << pow(transmission_field,2) << " W/W" << endl;
+        cout << "sensitivity = " << m_sensitivity << " rad/V" << endl;
+        cout << "initial phase delay = " << m_phaseshift_rad << " rad @1.55)" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in.get_interface()))->name();
+        cout << " --> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_out.get_interface()))->name();
+        cout << endl << "\t^" << endl;
+        cout << "\t|" << endl << "\t";
+        cout << (dynamic_cast<spx::ea_signal_type *>(p_vin.get_interface()))->name();
+        cout << endl;
+        cout << endl;
+    }
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read the input signal and apply attenuation
+        OpticalSignal s = p_in->read();
+
+
+        // Store field value in memory
+        m_memory_in[s.m_wavelength_id] = s.m_field;
+
+        // Get new ID for output event
+        s.getNewId();
+
+        // Apply transmission and phase-shift
+        s *= polar(transmission_field, m_sensitivity * p_vin->read());
+
+        // Write to ouput port after zero delay
+        m_out_writer.delayedWrite(s, SC_ZERO_TIME);
+    }
+}
+
+void PhaseShifterUni::on_port_vin_changed()
+{
+    auto transmission_field = pow(10.0, - m_attenuation_dB / 20);
+
+    uint32_t cur_wavelength_id = 0;
+    OpticalSignal::field_type cur_field = (complex<double>)0;
+
+    while (true)
+    {
+        wait();
+        // Read the new phase-delay
+        m_phaseshift_rad = m_sensitivity * p_vin->read();
+
+        // writes the signals of all wavelengths with the new phase shift
+        for(auto id_field : m_memory_in)
+        {
+            cur_wavelength_id = id_field.first;
+            cur_field = id_field.second;
+            auto s = OpticalSignal(cur_field, cur_wavelength_id);
+
+            // Get a new ID for the signal
+            s.getNewId();
+
+            // Apply transmission and phase-shift
+            s *= polar(transmission_field, m_phaseshift_rad);
+
+            // Write to ouput port after zero delay
+            m_out_writer.delayedWrite(s, SC_ZERO_TIME);
+        }
+    }
+}
+
+
+void PhaseShifterBi::on_p0_in_changed()
+{
+    auto transmission_field = pow(10.0, - m_attenuation_dB / 20);
+    m_memory_p0[0] = 0; // initializing for nan wavelength
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "transmission_power = " << pow(transmission_field,2) << " W/W" << endl;
+        cout << "sensitivity = " << m_sensitivity << " rad/V" << endl;
+        cout << "initial phase delay = " << m_phaseshift_rad << " rad @1.55)" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_in.get_interface()))->name();
+        cout << " --> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_out.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_out.get_interface()))->name();
+        cout << " <-- ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_in.get_interface()))->name();
+        cout << endl << "\t^" << endl;
+        cout << "\t|" << endl << "\t";
+        cout << (dynamic_cast<spx::ea_signal_type *>(p_vin.get_interface()))->name();
+        cout << endl;
+        cout << endl;
+    }
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read the input signal and apply attenuation
+        OpticalSignal s = p0_in->read();
+
+
+        // Store field value in memory
+        m_memory_p0[s.m_wavelength_id] = s.m_field;
+
+        // Get new ID for output event
+        s.getNewId();
+
+        // Apply transmission and phase-shift
+        s *= polar(transmission_field, m_sensitivity * p_vin->read());
+
+        // Write to ouput port after zero delay
+        m_p1_writer.delayedWrite(s, SC_ZERO_TIME);
+    }
+}
+
+void PhaseShifterBi::on_p1_in_changed()
+{
+    auto transmission_field = pow(10.0, - m_attenuation_dB / 20);
+    m_memory_p1[0] = 0; // initializing for nan wavelength
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read the input signal and apply attenuation
+        OpticalSignal s = p1_in->read();
+
+        // Store field value in memory
+        m_memory_p1[s.m_wavelength_id] = s.m_field;
+
+        // Get new ID for output event
+        s.getNewId();
+
+        // Apply transmission and phase-shift
+        s *= polar(transmission_field, m_sensitivity * p_vin->read());
+
+        // Write to ouput port after zero delay
+        m_p0_writer.delayedWrite(s, SC_ZERO_TIME);
+    }
+}
+
+void PhaseShifterBi::on_port_vin_changed()
+{
+    auto transmission_field = pow(10.0, - m_attenuation_dB / 20);
+
+    uint32_t cur_wavelength_id = 0;
+    OpticalSignal::field_type cur_field = (complex<double>)0;
+
+    while (true)
+    {
+        wait();
+        // Read the new phase-delay
+        m_phaseshift_rad = m_sensitivity * p_vin->read();
+
+        // writes the signals of all wavelengths with the new phase shift
+        for(auto id_field : m_memory_p0)
+        {
+            cur_wavelength_id = id_field.first;
+            cur_field = id_field.second;
+            auto s = OpticalSignal(cur_field, cur_wavelength_id);
+
+            // Get a new ID for the signal
+            s.getNewId();
+
+            // Apply transmission and phase-shift
+            s *= polar(transmission_field, m_phaseshift_rad);
+
+            // Write to ouput port after zero delay
+            m_p1_writer.delayedWrite(s, SC_ZERO_TIME);
+        }
+        for(auto id_field : m_memory_p1)
+        {
+            cur_wavelength_id = id_field.first;
+            cur_field = id_field.second;
+            auto s = OpticalSignal(cur_field, cur_wavelength_id);
+
+            // Get a new ID for the signal
+            s.getNewId();
+
+            // Apply transmission and phase-shift
+            s *= polar(transmission_field, m_phaseshift_rad);
+
+            // Write to ouput port after zero delay
+            m_p0_writer.delayedWrite(s, SC_ZERO_TIME);
+        }
+    }
+}
diff --git a/src/devices/phaseshifter.h b/src/devices/phaseshifter.h
new file mode 100644
index 0000000..04ac803
--- /dev/null
+++ b/src/devices/phaseshifter.h
@@ -0,0 +1,166 @@
+#pragma once
+
+#include "specs.h"
+#include <systemc.h>
+
+#include <spx_module.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+/** An electrically-controllable phase shifter. */
+class PhaseShifterBase : public spx_module {
+public:
+    // Member variables
+    /** The phaseshift applied to the pulse, in rad. */
+    double m_phaseshift_rad = 0;
+
+    /** The attenuation of the device in dB. */
+    double m_attenuation_dB;
+
+    /** The responsivity of the phase-shifter in rad/V. */
+    double m_sensitivity = 1;
+
+    /** Constructor for PhaseShifter
+     *
+     * @param name name of the module
+     * */
+    PhaseShifterBase(sc_module_name name, double attenuation_dB = 0)
+        : spx_module(name)
+        , m_phaseshift_rad(0)
+        , m_attenuation_dB(attenuation_dB)
+    {}
+};
+
+class PhaseShifterUni : public PhaseShifterBase {
+public:
+    // Ports
+    /** The electrical input port. */
+    spx::ea_port_in_type p_vin;
+    /** The optical input port. */
+    spx::oa_port_in_type p_in;
+    /** The optical output port. */
+    spx::oa_port_out_type p_out;
+
+    // Timed ports writers
+    /** Timed writer to the output port.
+     *
+     * @sa DelayedWriter
+     * */
+    OpticalOutputPort m_out_writer;
+
+    /** Memory of the current input value for all wavelengths. */
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_in;
+
+    // Processes
+    /** Main process of the module.
+     *
+     * It copies the input to the output, after attenuation and delay.
+     * Will use the current m_phaseshift_rad at that moment.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** p_in
+     * */
+    void on_port_in_changed();
+
+    /** Auxiliary process of the module.
+     *
+     * Updates @param m_phaseshift_rad and creates a new event
+     * using the current optical input, sending it to the output
+     * after zero time.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** v_in
+     * */
+    void on_port_vin_changed();
+
+    /** Constructor for PhaseShifter
+     *
+     * @param name name of the module
+     * */
+    PhaseShifterUni(sc_module_name name, double attenuation_dB = 0)
+        : PhaseShifterBase(name, attenuation_dB)
+        , m_out_writer("out_delayed_writer", p_out)
+    {
+        SC_HAS_PROCESS(PhaseShifterUni);
+
+        SC_THREAD(on_port_in_changed);
+        sensitive << p_in;
+        SC_THREAD(on_port_vin_changed);
+        sensitive << p_vin;
+    }
+};
+
+typedef PhaseShifterUni PhaseShifter;
+
+class PhaseShifterBi : public PhaseShifterBase {
+public:
+    // Ports
+    /** The electrical input port. */
+    spx::ea_port_in_type p_vin;
+
+    /** The optical input ports. */
+    spx::oa_port_in_type p0_in;
+    spx::oa_port_in_type p1_in;
+
+    /** The optical output ports. */
+    spx::oa_port_out_type p0_out;
+    spx::oa_port_out_type p1_out;
+
+    // Timed ports writers
+    /** Timed writer to the output port.
+     *
+     * @sa DelayedWriter
+     * */
+    OpticalOutputPort m_p0_writer;
+    OpticalOutputPort m_p1_writer;
+
+    /** Memory of the current input value for all wavelengths. */
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_p0;
+    std::map<uint32_t,OpticalSignal::field_type> m_memory_p1;
+
+    // Processes
+    /** Main process of the module.
+     *
+     * It copies the input to the output, after attenuation and delay.
+     * Will use the current m_phaseshift_rad at that moment.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** p0_in
+     * */
+    void on_p0_in_changed();
+    void on_p1_in_changed();
+
+    /** Auxiliary process of the module.
+     *
+     * Updates @param m_phaseshift_rad and creates a new event
+     * using the current optical input, sending it to the output
+     * after zero time.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** v_in
+     * */
+    void on_port_vin_changed();
+
+    /** Constructor for PhaseShifter
+     *
+     * @param name name of the module
+     * */
+    PhaseShifterBi(sc_module_name name, double attenuation_dB = 0)
+        : PhaseShifterBase(name, attenuation_dB)
+        , m_p0_writer("p0_out_delayed_writer", p0_out)
+        , m_p1_writer("p1_out_delayed_writer", p1_out)
+    {
+        SC_HAS_PROCESS(PhaseShifterBi);
+
+        SC_THREAD(on_p0_in_changed);
+        sensitive << p0_in;
+        SC_THREAD(on_p1_in_changed);
+        sensitive << p1_in;
+        SC_THREAD(on_port_vin_changed);
+        sensitive << p_vin;
+    }
+};
diff --git a/src/devices/probe.cpp b/src/devices/probe.cpp
new file mode 100644
index 0000000..f9054e9
--- /dev/null
+++ b/src/devices/probe.cpp
@@ -0,0 +1,164 @@
+#include <ios>
+#include <probe.h>
+#include <cstdlib> // system()
+
+#define __modname(SUFFIX, IDX) \
+    ((""s + this->name() + "_" + SUFFIX + to_string(IDX)).c_str())
+
+
+void Probe::on_port_in_changed()
+{
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "Signal: " << (dynamic_cast<spx::oa_signal_type *>(p_in.get_interface()))->name() << endl;
+        cout << "trace power: " << m_trace_power << endl;
+        cout << "trace modulus: " << m_trace_modulus << endl;
+        cout << "trace phase: " << m_trace_phase << endl;
+        cout << "trace wavelength: " << m_trace_wavelength << endl;
+        cout << endl;
+    }
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Check if enabled first
+        if (!enable.read().to_bool())
+        {
+            wait(enable.posedge_event());
+            continue;
+        }
+
+        auto &s = p_in->read();
+        // cout << name() << ": " << s << endl;
+        if (!isnan(s.getWavelength()))
+        {
+            if (m_trace_power)
+                m_trace_sig_power.write(s.power());
+            if (m_trace_modulus)
+                m_trace_sig_modulus.write(s.modulus());
+            if (m_trace_phase)
+                m_trace_sig_phase.write(s.phase());
+            if (m_trace_wavelength)
+                // m_trace_sig_wavelength.write(299792458.0 / s.m_wavelength);
+                m_trace_sig_wavelength.write(s.getWavelength());
+        }
+    }
+}
+
+void PowerProbe::on_port_in_changed()
+{
+    //m_trace_sig.write(0);
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+        auto &s = p_in->read();
+        if (!isnan(s.getWavelength()))
+            m_trace_sig_power.write(s.power());
+    }
+}
+
+void PhaseProbe::on_port_in_changed()
+{
+    //m_trace_sig.write(0);
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+        auto &s = p_in->read();
+        if (!isnan(s.getWavelength()))
+            m_trace_sig_phase.write(s.phase());
+    }
+}
+
+//__modname(SUFFIX, IDX)
+void MLambdaProbe::setTraceFile(sc_trace_file *Tf)
+{
+    m_Tf = Tf;
+    if (!m_Tf)
+        return;
+
+    unique_ptr<sc_signal<double>> temp_signal;
+    std::vector<unique_ptr<sc_signal<double>>> temp_vector;
+
+    // for each wavelength, create three signals:
+    //      power, abs, phase, that will monitor these characteristics in
+    // the input optical signals that arrive
+    int i = 0;
+    for(const auto &wl : m_lambdas)
+    {
+        stringstream ss;
+        // int wl_nm = floor(wl*1e9);
+        // int wl_sub_nm = round((wl*1e9 - wl_nm) * 1e6);
+        // ss << wl_nm << "nm" << wl_sub_nm;
+        ss << setprecision(6) << std::fixed << wl*1e9;
+        string wl_str = ss.str();
+        // Necessary because '.' is interpreted by traces as the hierarchical separator
+        std::replace(wl_str.begin(), wl_str.end(), '.', '_');
+
+        temp_vector.clear();
+
+        temp_signal = make_unique<sc_signal<double>>(__modname("trace_pow", i*3));
+        sc_trace(m_Tf, *temp_signal, (string(this->name()) + ".power@" + wl_str).c_str());
+        temp_vector.push_back(std::move(temp_signal));
+
+        temp_signal = make_unique<sc_signal<double>>(__modname("trace_mod", i*3));
+        sc_trace(m_Tf, *temp_signal, (string(this->name()) + ".abs@" + wl_str).c_str());
+        temp_vector.push_back(std::move(temp_signal));
+
+        temp_signal = make_unique<sc_signal<double>>(__modname("trace_phase", i*3));
+        sc_trace(m_Tf, *temp_signal, (string(this->name()) + ".phase@" + wl_str).c_str());
+        temp_vector.push_back(std::move(temp_signal));
+
+        //m_lambda_signals[m_lambdas[i]] = std::move(temp_vector);
+        //or
+        m_lambda_signals.insert({wl, std::move(temp_vector)});
+
+        ++i;
+    }
+}
+void MLambdaProbe::on_port_in_changed()
+{
+    // std::map< int, std::vector< unique_ptr<sc_signal<double> > > > wl_map;
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << " ready (";
+        for (const auto &p : m_lambda_signals)
+        {
+            cout << p.first << ", ";
+        }
+        cout << "\b\b)" << endl;
+        cout << "Signal: " << (dynamic_cast<spx::oa_signal_type *>(p_in.get_interface()))->name() << endl;
+        cout << endl;
+    }
+    //m_trace_sig.write(0);
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Check if enabled first
+        if (!enable.read().to_bool())
+        {
+            wait(enable.posedge_event());
+            continue;
+        }
+
+        auto &s = p_in->read();
+        auto search = m_lambda_signals.find(s.getWavelength());
+
+        if (search != m_lambda_signals.end())
+        {
+            //cout << name() << " received supported signal (lambda = " << s.getWavelength() << "m)" << endl;
+            m_lambda_signals[s.getWavelength()][0]->write(s.power());
+            m_lambda_signals[s.getWavelength()][1]->write(s.modulus());
+            m_lambda_signals[s.getWavelength()][2]->write(s.phase());
+        }
+        else {
+            cout << name() << " received unsupported signal (lambda = " << s.getWavelength() << "m)" << endl;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/devices/probe.h b/src/devices/probe.h
new file mode 100644
index 0000000..10865ba
--- /dev/null
+++ b/src/devices/probe.h
@@ -0,0 +1,131 @@
+#pragma once
+
+#include <systemc.h>
+#include <fstream>
+#include <map>
+#include <set>
+
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include "specs.h"
+#include "spx_module.h"
+
+/*
+This class defines an ideal optical probe. It will sample the signal at its input and
+write it in a file. Any OpticalSignal can be its input, without caring for optical
+splitting, as it is completely ideal.
+*/
+class Probe : public spx_module {
+public:
+    // Ports
+    spx::oa_port_in_type p_in;
+
+    // Processes
+    virtual void on_port_in_changed();
+
+    // Member variables
+
+    // If given a valid trace file as argument
+    // Will not save to txt and rather use VCD tracing
+    sc_trace_file *m_Tf;
+    sc_signal<double> m_trace_sig_power;
+    sc_signal<double> m_trace_sig_modulus;
+    sc_signal<double> m_trace_sig_phase;
+    sc_signal<double> m_trace_sig_wavelength;
+
+    sc_signal<sc_logic> enable;
+    bool m_trace_power;
+    bool m_trace_modulus;
+    bool m_trace_phase;
+    bool m_trace_wavelength;
+
+    // Constructor
+    Probe(sc_module_name name, const bool &trace_power = true, const bool &trace_modulus = true
+    , const bool &trace_phase = true, const bool &trace_wavelength = true)
+        : spx_module(name)
+        , m_Tf(nullptr)
+        , enable((string(this->name()) + "_enable").c_str(), sc_logic(1))
+        , m_trace_power(trace_power)
+        , m_trace_modulus(trace_modulus)
+        , m_trace_phase(trace_phase)
+        , m_trace_wavelength(trace_wavelength)
+    {
+        SC_HAS_PROCESS(Probe);
+
+        SC_THREAD(on_port_in_changed);
+        sensitive << p_in;
+    }
+
+    // Constructor overloading
+    Probe(sc_module_name name, sc_trace_file *Tf, const bool &trace_power = true, const bool &trace_modulus = true
+    , const bool &trace_phase = true, const bool &trace_wavelength = true)
+        : Probe(name, trace_power, trace_modulus, trace_phase, trace_wavelength)
+    {
+        setTraceFile(Tf);
+    }
+
+    void setTraceFile(sc_trace_file *Tf)
+    {
+        if (m_Tf == Tf)
+            return;
+        m_Tf = Tf;
+        if (m_Tf)
+        {
+            if (m_trace_power) sc_trace(m_Tf, m_trace_sig_power, (string(this->name()) + ".power").c_str());
+            if (m_trace_modulus) sc_trace(m_Tf, m_trace_sig_modulus, (string(this->name()) + ".abs").c_str());
+            if (m_trace_phase) sc_trace(m_Tf, m_trace_sig_phase, (string(this->name()) + ".phase").c_str());
+            if (m_trace_wavelength) sc_trace(m_Tf, m_trace_sig_wavelength, (string(this->name()) + ".wavelength").c_str());
+        }
+    }
+};
+
+class PowerProbe : public Probe {
+public:
+    virtual void on_port_in_changed();
+};
+
+class PhaseProbe : public Probe {
+public:
+    virtual void on_port_in_changed();
+};
+
+class MLambdaProbe : public spx_module {
+public:
+    // Ports
+    spx::oa_port_in_type p_in;
+
+    // Processes
+    virtual void on_port_in_changed();
+
+    // Member variables
+
+    // If given a valid trace file as argument
+    // Will not save to txt and rather use VCD tracing
+    sc_signal<sc_logic> enable;
+    sc_trace_file *m_Tf;
+
+    sc_signal<double> m_trace_sig_power;
+    sc_signal<double> m_trace_sig_modulus;
+    sc_signal<double> m_trace_sig_phase;
+
+    std::set<double> m_lambdas;
+    std::map< double, std::vector< unique_ptr<sc_signal<double> > > > m_lambda_signals;
+
+    void setTraceFile(sc_trace_file *Tf);
+    void prepare();
+
+    // Constructor
+    MLambdaProbe(sc_module_name name, set<double> lambdas = {})
+        : spx_module(name)
+        , enable((string(this->name()) + "_enable").c_str(), sc_logic(1))
+        , m_Tf(nullptr)
+        , m_lambdas(lambdas)
+    {
+        SC_HAS_PROCESS(MLambdaProbe);
+
+        SC_THREAD(on_port_in_changed);
+        sensitive << p_in;
+    }
+
+    // TODO: overload the constructor for the case of not informing lambdas, need to check all components
+};
diff --git a/src/devices/ring.cpp b/src/devices/ring.cpp
new file mode 100644
index 0000000..42f901e
--- /dev/null
+++ b/src/devices/ring.cpp
@@ -0,0 +1,8 @@
+#include <waveguide.h>
+
+//void Ring::on_port_tuning_changed()
+//{
+//    // Tuning of the ring parameters...
+//    // e.g. wg.neff = ...
+//}
+
diff --git a/src/devices/ring.h b/src/devices/ring.h
new file mode 100644
index 0000000..0633c13
--- /dev/null
+++ b/src/devices/ring.h
@@ -0,0 +1,99 @@
+#pragma once
+
+#include <systemc.h>
+
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+
+/** A unidirectional waveguide module. */
+class Ring : public sc_module {
+public:
+    // Ports
+    /** The optical input port. */
+    sc_port<sc_signal_in_if<OpticalSignal>> p_in;
+    /** The optical output port. */
+    sc_port<sc_signal_out_if<OpticalSignal>> p_out;
+
+    // Timed ports writers
+    /** Timed writer to the output port.
+     *
+     * @sa DelayedWriter
+     * */
+    OpticalOutputPort m_out_writer;
+
+    sc_signal<OpticalSignal> sig_in;
+    sc_signal<OpticalSignal> sig_internal_0;
+    sc_signal<OpticalSignal> sig_internal_1;
+    sc_signal<OpticalSignal> sig_out;
+    DirectionalCoupler dc;
+    Waveguide wg;
+
+    // Member variables
+    /** The attenuation inside the waveguide, in dB/cm. */
+    double m_attenuation_dB_cm = 0.2;
+    /** The effective index of the waveguide */
+    double m_neff = 2.2111;
+    /** The group index of the waveguide */
+    double m_ng = 2.2637;
+
+    /** The coupling from waveguide to ring, in dB. */
+    double m_cross_power_dB = 10*std::log10(0.5) - 0.15;
+    double m_through_power_dB = 10*std::log10(0.5) - 0.15;
+    double m_cross_phase_rad = M_PI / 2;
+    double m_through_phase_rad = M_PI / 2;
+
+    /** The radius of the ring in um. */
+    double m_radius_um = 0;
+
+    // Processes
+    /** Main process of the module.
+     *
+     * It copies the input to the output, after attenuation and delay.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** p_in
+     * */
+    void on_port_in_changed();
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * @param length_cm length of the waveguide in cm
+     * */
+    Ring(sc_module_name name, double length_cm = 30e-6)
+        : sc_module(name)
+        , m_out_writer("out_delayed_writer", p_out)
+        , dc((std::string(name) + ".DC1").c_str())
+        , wg((std::string(name) + ".WG1").c_str())
+    {
+        dc.p_in1(sig_in);
+        dc.p_in2(sig_internal_1);
+        dc.p_out1(sig_out);
+        dc.p_out2(sig_internal_0);
+
+        wg.p_in(sig_internal_0);
+        wg.p_out(sig_internal_1);
+
+        p_in(sig_in);
+        p_out(sig_out);
+
+        setLength(length_cm);
+        
+        SC_HAS_PROCESS(Waveguide);
+
+        SC_THREAD(on_port_in_changed);
+        sensitive << p_in;
+    }
+
+    void setRadius(double radius_um) {
+        wg.setLength(2 * M_PI * radius_um * 1e-4);
+        m_radius_um = radius_um;
+    }
+
+    void setLength(double length_cm) {
+        setRadius(length_cm * 1e4 / 2 / M_PI);
+    }
+};
diff --git a/src/devices/splitter.cpp b/src/devices/splitter.cpp
new file mode 100644
index 0000000..e6464f6
--- /dev/null
+++ b/src/devices/splitter.cpp
@@ -0,0 +1,41 @@
+#include <splitter.h>
+#include <specs.h>
+
+void Splitter::on_port_in_changed()
+{
+    const double transmission = pow(10.0, - m_attenuation_dB / 20);
+    const double S12 = transmission * sqrt(m_split_ratio);
+    const double S13 = transmission * sqrt(1 - m_split_ratio);
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "transmission = " << pow(transmission, 2) << " W/W" << endl;
+        cout << "splitting ratio_power = 0.5" << " W/W" << endl;
+        cout << "\t    " << (dynamic_cast<spx::oa_signal_type *>(p_out1.get_interface()))->name() << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in.get_interface()))->name()  << " -->" << endl;
+        cout << "\t    " << (dynamic_cast<spx::oa_signal_type *>(p_out2.get_interface()))->name();
+        cout << endl;
+        cout << endl;
+    }
+
+    while (true) {
+        // Wait for a new input signal
+        wait();
+
+        // Read input signal
+        const auto &s = p_in->read();
+
+        // Apply device's transmission
+        auto s1 = S12 * s;
+        auto s2 = S13 * s;
+
+        // Get new IDs
+        s1.getNewId();
+        s2.getNewId();
+
+        // Write to output ports after delay
+        m_out1_writer.delayedWrite(s1, SC_ZERO_TIME);
+        m_out2_writer.delayedWrite(s2, SC_ZERO_TIME);
+    }
+}
diff --git a/src/devices/splitter.h b/src/devices/splitter.h
new file mode 100644
index 0000000..1d5e730
--- /dev/null
+++ b/src/devices/splitter.h
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <systemc.h>
+
+#include <spx_module.h>
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include "specs.h"
+#include "spx_module.h"
+
+/** A 1x2 waveguide splitter module.
+ *
+ * This device copies any output to its two output, with power values defines by the
+ * split ratio and attenuation.
+ * */
+class Splitter : public spx_module {
+public:
+    // Ports
+    /** The optical input port. */
+    spx::oa_port_in_type p_in;
+    /** The first optical output port. */
+    spx::oa_port_out_type p_out1;
+    /** The second optical output port. */
+    spx::oa_port_out_type p_out2;
+
+private:
+    // Timed ports writers
+    /** Timed writer to the first output port.
+     *
+     * @sa DelayedWriter
+     * */
+    OpticalOutputPort m_out1_writer;
+    /** Timed writer to the second output port.
+     *
+     * @sa DelayedWriter
+     * */
+    OpticalOutputPort m_out2_writer;
+
+public:
+    // Member variables
+    /** The power transmission from input to branch 1, exclusive of losses
+     *
+     * The power transmission from input to branch 2 is (1 - m_split_ratio)
+     * */
+    double m_split_ratio;
+
+    /** The delay for an output to propagate to the outputs in ns.
+     *
+     * The delay is the same for both outputs.
+     * */
+    // static double m_delay_ns;
+    /** The attenuation of the signal in dB.
+     *
+     * The attenuation is applied before the split (although it does not really make a
+     * difference. */
+    double m_attenuation_dB;
+
+    // Processes
+    /** Main process of the module.
+     *
+     * It copies the input to both output, after attenuation and delay.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** p_in
+     * */
+    void on_port_in_changed();
+
+    // Constructor
+    /** Constructor for Splitter
+     *
+     * @param name name of the module
+     * @param split_ratio ratio of the light which goes to the first ouptut
+     * (pre-attenuation)
+     * */
+    Splitter(sc_module_name name, double split_ratio = 0.5, double attenuation_dB = 0)
+        : spx_module(name)
+        , m_out1_writer("out1_delayed_writer", p_out1)
+        , m_out2_writer("out2_delayed_writer", p_out2)
+        , m_split_ratio(split_ratio)
+        , m_attenuation_dB(attenuation_dB)
+    {
+        SC_HAS_PROCESS(Splitter);
+
+        SC_THREAD(on_port_in_changed);
+        sensitive << p_in;
+    }
+};
diff --git a/src/devices/spx_module.h b/src/devices/spx_module.h
new file mode 100644
index 0000000..0a4506f
--- /dev/null
+++ b/src/devices/spx_module.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "optical_signal.h"
+#include "specs.h"
+
+#include <systemc.h>
+#include <string>
+
+using std::string;
+using namespace std::string_literals;
+
+class spx_module : public sc_module {
+public:
+    typedef spx_module this_type;
+    typedef spx::oa_value_type sigval_type;
+    typedef spx::oa_signal_type sig_type;
+    typedef spx::oa_if_in_type if_in_type;
+    typedef spx::oa_if_out_type if_out_type;
+    typedef spx::oa_port_in_type port_in_type;
+    typedef spx::oa_port_out_type port_out_type;
+
+    enum ModuleFlags {
+        NON_LINEAR = 0b0001,
+        TIME_VARIANT = 0b0010,
+        FREQUENCY_DEPENDENT = 0b0100,
+    };
+
+    ModuleFlags flags = FREQUENCY_DEPENDENT;
+
+    virtual void init() {}
+    virtual string describe() const { return ""s; }
+
+    spx_module(sc_module_name name)
+    : sc_module(name)
+    {}
+};
\ No newline at end of file
diff --git a/src/devices/subcircuit_instance.h b/src/devices/subcircuit_instance.h
new file mode 100644
index 0000000..5c835e8
--- /dev/null
+++ b/src/devices/subcircuit_instance.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "specs.h"
+#include "spx_module.h"
+
+using std::vector;
+using std::string;
+using std::shared_ptr;
+
+class SubcircuitInstance: public spx_module {
+public:
+    // vector<shared_ptr<spx::oa_port_inout_type>> ports;
+    vector<shared_ptr<sc_object>> signals;
+    vector<shared_ptr<sc_object>> modules;
+
+    SubcircuitInstance(sc_module_name name)
+    : spx_module(name)
+    {}
+
+    ~SubcircuitInstance()
+    {}
+};
\ No newline at end of file
diff --git a/src/devices/time_monitor.cpp b/src/devices/time_monitor.cpp
new file mode 100644
index 0000000..0c4ab91
--- /dev/null
+++ b/src/devices/time_monitor.cpp
@@ -0,0 +1,152 @@
+
+#include "time_monitor.h"
+#include "optical_output_port.h"
+#include "specs.h"
+#include "sysc_utils.h"
+#include <vector>
+#include <set>
+
+using namespace std;
+
+string vec2str(const vector<bool> &v)
+{
+    string str;
+    for (const auto &x : v)
+        if (x)
+            str += "1|";
+        else
+            str += "0|";
+
+    return str;
+}
+
+void TimeMonitor::on_trigger() {
+    auto first = system_clock::now();
+    auto last = first;
+
+    set<OpticalOutputPort *> oops = sc_get_all_module_by_type<OpticalOutputPort>();
+    sc_time delay = sc_time(m_poll_period, SC_SEC);
+
+    //wait(1, SC_PS);
+    while (true) {
+        // Wait for next polling event
+        if (!sc_pending_activity())
+        {
+            // cout << "a" << endl;
+            wait();
+        }
+        else if (sc_pending_activity_at_current_time() && delay.value() != 0)
+        {
+            // cout << "b" << endl;
+            wait(delay);
+        }
+        else if (sc_pending_activity_at_current_time() && delay.value() == 0)
+        {
+            //cout << "c" << endl;
+            wait(delay);
+        }
+        else if (sc_pending_activity_at_future_time() && delay.value() != 0)
+        {
+            // cout << "d" << endl;
+            wait(delay);
+        }
+        else if (sc_pending_activity_at_future_time() && delay.value() == 0)
+        {
+            // cout << "e" << endl;
+            wait(sc_time_to_pending_activity());
+        }
+        else
+            cerr << "How did you get here ?" << endl;
+
+
+        // Get current wall clock
+        auto now = system_clock::now();
+        std::chrono::duration<double> elapsed_seconds = now - last;
+
+        // Report if it's time to do it
+        if (elapsed_seconds.count() >= m_wallclock_period)
+        {
+            #if 0
+            double error_sum = 0;
+            double max_error = 0;
+            double emitted_power_sum = 0;
+            double max_emitted_power = 0;
+            string max_error_name;
+            complex<double> culprit_emitted;
+            double culprit_emitted_pow = 0.0;
+            complex<double> culprit_wanted;
+            vector<bool> is_empty(oops.size(), false);
+            int i = 0;
+            int max_i = 0;
+            for (const auto &oop : oops)
+            {
+                is_empty[i] = oop->isempty();
+                error_sum += oop->current_err_fd();
+                max_error = max(max_error, oop->current_err_fd());
+                if (max_error == oop->current_err_fd())
+                // if (strcmp(oop->name(), "crow.dc_0.out1_delayed_writer") == 0)
+                {
+                    max_error_name = oop->name();
+                    // deprecated following lines on 05/04:
+                    // culprit_emitted = oop->m_emitted_val_fd;
+                    // culprit_emitted_pow = oop->m_emitted_val_fd.power();
+                    culprit_wanted = oop->m_cur_val_fd;
+                    max_i = i;
+                }
+                // deprecated following lines on 05/04:
+                // emitted_power_sum += oop->m_emitted_val_fd.power();
+                // max_emitted_power = max(max_emitted_power, oop->m_emitted_val_fd.power());
+                i++;
+            }
+            #endif
+
+            std::chrono::duration<double> elapsed_seconds_since_start = now - first;
+            last = now;
+            auto t = sc_time_stamp().to_seconds();
+            cout << "---------------------------------------------------------------------------" << endl;
+            cerr << "Time monitor incompatible with new multi-wavelength features" << endl;
+            exit(1);
+            cout << "Current simulation time (after "<< (int)(elapsed_seconds_since_start.count()) <<"s): " << endl
+            << "\tIn NS: " << t*1e9 << endl
+            << "\tIn PS: " << t*1e12 << endl
+            << "\tDelta-cycles at current time: " << sc_delta_count_at_current_time() << endl
+            //<< "\tCumulated error in ports: " << error_sum << endl
+            //<< "\tIsempty: " << vec2str(is_empty) << endl
+            //<< "\tCulprit: " << max_error_name << endl
+            //<< "\tCulprit i: " << max_i << endl
+            //<< setprecision(12)
+            //<< "\tWanted:  " << norm(culprit_wanted) << "W " << arg(culprit_wanted) << "rad" << endl
+            //<< "\tEmitted: " << norm(culprit_emitted) << "W " << arg(culprit_emitted) << "rad" << endl
+            //<< "\tDiff:    " << abs(norm(culprit_emitted) - norm(culprit_wanted)) << "W " << abs(arg(culprit_emitted) - arg(culprit_wanted)) << "rad" << endl
+            //<< "\tMax error in ports: " << max_error << endl
+            //<< "\tCumulated power output of all ports: " << emitted_power_sum << endl
+            //<< "\tMax port power output: " << max_emitted_power << endl
+            << "\tSimulation speed (NS/s): " << t*1e9 / elapsed_seconds_since_start.count() << endl;
+
+            // if (max_error < specsGlobalConfig.oop_configs[0]->m_abs_tol_power)
+            if (false)
+            {
+                // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                // DOES NOT WORK IF CODE IS COMPILED WITH -O3 ???
+                // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                specsGlobalConfig.drop_all_events = true;
+                wait(SC_ZERO_TIME);
+                while (true) {
+                    volatile bool isempty = true;
+                    for (const auto &oop : oops) {
+                        isempty &= oop->isempty();
+                        if (oop->isempty())
+                        {
+                            cout << oop->name() << " didnt empty its queue" << endl;
+                        }
+                    }
+                    if (isempty)
+                        break;
+                    wait(SC_ZERO_TIME);
+                }
+                specsGlobalConfig.drop_all_events = false;
+                wait(sc_time::from_value(1));
+            }
+        }
+    }
+}
diff --git a/src/devices/time_monitor.h b/src/devices/time_monitor.h
new file mode 100644
index 0000000..62d5626
--- /dev/null
+++ b/src/devices/time_monitor.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <systemc.h>
+#include <chrono>
+#include <iostream>
+
+using std::chrono::system_clock;
+using std::shared_ptr;
+using std::make_shared;
+
+class TimeMonitor : public sc_module {
+public:
+    double m_poll_period; // in seconds
+    double m_wallclock_period; // in seconds
+
+    void on_trigger();
+
+    TimeMonitor(sc_module_name name, double poll_period=100e-12, double wallclock_period = 2)
+        : sc_module(name),
+        m_poll_period(poll_period),
+        m_wallclock_period(wallclock_period)
+    {
+        SC_HAS_PROCESS(TimeMonitor);
+        SC_THREAD(on_trigger);
+    }
+};
diff --git a/src/devices/value_list_source.cpp b/src/devices/value_list_source.cpp
new file mode 100644
index 0000000..a10c1a1
--- /dev/null
+++ b/src/devices/value_list_source.cpp
@@ -0,0 +1,69 @@
+#include "specs.h"
+#include "value_list_source.h"
+
+using std::cout;
+using std::cerr;
+using std::endl;
+
+void VLSource::runner()
+{
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "value list (" << m_values_queue.size() << " values)";
+        if (false)
+        {
+            cout << ":" << endl;
+            for (const auto& val : m_values_queue)
+                cout << "\t" << "@" << sc_time(val.first, SC_SEC) << ": " << val.second << endl;
+        }
+        cout << endl;
+        cout << "--> " <<
+            (dynamic_cast<spx::oa_signal_type *>(p_out.get_interface()))->name() << endl;
+        cout << endl;
+    }
+
+    // Wait for enable signal
+    if (! enable.read().to_bool())
+    {
+        // cout << name() << " waiting for enable" << endl;
+        wait(enable.posedge_event());
+        cout << name() << " was enabled" << endl;
+    }
+
+    // Emitting 0 at enable (will only go through if there is no value at t=0)
+    if (m_values_queue.cbegin() == m_values_queue.cend()
+        || sc_time(m_values_queue.front().first, SC_SEC).value() > 0)
+    {
+        cout << "@" << sc_time_stamp() << ", " << name() << " emitted: " << spx::oa_value_type(0) << endl;
+        m_out_writer.delayedWrite(spx::oa_value_type(0), SC_ZERO_TIME);
+    }
+
+    auto it = m_values_queue.cbegin();
+    while (it != m_values_queue.cend())
+    {
+        sc_time now = sc_time_stamp();
+        sc_time next_emit;
+        if (sc_time(it->first, SC_SEC) < now)
+        {
+            cout << name() << ": invalid time for signal emission !" << endl;
+            ++it;
+            continue;
+        }
+        sc_time delay = sc_time(it->first, SC_SEC) - now;
+
+        // Wait until next output time
+        wait(delay);
+
+        auto s = it->second;
+
+        // Write value to output
+        m_out_writer.delayedWrite(s, SC_ZERO_TIME);
+        cout << "@" << sc_time_stamp() << ", " << name() << " emitted: " << s << endl;
+
+        ++it;
+    }
+
+    // cout << name() << " completed" << endl;
+    while(true) { wait(); }
+}
diff --git a/src/devices/value_list_source.h b/src/devices/value_list_source.h
new file mode 100644
index 0000000..a7ddb6e
--- /dev/null
+++ b/src/devices/value_list_source.h
@@ -0,0 +1,140 @@
+#pragma once
+
+#include <systemc.h>
+#include <fstream>
+#include <algorithm>
+#include <vector>
+#include <utility>
+
+#include "strutils.h"
+#include "optical_output_port.h"
+#include "optical_signal.h"
+#include "specs.h"
+#include "spx_module.h"
+
+using std::vector;
+using std::pair;
+
+class VLSource : public spx_module {
+public:
+    typedef pair<double, spx::oa_value_type> time_value_pair_type;
+    // Ports
+    spx::oa_port_out_type p_out;
+
+    // Timed ports writers
+    OpticalOutputPort m_out_writer;
+
+    // Signal to emit
+    vector<time_value_pair_type> m_values_queue;
+
+    // Source emission control
+    spx::ed_signal_type enable;
+
+    // Processes
+    void runner();
+
+    VLSource(sc_module_name name, const vector<time_value_pair_type> &values = {})
+    : spx_module(name)
+    , m_out_writer((string(this->name()) + "_out_writer").c_str(), p_out)
+    , m_values_queue(values)
+    {
+        sortValues();
+        enable = sc_logic(0);
+
+        SC_HAS_PROCESS(VLSource);
+        SC_THREAD(runner);
+    }
+
+    void setValues(const vector<time_value_pair_type> &values)
+    {
+        m_values_queue = values;
+        sortValues();
+    }
+
+    void setValues(const string &filename)
+    {
+        std::ifstream file(filename);
+
+        if (!file.is_open()) {
+            cerr << "Error: Cannot open the file." << endl;
+            exit(1);
+        }
+
+        string line;
+
+        getline(file, line);
+
+        int lineNumber = 0;
+        while (getline(file, line)) {
+            ++lineNumber;
+            istringstream s(line);
+            string field;
+
+            double t, P, WL;
+
+            // Skip if line is empty or starts with ;
+            if (line.empty())
+            {
+                cout << "Skipping empty line." << endl;
+                continue;
+            }
+            // Skip if line starts with ;
+            if (line[0] == ';')
+            {
+                cout << "Skipping commented line: " << line << endl;
+                continue;
+            }
+
+            // Read first field (time)
+            getline(s, field, ',');
+            strutils::trim(field);
+
+            // Skip header line if it exists
+            if(lineNumber == 1 && field == "time")
+            {
+                cout << "Skipping header line: " << line << endl;
+                continue;
+            }
+
+            try {
+                t = stod(field);
+            } catch (std::invalid_argument const& ex) {
+                cerr << "Invalid value for time: \"" << field << "\"" << endl;
+                exit(1);
+            }
+
+            // Read second field (P)
+            getline(s, field, ',');
+            try {
+                P = stod(field);
+            } catch (std::invalid_argument const& ex) {
+                cerr << "Invalid value for power: \"" << field << "\"" << endl;
+                exit(1);
+            }
+
+            // Read wavelength (WL)
+            std::getline(s, field);
+            try {
+                WL = stod(field);
+            } catch (std::invalid_argument const& ex) {
+                cerr << "Invalid value for wavelength: \"" << field << "\"" << endl;
+                exit(1);
+            }
+
+            cout << t << ": " << P << "W @" << WL*1e9 << "nm" << endl;
+            m_values_queue.emplace_back(t, OpticalSignal(sqrt(P), WL));
+        }
+
+        file.close();
+        sortValues();
+    }
+
+    void sortValues()
+    {
+        auto cmp = [](const time_value_pair_type& p1, const time_value_pair_type& p2) {
+            return p1.first < p2.first;
+        };
+        // Stable sort will keep initial ordering for values with identical time
+        std::stable_sort(m_values_queue.begin(), m_values_queue.end(), cmp);
+    }
+};
diff --git a/src/devices/waveguide.cpp b/src/devices/waveguide.cpp
new file mode 100644
index 0000000..dc20ec7
--- /dev/null
+++ b/src/devices/waveguide.cpp
@@ -0,0 +1,280 @@
+#include "specs.h"
+#include <waveguide.h>
+
+using namespace std;
+
+void WaveguideUni::on_port_in_changed()
+{
+    const double c = 299792458.0;
+
+    // attenuation in dB
+    m_attenuation_dB = m_attenuation_dB_cm * m_length_cm;
+
+    // transmission in field: 10^(-dB/20)
+    const double transmission = pow(10.0, - m_attenuation_dB / 20.0);
+
+    // vg = c/ng
+    // => delay = L / vg = (L * ng) / c
+    const double group_delay_ns = 1e9 * m_length_cm * 1e-2 / (c / m_ng);
+
+    // precalculate 2 * pi * L
+    double phase_delay_factor = 2.0 * M_PI * m_length_cm * 1e-2;
+
+    // ng = neff - lambda * dneff/dlambda
+    // => dneff/dlambda = (neff - ng)/lambda
+    double dneff_dlambda = (m_neff - m_ng) / 1.55e-6;
+
+    // Parameters relative to dispersion
+    double d2neff_dlambda2_over_2 = -1 * c * m_D / (2 * 1.55e-6);
+    double dng_dlambda = c*m_D;
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "length = " << m_length_cm/100 << " m" << endl;
+        cout << "neff = " << m_neff << "" << endl;
+        cout << "ng = " << m_ng << "" << endl;
+        cout << "transmission_power = " << pow(transmission, 2) << " W/W" << endl;
+        cout << "group delay = " << group_delay_ns << " ns" << endl;
+        // cout << "dneff/dlambda = " << dneff_dlambda*1e-6 << " um^-1" << endl;
+        cout << "phase delay = " << 1e9 * m_length_cm * 1e-2 / (c / m_neff) << " ns";
+        cout << " ("
+                << fmod((2 * M_PI * m_neff / 1.55e-6) * m_length_cm * 1e-2, 2 * M_PI)
+                << "rad @1.55)" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_in.get_interface()))->name();
+        cout << " --> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p_out.get_interface()))->name();
+        cout << endl;
+        cout << endl;
+    }
+
+    if(m_D == 0)
+    {
+        while (true) {
+            // Wait for a new input signal
+            wait();
+            // Read the input signal
+            auto s = p_in->read();
+
+            // calculate phase-delay
+            const double neff = m_neff + dneff_dlambda * (s.getWavelength() - 1.55e-6);
+
+            const double phase_delay = phase_delay_factor * neff / s.getWavelength();
+
+            // Apply transmission function
+            const OpticalSignal::field_type S12 = polar(transmission, phase_delay);
+            s *= S12;
+
+            // Get new ID for output event
+            s.getNewId();
+
+            // Write to ouput port after group delay
+            m_out_writer.delayedWrite(s, sc_time(group_delay_ns, SC_NS));
+        }
+    }
+    else // dispersion has a defined value
+    {
+        while (true) {
+            // Wait for a new input signal
+            wait();
+            // Read the input signal
+            auto s = p_in->read();
+
+            // calculate phase-delay
+            const double neff = m_neff + dneff_dlambda * (s.getWavelength() - 1.55e-6)
+                                 + d2neff_dlambda2_over_2 * pow(s.getWavelength() - 1.55e-6, 2);
+            const double ng = m_ng + dng_dlambda * (s.getWavelength() - 1.55e-6);
+
+            const double phase_delay_disp = phase_delay_factor * neff / s.getWavelength();
+            const double group_delay_ns_disp = 1e9 * m_length_cm * 1e-2 / (c / ng);
+            // Apply transmission function
+            const OpticalSignal::field_type S12 = polar(transmission, phase_delay_disp);
+            s *= S12;
+
+            // Get new ID for output event
+            s.getNewId();
+
+            // Write to ouput port after group delay
+            m_out_writer.delayedWrite(s, sc_time(group_delay_ns_disp, SC_NS));
+        }
+    }
+}
+
+
+void WaveguideBi::on_p0_in_changed()
+{
+    const double c = 299792458.0;
+
+    // attenuation in dB
+    m_attenuation_dB = m_attenuation_dB_cm * m_length_cm;
+
+    // transmission in field: 10^(-dB/20)
+    const double transmission = pow(10.0, - m_attenuation_dB / 20.0);
+
+    // vg = c/ng
+    // => delay = L / vg = (L * ng) / c
+    const double group_delay_ns = 1e9 * m_length_cm * 1e-2 / (c / m_ng);
+
+    // precalculate 2 * pi * L
+    double phase_delay_factor = 2.0 * M_PI * m_length_cm * 1e-2;
+
+    // ng = neff - lambda * dneff/dlambda
+    // => dneff/dlambda = (neff - ng)/lambda
+    double dneff_dlambda = (m_neff - m_ng) / 1.55e-6;
+
+    // Parameters relative to dispersion
+    double d2neff_dlambda2_over_2 = -1 * c * m_D / (2 * 1.55e-6);
+    double dng_dlambda = c*m_D;
+
+    if (specsGlobalConfig.verbose_component_initialization)
+    {
+        cout << name() << ":" << endl;
+        cout << "length = " << m_length_cm/100 << " m" << endl;
+        cout << "neff = " << m_neff << "" << endl;
+        cout << "ng = " << m_ng << "" << endl;
+        cout << "transmission_power = " << pow(transmission, 2) << " W/W" << endl;
+        cout << "group delay = " << group_delay_ns << " ns" << endl;
+        // cout << "dneff/dlambda = " << dneff_dlambda*1e-6 << " um^-1" << endl;
+        cout << "phase delay = " << 1e9 * m_length_cm * 1e-2 / (c / m_neff) << " ns";
+        cout << " ("
+                << fmod((2 * M_PI * m_neff / 1.55e-6) * m_length_cm * 1e-2, 2 * M_PI)
+                << "rad @1.55)" << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_in.get_interface()))->name();
+        cout << " --> ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_out.get_interface()))->name();
+        cout << endl;
+        cout << (dynamic_cast<spx::oa_signal_type *>(p0_out.get_interface()))->name();
+        cout << " <-- ";
+        cout << (dynamic_cast<spx::oa_signal_type *>(p1_in.get_interface()))->name();
+        cout << endl;
+        cout << endl;
+    }
+
+    if(m_D == 0)
+    {
+        while (true) {
+            // Wait for a new input signal
+            wait();
+            // Read the input signal
+            auto s = p0_in->read();
+
+            // calculate phase-delay
+            const double neff = m_neff + dneff_dlambda * (s.getWavelength() - 1.55e-6);
+
+            const double phase_delay = phase_delay_factor * neff / s.getWavelength();
+
+            // Apply transmission function
+            const OpticalSignal::field_type S12 = polar(transmission, phase_delay);
+            s *= S12;
+
+            // Get new ID for output event
+            s.getNewId();
+
+            // Write to ouput port after group delay
+            m_p1_out_writer.delayedWrite(s, sc_time(group_delay_ns, SC_NS));
+        }
+    }
+    else // dispersion has a defined value
+    {
+        while (true) {
+            // Wait for a new input signal
+            wait();
+            // Read the input signal
+            auto s = p0_in->read();
+
+            // calculate phase-delay
+            const double neff = m_neff + dneff_dlambda * (s.getWavelength() - 1.55e-6)
+                                 + d2neff_dlambda2_over_2 * pow(s.getWavelength() - 1.55e-6, 2);
+            const double ng = m_ng + dng_dlambda * (s.getWavelength() - 1.55e-6);
+
+            const double phase_delay_disp = phase_delay_factor * neff / s.getWavelength();
+            const double group_delay_ns_disp = 1e9 * m_length_cm * 1e-2 / (c / ng);
+            // Apply transmission function
+            const OpticalSignal::field_type S12 = polar(transmission, phase_delay_disp);
+            s *= S12;
+
+            // Get new ID for output event
+            s.getNewId();
+
+            // Write to ouput port after group delay
+            m_p1_out_writer.delayedWrite(s, sc_time(group_delay_ns_disp, SC_NS));
+        }
+    }
+}
+
+void WaveguideBi::on_p1_in_changed()
+{
+    const double c = 299792458.0;
+
+    // attenuation in dB
+    m_attenuation_dB = m_attenuation_dB_cm * m_length_cm;
+
+    // transmission in field: 10^(-dB/20)
+    const double transmission = pow(10.0, - m_attenuation_dB / 20.0);
+
+    // vg = c/ng
+    // => delay = L / vg = (L * ng) / c
+    const double group_delay_ns = 1e9 * m_length_cm * 1e-2 / (c / m_ng);
+
+    // precalculate 2 * pi * L
+    double phase_delay_factor = 2.0 * M_PI * m_length_cm * 1e-2;
+
+    // ng = neff - lambda * dneff/dlambda
+    // => dneff/dlambda = (neff - ng)/lambda
+    double dneff_dlambda = (m_neff - m_ng) / 1.55e-6;
+
+    // Parameters relative to dispersion
+    double d2neff_dlambda2_over_2 = -1 * c * m_D / (2 * 1.55e-6);
+    double dng_dlambda = c*m_D;
+
+    if(m_D == 0)
+    {
+        while (true) {
+            // Wait for a new input signal
+            wait();
+            // Read the input signal
+            auto s = p1_in->read();
+
+            // calculate phase-delay
+            const double neff = m_neff + dneff_dlambda * (s.getWavelength() - 1.55e-6);
+
+            const double phase_delay = phase_delay_factor * neff / s.getWavelength();
+
+            // Apply transmission function
+            const OpticalSignal::field_type S12 = polar(transmission, phase_delay);
+            s *= S12;
+
+            // Get new ID for output event
+            s.getNewId();
+
+            // Write to ouput port after group delay
+            m_p0_out_writer.delayedWrite(s, sc_time(group_delay_ns, SC_NS));
+        }
+    }
+    else // dispersion has a defined value
+    {
+        while (true) {
+            // Wait for a new input signal
+            wait();
+            // Read the input signal
+            auto s = p1_in->read();
+
+            // calculate phase-delay
+            const double neff = m_neff + dneff_dlambda * (s.getWavelength() - 1.55e-6)
+                                 + d2neff_dlambda2_over_2 * pow(s.getWavelength() - 1.55e-6, 2);
+            const double ng = m_ng + dng_dlambda * (s.getWavelength() - 1.55e-6);
+
+            const double phase_delay_disp = phase_delay_factor * neff / s.getWavelength();
+            const double group_delay_ns_disp = 1e9 * m_length_cm * 1e-2 / (c / ng);
+            // Apply transmission function
+            const OpticalSignal::field_type S12 = polar(transmission, phase_delay_disp);
+            s *= S12;
+
+            // Get new ID for output event
+            s.getNewId();
+
+            // Write to ouput port after group delay
+            m_p0_out_writer.delayedWrite(s, sc_time(group_delay_ns_disp, SC_NS));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/devices/waveguide.h b/src/devices/waveguide.h
new file mode 100644
index 0000000..c686bba
--- /dev/null
+++ b/src/devices/waveguide.h
@@ -0,0 +1,154 @@
+#pragma once
+
+#include <systemc.h>
+
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include "specs.h"
+#include "spx_module.h"
+
+/** The base class for the waveguide module */
+class WaveguideBase : public spx_module {
+public:
+    // Member variables
+
+    /** The length of the waveguide in cm. */
+    double m_length_cm;
+    /** The attenuation of the waveguide in dB. */
+    double m_attenuation_dB;
+    /** The attenuation inside the waveguide, in dB/cm */
+    double m_attenuation_dB_cm;
+
+    /** The effective index of the waveguide */
+    double m_neff;
+    /** The group index of the waveguide */
+    double m_ng;
+    /** The group velocity dispersion Dlambda of the waveguide in [s/m/m] */
+    double m_D;
+
+    /** Constructor for WaveguideBase
+     *
+     * @param name name of the module
+     * @param length_cm length of the waveguide in cm
+     * */
+    WaveguideBase(sc_module_name name, double length_cm = 1e-2,
+            double attenuation_dB_cm = 0, double neff = 2.2111,
+            double ng = 2.2637, double D = 0)
+        : spx_module(name)
+        , m_length_cm(length_cm)
+        , m_attenuation_dB_cm(attenuation_dB_cm)
+        , m_neff(neff)
+        , m_ng(ng)
+        , m_D(D)
+    {
+        // nothing to do
+    }
+
+    inline void setLength(double length_cm) {
+        if (length_cm < 0) {
+            std::cerr << "Error: waveguide length < 0" << std::endl;
+        }
+        m_length_cm = length_cm;
+    }
+};
+
+
+/** A unidirectional waveguide module */
+class WaveguideUni : public WaveguideBase {
+public:
+    // Ports
+    /** The optical input port. */
+    spx::oa_port_in_type p_in;
+    /** The optical output port. */
+    spx::oa_port_out_type p_out;
+
+    // Timed ports writers
+    /** Timed writer to the output port.
+     *
+     * @sa DelayedWriter
+     * */
+    OpticalOutputPort m_out_writer;
+
+    // Processes
+    /** Main process of the module.
+     *
+     * It copies the input to the output, after attenuation and delay.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** p_in
+     * */
+    void on_port_in_changed();
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * @param length_cm length of the waveguide in cm
+     * */
+    WaveguideUni(sc_module_name name, double length_cm = 1e-2,
+            double attenuation_dB_cm = 0, double neff = 2.2111,
+            double ng = 2.2637, double D = 0)
+        : WaveguideBase(name, length_cm, attenuation_dB_cm, neff, ng, D)
+        , m_out_writer("out_delayed_writer", p_out)
+    {
+        SC_HAS_PROCESS(WaveguideUni);
+
+        SC_THREAD(on_port_in_changed);
+        sensitive << p_in;
+    }
+};
+
+typedef WaveguideUni Waveguide;
+
+/** A bidirectional waveguide module */
+class WaveguideBi : public WaveguideBase {
+public:
+    // Ports
+    /** The optical input ports. */
+    spx::oa_port_in_type p0_in;
+    spx::oa_port_in_type p1_in;
+
+    /** The optical output ports. */
+    spx::oa_port_out_type p0_out;
+    spx::oa_port_out_type p1_out;
+
+    // Timed ports writers
+    /** Timed writer to the output port.
+     *
+     * @sa DelayedWriter
+     * */
+    OpticalOutputPort m_p0_out_writer;
+    OpticalOutputPort m_p1_out_writer;
+
+    // Processes
+    /** Main process of the module.
+     *
+     * It copies the input to the output, after attenuation and delay.
+     *
+     *   **SystemC type:** thread
+     *
+     *   **Sensitivity list:** p0_in or p1_in
+     * */
+    void on_p0_in_changed();
+    void on_p1_in_changed();
+
+    /** Constructor for Waveguide
+     *
+     * @param name name of the module
+     * @param length_cm length of the waveguide in cm
+     * */
+    WaveguideBi(sc_module_name name, double length_cm = 1e-2,
+            double attenuation_dB_cm = 0, double neff = 2.2111,
+            double ng = 2.2637, double D = 0)
+        : WaveguideBase(name, length_cm, attenuation_dB_cm, neff, ng, D)
+        , m_p0_out_writer("p0_out_delayed_writer", p0_out)
+        , m_p1_out_writer("p1_out_delayed_writer", p1_out)
+    {
+        SC_HAS_PROCESS(WaveguideBi);
+
+        SC_THREAD(on_p0_in_changed);
+        sensitive << p0_in;
+        SC_THREAD(on_p1_in_changed);
+        sensitive << p1_in;
+    }
+};
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..2dc9e93
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,325 @@
+#include <ctime>
+#include <iomanip>
+#include <sstream>
+#include <chrono>
+
+#include <optical_signal.h>
+#include <time_monitor.h>
+#include <tb/alltestbenches.h>
+#include <utils/strutils.h>
+
+#include <systemc.h>
+
+#include <args.hxx>
+
+#include <specs.h>
+#include "optical_output_port.h"
+#include "parser/parse_tree.h"
+
+class OpticalOutputPort;
+
+using namespace std;
+using namespace std::chrono;
+using namespace literals;
+
+#include "../build/parser/parser.tab.h"
+#include "../build/parser/parser.yy.h"
+extern int yydebug;
+
+int do_list_tests()
+{
+    cout << "Valid testbench identifiers:" << endl;
+    if (tb_map.empty())
+        cout << "\t # No test available #" << endl;
+    for (const auto &test_pair : tb_map) {
+        cout << "\t" << test_pair.first << endl;
+    }
+    return 0;
+}
+
+int do_test(const string &testname)
+{
+    // Try to find the test specified by testname from the tb_mab
+    auto it = tb_map.find(testname);
+    if (it == tb_map.end()) {
+        // Not found
+        cerr << "Test not found: " << testname << endl;
+        return 1;
+    }
+
+    // Call the testbench function associated with testname
+    auto start = high_resolution_clock::now();
+    it->second();
+    auto stop = high_resolution_clock::now();
+    auto duration = duration_cast<microseconds>(stop - start);
+    std::cout << "Total runtime: " << duration.count()/1000.0 << " ms" << std::endl;
+    return 0;
+}
+
+int do_circuit(const string &filename, bool is_dry_run = false, const string& json_filename = "")
+{
+    // Check whether the file exists
+    FILE *f;
+    if (filename == "-"s) {
+        f = NULL;
+    } else if (!(f = fopen(filename.c_str(), "r"))) {
+        cerr << "Error: File not found \"" << filename << "\"" << endl;
+        return 1;
+    }
+
+    cout << "╔═══════════════════╗" << endl;
+    cout << "║  PARSING CIRCUIT  ║" << endl;
+    cout << "╚═══════════════════╝" << endl;
+
+    yyscan_t scanner;
+    YY_BUFFER_STATE buf;
+
+    yylex_init(&scanner);
+    buf = yy_create_buffer(f, YY_BUF_SIZE, scanner);
+    yy_switch_to_buffer(buf, scanner);
+
+    ParseTree pt("ROOT");
+    int parsing_result = yyparse(scanner, &pt);
+
+    //yy_delete_buffer(buf, scanner);
+    yylex_destroy(scanner);
+
+    // Close the file
+    if (f)
+        fclose(f);
+
+    // Return if unsuccessful
+    if (parsing_result != 0) {
+        return parsing_result;
+    }
+
+    pt.print();
+
+    cout << "╔══════════════════════╗" << endl;
+    cout << "║   BUILDING CIRCUIT   ║" << endl;
+    cout << "╚══════════════════════╝" << endl;
+
+    pt.build_circuit();
+
+    if (!json_filename.empty())
+    {
+        ofstream outfile;
+        outfile.open(json_filename, ios::out | ios::trunc);
+        outfile << pt.to_json();
+        outfile.close();
+        cout << "Exported flattened circuit as JSON > " << json_filename << endl;
+    }
+
+    if (!is_dry_run)
+    {
+        cout << "╔══════════════════════╗" << endl;
+        cout << "║      SIMULATION      ║" << endl;
+        cout << "╚══════════════════════╝" << endl;
+
+        specsGlobalConfig.runAnalysis();
+    }
+    else
+    {
+        cout << "╔══════════════════════╗" << endl;
+        cout << "║  SIMULATION SKIPPED  ║" << endl;
+        cout << "╚══════════════════════╝" << endl;
+    }
+
+    cout << "╔═══════════════════╗" << endl;
+    cout << "║        DONE       ║" << endl;
+    cout << "╚═══════════════════╝" << endl;
+
+    return 0;
+}
+
+int raphael_main() { cout<< "Hello world" << endl; return 0; }
+
+int tests_module_registry_access();
+
+int sc_main(int argc, char *argv[])
+{
+    // Define command line interface using args
+    args::ArgumentParser parser("The Scalable Photonic Event-driven Circuit Simulator.", "");
+    args::ValueFlag<string> file(
+        parser, "circuit", "Simulate from circuit file", { 'f', "file" });
+    args::ValueFlag<int> set_timescale(parser,
+                          "set_timescale",
+                          "Set the engine timescale (as log10(timestep/1s))"
+                          "(0: seconds, -3: ms, -6:µs, ..., -15: fs)",
+                          { 'R', "resolution" });
+    args::ValueFlag<string> set_simulator_mode(parser,
+                          "set_simulator_mode",
+                          "Set simulator mode. Possible values:\n"
+                          " - time-domain, event-driven, td (default)\n"
+                          " - sampled-time\n"
+                          " - frequency-domain, fd",
+                          { 'm', "mode"});
+    args::Flag run_manual_test(parser,
+                          "run_manual_test",
+                          "Run manual test function",
+                          { 'T', "run-manual-test" });
+#if YYDEBUG
+    args::Flag debug_netlist_parser(parser,
+                          "debug_netlist_parser",
+                          "Run with netlist parser debug information",
+                          { "debug-parser" });
+#endif
+    args::ValueFlag<string> set_tracefile(parser,
+                          "set_tracefile",
+                          "Set the default trace file",
+                          { 'o', "output" });
+    args::ValueFlag<string> export_json(parser,
+                          "export_json",
+                          "Export json of completed circuit to file",
+                          { "json" });
+    args::Flag set_dry_run(parser,
+                          "dry_run",
+                          "Do not run simulation directives",
+                          { 'n', "dryrun" });
+    // args::ValueFlag<double> set_reltol(parser,
+    //                       "set_reltol",
+    //                       "Set the value of the rel_tol parameter",
+    //                       { "reltol" });
+    args::ValueFlag<double> set_reltol(parser,
+                          "set_reltol",
+                          "Set the value of the relative tolerance parameter for field",
+                          { "reltol" });
+    args::ValueFlag<double> set_abstol(parser,
+                          "set_abstol",
+                          "Set the value of the absolute tolerance parameter for field",
+                          { "abstol" });
+
+    args::ValueFlag<size_t> set_nrings_crow(parser,
+                          "set_nrings_crow",
+                          "temporary",
+                          { "nrings_crow" });
+
+    args::Flag set_verbose_component_initialization(parser,
+                          "set_verbose_component_initialization",
+                          "Print components detail before starting simulation",
+                          { "vci", "verbose_ci" });
+
+    args::Flag list_tests(parser,
+                          "list_tests",
+                          "List available testbenches",
+                          { 'p', "list-testbenches" });
+    args::Flag add_time_monitor(parser,
+                          "add_time_monitor",
+                          "Monitor simulation status",
+                          { "mon" });
+    args::ValueFlag<string> test(
+        parser,
+        "test_name",
+        "Run the specified testbench (use -p to list available testbenches)",
+        { 't', "testbench" });
+    args::HelpFlag help(parser, "help", "Display this help menu", { 'h', "help" });
+    args::CompletionFlag completion(parser, { "complete" });
+    try {
+        parser.ParseCLI(argc, argv);
+    } catch (const args::Completion &e) {
+        cout << e.what();
+        return 0;
+    } catch (const args::Help &) {
+        cout << parser;
+        return 0;
+    } catch (const args::ParseError &e) {
+        cerr << e.what() << endl;
+        cerr << parser;
+        return 1;
+    } catch (const args::ValidationError &e) {
+        cerr << e.what() << endl;
+        cerr << parser;
+        return 1;
+    }
+
+    if (set_simulator_mode) {
+        const string &s = set_simulator_mode.Get();
+        if (strutils::iequals(s, "event-driven") || strutils::iequals(s, "time-domain") || strutils::iequals(s, "td"))
+        {
+            cout << "Optical ports working in event-driven mode by default" << endl;
+            specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+        }
+        else if (strutils::iequals(s, "sampled-time"))
+        {
+            cout << "Optical ports working in sampled-time mode by default" << endl;
+            specsGlobalConfig.simulation_mode = OpticalOutputPortMode::SAMPLED_TIME;
+        }
+        else if (strutils::iequals(s, "frequency-domain") || strutils::iequals(s, "fd"))
+        {
+            cout << "Simulation mode set to frequency domain" << endl;
+            specsGlobalConfig.simulation_mode = OpticalOutputPortMode::FREQUENCY_DOMAIN;
+        }
+        else
+        {
+            cerr << "Unknown mode: '" << s << "'" << endl;
+            return 1;
+        }
+    }
+    if (set_reltol) {
+        if (set_reltol.Get() > 0) {
+            specsGlobalConfig.default_reltol = set_reltol.Get();
+        } else {
+            cerr << "Invalid abs_tol_phase value" << endl;
+            return 1;
+        }
+    }
+    if (set_abstol) {
+        if (set_abstol.Get() > 0) {
+            specsGlobalConfig.default_abstol = set_abstol.Get();
+        } else {
+            cerr << "Invalid abs_tol_power value" << endl;
+            return 1;
+        }
+    }
+    if (set_verbose_component_initialization) {
+        specsGlobalConfig.verbose_component_initialization = set_verbose_component_initialization.Get();
+    }
+    if (set_nrings_crow) {
+        #if BUILD_TB == 1
+        //nrings_crow = set_nrings_crow.Get();
+        #endif
+    }
+    if (set_timescale) {
+        cout << set_timescale.Get() << endl;
+        specsGlobalConfig.engine_timescale = SPECSConfig::EngineTimescale(set_timescale.Get());
+    }
+    if (run_manual_test) {
+        return 0;
+    }
+#if YYDEBUG
+    if (debug_netlist_parser) {
+        yydebug = 1;
+    }
+#endif
+    if (list_tests) {
+        return do_list_tests();
+    }
+    if (set_tracefile) {
+        cout << "Using trace file: " << set_tracefile.Get() << endl;
+        // TODO: validate filename
+        specsGlobalConfig.trace_filename = set_tracefile.Get();
+    }
+
+    shared_ptr<TimeMonitor> tm;
+    if (add_time_monitor) {
+        if (specsGlobalConfig.simulation_mode == OpticalOutputPortMode::FREQUENCY_DOMAIN)
+            tm = make_shared<TimeMonitor>("TM", 0, 0.5);
+        else
+            tm = make_shared<TimeMonitor>("TM", 1e-14, 0.5);
+    }
+
+    if (file) {
+        return do_circuit(file.Get(), set_dry_run.Get(), export_json.Get());
+    }
+    if (set_dry_run)
+    {
+        return 0;
+    }
+    if (test) {
+        return do_test(test.Get());
+    }
+
+    // Print help if nothing else was done
+    cout << parser;
+    return 1;
+}
diff --git a/src/optical_output_port.cpp b/src/optical_output_port.cpp
new file mode 100644
index 0000000..7a6fe9c
--- /dev/null
+++ b/src/optical_output_port.cpp
@@ -0,0 +1,424 @@
+#include <optical_output_port.h>
+#include <optical_signal.h>
+#include <specs.h>
+
+string oopPortMode2str(OpticalOutputPortMode mode)
+{
+    switch (mode) {
+        case EVENT_DRIVEN:
+            return "Event-driven time-domain";
+        case SAMPLED_TIME:
+            return "Emulated time-driven time-domain";
+        case FREQUENCY_DOMAIN:
+            return "Event-driven frequency-domain";
+        default:
+            return "UNDEFINED";
+    }
+}
+
+OpticalOutputPort::OpticalOutputPort(sc_module_name name, port_type &p)
+    : sc_module(name)
+    , m_port(p)
+    , m_config(nullptr)
+{
+    SC_HAS_PROCESS(OpticalOutputPort);
+
+    // SC_THREAD(on_data_ready);
+    // sensitive << m_event_queue;
+
+    SC_THREAD(on_data_ready);
+    sensitive << m_event_queue;
+
+    // SC_THREAD(on_data_ready_fd);
+    // sensitive << m_event_queue_fd;
+
+    // SC_THREAD(drop_all_events);
+    // sensitive << specsGlobalConfig.drop_all_events;
+}
+
+// void OpticalOutputPort::drop_all_events() {
+//     while(true)
+//     {
+//         wait();
+//         cout << name() << ": dropping all events!" << endl;
+//         while (!isempty())
+//         {
+//             cout << name() << ": dropping all events" << endl;
+//             m_event_queue.cancel_all();
+//             m_queue = queue_type();
+//             m_emitted_val = OpticalSignal(0);
+//             m_queue_td = queue_type();
+//             m_emitted_val = OpticalSignal(0);
+//             m_queue_fd = queue_type();
+//             m_emitted_val = OpticalSignal(0);
+//             m_cur_val = OpticalSignal(0);
+//             wait(SC_ZERO_TIME);
+//         }
+//     }
+// }
+
+inline bool OpticalOutputPort::check_emit_by_abstol(const OpticalSignal::field_type &desired,
+                                                    const OpticalSignal::field_type &last)
+{
+    double vector_distance = abs(desired - last);
+    return vector_distance > m_abstol;
+}
+
+inline bool OpticalOutputPort::check_emit_by_reltol(const OpticalSignal::field_type &desired,
+                                                    const OpticalSignal::field_type &last)
+{
+    double vector_distance = abs(desired - last);
+    double last_size = abs(last);
+    return (vector_distance/last_size) > m_reltol;
+}
+
+void OpticalOutputPort::applyConfig() {
+    if (!m_config)
+    {
+        // Shouldn't ever need to come here if prepareSimulation was called
+        cerr << "Found OpticalOutputPort without configuration. ";
+        cerr << "Did you forget to run prepareSimulation() ?" << endl;
+        exit(1);
+        //m_config = make_shared<OpticalOutputPortConfig>();
+    }
+
+    m_temporal_resolution = sc_time::from_value(m_config->m_timestep_value);
+    m_mode = m_config->m_mode;
+    m_reltol = m_config->m_reltol;
+    m_abstol = m_config->m_abstol;
+}
+
+void OpticalOutputPort::start_of_simulation() {
+    applyConfig();
+}
+
+void OpticalOutputPort::on_data_ready()
+{
+    // Initialize output queue
+    m_queue = queue_type();
+
+    spx::oa_value_type::field_type desired;
+
+    while (true) {
+        // Wait for data ready notification
+        wait();
+
+        // Check if output queue is empty (would be a bug)
+        if (m_queue.size() == 0) {
+            if (specsGlobalConfig.drop_all_events)
+                continue;
+            cerr << "error: write cancelled, because no values are present" << endl;
+            if (true) sc_stop();
+            else      continue;
+        }
+
+        // Get current time
+        sc_time now = sc_time_stamp();
+
+        // Get the next queue item and pop it from the queue
+        auto tuple = m_queue.top();
+        m_queue.pop();
+
+        // If next event is also now, notify event queue
+        // if (m_queue.top().first == now)
+        //     m_event_queue.notify(SC_ZERO_TIME);
+
+        // Assign to more readable names
+        const auto &t = tuple.first; //time
+        const auto &s = tuple.second; //signal
+
+        // Check whether the signal should indeed be emitted now (if not, it's a bug)
+        if (t != now)
+        {
+            cerr << "error: desync in optical output port " << this->name() << endl;
+            cerr << "\t - expected time:" << t.to_seconds() << endl;
+            cerr << "\t - current time:" << now.to_seconds() << endl;
+            cerr << "\t - signal:" << s << endl;
+            if (true) sc_stop();
+            else      continue;
+        }
+
+        // Check signal error to decice whether to emit signal
+        bool emit_signal = false;
+        bool pass_abstol = false;
+        bool pass_reltol = false;
+
+        uint32_t wlid = s.m_wavelength_id;
+
+        //auto &desired = m_desired_fields[wlid];
+        auto &emitted = m_emitted_fields[wlid];
+
+        // Store the desired output value which we know is valid
+        if (m_use_deltas)
+        {
+            desired = m_desired_fields[wlid] + s.m_field;
+            m_desired_fields[wlid] = desired;
+        }
+        else
+            desired = s.m_field;
+
+        // Decide whether to emit signal or not
+        pass_abstol = check_emit_by_abstol(desired, emitted);
+        pass_reltol = check_emit_by_reltol(desired, emitted);
+
+        // Only emits when passes both tests
+        emit_signal = pass_abstol && pass_reltol;
+
+        // Emit zeros instead of signals smaller than a 10 abstol
+        // TODO: check this !!
+        if (emit_signal && (abs(desired) < 10*m_abstol))
+            desired = complex<double>(0,0);
+
+
+        // cout << "emit: " << emit_signal << endl;
+        // Emit the desired output value if its stars are aligned
+        if (emit_signal || m_skip_next_convergence_check || m_skip_convergence_check)
+        {
+            // cout << dynamic_cast<spx::oa_signal_type *>(m_port.get_interface())->name();
+            // cout << " emitting " << m_desired_fields[wlid] << endl;
+            m_skip_next_convergence_check = false;
+
+            // Replace the stored emitted output value at that wavelength
+            emitted = desired;
+
+            // Write the value to the port
+            m_port->write(spx::oa_value_type(desired, wlid));
+        }
+    }
+}
+
+// Should be removed
+void OpticalOutputPort::on_data_ready_fd()
+{
+    cerr << "Using deprecated function: " << __FUNCTION__ << endl;
+    exit(1);
+#if 0
+    // Initialize output queue
+    m_queue_fd = queue_type();
+
+    m_cur_val_fd = OpticalSignal(0);
+    m_emitted_val_fd = OpticalSignal(0);
+
+    // Current error between cur_val and emitted_val
+    double err_abs_power = 0;
+    double err_abs_phase = 0;
+
+    while (true) {
+        // Wait for data ready notification
+        wait();
+
+        // Check if output queue is empty (would be a bug)
+        if (m_queue_fd.size() == 0) {
+            if (specsGlobalConfig.drop_all_events)
+                continue;
+            cerr << "error: write cancelled, because no values are present" << endl;
+            if (true) sc_stop();
+            else      continue;
+        }
+
+        // Get current time
+        sc_time now = sc_time_stamp();
+
+        // Get the next queue item and pop it from the queue
+        auto tuple = m_queue_fd.top();
+        m_queue_fd.pop();
+
+        // Assign to more readable names
+        const auto &t = tuple.first;
+        const auto &s = tuple.second;
+
+        // Check whether the signal should indeed be emitted now (if not, it's a bug)
+        if (t != now)
+        {
+            cerr << "error: desync in optical output port" << endl;
+            cerr << "\t - expected time:" << t.to_seconds() << endl;
+            cerr << "\t - current time:" << now.to_seconds() << endl;
+            if (true) sc_stop();
+            else      continue;
+        }
+
+        // If the new desired signal has NaN wavelength, ignore it
+        if (isnan(s.getWavelength()))
+        {
+            continue;
+        }
+
+        // Check if wavelength is the same as stored signal
+        bool wavelength_nan = isnan(m_emitted_val_fd.getWavelength());
+        bool wavelength_same = s.m_wavelength_id == m_emitted_val_fd.m_wavelength_id;
+        bool wavelength_greater = s.getWavelength() > m_emitted_val_fd.getWavelength();
+        bool wavelength_ok = wavelength_same || wavelength_nan || wavelength_greater;
+
+        // Check signal error to decice whether to emit signal
+        bool emit_signal = false;
+        bool pass_abstol = false;
+        bool pass_reltol = false;
+
+        // If new wavelength should not be emitted, don't do anything and
+        // wait for the next signal
+        if (!wavelength_ok)
+            continue;
+
+        // Here we know s can be emitted. Update the desired output value
+        if (m_use_deltas)
+            m_cur_val_fd += s;
+        else
+            m_cur_val_fd = s;
+
+        // If previous wavelength was NaN or smaller than current wavelength, emit new signal
+        if (wavelength_nan || wavelength_greater)
+        {
+            emit_signal = true;
+        }
+
+        // If same wavelength, decide whether to emit signal or not based on tolerances
+        if (wavelength_same)
+        {
+            pass_abstol = check_emit_by_abstol(m_cur_val_fd, m_emitted_val_fd);
+            pass_reltol = check_emit_by_reltol(m_cur_val_fd, m_emitted_val_fd);
+
+            // Only emits when passes both tests
+            emit_signal = pass_abstol && pass_reltol;
+
+            // Emit zeros instead of signals smaller than 10 abstol
+            if (emit_signal && (abs(m_cur_val_fd.m_field) < 10*m_abstol))
+                m_cur_val_fd.m_field = complex<double>(0,0);
+        }
+
+        // Emit the desired output value if its stars are aligned
+        if (emit_signal)
+        {
+            // Replace the stored emitted output value
+            m_emitted_val_fd = m_cur_val_fd;
+
+            // Write the value to the port
+            m_port->write(m_cur_val_fd);
+        }
+    }
+#endif
+}
+
+sc_time OpticalOutputPort::snap_to_next_valid_time(const sc_time &t, const unsigned int resolution_multiplier)
+{
+    // Squash time to closest timestamp using device temporal resolution and multiplier
+
+    // Find the effective number of ticks/timestep of the output port
+    sc_time::value_type dt_val = m_temporal_resolution.value() * resolution_multiplier;
+
+    // Should be at least one tick
+    if (dt_val <= 1)
+       return t;
+
+    // Snap the time to the closest multiple of dt
+    //auto t_snap_value = dt_val * round((double)t.value() / dt_val);
+    auto t_snap_value = dt_val * ((t.value() + dt_val/2)/ dt_val);
+
+    // If we end up before current time, snap to the next multiple of dt
+    // We do this instead of using ceil() because in the case where the event
+    // is far into the future, it is more accurate to round().
+    if (t_snap_value < sc_time_stamp().value())
+        t_snap_value += dt_val;
+
+    // Return the snaped time value (in number of simulation ticks)
+    return sc_time::from_value(t_snap_value);
+}
+
+void OpticalOutputPort::delayedWriteEventDriven(const OpticalSignal &value, const sc_time &delay, const unsigned int resolution_multiplier)
+{
+    // Calculate the simulation time at which event was requested to be emitted.
+    auto t = sc_time_stamp() + delay;
+    if (t.value() - sc_time_stamp().value() != delay.value())
+        cerr << "Event cannot be correctly described with current timestep" << endl;
+
+    //
+    if (true /*&& resolution_multiplier > 1*/) {
+        // squash time to closest timestamp using device temporal resolution
+        t = snap_to_next_valid_time(t, resolution_multiplier);
+    }
+
+
+    // find first scheduled signal with this timestamp and this lambda
+    auto it = std::find_if(m_queue.begin(), m_queue.end(), [&value,&t](const auto &x) {
+            return t == x.first && value.m_wavelength_id == x.second.m_wavelength_id;
+            });
+
+    // check if an event was already scheduled for the same timestamp
+    if (it == m_queue.cend()) {
+        // if not, just schedule the new event
+        m_queue.push(std::make_pair(t, value));
+        m_event_queue.notify(t - sc_time_stamp());
+    }
+    else {
+        // if yes, just replace or sum with the old one
+        if (m_use_deltas)
+            it->second += value;
+        else
+            it->second = value;
+    }
+}
+
+void OpticalOutputPort::delayedWriteSampledTime(const OpticalSignal &value, const sc_time &delay, const unsigned int resolution_multiplier)
+{
+    (void)value;
+    (void)delay;
+    (void)resolution_multiplier;
+    // TODO
+    // Goal here will be to manage, maybe, some averaging
+    // i.e. when we output sampled-time, if we receive event-driven signals, we convert them
+    // to sampled-time by averaging over the timestep and emitting the average
+}
+
+void OpticalOutputPort::immediateWriteFrequencyDomain(const OpticalSignal &value)
+{
+#if 1
+    //if (specsGlobalConfig.drop_all_events)
+    //    return;
+    //if (value.power() <= m_abs_tol_power && m_emitted_val_fd.power() <= m_abs_tol_power)
+    //    return;
+
+    const sc_time &now = sc_time_stamp();
+    if (m_queue.empty() || m_queue.cbegin()->first != now) {
+        // if the queue is empty, or contains no event for current time,
+        // push the signal directly
+        m_queue.push(make_pair(now, value));
+        m_event_queue.notify(SC_ZERO_TIME);
+    }
+    else {
+        // if the queue is contains an event for current time
+        if (m_queue.cbegin()->second.m_wavelength_id == value.m_wavelength_id) {
+            // if wavelengths are equal, just replace or sum with the old one
+            if (m_use_deltas)
+                m_queue.begin()->second += value;
+            else
+                m_queue.begin()->second = value;
+            //m_event_queue_fd.cancel_all();
+            //m_event_queue_fd.notify(SC_ZERO_TIME);
+        } else {
+            // otherwise just schedule event separately
+            m_queue.push(make_pair(now, value));
+            m_event_queue.notify(SC_ZERO_TIME);
+        }
+    }
+#else
+    cerr << "Using implemented function: " << __FUNCTION__ << endl;
+#endif
+}
+
+void OpticalOutputPort::delayedWrite(const OpticalSignal &value, const sc_time &delay, const unsigned int resolution_multiplier)
+{
+    switch(m_mode) {
+        case OpticalOutputPortMode::EVENT_DRIVEN:
+            delayedWriteEventDriven(value, delay, resolution_multiplier);
+            return;
+        case OpticalOutputPortMode::SAMPLED_TIME:
+            delayedWriteSampledTime(value, delay, resolution_multiplier);
+            return;
+        case OpticalOutputPortMode::FREQUENCY_DOMAIN:
+            //delayedWriteEventDriven(value, SC_ZERO_TIME, 1);
+            immediateWriteFrequencyDomain(value);
+        default:
+            break; // throw here
+    }
+
+}
+
diff --git a/src/optical_output_port.h b/src/optical_output_port.h
new file mode 100644
index 0000000..c0cd7dd
--- /dev/null
+++ b/src/optical_output_port.h
@@ -0,0 +1,178 @@
+#pragma once
+
+#include <cstdlib>
+#include <deque>
+#include <systemc.h>
+#include <utility>
+#include <vector>
+#include <queue>
+#include <map>
+
+#include <optical_signal.h>
+#include <pqueue.h>
+
+using std::cout;
+using std::endl;
+
+using std::pair;
+using std::vector;
+using std::priority_queue;
+
+enum OpticalOutputPortMode {
+    PORT_MODE_MINVAL,
+    EVENT_DRIVEN,
+    SAMPLED_TIME,
+    NO_DELAY,
+    PORT_MODE_MAXVAL,
+
+    // aliases
+    TIME_DOMAIN      = EVENT_DRIVEN,
+    FREQUENCY_DOMAIN = NO_DELAY,
+    DEFAULT          = EVENT_DRIVEN,
+    UNDEFINED        = PORT_MODE_MAXVAL,
+};
+
+string oopPortMode2str(OpticalOutputPortMode mode);
+
+class OpticalOutputPortConfig {
+public:
+    OpticalOutputPortMode m_mode = OpticalOutputPortMode::DEFAULT;
+    double m_abstol = 1e-8;
+    double m_reltol = 1e-4;
+    sc_time::value_type m_timestep_value = 1; // relative to systemc timestep
+
+    OpticalOutputPortConfig() {}
+};
+
+class OpticalOutputPort : public sc_module {
+public:
+    typedef OpticalOutputPort this_type;
+	typedef sc_port<sc_signal_out_if<OpticalSignal>> port_type;
+	typedef pair<sc_time, OpticalSignal> pair_type;
+    typedef PQueue<pair_type> queue_type;
+
+
+// private:
+public:
+    port_type &m_port;
+    queue_type m_queue;
+    // queue_type m_queue_fd;
+    // queue_type m_queue_td;
+    sc_event_queue m_event_queue;
+    // sc_event_queue m_event_queue_td;
+    // sc_event_queue m_event_queue_fd;
+    // OpticalSignal m_cur_val;
+    // OpticalSignal m_cur_val_td;
+    // OpticalSignal m_cur_val_fd;
+    // OpticalSignal m_emitted_val;
+    // OpticalSignal m_emitted_val_fd;
+
+    std::map<uint32_t,OpticalSignal::field_type> m_desired_fields;
+    std::map<uint32_t,OpticalSignal::field_type> m_emitted_fields;
+
+    sc_time m_temporal_resolution;
+    OpticalOutputPortMode m_mode;
+    double m_reltol;
+    double m_abstol;
+    bool m_use_deltas = false;
+    bool m_converger = false;
+    bool m_skip_next_convergence_check = false;
+    bool m_skip_convergence_check = false;
+
+    std::shared_ptr<const OpticalOutputPortConfig> m_config;
+
+    // void drop_all_events();
+    void on_data_ready();
+    void on_data_ready_fd();
+    bool check_emit_by_abstol(const OpticalSignal::field_type &desired, const OpticalSignal::field_type &last);
+    bool check_emit_by_reltol(const OpticalSignal::field_type &desired, const OpticalSignal::field_type &last);
+
+    void applyConfig();
+    virtual void start_of_simulation();
+    sc_time snap_to_next_valid_time(const sc_time &t, const unsigned int resolution_multiplier=1);
+    void delayedWriteEventDriven(const OpticalSignal &value, const sc_time &delay, const unsigned int resolution_multiplier=1);
+    void delayedWriteSampledTime(const OpticalSignal &value, const sc_time &delay, const unsigned int resolution_multiplier=1);
+    void immediateWriteFrequencyDomain(const OpticalSignal &value);
+
+public:
+    OpticalOutputPort(sc_module_name name, port_type &p);
+
+    ~OpticalOutputPort() {}
+
+    // Set config
+    void setConfig(shared_ptr<OpticalOutputPortConfig> &config)
+    {
+        m_config = config;
+    }
+    const shared_ptr<const OpticalOutputPortConfig>& getConfig() const
+    {
+        return m_config;
+    }
+
+    void drop_queue()
+    {
+        if (sc_get_simulator_status() == SC_RUNNING)
+        {
+            cerr << "Cannot drop if simulation is running" << endl;
+            exit(1);
+        }
+        m_event_queue.cancel_all();
+        m_queue = queue_type();
+    }
+
+    void reset()
+    {
+        drop_queue();
+        m_desired_fields.clear();
+        m_emitted_fields.clear();
+    }
+
+    void swap_wavelengths(uint32_t wl1, uint32_t wl2)
+    {
+        drop_queue();
+
+        // Create entries with 0 if they don't exist
+        m_desired_fields.emplace(wl1, 0);
+        m_desired_fields.emplace(wl2, 0);
+        m_emitted_fields.emplace(wl1, 0);
+        m_emitted_fields.emplace(wl2, 0);
+
+        // Swap wl1 and wl2 entries
+        swap(m_desired_fields.at(wl1), m_desired_fields.at(wl2));
+        swap(m_emitted_fields.at(wl1), m_emitted_fields.at(wl2));
+    }
+
+    void delete_wavelength(uint32_t wl)
+    {
+        drop_queue();
+        // Create entries with 0 if they don't exist
+        m_desired_fields.erase(wl);
+        m_emitted_fields.erase(wl);
+    }
+
+    // inline double current_err() const {
+    //     double err_abs_power = abs(m_cur_val.power() - m_emitted_val.power());
+    //     double err_abs_phase = abs(m_cur_val.phase() - m_emitted_val.phase());
+    //     if (m_cur_val.power() > m_abstol)
+    //         return max(err_abs_power, err_abs_phase);
+    //     return err_abs_power;
+    // }
+
+    inline double current_err_fd() const {
+        cerr << "Using deprecated function: " << __FUNCTION__ << endl;
+        exit(1);
+        // double err_abs_power = abs(m_cur_val_fd.power() - m_emitted_val_fd.power());
+        // double err_abs_phase = abs(m_cur_val_fd.phase() - m_emitted_val_fd.phase());
+        // if (m_cur_val_fd.power() >= m_abstol)
+        //     return max(err_abs_power, err_abs_phase);
+        // return err_abs_power;
+        return 0;
+    }
+
+    inline bool isempty() const
+    {
+        return m_queue.empty();
+    }
+
+    void delayedWrite(const OpticalSignal &value, const sc_time &delay, const unsigned int resolution_multiplier=1);
+};
diff --git a/src/optical_signal.cpp b/src/optical_signal.cpp
new file mode 100644
index 0000000..704dfd6
--- /dev/null
+++ b/src/optical_signal.cpp
@@ -0,0 +1,157 @@
+#include <optical_signal.h>
+#include <specs.h>
+
+using namespace std::complex_literals;
+
+unsigned int OpticalSignal::nextId = 0;
+
+OpticalSignal &OpticalSignal::operator+=(const OpticalSignal &rhs)
+{
+    // cout << "Summing two signals: " << endl;
+    // cout << "\t" << *this << endl;
+    // cout << "\t" << rhs << endl;
+
+    auto this_wavelength = this->getWavelength();
+    auto rhs_wavelength = rhs.getWavelength();
+
+    if (this_wavelength == rhs_wavelength)
+        m_field += rhs.m_field;
+    else if (isnan(rhs_wavelength))
+        (void)rhs; // nothing to do
+    else if (isnan(this_wavelength))
+        *this = rhs;
+    else if (specsGlobalConfig.simulation_mode == FREQUENCY_DOMAIN)
+    {
+        // TODO: move that somewhere else ???
+        // Replace with rhs
+        if (rhs_wavelength > this_wavelength)
+            *this = rhs;
+    }
+    else
+        cerr << "Attempted to sum signals of different wavelengths, but current"
+             << "simulation mode doesn't allow it (" << __FUNCTION__ << ")" << endl;
+    // cout << "\t--> " << *this << endl;
+    return *this;
+}
+
+OpticalSignal &OpticalSignal::operator-=(const OpticalSignal &rhs)
+{
+    // cout << "Substracting two signals: " << endl;
+    // cout << "\t" << *this << endl;
+    // cout << "\t" << rhs << endl;
+
+    auto this_wavelength = this->getWavelength();
+    auto rhs_wavelength = rhs.getWavelength();
+
+    if (this_wavelength == rhs_wavelength)
+        m_field -= rhs.m_field;
+    else if (isnan(rhs_wavelength))
+        (void)rhs; // nothing to do
+    else if (isnan(this_wavelength))
+        *this = rhs;
+    else if (specsGlobalConfig.simulation_mode == FREQUENCY_DOMAIN)
+    {
+        // TODO: move that somewhere else ???
+        // Replace with rhs
+        if (rhs_wavelength > this_wavelength)
+            *this = rhs;
+    }
+    else
+        cerr << "Attempted to substract signals of different wavelengths, but current"
+             << "simulation mode doesn't allow it (" << __FUNCTION__ << ")" << endl;
+    // cout << "\t--> " << *this << endl;
+    return *this;
+}
+
+OpticalSignal OpticalSignal::sumSignals(OpticalSignal s0, OpticalSignal s1)
+{
+    cerr << "Use of deprecated" << __FUNCTION__<< endl;
+
+    // Maybe doing just the sum is faster than this
+    if (s0.m_field == 0.0) {
+        OpticalSignal os_sum = s1;
+        os_sum.getNewId();
+        return os_sum;
+    }
+    if (s1.m_field == (complex<double>) 0) {
+        OpticalSignal os_sum = s0;
+        os_sum.getNewId();
+        return os_sum;
+    }
+
+    if (s0.getWavelength() != s1.getWavelength())
+    {
+        bool ignore_wavelength_error = false;
+        if (ignore_wavelength_error)
+        {
+            cerr << "Signals have different wavelengths:" << std::endl;
+            cerr << "\t" << s0.getWavelength() << "(" << norm(s0.m_field) << ")"
+                 << "\t" << s1.getWavelength() << "(" << norm(s1.m_field) << ")"
+                 << std::endl;
+
+            sc_stop();
+        } else {
+            OpticalSignal os_sum = s0;
+            if (norm(s1.m_field) > norm(s0.m_field))
+                os_sum = s1;
+            os_sum.getNewId();
+            return os_sum;
+        }
+    }
+
+    complex<double> Asum = s0.m_field + s1.m_field;
+
+    OpticalSignal os_sum = s0;
+    os_sum.m_field = Asum;
+    os_sum.getNewId();
+
+    return os_sum;
+}
+
+uint32_t OpticalSignal::getIDFromWavelength(const double &wavelength)
+{
+    auto it = find (specsGlobalConfig.wavelengths_vector.cbegin(),
+                    specsGlobalConfig.wavelengths_vector.cend(),
+                    wavelength);
+
+    uint32_t index;
+
+    if (it != specsGlobalConfig.wavelengths_vector.cend())
+    { // Found
+        index = it - specsGlobalConfig.wavelengths_vector.cbegin();
+    }
+    else
+    { // Didn't find, has to add it to the vector
+        specsGlobalConfig.wavelengths_vector.push_back(wavelength);
+        index = specsGlobalConfig.wavelengths_vector.size() - 1;
+        // -1 because of zero indexing
+    }
+
+    if (index == (uint32_t)(-1))
+    {
+        cerr << "Error: too many wavelengths being used ." << endl;
+        exit(1);
+    }
+
+    return index;
+}
+
+double OpticalSignal::getWavelength() const
+{
+    if (m_wavelength_id >= specsGlobalConfig.wavelengths_vector.size())
+    {
+        cerr << "Wavelength not found in global vector." << endl;
+        exit(1);
+    }
+    return specsGlobalConfig.wavelengths_vector[m_wavelength_id];
+}
+
+double OpticalSignal::getWavelength(const uint32_t &wavelength_id)
+{
+    if (wavelength_id >= specsGlobalConfig.wavelengths_vector.size())
+    {
+        cerr << "Wavelength not found in global vector." << endl;
+        exit(1);
+    }
+    return specsGlobalConfig.wavelengths_vector[wavelength_id];
+}
\ No newline at end of file
diff --git a/src/optical_signal.h b/src/optical_signal.h
new file mode 100644
index 0000000..b597b98
--- /dev/null
+++ b/src/optical_signal.h
@@ -0,0 +1,251 @@
+#pragma once
+
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+#include <complex>
+#include <stdlib.h>
+
+#include <systemc.h>
+
+using namespace std;
+
+class OpticalSignal {
+public:
+    typedef complex<double> field_type;
+
+private:
+    // class variable for holding next id to attribute
+    static unsigned int nextId;
+
+public:
+    field_type m_field; // complex field of the signal (V/m)
+    uint32_t m_wavelength_id; // accesses the global vector of wavelengths
+    unsigned int m_id;
+
+    // Constructor from values
+    OpticalSignal(const field_type &field = 0.0,
+                  const double &wavelength = numeric_limits<double>::quiet_NaN())
+        : m_field(field)
+    {
+        if (!isnan(wavelength))
+            m_wavelength_id = getIDFromWavelength(wavelength);
+        else
+            m_wavelength_id = 0;
+        getNewId();
+    }
+
+    // Constructor sending an id
+    OpticalSignal(const field_type &field,
+                  const uint32_t &wavelength_id)
+        : m_field(field)
+        , m_wavelength_id(wavelength_id)
+    {
+        getNewId();
+    }
+
+    // Copy constructor
+    OpticalSignal(const OpticalSignal &s)
+        : m_field(s.m_field)
+        , m_wavelength_id(s.m_wavelength_id)
+        , m_id(s.m_id)
+    { getNewId(); }
+
+    virtual ~OpticalSignal() {}
+
+    inline void getNewId()
+    {
+        m_id = nextId++;
+    }
+
+    void setWavelength(const double &wavelength)
+    {
+        if (!isnan(wavelength))
+            m_wavelength_id = getIDFromWavelength(wavelength);
+        else
+            m_wavelength_id = 0;
+    }
+
+    double getWavelength() const;
+
+    static double getWavelength(const uint32_t &wavelength_id);
+
+    uint32_t getIDFromWavelength(const double &wavelength);
+
+    inline static complex<double> amplitudePhaseToField(double amplitude, double phase)
+    {
+        return polar(amplitude, phase);
+    }
+
+    inline double modulus() const {
+        return abs(m_field);
+    }
+
+    inline double power() const {
+        return norm(m_field);
+    }
+
+    inline double phase() const {
+        return arg(m_field);
+    }
+
+    // Equality is used to determine if a signal changes
+    // which is why true `==` is used here in field
+    // TODO: check if we need to use is_close() instead
+    // For wavelength, there should be no need not to use `==`
+    // for now, as no calculation is done on it. But in the future,
+    // we might need to review this as well
+    bool operator==(const OpticalSignal &rhs) const
+    {
+#if 0
+        // Work with ID
+        return rhs.m_id == m_id
+            || (isnan(rhs.m_wavelength) && isnan(m_wavelength));
+#else
+        // Work with field value
+        return rhs.m_field == m_field
+            && rhs.m_wavelength_id == m_wavelength_id;
+#endif
+    }
+
+    bool operator!=(const OpticalSignal &rhs) const
+    {
+        return !(*this == rhs);
+    }
+
+    bool operator<(const OpticalSignal &rhs) const
+    {
+        return rhs.modulus() < modulus();
+    }
+
+    inline void advancePhaseByPhase(const double &phase_rad)
+    {
+        m_field *= polar(1.0, phase_rad);
+    }
+
+    inline void advancePhaseByTime(const double &time_s)
+    {
+        // phase in rad = w * t = (2pi * (c/lambda)) * t
+        constexpr const auto c_2pi = 2 * M_PI * 299792458.0;
+        const auto phase_rad = (c_2pi / this->getWavelength()) * time_s;
+
+        advancePhaseByPhase(phase_rad);
+    }
+
+    static OpticalSignal sumSignals(
+        OpticalSignal s0,
+        OpticalSignal s1);
+
+    operator field_type() const {
+        return m_field;
+    }
+
+    OpticalSignal operator=(const OpticalSignal &rhs)
+    {
+        m_field = rhs.m_field;
+        m_wavelength_id = rhs.m_wavelength_id;
+        getNewId();
+        return *this;
+    }
+
+    OpticalSignal &operator+=(const OpticalSignal &rhs);
+    OpticalSignal &operator-=(const OpticalSignal &rhs);
+
+    OpticalSignal &operator*=(const field_type &rhs)
+    {
+        m_field *= rhs;
+        return *this;
+    }
+
+    OpticalSignal &operator*=(const double &rhs)
+    {
+        m_field *= rhs;
+        return *this;
+    }
+
+    OpticalSignal &operator/=(const double &rhs)
+    {
+        (*this) *= (1 / rhs);
+        return *this;
+    }
+
+    inline friend OpticalSignal operator+(OpticalSignal lhs, const OpticalSignal &rhs);
+    inline friend OpticalSignal operator-(OpticalSignal lhs, const OpticalSignal &rhs);
+
+    template <typename T>
+    inline friend OpticalSignal operator*(OpticalSignal lhs, const T &rhs);
+
+    template <typename T>
+    inline friend OpticalSignal operator*(const T &lhs, OpticalSignal rhs);
+
+    template <typename T>
+    inline friend OpticalSignal operator/(OpticalSignal lhs, const T &rhs);
+
+    inline friend std::ostream &operator<<(std::ostream &os, const OpticalSignal &s);
+    inline friend void
+    sc_trace(sc_trace_file *tf, const OpticalSignal &s, const std::string &NAME);
+};
+
+OpticalSignal operator+(OpticalSignal lhs, const OpticalSignal &rhs)
+{
+    return lhs += rhs;
+}
+
+OpticalSignal operator-(OpticalSignal lhs, const OpticalSignal &rhs)
+{
+    return lhs -= rhs;
+}
+
+template <typename T>
+OpticalSignal operator*(OpticalSignal lhs, const T &rhs)
+{
+    return lhs *= rhs;
+}
+
+template <typename T>
+OpticalSignal operator*(const T &lhs, OpticalSignal rhs)
+{
+    return rhs *= lhs;
+}
+
+template <typename T>
+inline OpticalSignal operator/(OpticalSignal lhs, const T &rhs)
+{
+    return lhs /= rhs;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const OpticalSignal &s)
+{
+    using std::defaultfloat;
+    using std::fixed;
+    using std::setfill;
+    using std::setprecision;
+    using std::setw;
+
+    std::ostringstream oss;
+
+    oss << "[" << setw(4) << setfill('0') << s.m_id << setfill(' ') << "] ";
+    oss << " @ " << setw(4) << setprecision(8) << s.getWavelength() * 1e9 << setw(2)
+        << (isnan(s.getWavelength()) ? "" : " nm");
+    oss << " (" << setprecision(6) << fixed << s.modulus() << " V.m⁻¹";
+    oss << ", " << setprecision(6) << fixed << s.power() << " W";
+    oss << ", " << setprecision(4) << fixed << s.phase() << " rad";
+    oss << ")";
+
+    os << oss.str();
+    return os;
+}
+
+inline void sc_trace(sc_trace_file *tf, const OpticalSignal &s, const std::string &NAME)
+{
+    cerr << "Use of deprecated" << __FUNCTION__<< endl;
+
+    // Note: C++ complex doesn't provide access to real and imaginary part
+    // Therefore we cannot have references or pointers to it...
+    sc_trace(tf, s.m_id, NAME + ".id");
+    sc_trace(tf, s.m_wavelength_id, NAME + ".wavelengthid");
+}
diff --git a/src/parser/parse_analysis.cpp b/src/parser/parse_analysis.cpp
new file mode 100644
index 0000000..3168858
--- /dev/null
+++ b/src/parser/parse_analysis.cpp
@@ -0,0 +1,109 @@
+#include "parse_analysis.h"
+#include "cw_source.h"
+#include "devices/alldevices.h"
+#include "directional_coupler.h"
+#include "optical_output_port.h"
+#include "parse_tree.h"
+#include "specs.h"
+#include "strutils.h"
+#include "sysc_utils.h"
+#include "general_utils.h"
+#include <functional>
+
+using spx::oa_value_type;
+using spx::ea_value_type;
+using spx::ed_value_type;
+
+using spx::ed_bus_type;
+using spx::oa_signal_type;
+using spx::ea_signal_type;
+using spx::ed_signal_type;
+using spx::ed_bus_type;
+
+void OPAnalysis::create() const
+{
+    specsGlobalConfig.analysis_type = SPECSConfig::OP;
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::FREQUENCY_DOMAIN;
+}
+
+void DCAnalysis::create() const
+{
+    specsGlobalConfig.analysis_type = SPECSConfig::DC;
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::FREQUENCY_DOMAIN;
+
+    assert(sweep_orders.size() > 0);
+
+    set<CWSource *>  all_cws = sc_get_all_object_by_type<CWSource>();
+    vector<CWSource *>  all_cws_vec(all_cws.begin(), all_cws.end());
+
+    int i = 0;
+    for (const auto &sweep_order: sweep_orders)
+    {
+        string element_name = parent->name_prefix() + sweep_order.first.first;
+        string attribute_name = sweep_order.first.second;
+
+        auto is_desired_element = [&element_name](const auto &x){ return x->name() == element_name; };
+        auto it = std::find_if(all_cws_vec.begin(), all_cws_vec.end(), is_desired_element);
+        if (it == all_cws_vec.end())
+        {
+            cerr << "Element not found: " << element_name << endl;
+            exit(1);
+        }
+        CWSource *elem = *it;
+        // cout << elem << endl;
+        // cout << &CWSource::setWavelength << endl;
+
+        function<void(double)> f;
+        if (attribute_name == "WL" || attribute_name == "WAVELENGTH" || attribute_name == "LAMBDA")
+        {
+            f = std::bind(&CWSource::setWavelength, elem, placeholders::_1);
+        }
+        else if (attribute_name == "P" || attribute_name == "POW" || attribute_name == "POWER")
+        {
+            f = std::bind(static_cast<void (CWSource::*)(const double&)>(&CWSource::setPower), elem, placeholders::_1);
+        }
+        else if (attribute_name == "F" || attribute_name == "FREQ" || attribute_name == "FREQUENCY")
+        {
+            f = std::bind((&CWSource::setFrequency), elem, placeholders::_1);
+        }
+        else
+        {
+            cerr << "Unknown attribute for " << sweep_order.first.first << ": " << attribute_name << endl;
+            exit(1);
+        }
+        auto values = range(sweep_order.second[0], sweep_order.second[1], sweep_order.second[2]);
+        auto order = pair<function<void(double)>, vector<double>>(f, values);
+        auto order_name = attribute_name + "(" + element_name + ")";
+        specsGlobalConfig.cw_sweep_orders.emplace(order_name, order);
+        ++i;
+    }
+}
+
+void TRANAnalysis::create() const
+{
+    specsGlobalConfig.analysis_type = SPECSConfig::TRAN;
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::TIME_DOMAIN;
+
+    assert(args.size() <= 1);
+
+    if (args.size() >= 1)
+    {
+        double val = args[0].as_double();
+        // cout << val << endl;
+        if (val > 0)
+            specsGlobalConfig.tran_duration = args[0].as_double();
+        else
+        {
+            cerr << "Negative simulation duration is not accepted" << endl;
+            exit(1);
+        }
+    }
+
+    for (const auto &p : kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        cerr << "Unknown keyword " << kw << endl;
+        exit(1);
+    }
+}
diff --git a/src/parser/parse_analysis.h b/src/parser/parse_analysis.h
new file mode 100644
index 0000000..9e3f44c
--- /dev/null
+++ b/src/parser/parse_analysis.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#include "parse_tree.h"
+#include "specs.h"
+#include "strutils.h"
+
+#include <initializer_list>
+#include <utility>
+#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+
+using std::pair;
+using std::make_pair;
+using std::string;
+using std::vector;
+using std::map;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::pair;
+using std::unique_ptr;
+
+/* OP: operating point analysis */
+struct OPAnalysis : public ParseAnalysis {
+    /* Import constructor from ParseAnalysis */
+    using ParseAnalysis::ParseAnalysis;
+
+    virtual ParseAnalysis* clone() const
+    { return new OPAnalysis(*this); }
+    virtual void create() const;
+    virtual string kind() const
+    { return "OP"; }
+};
+
+/* DC: stepped-source operating point analysis */
+struct DCAnalysis : public ParseAnalysis {
+    typedef pair<string, string> sweep_param_type;
+    typedef vector<double> sweep_range_type;
+    typedef pair<sweep_param_type, sweep_range_type> sweep_order_type;
+
+    /* Import constructor from ParseAnalysis */
+    using ParseAnalysis::ParseAnalysis;
+
+    map<sweep_param_type, sweep_range_type> sweep_orders;
+
+    void register_sweep_order(sweep_param_type param, sweep_range_type range)
+    {
+        strutils::toupper(param.first);
+        strutils::toupper(param.second);
+        if (sweep_orders.count(param) != 0)
+        {
+            cerr << "A sweep order for " << param.second << "(" << param.first << ")";
+            cerr << " was already recoreded." << endl;
+            exit(1);
+        }
+        auto n = (range[1] - range[0]) / range[2];
+        n = max(0.0, n);
+        n = floor(n);
+        if (n <= 1.5)
+        {
+            cerr << "Sweep order must contain at least 2 point." << endl;
+            exit(1);
+        }
+        cout << "Recorded sweep order for " << param.second << "(" << param.first << ")";
+        cout << " (" << n << "points)" << endl;
+        sweep_orders.emplace(param, range);
+    }
+
+    void register_sweep_order(sweep_order_type order)
+    {
+        register_sweep_order(order.first, order.second);
+    }
+
+    virtual ParseAnalysis* clone() const
+    { return new DCAnalysis(*this); }
+    virtual void create() const;
+    virtual string kind() const
+    { return "DC"; }
+};
+
+/* TRAN: transient analysis */
+struct TRANAnalysis : public ParseAnalysis {
+    /* Import constructor from ParseElement */
+    using ParseAnalysis::ParseAnalysis;
+
+    virtual ParseAnalysis* clone() const
+    { return new TRANAnalysis(*this); }
+    virtual void create() const;
+    virtual string kind() const
+    { return "TRAN"; }
+};
\ No newline at end of file
diff --git a/src/parser/parse_directive.cpp b/src/parser/parse_directive.cpp
new file mode 100644
index 0000000..e66e8cf
--- /dev/null
+++ b/src/parser/parse_directive.cpp
@@ -0,0 +1,132 @@
+#include "parse_directive.h"
+#include "devices/alldevices.h"
+#include "directional_coupler.h"
+#include "optical_signal.h"
+#include "parse_tree.h"
+#include "specs.h"
+
+using spx::oa_value_type;
+using spx::ea_value_type;
+using spx::ed_value_type;
+
+using spx::ed_bus_type;
+using spx::oa_signal_type;
+using spx::ea_signal_type;
+using spx::ed_signal_type;
+using spx::ed_bus_type;
+
+void OPTIONSDirective::create() const
+{
+    // Verify number of nodes
+    assert(args.size() == 0);
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "TRACEALL")
+            specsGlobalConfig.trace_all_optical_nets = p.second.as_boolean();
+        else if (kw == "ABSTOL")
+            specsGlobalConfig.default_abstol = p.second.as_double();
+        else if (kw == "RELTOL")
+            specsGlobalConfig.default_reltol = p.second.as_double();
+        else if (kw == "TS" || kw == "TIMESCALE")
+            specsGlobalConfig.engine_timescale = (SPECSConfig::EngineTimescale)p.second.as_integer();
+        else if (kw == "RESOLUTION")
+            specsGlobalConfig.default_resolution_multiplier = p.second.as_double();
+        else if (kw == "TRACEALL")
+            specsGlobalConfig.trace_all_optical_nets = p.second.as_double();
+        else if (kw == "TEST_VARIABLE")
+            cout << kw << "(" << p.second.kind() << "): " << p.second.get_str() << endl;
+        else {
+            cerr << "Unknown keyword: " << p.first;
+            cerr << " (value: " << p.second.get_str() << " (" << p.second.kind() << "))" <<endl;
+            exit(1);
+        }
+    }
+}
+
+void NODESETDirective::print() const
+{
+    ParseDirective::print();
+    cout << "{";
+    for (const auto &x : net_assignments)
+    {
+        for (const auto &ass : x.second)
+        cout << ass.first << "(" << x.first << ") = "
+             << ass.second.get_str() << " (" << ass.second.kind() << ") , ";
+    }
+    if ( !net_assignments.empty() )
+        cout << "\b\b";
+    cout << "}" << endl;
+}
+
+void NODESETDirective::create() const
+{
+    cerr << "NODESET is disabled pending bugfixes" << endl;
+    exit(1);
+#if 0
+    map<string, pair<spx::oa_signal_type *, oa_value_type>> ic_map;
+    auto &signals = parent->circuit_nets;
+    for (const auto &x : net_assignments)
+    {
+        const auto &key = x.first;
+        if (signals.count(key) == 0)
+        {
+            cerr << "Net not found " << key << endl;
+            exit(1);
+        }
+        if (ic_map.count(key) == 0)
+        {
+            //FIXME:
+            auto sig = dynamic_cast<oa_signal_type *>(signals[key].get());
+            auto initial_val = sig->read();
+            auto sig_address = dynamic_cast<oa_signal_type *>(signals[key].get());
+            pair<oa_signal_type *, oa_value_type> assignment{sig_address, initial_val};
+            ic_map.emplace(key, assignment);
+        }
+        oa_value_type signal_val = ic_map[key].second;
+        for (const auto &assignment: x.second)
+        {
+            string attribute_name = assignment.first;
+            strutils::toupper(attribute_name);
+            const Variable &value = assignment.second;
+
+            // cout << attribute_name << endl;
+            if (attribute_name == "P" || attribute_name == "POW" || attribute_name == "POWER")
+            {
+                signal_val.m_field = polar(sqrt(value.as_double()), arg(signal_val.m_field));
+                // cout << "################" << endl;
+                // cout << signal_val << endl;
+            }
+            else if (attribute_name == "PHASE" || attribute_name == "PHI")
+            {
+                signal_val.m_field = polar(abs(signal_val.m_field), value.as_double());
+                // cout << "################" << endl;
+                // cout << signal_val << endl;
+            }
+            else if (attribute_name == "WL" || attribute_name == "LAMBDA" || attribute_name == "WAVELENGTH")
+            {
+                signal_val.setWavelength(value.as_double());
+                // cout << "################" << endl;
+                // cout << signal_val << endl;
+            }
+            else
+            {
+                cerr << "Unknown attribute" << endl;
+                exit(1);
+            }
+        }
+        specsGlobalConfig.nodeset_orders[key] = pair<oa_signal_type *, oa_value_type>(
+            dynamic_cast<oa_signal_type *>(signals[key].get())
+            , signal_val);
+    }
+#endif
+}
+
+void ICDirective::create() const
+{
+    cerr << "IC directive is not implemented" << endl;
+    exit(1);
+}
\ No newline at end of file
diff --git a/src/parser/parse_directive.h b/src/parser/parse_directive.h
new file mode 100644
index 0000000..212fd4a
--- /dev/null
+++ b/src/parser/parse_directive.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include "parse_tree.h"
+
+#include <initializer_list>
+#include <utility>
+#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+
+using std::pair;
+using std::make_pair;
+using std::string;
+using std::vector;
+using std::map;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::pair;
+using std::unique_ptr;
+
+/* OPTIONS: specify simulator options */
+struct OPTIONSDirective : public ParseDirective {
+    /* Import constructor from ParseDirective */
+    using ParseDirective::ParseDirective;
+
+    virtual ParseDirective* clone() const
+    { return new OPTIONSDirective(*this); }
+    virtual void create() const;
+    virtual string kind() const
+    { return "OPTIONS"; }
+};
+
+/* NODESET: specify initial guesses  */
+struct NODESETDirective : public ParseDirective {
+    typedef string net_name;
+    typedef string property_name;
+    typedef Variable property_val;
+    typedef pair<property_name, property_val> assignment;
+
+    map<net_name, vector<assignment>> net_assignments;
+
+    /* Import constructor from ParseDirective */
+    using ParseDirective::ParseDirective;
+
+    virtual void print() const;
+
+    virtual ParseDirective* clone() const
+    { return new NODESETDirective(*this); }
+    virtual void create() const;
+    virtual string kind() const
+    { return "NODESET"; }
+};
+
+/* IC: specify initial conditions options */
+// Inherit from NODESETDirective as options are the same.
+struct ICDirective : public NODESETDirective {
+    /* Import constructor from ParseDirective */
+    using NODESETDirective::NODESETDirective;
+
+    virtual ParseDirective* clone() const
+    { return new ICDirective(*this); }
+    virtual void create() const;
+    virtual string kind() const
+    { return "IC"; }
+};
\ No newline at end of file
diff --git a/src/parser/parse_element.cpp b/src/parser/parse_element.cpp
new file mode 100644
index 0000000..14de6e9
--- /dev/null
+++ b/src/parser/parse_element.cpp
@@ -0,0 +1,1266 @@
+#include "parse_element.h"
+#include "alldevices.h"
+#include "subcircuit_instance.h"
+#include "specs.h"
+#include "strutils.h"
+
+#include <string>
+
+/** ******************************************* **/
+/**     Helper macros and defines               **/
+/** ******************************************* **/
+#define AS_READER (false)
+#define AS_WRITER (!AS_READER)
+
+#define INSTANTIATE_AND_CONNECT_UNI(ELEM_NAME, pt_helper) \
+ELEM_NAME::element_type_base *ELEM_NAME::instantiate_and_connect_uni(ParseTreeCreationHelper &pt_helper) const
+
+#define INSTANTIATE_AND_CONNECT_BI(ELEM_NAME, pt_helper) \
+ELEM_NAME::element_type_base *ELEM_NAME::instantiate_and_connect_bi(ParseTreeCreationHelper &pt_helper) const
+
+#define INSTANTIATE(pt_helper, bidirectional) \
+\
+if (bidirectional)\
+    obj = (element_type_base *)instantiate_and_connect_bi(pt_helper);\
+else\
+    obj = (element_type_base *)instantiate_and_connect_uni(pt_helper);
+
+/** ******************************************* **/
+/**               Waveguide                     **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(WGElement, pt_helper)
+{
+    // create object with default params
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in,  nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out, nets[1], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+INSTANTIATE_AND_CONNECT_BI(WGElement, pt_helper)
+{
+    // create object with default params
+    element_type_bi *obj = new element_type_bi(name.c_str());
+
+    // Update unidirectional nets connected to the waveguide
+    if (!pt_helper.nets->at(nets[0]).bidirectional())
+        (*pt_helper.nets)[nets[0]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[1]).bidirectional())
+        (*pt_helper.nets)[nets[1]].m_readers_count++;
+
+    // Bidirectional waveguide needs all nets as bidir
+    for (const auto &net : nets)
+        pt_helper.upgrade_signal(net);
+
+    // connect ports
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p0_in, obj->p0_out, nets[0]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p1_in, obj->p1_out, nets[1]);
+
+    return obj;
+}
+
+sc_module *WGElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Prevent connecting a waveguide to itself, it will hang the execution!!!
+    if (nets[0] == nets[1])
+    {
+        cerr << "Error: A waveguide cannot be looped back upon himself" << endl;
+        exit(1);
+    }
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Check if device has to be bidirectional
+    bool bidirectional = false;
+    for (const auto &net : nets)
+    {
+        // for waveguide, if any net is bidir, module has to be bidir
+        bidirectional |= pt_helper.nets->at(net).bidirectional();
+    }
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, bidirectional);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        obj->m_length_cm = args[0].as_double() * 100;
+    if(args.size() > 1)
+        obj->m_neff = args[1].as_double();
+    if(args.size() > 2)
+        obj->m_ng = args[2].as_double();
+    if(args.size() > 3)
+        obj->m_attenuation_dB_cm = args[3].as_double();
+    if(args.size() > 4)
+        obj->m_D = args[4].as_double();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "NEFF")
+            obj->m_neff = p.second.as_double();
+        else if (kw == "NG")
+            obj->m_ng = p.second.as_double();
+        else if (kw == "L" || kw == "LENGTH")
+            obj->m_length_cm = p.second.as_double() * 100;
+        else if (kw == "ATT")
+            obj->m_attenuation_dB_cm = p.second.as_double();
+        else if (kw == "D")
+            obj->m_D = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+
+    return obj;
+}
+
+/** ******************************************* **/
+/**               Merger                        **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(MergerElement, pt_helper)
+{
+    // create object with default params
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in1, nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in2, nets[1], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out, nets[2], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *MergerElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        obj->m_attenuation_dB = args[0].as_double();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "IL" || kw == "INSERTION_LOSS")
+            obj->m_attenuation_dB = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**               Splitter                      **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(SplitterElement, pt_helper)
+{
+    // create object with default params
+    element_type_uni *obj = new element_type_base(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in,   nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out1, nets[1], AS_WRITER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out2, nets[2], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *SplitterElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        obj->m_split_ratio = args[0].as_double();
+    if(args.size() > 1)
+        obj->m_attenuation_dB = args[1].as_double();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "IL" || kw == "INSERTION_LOSS")
+            obj->m_attenuation_dB = p.second.as_double();
+        else if (kw == "SPLITTING_RATIO" || kw == "RATIO")
+            obj->m_split_ratio = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**            Directional coupler              **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(DCElement, pt_helper)
+{
+    // create object with default params
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect p_in1
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in1,  nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in2,  nets[1], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out1, nets[2], AS_WRITER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out2, nets[3], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+INSTANTIATE_AND_CONNECT_BI(DCElement, pt_helper)
+{
+    // create object with default params
+    element_type_bi *obj = new element_type_bi(name.c_str());
+
+    // Update unidirectional nets connected to the waveguide
+    if (!pt_helper.nets->at(nets[0]).bidirectional())
+        (*pt_helper.nets)[nets[0]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[1]).bidirectional())
+        (*pt_helper.nets)[nets[1]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[2]).bidirectional())
+        (*pt_helper.nets)[nets[2]].m_readers_count++;
+    if (!pt_helper.nets->at(nets[3]).bidirectional())
+        (*pt_helper.nets)[nets[3]].m_readers_count++;
+
+    // Bidirectional DC needs all nets as bidir
+    for (const auto &net : nets)
+        pt_helper.upgrade_signal(net);
+
+    // connect ports
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p0_in, obj->p0_out, nets[0]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p1_in, obj->p1_out, nets[1]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p2_in, obj->p2_out, nets[2]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p3_in, obj->p3_out, nets[3]);
+
+    // return the module
+    return obj;
+}
+
+sc_module *DCElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    // TODO: change from field to power?
+    cout << "Warning: coupling power for DC currently set to field." << endl;
+
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Check if device has to be bidirectional
+    bool bidirectional = false;
+    for (const auto &net : nets)
+    {
+        // for waveguide, if any net is bidir, module has to be bidir
+        bidirectional |= pt_helper.nets->at(net).bidirectional();
+    }
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, bidirectional);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        // convert from cross-coupling field coef
+        obj->m_dc_through_coupling_power = 1 - pow(args[0].as_double(), 2);
+    if(args.size() > 1)
+        obj->m_dc_loss = args[1].as_double();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "K" || kw == "KF" || kw == "KFIELD")
+            // convert from cross-coupling field coef
+            obj->m_dc_through_coupling_power = 1 - pow(p.second.as_double(), 2);
+        else if (kw == "KP" || kw == "KPOW" || kw == "KPOWER")
+            // convert from cross-coupling field coef
+            obj->m_dc_through_coupling_power = 1 - p.second.as_double();
+        else if (kw == "T")
+            // convert from cross-coupling field coef
+            obj->m_dc_through_coupling_power = pow(p.second.as_double(), 2);
+        else if (kw == "LOSS")
+            obj->m_dc_loss = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**               Phase-shifter                 **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(PhaseShifterElement, pt_helper)
+{
+    // create object with default params
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in,  nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out, nets[1], AS_WRITER);
+    pt_helper.connect_uni<spx::ea_signal_type>(obj->p_vin, nets[2], AS_READER);
+
+    // return the module
+    return obj;
+}
+
+INSTANTIATE_AND_CONNECT_BI(PhaseShifterElement, pt_helper)
+{
+    // create object with default params
+    element_type_bi *obj = new element_type_bi(name.c_str());
+
+    // Update unidirectional nets connected to the waveguide
+    if (!pt_helper.nets->at(nets[0]).bidirectional())
+        (*pt_helper.nets)[nets[0]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[1]).bidirectional())
+        (*pt_helper.nets)[nets[1]].m_readers_count++;
+
+    // Bidirectional phase-shifter needs only optical nets as bidir
+    pt_helper.upgrade_signal(nets[0]);
+    pt_helper.upgrade_signal(nets[1]);
+
+    // connect ports
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p0_in, obj->p0_out, nets[0]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p1_in, obj->p1_out, nets[1]);
+    pt_helper.connect_uni<spx::ea_signal_type>(obj->p_vin, nets[2], AS_READER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *PhaseShifterElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    cout << "Warning (" << name << "): default coupling power for DC currently set to field." << endl;
+
+    // Verify number of nodes
+    assert(nets.size() == n_nets);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Check if device has to be bidirectional
+    // for PS, if any optical net is bidir, module has to be bidir
+    bool bidirectional = false;
+    bidirectional |= pt_helper.nets->at(nets[0]).bidirectional();
+    bidirectional |= pt_helper.nets->at(nets[1]).bidirectional();
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, bidirectional);
+
+    // Verify number of args
+    assert(args.size() <= 2);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        obj->m_sensitivity = args[0].as_double();
+    if(args.size() > 1)
+        obj->m_attenuation_dB = args[1].as_double();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+
+        if (kw == "ATTENUATION" || kw == "ATT")
+            obj->m_attenuation_dB = p.second.as_double();
+        else if (kw == "SENSITIVITY" || kw == "GAIN" || kw == "G")
+            obj->m_sensitivity = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**                    MZI                      **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(MZIElement, pt_helper)
+{
+    // create object with default params
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in1,  nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in2,  nets[1], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out1, nets[2], AS_WRITER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out2, nets[3], AS_WRITER);
+    pt_helper.connect_uni<spx::ea_signal_type>(obj->p_vin,  nets[4], AS_READER);
+
+    return obj;
+}
+
+INSTANTIATE_AND_CONNECT_BI(MZIElement, pt_helper)
+{
+    // create object with default params
+    element_type_bi *obj = new element_type_bi(name.c_str());
+
+    // Update unidirectional nets connected to the waveguide
+    if (!pt_helper.nets->at(nets[0]).bidirectional())
+        (*pt_helper.nets)[nets[0]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[1]).bidirectional())
+        (*pt_helper.nets)[nets[1]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[2]).bidirectional())
+        (*pt_helper.nets)[nets[2]].m_readers_count++;
+    if (!pt_helper.nets->at(nets[3]).bidirectional())
+        (*pt_helper.nets)[nets[3]].m_readers_count++;
+
+    // Bidirectional phase-shifter needs only optical nets as bidir
+    pt_helper.upgrade_signal(nets[0]);
+    pt_helper.upgrade_signal(nets[1]);
+    pt_helper.upgrade_signal(nets[2]);
+    pt_helper.upgrade_signal(nets[3]);
+
+    // connect ports
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p0_in, obj->p0_out, nets[0]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p1_in, obj->p1_out, nets[1]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p2_in, obj->p2_out, nets[2]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p3_in, obj->p3_out, nets[3]);
+    pt_helper.connect_uni<spx::ea_signal_type>(obj->p_vin,             nets[4], AS_READER);
+
+    return obj;
+}
+
+sc_module *MZIElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    cout << "Warning (" << name << "): default coupling power for DC currently set to field." << endl;
+
+    // Verify number of nodes
+    assert(nets.size() == n_nets);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Check if device has to be bidirectional
+    // for PS, if any optical net is bidir, module has to be bidir
+    bool bidirectional = false;
+    bidirectional |= pt_helper.nets->at(nets[0]).bidirectional();
+    bidirectional |= pt_helper.nets->at(nets[1]).bidirectional();
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, bidirectional);
+
+    assert(args.size() <= 1);
+    // Parse positional arguments
+    if(args.size() > 0)
+        // convert from cross-coupling field coef
+        obj->m_ps_sens_rad_v = args[0].as_double();
+    // TODO: other positional args
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "SENSITIVITY")
+            // convert from cross-coupling field coef
+            obj->m_ps_sens_rad_v = p.second.as_double();
+        else if (kw == "LENGTH")
+            obj->m_length_cm = 100 * p.second.as_double();
+        else if (kw == "LENGTH_REF")
+            obj->m_length_ref_cm = 100 * p.second.as_double();
+        else if (kw == "NEFF")
+            obj->m_neff = p.second.as_double();
+        else if (kw == "NG")
+            obj->m_ng = p.second.as_double();
+        else if (kw == "ATT")
+            obj->m_attenuation_dB_cm = p.second.as_double();
+        else if (kw == "IL_DC")
+            obj->m_dc_loss_dB = p.second.as_double();
+        else if (kw == "IL_PHASESHIFTER")
+            obj->m_ps_loss_dB = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**                 Crossing                    **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(CrossingElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in1,  nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in2,  nets[1], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out1, nets[2], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out2, nets[3], AS_READER);
+
+    // return the module
+    return obj;
+}
+
+INSTANTIATE_AND_CONNECT_BI(CrossingElement, pt_helper)
+{
+    element_type_bi *obj = new element_type_bi(name.c_str());
+
+    // Update unidirectional nets connected to the waveguide
+    if (!pt_helper.nets->at(nets[0]).bidirectional())
+        (*pt_helper.nets)[nets[0]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[1]).bidirectional())
+        (*pt_helper.nets)[nets[1]].m_writers_count++;
+    if (!pt_helper.nets->at(nets[2]).bidirectional())
+        (*pt_helper.nets)[nets[2]].m_readers_count++;
+    if (!pt_helper.nets->at(nets[3]).bidirectional())
+        (*pt_helper.nets)[nets[3]].m_readers_count++;
+
+    // Bidirectional crossing needs all optical nets as bidir
+    pt_helper.upgrade_signal(nets[0]);
+    pt_helper.upgrade_signal(nets[1]);
+    pt_helper.upgrade_signal(nets[2]);
+    pt_helper.upgrade_signal(nets[3]);
+
+    // connect ports
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p0_in, obj->p0_out, nets[0]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p1_in, obj->p1_out, nets[1]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p2_in, obj->p2_out, nets[2]);
+    pt_helper.connect_bi<spx::oa_signal_type>(obj->p3_in, obj->p3_out, nets[3]);
+
+    // return the module
+    return obj;
+}
+
+sc_module *CrossingElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Verify number of positional args
+    assert(args.size() <= 2);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        obj->m_attenuation_power_dB = args[0].as_double();
+    if(args.size() > 1)
+        obj->m_crosstalk_power_dB = args[1].as_double();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "ATTENUATION" || kw == "ATT")
+            obj->m_attenuation_power_dB = p.second.as_double();
+        else if (kw == "CROSSTALK" || kw == "XTALK")
+            obj->m_crosstalk_power_dB = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**                  CW Source                  **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(CWSourceElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out, nets[0], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *CWSourceElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    CWSource *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == 1);
+
+    // Verify number of positional args
+    assert(args.size() <= 3);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 1)
+        // convert from cross-coupling field coef
+        obj->setWavelength(args[1].as_double());
+    if(args.size() > 2)
+        obj->setPower(args[2].as_double());
+    if(args.size() > 3)
+        obj->setPhase(args[3].as_double());
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "WL" || kw == "WAVELENGTH")
+            // convert from cross-coupling field coef
+            obj->setWavelength(p.second.as_double());
+        else if (kw == "POWER")
+            // convert from cross-coupling field coef
+            obj->setPower(p.second.as_double());
+        else if (kw == "PHI")
+            continue; // handle it after all power commands are executed
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    // TODO: make this cleaner (priority between setting kwargs...)
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "PHI")
+            obj->setPhase(p.second.as_double());
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**                  VL Source                  **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(VLSourceElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out, nets[0], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *VLSourceElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    VLSource *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Verify number of positional args
+    assert(args.size() <= 1);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 1)
+        obj->setValues(args[0].as_string());
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "FILE")
+        {
+            cerr << "not implemented" << endl;
+            exit(1);
+        }
+        else if (kw == "SCALE")
+        {
+            cerr << "not implemented" << endl;
+            exit(1);
+        }
+        else if (kw == "VALUES")
+        {
+            // cout << "here" << endl;
+            vector<VLSource::time_value_pair_type> values;
+            bool is_string = p.second.type == Variable::STRING;
+            bool is_list = p.second.type == Variable::LIST;
+            if (!is_list && !is_string)
+            {
+                // cout << "A" << endl;
+                cerr << "Variable passed to keyword 'values' should be either:"<< endl;
+                cerr << " - an Nx3 list [[t0, p0, wl0], ...] with t0, p0 and wl0 convertible to double"
+                     << " (or None if no change from previous entry)" << endl;
+                cerr << " - a filename containing the list" << endl;
+                exit(1);
+            }
+
+            if (is_list)
+            {
+                for (const Variable &var : p.second.vec)
+                {
+                    if (var.type != Variable::LIST || var.vec.size() != 3)
+                    {
+                        // cout << "B" << endl;
+                        cerr << "Variable passed to keyword 'values' should be a an Nx3 list [[t0, p0, wl0], ...]" << endl;
+                        cerr << "with t0, p0 and wl0 convertible to double (or None if no change from previous entry)" << endl;
+                        exit(1);
+                    }
+                    for (const Variable &ivar : var.vec)
+                    {
+                        // cout << "C" << ivar.get_str() << endl;
+
+                        if (ivar.is_number() || ivar.is_none())
+                            continue;
+
+                        cerr << "Variable passed to keyword 'values' should be a an Nx3 list [[t0, p0, wl0], ...]" << endl;
+                        cerr << "with t0, p0 and wl0 convertible to double (or None if no change from previous entry)" << endl;
+                        exit(1);
+                    }
+                    double t, p, wl;
+                    int none_cnt = 0;
+                    if (var.vec[0].is_number())
+                        t = var.vec[0].as_double();
+                    else if (var.vec[0].is_none() && ! values.empty())
+                    {
+                        t = values.back().first;
+                        ++none_cnt;
+                    }
+                    else
+                    {
+                        cerr << "First values list entry should be fully specified" << endl;
+                        exit(1);
+                    }
+
+                    if (var.vec[1].is_number())
+                        p = var.vec[1].as_double();
+                    else if (var.vec[1].is_none() && ! values.empty())
+                    {
+                        p = values.back().second.power();
+                        ++none_cnt;
+                    }
+                    else
+                    {
+                        cerr << "First values list entry should be fully specified" << endl;
+                        exit(1);
+                    }
+
+                    if (var.vec[2].is_number())
+                        wl = var.vec[2].as_double();
+                    else if (var.vec[2].is_none() && ! values.empty())
+                    {
+                        wl = values.back().second.getWavelength();
+                        ++none_cnt;
+                    }
+                    else
+                    {
+                        cerr << "First values list entry should be fully specified" << endl;
+                        exit(1);
+                    }
+
+                    if (none_cnt < 3)
+                    // OpticalSignal takes amplitude as value in the constructor
+                        values.emplace_back(t, spx::oa_value_type(sqrt(p), wl));
+                    else
+                    {
+                        cerr << "Values list entry cannot be all none" << endl;
+                    }
+                }
+                obj->setValues(values);
+            }
+
+            if (is_string)
+            {
+                obj->setValues(p.second.as_string());
+            }
+        }
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**                 EVL Source                  **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(EVLSourceElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::ea_signal_type>(obj->p_out, nets[0], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *EVLSourceElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    EVLSource *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Verify number of positional args
+    assert(args.size() <= 1);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 1)
+        obj->setValues(args[0].as_string());
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "FILE")
+        {
+            cerr << "not implemented" << endl;
+            exit(1);
+        }
+        else if (kw == "SCALE")
+        {
+            cerr << "not implemented" << endl;
+            exit(1);
+        }
+        else if (kw == "VALUES")
+        {
+            // cout << "here" << endl;
+            vector<EVLSource::time_value_pair_type> values;
+            bool is_string = p.second.type == Variable::STRING;
+            bool is_list = p.second.type == Variable::LIST;
+            if (!is_list && !is_string)
+            {
+                cerr << "Variable passed to keyword 'values' should be either:"<< endl;
+                cerr << " - an Nx2 list [[t0, V0], ...] with t0 and V0 convertible to double"
+                     << " (or None if no change from previous entry)" << endl;
+                cerr << " - a filename containing the list" << endl;
+                exit(1);
+            }
+
+            if (is_list)
+            {
+                for (const Variable &var : p.second.vec)
+                {
+                    if (var.type != Variable::LIST || var.vec.size() != 2)
+                    {
+                        cerr << "Variable passed to keyword 'values' should be either:"<< endl;
+                        cerr << " - an Nx2 list [[t0, V0], ...] with t0 and V0 convertible to double"
+                            << " (or None if no change from previous entry)" << endl;
+                        cerr << " - a filename containing the list" << endl;
+                        exit(1);
+                    }
+                    for (const Variable &ivar : var.vec)
+                    {
+                        if (ivar.is_number() || ivar.is_none())
+                            continue;
+
+                        cerr << "Variable passed to keyword 'values' should be either:"<< endl;
+                        cerr << " - an Nx2 list [[t0, V0], ...] with t0 and V0 convertible to double"
+                            << " (or None if no change from previous entry)" << endl;
+                        cerr << " - a filename containing the list" << endl;
+                        exit(1);
+                    }
+                    double t, V;
+                    int none_cnt = 0;
+                    if (var.vec[0].is_number())
+                        t = var.vec[0].as_double();
+                    else if (var.vec[0].is_none() && ! values.empty())
+                    {
+                        t = values.back().first;
+                        ++none_cnt;
+                    }
+                    else
+                    {
+                        cerr << "First values list entry should be fully specified" << endl;
+                        exit(1);
+                    }
+
+                    if (var.vec[1].is_number())
+                        V = var.vec[1].as_double();
+                    else if (var.vec[1].is_none() && ! values.empty())
+                    {
+                        V = values.back().second;
+                        ++none_cnt;
+                    }
+                    else
+                    {
+                        cerr << "First values list entry should be fully specified" << endl;
+                        exit(1);
+                    }
+
+                    if (none_cnt < 2)
+                        values.emplace_back(t, spx::ea_value_type(V));
+                    else
+                    {
+                        cerr << "Values list entry cannot be all none" << endl;
+                    }
+                }
+                obj->setValues(values);
+            }
+
+            if (is_string)
+            {
+                obj->setValues(p.second.as_string());
+            }
+        }
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**                   Probe                     **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(ProbeElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect p_in
+    pt_helper.connect_uni<spx::oa_signal_type>(
+        obj->p_in,
+        nets[0],
+        AS_READER
+    );
+
+    // return the module
+    return obj;
+}
+
+sc_module *ProbeElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    Probe *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Verify number of positional args
+    assert(args.size() <= 4);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    if (args.empty() && kwargs.empty())
+    {
+        // cout << "empty args" << endl;
+        obj->m_trace_power = true;
+        obj->m_trace_modulus = true;
+        obj->m_trace_phase = true;
+        obj->m_trace_wavelength = true;
+    }
+
+    // Parse positional args
+    for (size_t i = 0; i < args.size(); ++i)
+    {
+        switch (i) {
+            case 0:
+                obj->m_trace_power = args[i].as_boolean();
+                break;
+            case 1:
+                obj->m_trace_modulus = args[i].as_boolean();
+                break;
+            case 2:
+                obj->m_trace_phase = args[i].as_boolean();
+                break;
+            case 3:
+                obj->m_trace_wavelength = args[i].as_boolean();
+                break;
+            default:
+                cerr << "Too many input arguments for " << name << endl;
+                exit(1);
+        }
+    }
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "POWER" || kw == "POW" || kw == "P")
+            obj->m_trace_power = p.second.as_boolean();
+        else if (kw == "MAGNITUDE" || kw == "MAG" || kw == "MODULUS" || kw == "MOD" || kw == "E")
+            obj->m_trace_modulus = p.second.as_boolean();
+        else if (kw == "PHASE" || kw == "PHI")
+            obj->m_trace_phase = p.second.as_boolean();
+        else if (kw == "WAVELENGTH" || kw == "WL")
+            obj->m_trace_wavelength = p.second.as_boolean();
+        else {
+            cerr << name << ": unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    cout<< "created " << obj->name() << endl;
+    return obj;
+}
+
+/** ******************************************* **/
+/**            Multilambda Probe                **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(MLProbeElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect p_in
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in, nets[0], AS_READER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *MLProbeElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Verify number of positional args
+    assert(args.size() <= 1);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional args
+    if (args.size() > 0)
+    {
+        if (args[0].is_list())
+        {
+            for(auto v: args[0].vec)
+            {
+                obj->m_lambdas.insert(v.as_double());
+            }
+        }
+        else {
+            cerr << "Positional arg to MLPROBE should be a list of wavelengths (e.g. [1.55e-6, 1.54e-6,...])" << endl;
+            exit(1);
+        }
+    }
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "WAVELENGTHS" || kw == "WL") {
+            if (p.second.is_list())
+            {
+                for(auto v: p.second.vec)
+                {
+                    obj->m_lambdas.insert(v.as_double());
+                    //obj->m_lambdas.push_back(v.as_double());
+                }
+            }
+            else {
+                cerr << "value of kwarg \"" << kw << "\" to MLPROBE should be a list of wavelengths (e.g. [1.55e-6, 1.54e-6,...])" << endl;
+                exit(1);
+            }
+        } else {
+            cerr << name << ": unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+
+    return obj;
+}
+
+/** ******************************************* **/
+/**                 Photodetector               **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(PCMCellElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in,  nets[0], AS_READER);
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_out, nets[1], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *PCMCellElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Verify number of positional args
+    assert(args.size() <= 2);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        obj->m_meltEnergy = args[0].as_double();
+    if(args.size() > 1)
+        obj->m_nStates = args[1].as_integer();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "MELT_ENERGY" || kw == "EMELT")
+            obj->m_meltEnergy = p.second.as_double();
+        else if (kw == "N" || kw == "NSTATES")
+            obj->m_nStates = p.second.as_integer();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    if (obj->m_meltEnergy == 0 || obj->m_nStates == 0)
+    {
+        cerr << "PCM Cell needs values for both Emelt and Nstates" << endl;
+        exit(1);
+    }
+    cout << "-----" << endl;
+    return obj;
+}
+
+
+/** ******************************************* **/
+/**                 Photodetector               **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(PhotodetectorElement, pt_helper)
+{
+    element_type_uni *obj = new element_type_uni(name.c_str());
+
+    // connect ports
+    pt_helper.connect_uni<spx::oa_signal_type>(obj->p_in,      nets[0], AS_READER);
+    pt_helper.connect_uni<spx::ea_signal_type>(obj->p_readout, nets[1], AS_WRITER);
+
+    // return the module
+    return obj;
+}
+
+sc_module *PhotodetectorElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    element_type_base *obj = nullptr;
+
+    // Verify number of nets
+    assert(nets.size() == n_nets);
+
+    // Verify number of positional args
+    assert(args.size() <= 2);
+
+    // Create signals if they don't exist
+    pt_helper.create_signals(this);
+
+    // Create the object and connect ports to signals
+    INSTANTIATE(pt_helper, false);
+
+    // Parse positional arguments
+    if(args.size() > 0)
+        obj->m_sampling_time = args[0].as_double();
+    if(args.size() > 1)
+        obj->m_responsivity_A_W = args[1].as_double();
+
+    // Parse keyword arguments
+    for (auto &p: kwargs)
+    {
+        string kw = p.first;
+        strutils::toupper(kw);
+        if (kw == "SAMPLING_TIME" || kw == "TS")
+            obj->m_sampling_time = p.second.as_double();
+        else if (kw == "R" || kw == "RESPONSIVITY" || kw == "GAIN")
+            obj->m_responsivity_A_W = p.second.as_double();
+        else {
+            cerr << "Unknown keyword: " << p.first << endl;
+            exit(1);
+        }
+    }
+    return obj;
+}
+
+/** ******************************************* **/
+/**             Subcircuit instance             **/
+/** ******************************************* **/
+INSTANTIATE_AND_CONNECT_UNI(XElement, pt_helper)
+{
+    (void)pt_helper;
+    return nullptr;
+}
+
+sc_module *XElement::create(ParseTreeCreationHelper &pt_helper) const
+{
+    (void)pt_helper;
+    cerr << "X element should never be called directly" << endl;
+    exit(1);
+    return nullptr;
+}
diff --git a/src/parser/parse_element.h b/src/parser/parse_element.h
new file mode 100644
index 0000000..58ad694
--- /dev/null
+++ b/src/parser/parse_element.h
@@ -0,0 +1,104 @@
+#pragma once
+
+#include "alldevices.h"
+#include "subcircuit_instance.h"
+#include "parse_tree.h"
+#include "specs.h"
+
+#include <initializer_list>
+#include <utility>
+#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+
+using std::pair;
+using std::make_pair;
+using std::string;
+using std::vector;
+using std::map;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::pair;
+using std::unique_ptr;
+
+/** ******************************************* **/
+/**  Helper macros for declaring devices        **/
+/** ******************************************* **/
+#define DECLARE_UNIDIR_ELEMENT(ELEM_NAME, ELEM_NAME_LONG, MOD_CLASS_PREFIX, N_NETS)    \
+    struct ELEM_NAME : public ParseElement {                                           \
+        typedef MOD_CLASS_PREFIX element_type_base;                                    \
+        typedef MOD_CLASS_PREFIX element_type_uni;                                     \
+                                                                                       \
+        const size_t n_nets = N_NETS;                                                  \
+                                                                                       \
+        /* Import constructor from ParseElement */                                     \
+        using ParseElement::ParseElement;                                              \
+                                                                                       \
+        virtual ParseElement *clone() const                                            \
+        { return new ELEM_NAME(*this); }                                               \
+        /* Implement virtual function create(...) to construct element */              \
+        virtual sc_module *create(ParseTreeCreationHelper &pt_helper) const;               \
+        virtual element_type_base *                                                    \
+        instantiate_and_connect_uni(ParseTreeCreationHelper &pt_helper) const;             \
+                                                                                       \
+        virtual string kind() const { return ELEM_NAME_LONG; }                         \
+    };
+
+/*************************************************/
+
+#define DECLARE_BIDIR_ELEMENT(ELEM_NAME, ELEM_NAME_LONG, MOD_CLASS_PREFIX, N_NETS)     \
+                                                                                       \
+    struct ELEM_NAME : public ParseElement {                                           \
+        typedef MOD_CLASS_PREFIX##Base element_type_base;                              \
+        typedef MOD_CLASS_PREFIX##Uni element_type_uni;                                \
+        typedef MOD_CLASS_PREFIX##Bi element_type_bi;                                  \
+                                                                                       \
+        const size_t n_nets = N_NETS;                                                  \
+                                                                                       \
+        /* Import constructor from ParseElement */                                     \
+        using ParseElement::ParseElement;                                              \
+                                                                                       \
+        virtual ParseElement *clone() const                                            \
+        { return new ELEM_NAME(*this); }                                               \
+        /* Implement virtual function create(...) to construct element */              \
+        virtual sc_module *create(ParseTreeCreationHelper &pt_helper) const;               \
+        virtual element_type_base *                                                    \
+        instantiate_and_connect_uni(ParseTreeCreationHelper &pt_helper) const;             \
+        virtual element_type_base *                                                    \
+        instantiate_and_connect_bi(ParseTreeCreationHelper &pt_helper) const;              \
+                                                                                       \
+        virtual string kind() const { return string(ELEM_NAME_LONG) + " (bidir)"; }    \
+    };
+
+/** ******************************************* **/
+/**            Devices declarations             **/
+/** ******************************************* **/
+DECLARE_BIDIR_ELEMENT(WGElement, "WAVEGUIDE", Waveguide, 2);
+DECLARE_BIDIR_ELEMENT(DCElement, "DIRECTIONAL COUPLER", DirectionalCoupler, 4);
+DECLARE_UNIDIR_ELEMENT(MergerElement, "MERGER", Merger, 3);
+DECLARE_UNIDIR_ELEMENT(SplitterElement, "SPLITTER", Splitter, 3);
+DECLARE_BIDIR_ELEMENT(PhaseShifterElement, "PHASE SHIFTER", PhaseShifter, 3);
+DECLARE_BIDIR_ELEMENT(MZIElement, "MZI MODULATOR", MZIActive, 5);
+//DECLARE_UNIDIR_ELEMENT(MZIElement, "MZI MODULATOR (2 PHASE-SHIFTER)", MZI, 6);
+DECLARE_BIDIR_ELEMENT(CrossingElement, "CROSSING", Crossing, 4);
+DECLARE_UNIDIR_ELEMENT(CWSourceElement, "CW SOURCE", CWSource, 1);
+DECLARE_UNIDIR_ELEMENT(VLSourceElement, "VALUE LIST SOURCE (OPTICAL)", VLSource, 1);
+DECLARE_UNIDIR_ELEMENT(EVLSourceElement, "VALUE LIST SOURCE (ELECTRICAL)", EVLSource, 1);
+
+// TODO: make the following bidirectional
+DECLARE_UNIDIR_ELEMENT(PCMCellElement, "PCM CELL", PCMElement, 2);
+DECLARE_UNIDIR_ELEMENT(PhotodetectorElement, "PHOTODETECTOR", Detector, 2);
+DECLARE_UNIDIR_ELEMENT(ProbeElement, "PROBE", Probe, 1);
+DECLARE_UNIDIR_ELEMENT(MLProbeElement, "MULTIWAVELENGTH PROBE", MLambdaProbe, 1);
+
+// TODO: take care of subcircuit instance...
+DECLARE_UNIDIR_ELEMENT(XElement, "SUBCIRCUIT", SubcircuitInstance, 1);
+
+/** ******************************************* **/
+/**        Undefine macros                      **/
+/** ******************************************* **/
+#undef DECLARE_UNIDIR_ELEMENT
+#undef DECLARE_BIDIR_ELEMENT
\ No newline at end of file
diff --git a/src/parser/parse_tree.cpp b/src/parser/parse_tree.cpp
new file mode 100644
index 0000000..76c67b0
--- /dev/null
+++ b/src/parser/parse_tree.cpp
@@ -0,0 +1,972 @@
+#include "parse_tree.h"
+#include "parse_directive.h"
+#include "parse_element.h"
+#include "specs.h"
+
+#include <sstream>
+#include <iomanip>
+
+using std::ostringstream;
+
+using spx::oa_value_type;
+using spx::ea_value_type;
+using spx::ed_value_type;
+
+using spx::ed_bus_type;
+using spx::oa_signal_type;
+using spx::ea_signal_type;
+using spx::ed_signal_type;
+using spx::ed_bus_type;
+
+#include "../build/parser/parser.tab.h"
+#include "../build/parser/parser.yy.h"
+
+vector<shared_ptr<sc_object>> ParseNet::create(const string &name, bool force_bidir) const
+{
+    if ( !bidirectional() && !force_bidir )
+        return { create_uni(name) };
+    else
+    {
+        assert(type() == OANALOG && "Only optical nets can be bidirectional for now");
+        return { create_uni((name + "_0").c_str()), create_uni((name + "_1").c_str()) };
+    }
+}
+
+shared_ptr<sc_object> ParseNet::create_uni(const string &name) const
+{
+    switch (m_type)
+    {
+        case OANALOG:
+            return { make_shared<spx::oa_signal_type>(name.c_str()) };
+        case EANALOG:
+            return { make_shared<spx::ea_signal_type>(name.c_str()) };
+        case EDIGITAL:
+            if (m_size == 1)
+                return { make_shared<spx::ed_signal_type>(name.c_str()) };
+            else
+                return { make_shared<spx::ed_bus_type>(name.c_str(), sc_lv_base(m_size)) };
+        default:
+            cerr << "Unknown net type: " << name << endl;
+            exit(1);
+    }
+    return { nullptr };
+}
+
+string ParseNet::name_from_id(int id)
+{
+    assert(id >= 0);
+    ostringstream ss;
+    ss << "N" << std::setfill('0') << std::setw(5) << id;
+    return ss.str();
+}
+
+// return next bidir net which doesn't have a corresponding signal in circuit_signals
+map<string, ParseNet>::iterator ParseTreeCreationHelper::next_fresh_bidir_net()
+{
+    for (auto it = pt->nets.begin(); it != pt->nets.end(); ++it)
+    {
+        const auto &net = *it;
+
+        // check if net is bidirectional
+        if (!net.second.bidirectional())
+            continue;
+
+        // check if net has a corresponding signal instanciated
+        auto it_sig = find_if(circuit_signals.cbegin(), circuit_signals.cend(), [&it](const auto &p)
+        { return p.first == it->first; }
+        );
+        if (it_sig != circuit_signals.cend())
+            continue;
+
+        // check if net is unbound
+        auto it_elem = next_fresh_element_bound_to(it->first);
+        if (it_elem == pt->elements.cend())
+            continue;
+
+        return it;
+    }
+    return pt->nets.end();
+}
+
+// return next bidir net which doesn't have a corresponding signal in circuit_signals
+map<string, ParseNet>::iterator ParseTreeCreationHelper::next_fresh_net()
+{
+    for (auto it = pt->nets.begin(); it != pt->nets.end(); ++it)
+    {
+        // check if net has a corresponding signal
+        auto it_sig = find_if(circuit_signals.cbegin(), circuit_signals.cend(), [&it](const auto &p)
+        { return p.first == it->first; }
+        );
+        if (it_sig != circuit_signals.cend())
+            continue;
+
+        // check if net is unbound
+        auto it_elem = next_fresh_element_bound_to(it->first);
+        if (it_elem == pt->elements.cend())
+            continue;
+
+        return it;
+    }
+    return pt->nets.end();
+}
+
+// return next element which is connected to "net_name" and doesnt have a corresponding
+// module in circuit_modules and isn't already in the backlog
+vector<ParseElement *>::iterator ParseTreeCreationHelper::next_fresh_element_bound_to(const string &net_name, const set<const ParseElement *> &excludes)
+{
+    // Loop over elements
+    for (auto it = pt->elements.begin(); it != pt->elements.end(); ++it)
+    {
+        const auto &elem = *it;
+
+        // Check if element is part of exlude set
+        if (excludes.find(elem) != excludes.cend())
+            continue;
+
+        // Check if element is part of backlog set
+        if (elements_backlog.find(elem) != elements_backlog.cend())
+            continue;
+
+        // Check if net_name is in element nets
+        if (find(elem->nets.cbegin(), elem->nets.cend(), net_name) == elem->nets.cend())
+            continue;
+
+        // Check if element has a corresponding module instantiated
+        auto it_mod = find_if(circuit_modules.cbegin(), circuit_modules.cend(), [&it](const auto &p)
+        { return p.first == (*it)->name; }
+        );
+
+        // if not, return current iterator `it`
+        if (it_mod == circuit_modules.cend())
+            return it;
+    }
+    return pt->elements.end();
+}
+
+void ParseTreeCreationHelper::create_signals(const ParseElement *elem)
+{
+    // element should be in the parsetree
+    assert(find(pt->elements.begin(), pt->elements.end(), elem) != pt->elements.end());
+
+    // for all nets connected to elements
+    for (const auto &net : elem->nets)
+    {
+        // find whether it has already been instantiated
+        if (circuit_signals.find(net) == circuit_signals.end())
+        {
+            // if not, do it
+            circuit_signals.emplace(net, pt->nets.at(net).create(net));
+
+            // verify the net had no connection (it would be a bug otherwise,
+            // since it hadn't been instantiated)
+            assert(pt->nets.at(net).m_connect_count == 0);
+
+            // find all elements connected to net and add them to the elements backlog
+            // FIXME: potential bug here if an element can have both bidir and unidir nets
+            auto it = next_fresh_element_bound_to(net, {elem});
+            while (it != pt->elements.end())
+            {
+                elements_backlog.insert(*it);
+                it = next_fresh_element_bound_to(net, {elem});
+            }
+        }
+    }
+}
+
+void ParseTreeCreationHelper::upgrade_signal(const string &net_name)
+{
+    // Upgrade even if: net.bidirectional() is false
+
+    // The signal should exist because it has been created by pt_helper.create_signals()
+    // but it doesn't hurt to check once more time
+    assert(circuit_signals.find(net_name) != circuit_signals.end());
+
+    // Set the bidirectional flag to true
+    pt->nets[net_name].m_bidirectional = true;
+
+    // Check if the net was created as unidirectional (only one signal)
+    if (circuit_signals.at(net_name).size() == 1)
+    {
+        // if the existing signal is unidirectional
+
+        // check if a port is already connected to the signal
+        if (pt->nets[net_name].m_connect_count)
+        {
+            // if yes, that means a port is already connected to the signal
+            // we cannot easily re-instantiate it as it may be bound to a port;
+            // instead, we add a second signal to the vector to make it bidirectional
+            circuit_signals[net_name].push_back(pt->nets[net_name].create_uni(net_name + "_1"));
+
+            // For bidirectional signals, first port to connect binds to signal_0
+            // for writing and signal_1 for reading
+            // Therefore we have to "re-create" this scenario, as if the first device
+            // connected to a bidirectional net. But for this we need to know which
+            // if the first device was a writer or a reader.
+
+            // first determine if the connected port was writing or reading the signal
+            bool has_writer = pt->nets[net_name].m_connect_writer_count;
+            bool has_reader = pt->nets[net_name].m_connect_reader_count;
+
+            // only one should be true since the net was unidirectional
+            assert(has_writer ^ has_reader);
+
+            // if a writer, then it's as expected
+            if (has_writer)
+            {
+                // if a writer, then it's as expected:
+                // the next port will connect to signal_1 for writing
+                // we just need to update the number of "readers" connected to the net
+                pt->nets[net_name].m_readers_count++;
+            }
+            else
+            {
+                // if a writer, then the next port needs to reverse its order.
+                // for this we swap signal_0 and signal_1
+                swap(circuit_signals[net_name][0], circuit_signals[net_name][1]);
+                // then we need to update the number of "writers" connected to the net
+                pt->nets[net_name].m_writers_count++;
+            }
+        }
+        else
+        {
+            // otherwise, we can recreate the first signal as well
+            circuit_signals[net_name].clear(); // will delete the net through the constructor
+            circuit_signals[net_name] = pt->nets.at(net_name).create(net_name);
+        }
+    }
+}
+
+string ParseElement::to_json() const
+{
+    // name
+    // kind()
+    // nets
+    // args
+    // kwargs
+
+    stringstream ss;
+    ss << "{";
+    ss << "\"name\":" << '"' << name << '"';
+    ss << ',';
+    ss << "\"type\":" << '"' << kind() << '"';
+    ss << ',';
+    ss << "\"nets\":";
+    {
+        ss << '[';
+        for (size_t i = 0; i < nets.size(); ++i)
+        {
+            ss << '"' << nets[i] << '"';
+            if (i != nets.size() - 1)
+                ss << ", ";
+        }
+        ss << ']';
+    }
+    ss << ',';
+    ss << "\"args\":";
+    {
+        ss << '[';
+        for (size_t i = 0; i < args.size(); ++i)
+        {
+            ss << args[i].to_json();
+            if (i != args.size() - 1)
+                ss << ", ";
+        }
+        ss << ']';
+    }
+    ss << ',';
+    ss << "\"kwargs\":";
+    {
+        ss << '{';
+        for (auto it = kwargs.begin(); it != kwargs.end(); ++it)
+        {
+            if (it != kwargs.begin())
+                ss << ',';
+            ss << '"' << it->first << '"' << ':';
+            ss << it->second.to_json();
+        }
+        ss << '}';
+    }
+    ss << '}';
+    return ss.str();
+}
+
+ParseTree::ParseTree(const string &name, const ParseSubcircuit &subcircuit, const map<string, Variable> &kwargs)
+: ParseTree(name)
+{
+    parent = subcircuit.parent;
+    is_subcircuit = true;
+
+    // take kwargs as local assignments
+    local_assignments = subcircuit.kwargs;
+
+    for (const auto &p : kwargs)
+    {
+        if (local_assignments.count(p.first) == 0)
+        {
+            cerr << name << ": Unknown subcircuit parameter " << p.first << endl;
+            exit(1);
+        }
+        local_assignments[p.first] = p.second;
+    }
+
+    yyscan_t scanner;
+    YY_BUFFER_STATE buf;
+
+    yylex_init(&scanner);
+    buf = yy_scan_string(subcircuit.netlist.c_str(), scanner);
+    yy_switch_to_buffer(buf, scanner);
+
+    int parsing_result = yyparse(scanner, this);
+
+    //yy_delete_buffer(buf, scanner);
+    yylex_destroy(scanner);
+
+    // Return if unsuccessful
+    if (parsing_result != 0) {
+        cerr << name << ": failed parsing subcircuit netlist" << endl;
+        exit(1);
+    }
+
+    if (directives.size() > 0)
+    {
+        cerr << name << ": found a directive in subcircuit, ignoring." << endl;
+        directives.clear();
+    }
+
+    if (analyses.size() > 0)
+    {
+        cerr << name << ": found an analysis in subcircuit, ignoring." << endl;
+        analyses.clear();
+    }
+    // print();
+}
+
+int ParseTree::register_directive(ParseDirective *directive)
+{
+    directive->parent = this;
+    directives.push_back(directive);
+    // cout << "Created directive " << directive->kind() << endl;
+    // cout << "current number of directives: " << directives.size() << endl;
+    return directives.size() - 1;
+
+}
+
+int ParseTree::register_element(ParseElement *element)
+{
+    element->name = name_prefix() + element->name;
+    strutils::toupper(element->name);
+    element->parent = this;
+    elements.push_back(element);
+    // cout << "Created element " << element->name << endl;
+    // cout << "current number of elements: " << elements.size() << endl;
+    return elements.size() - 1;
+}
+
+int ParseTree::register_analysis(ParseAnalysis *analysis)
+{
+    if ( !analyses.empty() )
+    {
+        cerr << "Attempted to register a new analysis (" << analysis->kind() << ")" << endl;
+        cerr << "But another one was already specified (" << analyses[0]->kind() << ")" << endl;
+        exit(1);
+    }
+    analysis->parent = this;
+    analyses.push_back(analysis);
+    // cout << "Created analysis " << analysis->kind() << endl;
+    // cout << "current number of analysis: " << analyses.size() << endl;
+    return analyses.size() - 1;
+}
+
+int ParseTree::register_subcircuit(string name)
+{
+    strutils::toupper(name);
+    //name = name_prefix() + name;
+
+    auto it = find_if(subcircuits.cbegin(), subcircuits.cend(),
+        [&name](const ParseSubcircuit *p){ return p->name == name;});
+    if (it != subcircuits.cend())
+    {
+        cerr << "Attempted to register a new subcircuit with name " << name << endl;
+        cerr << "But another subcircuit with this name already exists" << endl;
+        exit(1);
+    }
+
+    subcircuits.push_back(new ParseSubcircuit(name, this));
+    int i = subcircuits.size() - 1;
+
+    // TODO: Copy variables definitions ?
+
+    // cout << "Created subcircuit " << subcircuits[i]->name << endl;
+    // cout << "(current number of subcircuits: " << subcircuits.size() << ")" << endl;
+
+    return i;
+}
+
+const ParseSubcircuit *ParseTree::find_subcircuit(const string &name) const
+{
+    auto pred = [&name](const ParseSubcircuit *p) {
+        return p->name == name;
+    };
+    auto it = find_if(subcircuits.begin(), subcircuits.end(), pred);
+    if (it != subcircuits.end())
+        return *it;
+
+    cerr << "Subcircuit definition not found: " << name << endl;
+    exit(1);
+}
+
+void ParseTree::print() const
+{
+    cout << "-----------" << endl;
+    cout << global_assignments.size() << " global assignments" << endl;
+    for (const auto &x : global_assignments)
+        cout << " - " << x.first << " (" << x.second.kind()
+             << ") = " << x.second.get_str() << endl;
+
+    cout << "-----------" << endl;
+    cout << local_assignments.size() << " local assignments" << endl;
+    for (const auto &x : local_assignments)
+        cout << " - " << x.first << " (" << x.second.kind()
+             << ") = " << x.second.get_str() << endl;
+
+    cout << "-----------" << endl;
+    cout << elements.size() << " elements" << endl;
+    for (const auto &x : elements)
+    {
+        cout << " - ";
+        x->print();
+    }
+
+    cout << "-----------" << endl;
+    cout << nets.size() << " named nets" << endl;
+    for (const auto &x : nets)
+        cout << " - " << x.first << ": " << x.second.type_str()
+        << "<" << x.second.size() << ">"
+        << (x.second.bidirectional() ? "b" : "u")
+        << " (" << x.second.m_writers_count << "|" << x.second.m_readers_count << ")"
+        << endl;
+
+    cout << "-----------" << endl;
+    cout << directives.size() << " directives" << endl;
+    for (const auto &x : directives)
+    {
+        cout << " - ";
+        x->print();
+    }
+
+    cout << "-----------" << endl;
+    cout << subcircuits.size() << " subcircuits" << endl;
+    for (const auto &x : subcircuits)
+    {
+        cout << " - ";
+        x->print();
+    }
+
+    cout << "-----------" << endl;
+    cout << analyses.size() << " analyses" << endl;
+    for (const auto &x : analyses)
+    {
+        cout << " - ";
+        x->print();
+    }
+}
+
+string ParseDirective::to_json() const
+{
+    stringstream ss;
+    ss << "{";
+    ss << "\"type\":" << '"' << kind() << '"';
+    ss << ',';
+    ss << "\"args\":";
+    {
+        ss << '[';
+        for (size_t i = 0; i < args.size(); ++i)
+        {
+            ss << args[i].to_json();
+            if (i != args.size() - 1)
+                ss << ", ";
+        }
+        ss << ']';
+    }
+    ss << ',';
+    ss << "\"kwargs\":";
+    {
+        ss << '{';
+        for (auto it = kwargs.begin(); it != kwargs.end(); ++it)
+        {
+            if (it != kwargs.begin())
+                ss << ',';
+            ss << '"' << it->first << '"' << ':';
+            ss << it->second.to_json();
+        }
+        ss << '}';
+    }
+    ss << '}';
+    return ss.str();
+}
+
+string ParseAnalysis::to_json() const
+{
+    stringstream ss;
+    ss << "{";
+    ss << "\"type\":" << '"' << kind() << '"';
+    ss << ',';
+    ss << "\"args\":";
+    {
+        ss << '[';
+        for (size_t i = 0; i < args.size(); ++i)
+        {
+            ss << args[i].to_json();
+            if (i != args.size() - 1)
+                ss << ", ";
+        }
+        ss << ']';
+    }
+    ss << ',';
+    ss << "\"kwargs\":";
+    {
+        ss << '{';
+        for (auto it = kwargs.begin(); it != kwargs.end(); ++it)
+        {
+            if (it != kwargs.begin())
+                ss << ',';
+            ss << '"' << it->first << '"' << ':';
+            ss << it->second.to_json();
+        }
+        ss << '}';
+    }
+    ss << '}';
+    return ss.str();
+}
+
+string ParseSubcircuit::to_json() const
+{
+    stringstream ss;
+    ss << "TODO";
+    return ss.str();
+}
+
+string ParseNet::to_json() const
+{
+    stringstream ss;
+    ss << "{";
+    ss << "\"type\":" << '"' << type_str() << '"';
+    ss << ',';
+    ss << "\"size\":" << m_size;
+    ss << ',';
+    ss << "\"bidirectional\":" << bidirectional();
+    ss << ',';
+    ss << "\"readers\":" << m_readers_count;
+    ss << ',';
+    ss << "\"writers\":" << m_readers_count;
+    ss << '}';
+    return ss.str();
+}
+
+string ParseTree::to_json() const
+{
+    stringstream ss;
+    ss << "{";
+    ss << "\"name\":" << '"' << name << '"';
+    ss << ',';
+    ss << "\"parent\":";
+    if (parent)
+        ss << '"' << parent->name << '"';
+    else
+        ss << "null";
+    ss << ',';
+    ss << "\"is_subcircuit\":" << (is_subcircuit ? "true" : "false");
+    ss << ',';
+    ss << "\"unnamed_nets\":" << unnamed_net_count;
+    ss << ',';
+    ss << "\"nets\":";
+    {
+        ss << '{';
+        for (auto it = nets.begin(); it != nets.end(); ++it)
+        {
+            if (it != nets.begin())
+                ss << ',';
+            ss << '"' << it->first << '"' << ':';
+            ss << it->second.to_json();
+        }
+        ss << '}';
+    }
+    ss << ',';
+    ss << "\"elements\":";
+    {
+        ss << '[';
+        for (size_t i = 0; i < elements.size(); ++i)
+        {
+            ss << elements[i]->to_json();
+            if (i != elements.size() - 1)
+                ss << ", ";
+        }
+        ss << ']';
+    }
+    ss << ',';
+    ss << "\"directives\":";
+    {
+        ss << '[';
+        for (size_t i = 0; i < directives.size(); ++i)
+        {
+            ss << directives[i]->to_json();
+            if (i != directives.size() - 1)
+                ss << ", ";
+        }
+        ss << ']';
+    }
+    ss << ',';
+    ss << "\"analyses\":";
+    {
+        ss << '[';
+        for (size_t i = 0; i < analyses.size(); ++i)
+        {
+            ss << analyses[i]->to_json();
+            if (i != analyses.size() - 1)
+                ss << ", ";
+        }
+        ss << ']';
+    }
+    ss << ',';
+    ss << "\"subcircuits\":";
+    {
+        ss << "\"TODO\"";
+        if (false)
+        {
+            ss << '[';
+            for (size_t i = 0; i < subcircuits.size(); ++i)
+            {
+                ss << subcircuits[i]->to_json();
+                if (i != subcircuits.size() - 1)
+                    ss << ", ";
+            }
+            ss << ']';
+        }
+    }
+    ss << ',';
+    ss << "\"local_variables\":";
+    {
+        ss << '{';
+        for (auto it = local_assignments.begin(); it != local_assignments.end(); ++it)
+        {
+            if (it != local_assignments.begin())
+                ss << ',';
+            ss << '"' << it->first << '"' << ':';
+            ss << it->second.to_json();
+        }
+        ss << '}';
+    }
+    ss << ',';
+    ss << "\"global_variables\":";
+    {
+        ss << '{';
+        for (auto it = global_assignments.begin(); it != global_assignments.end(); ++it)
+        {
+            if (it != global_assignments.begin())
+                ss << ',';
+            ss << '"' << it->first << '"' << ':';
+            ss << it->second.to_json();
+        }
+        ss << '}';
+    }
+    ss << '}';
+    return ss.str();
+}
+
+void ParseTree::build_circuit()
+{
+    cout << "Flattening..." << endl;
+    // flatten current parse tree by expanding subcircuits
+    flatten();
+    cout << "Done (flattening)" << endl;
+
+    auto pt_helper = ParseTreeCreationHelper(this);
+
+    auto &elements_backlog = pt_helper.elements_backlog;
+    auto &circuit_signals = pt_helper.circuit_signals;
+    auto &circuit_modules = pt_helper.circuit_modules;
+
+    // Find first bidirectional net in nets that is not in circuit_nets
+    auto next_net = pt_helper.next_fresh_bidir_net();
+    while(next_net != nets.end())
+    {
+        cout << "Elaborating network of " << next_net->first << "..." << endl;
+
+        // Find elements which are connected
+        auto elem = pt_helper.next_fresh_element_bound_to(next_net->first);
+        while (elem != elements.end())
+        {
+            cout << "Creating " << (*elem)->name << " (reason: connection to bidir net)" << endl;
+            auto mod = (*elem)->create(pt_helper);
+            cout << "Done creating " << (*elem)->name << endl;
+            if (mod->name() != (*elem)->name)
+            {
+                cerr << "Error: a module with name '" << (*elem)->name << "' already exists or";
+                cerr << " it was renamed due to a bad naming." << endl;
+                cerr << "Make sure there is no naming conflict in the netlist" << endl;
+                exit(1);
+            }
+            circuit_modules.emplace(mod->name(), mod);
+
+            // Process backlog elements (elements that were connected to the nets)
+            while ( !elements_backlog.empty() )
+            {
+                auto it = elements_backlog.begin();
+                auto &backlog_elem = *it;
+                cout << "Creating " << backlog_elem->name << " (reason: backlog)" << endl;
+                auto mod = backlog_elem->create(pt_helper);
+                cout << "Done creating " << backlog_elem->name << endl;
+
+                if (mod->name() != (*it)->name)
+                {
+                    cerr << "Error: a module with name '" << (*it)->name << "' already exists or";
+                    cerr << " it was renamed due to a bad naming." << endl;
+                    cerr << "Make sure there is no naming conflict in the netlist" << endl;
+                    exit(1);
+                }
+
+                circuit_modules.emplace(mod->name(), mod);
+                elements_backlog.erase(*it);
+            }
+            elem = pt_helper.next_fresh_element_bound_to(next_net->first);
+        }
+
+        cout << "Done (elaborating network of " << next_net->first << ")" << endl;
+
+        // At this point all elements connected to the bidirectional net have been created
+        // move on to the next one
+        next_net = pt_helper.next_fresh_bidir_net();
+    }
+    cout << "Done with bidirectional nets" << endl;
+    // At this point all bidirectional nets have been created, and all devices
+    // connected to them as well we can proceed with unidirectional nets
+    next_net = pt_helper.next_fresh_net();
+    while(next_net != nets.end())
+    {
+        cout << "Elaborating network of " << next_net->first << "..." << endl;
+
+        // Find elements which are connected
+        auto elem = pt_helper.next_fresh_element_bound_to(next_net->first);
+        while (elem != elements.end())
+        {
+            cout << "Creating " << (*elem)->name << " (reason: connection to unidir net)" << endl;
+            auto mod = (*elem)->create(pt_helper);
+            cout << "Done creating " << (*elem)->name << endl;
+            if (mod->name() != (*elem)->name)
+            {
+                cerr << "Error: a module with name '" << (*elem)->name << "' already exists or";
+                cerr << " it was renamed due to a bad naming." << endl;
+                cerr << "Make sure there is no naming conflict in the netlist" << endl;
+                exit(1);
+            }
+            circuit_modules.emplace(mod->name(), mod);
+
+            // Process backlog elements (elements that were connected to the nets)
+            while ( !elements_backlog.empty() )
+            {
+                auto it = elements_backlog.begin();
+                auto &backlog_elem = *it;
+                cout << "Creating " << backlog_elem->name << " (reason: backlog)" << endl;
+                auto mod = backlog_elem->create(pt_helper);
+                cout << "Done creating " << backlog_elem->name << endl;
+
+                if (mod->name() != (*it)->name)
+                {
+                    cerr << "Error: a module with name '" << (*it)->name << "' already exists or";
+                    cerr << " it was renamed due to a bad naming." << endl;
+                    cerr << "Make sure there is no naming conflict in the netlist" << endl;
+                    exit(1);
+                }
+
+                circuit_modules.emplace(mod->name(), mod);
+                elements_backlog.erase(*it);
+            }
+            elem = pt_helper.next_fresh_element_bound_to(next_net->first);
+        }
+
+        cout << "Done (elaborating network of " << next_net->first << ")" << endl;
+
+        // At this point all elements connected to the bidirectional net have been created
+        // move on to the next one
+        next_net = pt_helper.next_fresh_net();
+    }
+    for (const auto &x : directives)
+        x->create();
+
+    if (! analyses.empty())
+        analyses.at(0)->create();
+
+    // Add all nets and elements to SPECSGlobalConfig
+    for (const auto &x: circuit_modules)
+        specsGlobalConfig.register_object(x.second);
+    for (const auto &x: circuit_signals)
+        for (const auto &sig: x.second)
+            specsGlobalConfig.register_object(sig);
+}
+
+void ParseTree::flatten()
+{
+    cout << "Flattening " << name << endl;
+
+    vector<ParseElement *> elements_flat;
+    map<string, ParseNet> nets_flat = nets;
+
+    // First, find all subcircuit instances (X elements) and ingest their parse-tree
+    // (flattening the global parse-tree)
+    for (auto &elem : elements)
+    {
+        // try to cast as XElement
+        XElement *xelem = dynamic_cast<XElement *>(elem);
+
+        // if unsuccessful, it means the device doesnt need to be flattened
+        if (!xelem)
+        {
+            elements_flat.push_back(elem);
+            continue;
+        }
+
+        // get subcircuit name
+        string subcircuit_name = xelem->args.back().as_string();
+        strutils::toupper(subcircuit_name);
+
+        // get subcircuit definition in element's parent
+        // TODO: figure out if we want global subcircuits
+        auto subcircuit = xelem->parent->find_subcircuit(subcircuit_name);
+
+        // parse the subcircuit netlist into a new parse tree
+        ParseTree sub_pt(xelem->name, *subcircuit, xelem->kwargs);
+
+        // flatten it
+        sub_pt.flatten();
+
+        // Check the number of nets (in args)
+        if(xelem->args.size() - 1 != subcircuit->ports.size())
+        {
+            cerr << "Wrong number of nets for subcircuit instance: ";
+            cerr << xelem->name << endl;
+            exit(1);
+        }
+
+        // Compute net_name equivalence between internal and external nets
+        map<string, string> net_names_translations;
+        for (size_t i = 0; i < subcircuit->ports.size(); ++i)
+        {
+            Variable v = xelem->args[i]; // naming from Xnn ... line
+            string internal_net_name = sub_pt.name_prefix() + subcircuit->ports[i]; // naming from .SUBCKT line
+            string external_net_name = "";
+
+            // build full exposed net_name
+            string net_base;
+
+            // extract from Variable (either string or integer)
+            // normally parser should always transform it to a string variable
+            // for us
+            if (v.type == Variable::STRING)
+                net_base = v.as_string();
+            else if (v.type == Variable::INTEGER)
+                net_base = ParseNet::name_from_id(v.as_integer());
+            else
+            {
+                cerr << "Incompatible net name for " << xelem->name << endl;
+                exit(1);
+            }
+
+            // if a single underscore was given, use the unnamed net count to
+            // define a unique net
+            // FIXME: this way is not correct; it should really increment the
+            // parent's unnamed net count; I think it would be acceptable to
+            // discard const for this, as the user specifically doesn't care about
+            // the actual name of unnamed nets.
+            if (net_base == "_")
+                net_base = "_" + to_string(this->unnamed_net_count++);
+
+            // add current prefix
+            external_net_name = name_prefix() + net_base;
+
+            // see if the net was already defined (was used by another device)
+            if (nets.find(external_net_name) != nets.end())
+            {
+                // if so, combined the previously defined net with the internal one
+                bool ok = sub_pt.nets[internal_net_name].combine_with(nets.at(external_net_name));
+                if (!ok)
+                {
+                    cerr << "Could not reconcile nets: " << internal_net_name;
+                    cerr << " and " << external_net_name << endl;
+                    cerr << "During flattening of " << xelem->name << endl;
+                    exit(1);
+                }
+            }
+            // Add the (potentially combined) net to pt_helper nets
+            nets_flat[external_net_name] = sub_pt.nets.at(internal_net_name);
+
+            // Update the net name translations list
+            net_names_translations[internal_net_name] = external_net_name;
+
+            // Erase the internal net_name (replaced by the global net name)
+            sub_pt.nets.erase(internal_net_name);
+        } // for (size_t i = 0; i < subcircuit->ports.size(); ++i)
+
+        // show result of translation
+        if (false)
+            for (const auto &p : net_names_translations)
+                cout << p.first << " <==> " << p.second << endl;
+
+        // translate internal net names by modifying the elements within the
+        // subcircuit which are bound to them
+        for (auto subelem : sub_pt.elements)
+        {
+            // loop over translation, and update if necessary
+            for (const auto &p : net_names_translations)
+            {
+                auto it = find(subelem->nets.begin(), subelem->nets.end(), p.first);
+                if (it == subelem->nets.end())
+                    continue;
+                *it = p.second;
+            }
+        } // for (auto subelem : sub_pt.elements)
+
+        // insert the (globally named) internal-only nets into flattened netlist
+        nets_flat.insert(sub_pt.nets.cbegin(), sub_pt.nets.cend());
+        // insert the (potentially updated) elements to flattened netlist
+        elements_flat.insert(elements_flat.end(), sub_pt.elements.cbegin(), sub_pt.elements.cend());
+
+        // finally, free the memory of the elem object
+        // note that the pointer itself is still in the elements vector!
+        // we cannot remove it due to the for loop
+        delete elem;
+        elem = nullptr;
+    } // for (auto elem : elements)
+
+    // Print new list of elements and nets
+    if (false)
+    {
+        cout << "-----------" << endl;
+        cout << elements_flat.size() << " elements" << endl;
+        for (const auto &x : elements_flat)
+        {
+            cout << " - ";
+            x->print();
+        }
+
+        cout << "-----------" << endl;
+        cout << nets_flat.size() << " named nets" << endl;
+        for (const auto &x : nets_flat)
+            cout << " - " << x.first << ": " << x.second.type_str()
+            << "<" << x.second.size() << ">"
+            << (x.second.bidirectional() ? "b" : "u")
+            << " (" << x.second.m_writers_count << "|" << x.second.m_readers_count << ")"
+            << endl;
+    }
+
+    // move to flattened nets and elements
+    nets = nets_flat;
+    elements = elements_flat;
+
+    return;
+}
+
+map<string, Variable> ParseTree::global_assignments =
+{
+    { "pi", Variable(M_PI) },
+    { "c",  Variable(299792458.0) },
+};
\ No newline at end of file
diff --git a/src/parser/parse_tree.h b/src/parser/parse_tree.h
new file mode 100644
index 0000000..fbcefbc
--- /dev/null
+++ b/src/parser/parse_tree.h
@@ -0,0 +1,890 @@
+#pragma once
+
+#include "specs.h"
+#include "strutils.h"
+
+#include <initializer_list>
+#include <utility>
+#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+
+using std::pair;
+using std::make_pair;
+using std::string;
+using std::vector;
+using std::map;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::pair;
+using std::unique_ptr;
+
+struct ParseTree;
+struct SUBCKTDirective;
+
+/* Struct to hold a typed variable */
+struct Variable {
+    enum Type {
+        TYPE_MIN = -1,
+        DOUBLE = 0,
+        COMPLEX_DOUBLE,
+        INTEGER,
+        BOOLEAN,
+        STRING,
+        LIST,
+        NONE,
+        TYPE_MAX,
+    };
+    Type type;
+    double num;
+    complex<double> cnum;
+    int inum;
+    bool bnum;
+    string str;
+    vector<Variable> vec;
+
+    Variable(const Variable &v) { *this = v; }
+    Variable(Type type): type(type) {}
+    Variable(double num = 0): type(DOUBLE), num(num) {}
+    explicit Variable(const complex<double> &cnum): type(COMPLEX_DOUBLE), cnum(cnum) {}
+    explicit Variable(int inum): type(INTEGER), inum(inum) {}
+    explicit Variable(bool bnum): type(BOOLEAN), bnum(bnum) {}
+    explicit Variable(const string &str): type(STRING), str(str) {}
+    explicit Variable(const vector<Variable> &vec): type(LIST), vec(vec) {}
+    explicit Variable(const vector<double> &dvec): type(LIST)
+    {
+        vec.resize(dvec.size());
+        for (size_t i = 0; i < dvec.size(); ++i)
+        {
+            vec[i] = Variable(dvec[i]);
+        }
+    }
+
+    bool type_is_valid() const {
+        return TYPE_MIN < type && type < TYPE_MAX;
+    }
+
+    bool is_none() const {
+        return type == NONE;
+    }
+
+    bool is_list() const {
+        return type == LIST;
+    }
+
+    bool is_number() const {
+        return type == DOUBLE || type == INTEGER || type == BOOLEAN;
+    }
+
+    string get_str() const
+    {
+        stringstream ss;
+        switch (type)
+        {
+            case STRING:
+                return str;
+            case DOUBLE:
+                ss << num;
+                return ss.str();
+            case COMPLEX_DOUBLE:
+                ss << cnum.real() << " + " << cnum.imag() << "i";
+                return ss.str();
+            case INTEGER:
+                ss << inum;
+                return ss.str();
+            case BOOLEAN:
+                ss << bnum;
+                return ss.str();
+            case LIST:
+                ss << "[";
+                for (size_t i = 0; i < vec.size(); ++i)
+                {
+                    ss << vec[i].to_json();
+                    if (i != vec.size() - 1)
+                        ss << ", ";
+                }
+                ss << "]";
+                return ss.str();
+            case NONE:
+                return "None";
+            default:
+                cerr << "error: cannot convert variable to string" << endl;
+                exit(1);
+        }
+    }
+
+    string to_json() const
+    {
+        stringstream ss;
+        ss << '{';
+        ss << "\"type\":" << '"' << kind() << '"' << ',';
+        ss << "\"value\":";
+        {
+            stringstream tss;
+            switch (type) {
+            case STRING:
+                tss << '"' << str << '"';
+                break;
+            case DOUBLE:
+                tss << scientific << num;
+                break;
+            case COMPLEX_DOUBLE:
+                tss << "{\"real\":";
+                tss << scientific << cnum.real();
+                tss << ",\"imag\":" << cnum.imag();
+                tss << '}';
+                break;
+            case INTEGER:
+                tss << inum;
+                break;
+            case BOOLEAN:
+                tss << (bnum ? "true" : "false");
+                break;
+            case LIST:
+                tss << "[";
+                for (size_t i = 0; i < vec.size(); ++i) {
+                    tss << vec[i].to_json();
+                    if (i != vec.size() - 1)
+                        tss << ", ";
+                }
+                tss << "]";
+                break;
+            case NONE:
+                tss << "null";
+                break;
+            default:
+                cerr << "error: cannot convert variable to json representation" << endl;
+                exit(1);
+            }
+            ss << tss.str();
+        }
+        ss << '}';
+        return ss.str();
+    }
+
+    double as_double() const
+    {
+        if (type == DOUBLE)
+            return num;
+        if (type == INTEGER)
+            return inum;
+        if (type == BOOLEAN)
+            return bnum;
+        cerr << "Variable cannot be converted to a double value: " << get_str() << endl;
+        exit(1);
+    }
+
+    int as_integer() const
+    {
+        if (type == DOUBLE)
+            return num;
+        if (type == INTEGER)
+            return inum;
+        if (type == BOOLEAN)
+            return bnum;
+        cerr << "Variable cannot be converted to an integer value: " << get_str() << endl;
+        exit(1);
+    }
+
+    bool as_boolean() const
+    {
+        if (type == DOUBLE)
+            return num;
+        if (type == INTEGER)
+            return inum;
+        if (type == BOOLEAN)
+            return bnum;
+        cerr << "Variable cannot be converted to a boolean value: " << get_str() << endl;
+        exit(1);
+    }
+
+    complex<double> as_complex() const
+    {
+        if (type == DOUBLE)
+            return num;
+        if (type == COMPLEX_DOUBLE)
+            return cnum;
+        if (type == INTEGER)
+            return inum;
+        if (type == BOOLEAN)
+            return bnum;
+        cerr << "Variable cannot be converted to a complex value: " << get_str() << endl;
+        exit(1);
+    }
+
+    string as_string() const
+    {
+        if (type == STRING)
+            return str;
+        cerr << "Variable is not a string: " << get_str() << endl;
+        exit(1);
+        return 0;
+    }
+
+    string kind() const
+    {
+        if (type == DOUBLE)
+            return "DOUBLE";
+        if (type == COMPLEX_DOUBLE)
+            return "COMPLEX_DOUBLE";
+        if (type == INTEGER)
+            return "INTEGER";
+        if (type == BOOLEAN)
+            return "BOOLEAN";
+        if (type == STRING)
+            return "STRING";
+        if (type == LIST)
+            return "LIST";
+        if (type == NONE)
+            return "NONE";
+
+        return "UNDEFINED";
+    }
+
+    Variable &operator+=(const Variable &rhs)
+    {
+        num = as_double() + rhs.as_double();
+        type = DOUBLE;
+        return *this;
+    }
+    Variable &operator-=(const Variable &rhs)
+    {
+        num = as_double() - rhs.as_double();
+        type = DOUBLE;
+        return *this;
+    }
+    Variable &operator*=(const Variable &rhs)
+    {
+        num = as_double() * rhs.as_double();
+        type = DOUBLE;
+        return *this;
+    }
+    Variable &operator/=(const Variable &rhs)
+    {
+        num = as_double() / rhs.as_double();
+        type = DOUBLE;
+        return *this;
+    }
+    Variable &operator^=(const Variable &rhs)
+    {
+        num = pow(as_double(), rhs.as_double());
+        type = DOUBLE;
+        return *this;
+    }
+    Variable &operator=(const Variable &rhs) = default;
+    operator string() const { return get_str(); }
+};
+
+/* Dummy circuit directive struct */
+struct ParseDirective {
+    ParseTree *parent;
+    vector<Variable> args; // list of non-keyword arguments found on netlist
+    map<string, Variable> kwargs; // list of kw arguments found on netlist
+
+    ParseDirective()
+    {}
+
+    ParseDirective(const ParseDirective& other) = default;
+
+    virtual void print() const
+    {
+        cout << "DIRECTIVE[" << kind() << "] ";
+        cout << "{";
+        for (const auto &x : args)
+            cout << x.get_str() << " (" << x.kind() << "), ";
+        if ( !args.empty() )
+            cout << "\b\b";
+        cout << "} ";
+        cout << "{";
+        for (const auto &x : kwargs)
+            cout << x.first << " (" << x.second.kind() << ") = " << x.second.get_str() << ", ";
+        if ( !kwargs.empty() )
+            cout << "\b\b";
+        cout << "}" << endl;
+    }
+    virtual string to_json() const;
+
+    virtual ParseDirective *clone() const = 0;
+    virtual void create() const = 0;
+    virtual string kind() const { return "UNDEFINED"; }
+    virtual ~ParseDirective() {}
+};
+
+/* Dummy circuit analysis struct */
+struct ParseAnalysis {
+    const ParseTree *parent;
+    vector<Variable> args; // list of non-keyword arguments found on netlist
+    map<string, Variable> kwargs; // list of kw arguments found on netlist
+
+    ParseAnalysis()
+    {}
+
+    ParseAnalysis(const ParseAnalysis& other) = default;
+
+    void print() const
+    {
+        cout << "ANALYSIS[" << kind() << "] ";
+        cout << "{";
+        for (const auto &x : args)
+            cout << x.get_str() << " (" << x.kind() << "), ";
+        if ( !args.empty() )
+            cout << "\b\b";
+        cout << "} ";
+        cout << "{";
+        for (const auto &x : kwargs)
+            cout << x.first << " (" << x.second.kind() << ") = " << x.second.get_str() << ", ";
+        if ( !kwargs.empty() )
+            cout << "\b\b";
+        cout << "}" << endl;
+    }
+    virtual string to_json() const;
+
+    virtual ParseAnalysis *clone() const = 0;
+    virtual void create() const = 0;
+    virtual string kind() const { return "UNDEFINED"; }
+    virtual ~ParseAnalysis() {}
+};
+
+/* SUBCKT: subcircuit definition */
+struct ParseSubcircuit {
+    string name; // name of the subcircuit
+    string netlist; // subcircuit netlist (extracted from parent netlist)
+    vector<string> ports; // name of ports
+    map<string, Variable> kwargs; // list of kw arguments found on netlist
+    const ParseTree *parent;
+
+    ParseSubcircuit(const string &name, ParseTree *parent = nullptr)
+    : name(name)
+    , parent(parent)
+    {}
+
+    ParseSubcircuit(const ParseSubcircuit& other) = default;
+
+    void register_port(const string &port_name)
+    {
+        auto it = find(ports.cbegin(), ports.cend(), port_name);
+        if (it == ports.cend())
+        {
+            ports.push_back(port_name);
+        }
+        else
+        {
+            cerr << "Subcircuit cannot have duplicate port names";
+            cerr << "(" << port_name << " was already defined)" << endl;
+            exit(1);
+        }
+    }
+    //ParseTree *instantiate(const string &instance_name, const map<string,Variable> &kwargs) const;
+    void print() const
+    {
+        cout << name << " (" << kind() << ") ";
+        for (const auto &x : ports)
+            cout << x << " ";
+        cout << "{";
+        for (const auto &x : kwargs)
+            cout << x.first << " (" << x.second.kind() << ") = " << x.second.get_str() << ", ";
+        if ( !kwargs.empty() )
+            cout << "\b\b";
+        cout << "}" << endl;
+        if (false)
+        {
+            cout << "###########################" << endl;
+            cout << "## Start netlist of " << name << endl;
+            cout << "###########################" << endl;
+            cout << netlist;
+            cout << "###########################" << endl;
+            cout << "## End netlist of " << name << endl;
+            cout << "###########################" << endl;
+        }
+    }
+    string to_json() const;
+    string kind() const
+    { return "SUBCIRCUIT DEFINITION"; }
+    ParseSubcircuit *clone() const
+    { return new ParseSubcircuit(*this); }
+};
+
+/* Dummy circuit net struct (although close to what it should look like) */
+struct ParseNet {
+    /* Possible net types */
+    enum Type {
+        NONE,
+        OANALOG,
+        EANALOG,
+        EDIGITAL,
+    };
+
+    /* Member variables */
+    Type m_type;
+    unsigned int m_size; // number of "wires (more than 1 for buses)
+    bool m_bidirectional = false; // whether the signal should be bidirectional (for oanalog and eanalog representing forward/backward waves)
+    unsigned int m_writers_count = 0; // number of writers
+    unsigned int m_readers_count = 0; // number of readers
+    unsigned int m_ports_count = 0; // number of individual ports connected (in total)
+    unsigned int m_connect_count = 0; // number of ports actually connected (updated during creation phase only)
+    unsigned int m_connect_writer_count = 0; // number of writer ports actually connected (updated during creation phase only)
+    unsigned int m_connect_reader_count = 0; // number of reader ports actually connected (updated during creation phase only)
+
+    /* Constructor */
+    ParseNet(Type type = NONE, unsigned int size = 1): m_type(type), m_size(size) {}
+    ParseNet(const ParseNet &n) = default;
+    inline ParseNet& operator=(const ParseNet &n) = default;
+    bool combine_with(const ParseNet &n)
+    {
+        if (m_type != n.m_type)
+            return false;
+        if (m_size != n.m_size)
+            return false;
+        if (m_connect_count || n.m_connect_count)
+            return false;
+
+        m_bidirectional |= n.m_bidirectional;
+        m_writers_count += n.m_writers_count;
+        m_readers_count += n.m_readers_count;
+        m_ports_count += n.m_ports_count;
+
+        return true;
+    }
+
+    /* const Getters */
+    unsigned int size() const { return m_size; }
+    Type type() const { return m_type; }
+    bool bidirectional() const
+    {
+        return m_bidirectional || (m_writers_count == 2);
+        //return m_bidirectional || (m_writers_count == 2) || (m_readers_count == 2);
+    }
+    bool validate() const
+    {
+        return m_writers_count <= 2 && m_ports_count <= 2;
+    }
+
+    /* setters */
+    inline bool setType(Type type, bool force = false) {
+        //cout << type_str() << " - " << ParseNet(type).type_str() << endl;
+        if (m_type == type)
+            // no need to do anything
+            return true;
+        if (m_type == NONE || force)
+        {
+            m_type = type;
+            return true;
+        }
+        // cerr << "Incompatible net type assignment" << endl;
+        return false;
+    }
+
+    string type_str() const
+    {
+        switch (m_type) {
+        case Type::NONE:
+            return "NONE";
+        case Type::OANALOG:
+            return "OANALOG";
+        case Type::EANALOG:
+            return "EANALOG";
+        case Type::EDIGITAL:
+            return "EDIGITAL";
+        default:
+            cerr << "Unexpected type" << endl;
+            exit(1);
+        }
+    }
+
+    string to_json() const;
+
+    // create the net
+    vector<shared_ptr<sc_object>> create(const string &name, bool force_bidir = false) const;
+    shared_ptr<sc_object> create_uni(const string &name) const;
+
+    /* Get a generic net name from net number (different from id) */
+    static string name_from_id(int net_number);
+};
+
+struct ParseTreeCreationHelper;
+
+/* Dummy circuit element struct (although close to )*/
+struct ParseElement {
+    typedef sc_module element_type_base;
+
+    string name;
+    const ParseTree *parent;
+    vector<string> nets; // name of parent nets connected to element
+    vector<Variable> args; // list of non-keyword arguments found on netlist
+    map<string, Variable> kwargs; // list of kw arguments found on netlist
+
+    const int n_nets = 0;
+    const bool bidirectionalable = false;
+
+    ParseElement(const string &name)
+    : name(name)
+    {}
+
+    ParseElement(const string &name, const vector<string> &nets)
+    : name(name)
+    , nets(nets)
+    {}
+
+    ParseElement(const ParseElement& other) = default;
+
+    void print() const
+    {
+        cout << name << " (" << kind() << ") ";
+        for (const auto &x : nets)
+            cout << x << " ";
+        cout << "{";
+        for (const auto &x : args)
+            cout << x.get_str() << " (" << x.kind() << "), ";
+        if ( !args.empty() )
+            cout << "\b\b";
+        cout << "} ";
+        cout << "{";
+        for (const auto &x : kwargs)
+            cout << x.first << " (" << x.second.kind() << ") = " << x.second.get_str() << ", ";
+        if ( !kwargs.empty() )
+            cout << "\b\b";
+        cout << "}" << endl;
+    }
+
+    virtual ParseElement *clone() const = 0;
+    virtual sc_module *create(ParseTreeCreationHelper &pt_helper) const = 0;
+    virtual element_type_base *instantiate_and_connect_uni(ParseTreeCreationHelper &pt_helper) const = 0;
+    virtual element_type_base *instantiate_and_connect_bi(ParseTreeCreationHelper &pt_helper) const
+    {
+        (void) pt_helper;
+        cerr << "Elements of type " << kind() << " cannot be bidirectional" << endl;
+        exit(1);
+    }
+
+    virtual string kind() const { return "UNDEFINED"; }
+    virtual ~ParseElement() {}
+
+    virtual string to_json() const;
+};
+
+struct ParseTree {
+    string name;
+    const ParseTree *parent = nullptr;
+    bool is_subcircuit = false;
+    size_t unnamed_net_count = 0;
+
+    map<string, ParseNet> nets;
+    vector<string> ports; // only for subcircuits
+    vector<ParseElement *> elements;
+    vector<ParseAnalysis *> analyses;
+    vector<ParseDirective *> directives;
+    vector<ParseSubcircuit *> subcircuits;
+    map<string, Variable> local_assignments;
+    static map<string, Variable> global_assignments;
+
+    ParseTree(const string &name = "ROOT")
+    : name(name)
+    {}
+
+    ParseTree(const string &name, const ParseSubcircuit &subcircuit, const map<string, Variable> &kwargs);
+
+    int register_directive(ParseDirective *directive);
+    int register_element(ParseElement *element);
+    int register_analysis(ParseAnalysis *analysis);
+    int register_subcircuit(string name);
+    const ParseSubcircuit *find_subcircuit(const string &name) const;
+
+    string get_or_create_net(string net_name, unsigned int size = 1,
+                             ParseNet::Type type = ParseNet::NONE)
+    {
+        if (net_name == "_")
+        {
+            net_name = "_" + to_string(unnamed_net_count++);
+        }
+
+        string full_net_name = name_prefix() + net_name;
+        if (nets.count(full_net_name) == 0)
+        {
+            nets.emplace(full_net_name, ParseNet(type, size));
+            return full_net_name;
+        }
+        if (nets[full_net_name].size() != size)
+        {
+            cerr << "Incompatible size: " << net_name << "<" << size << ">"
+                 << " (previously declared size was: " << nets[full_net_name].size()
+                 << ")" << endl;
+            exit(1);
+        }
+        if (nets[full_net_name].type() == ParseNet::NONE && type != ParseNet::NONE)
+            nets[full_net_name].m_type = type;
+        if (type == ParseNet::NONE && nets[full_net_name].type() != ParseNet::NONE)
+            type = nets[full_net_name].m_type;
+        if (nets[full_net_name].type() != type)
+        {
+            cerr << "Incompatible type: " << net_name << "[" << ParseNet(type).type_str() << "]"
+                 << " (previously declared type was: " << nets[full_net_name].type_str()
+                 << ")" << endl;
+            exit(1);
+        }
+        return full_net_name;
+    }
+
+    string get_or_create_net(int i, unsigned int size = 1,
+                             ParseNet::Type type = ParseNet::NONE)
+    {
+        return get_or_create_net(ParseNet::name_from_id(i), size, type);
+    }
+    string get_or_create_net(Variable v, unsigned int size = 1,
+                             ParseNet::Type type = ParseNet::NONE)
+    {
+        if (v.type == Variable::STRING)
+            return get_or_create_net(v.as_string(), size, type);
+        else if (v.type == Variable::INTEGER)
+            return get_or_create_net(v.as_integer(), size, type);
+        else
+        {
+            cerr << "Incompatible variable type for creating a net" << endl;
+            exit(1);
+        }
+    }
+
+    string name_prefix() const
+    {
+        string ret = "";
+        if ( !is_subcircuit && parent )
+        {
+            ret = parent->name_prefix();
+            if ( name.empty() )
+            {
+                cerr << "Name of child parse tree should not be empty" << endl;
+                exit(1);
+            }
+        }
+        ret += name + "/";
+        strutils::toupper(ret);
+        return ret;
+    }
+
+    template <typename T>
+    void set_local_variable(string &name, T val)
+    {
+        // will throw a compile error if type T is not supported by Variable
+        local_assignments[name] = val;
+    }
+
+    template <typename T>
+    void set_global_variable(string &name, T val)
+    {
+        // will throw a compile error if type T is not supported by Variable
+        global_assignments[name] = val;
+    }
+
+    Variable get_variable(string &name)
+    {
+        // try to find variable in locals table first
+        auto it = local_assignments.find(name);
+        if (it != local_assignments.end())
+            return it->second;
+
+        // try to find variable in globals table
+        it = global_assignments.find(name);
+        if (it != global_assignments.end())
+            return it->second;
+
+        // error
+        cerr << "Variable not found: " << name << endl;
+        exit(1);
+    }
+
+    void print() const;
+    string to_json() const;
+
+    ParseTree *clone() const
+    {
+        ParseTree *clone = new ParseTree(name);
+
+        clone->parent = nullptr;
+        clone->ports = ports;
+        clone->nets = nets;
+        clone->local_assignments = local_assignments;
+        clone->unnamed_net_count = unnamed_net_count;
+
+        for (const auto &x : elements)
+            clone->elements.push_back(x->clone());
+        for (const auto &x : analyses)
+            clone->analyses.push_back(x->clone());
+        for (const auto &x : directives)
+            clone->directives.push_back(x->clone());
+        for (const auto &x : subcircuits)
+            clone->subcircuits.push_back(x->clone());
+
+        return clone;
+    }
+    void build_circuit();
+    void flatten();
+
+    ~ParseTree()
+    {
+        if (!parent)
+        {
+            for (const auto &x : elements)
+                if(x) delete x;
+            for (const auto &x : analyses)
+                if(x) delete x;
+            for (const auto &x : directives)
+                if(x) delete x;
+            for (const auto &x : subcircuits)
+                if(x) delete x;
+        }
+    }
+};
+
+struct ParseTreeCreationHelper {
+    ParseTree *pt;
+
+    // backlog: elements to be created in priority
+    map<string, ParseNet> *nets;
+
+    // backlog: elements to be created in priority
+    set<const ParseElement *> elements_backlog;
+
+    // Circuit elements generated by build
+    map<string, vector<shared_ptr<sc_object>>> circuit_signals;
+    map<string, shared_ptr<sc_module>> circuit_modules;
+
+    ParseTreeCreationHelper()
+    : pt(nullptr)
+    {}
+
+    ParseTreeCreationHelper(ParseTree *parse_tree)
+    {
+        resetParseTree(parse_tree);
+    }
+
+    void resetParseTree(ParseTree *parse_tree)
+    {
+        pt = parse_tree;
+        nets = &parse_tree->nets;
+        elements_backlog.clear();
+        circuit_signals.clear();
+        circuit_modules.clear();
+    }
+
+    // return next bidir net which doesn't have a corresponding signal in circuit_signals
+    map<string, ParseNet>::iterator next_fresh_bidir_net();
+
+    // return next net which doesn't have a corresponding signal in circuit_signals
+    map<string, ParseNet>::iterator next_fresh_net();
+
+    // return next element which is connected to "net_name" and doesnt have a corresponding module in circuit_modules
+    vector<ParseElement *>::iterator next_fresh_element_bound_to(const string &net_name, const set<const ParseElement *> &excludes = {});
+
+    // upgrade a signal to bidirectional
+    void upgrade_signal(const string &name);
+
+    // Create signals connected to a given element
+    void create_signals(const ParseElement *elem);
+
+    // Connect a port to a signal using the net name
+    template <typename signal_type, typename port_type>
+    void connect_uni(port_type &port, const string& net_name, bool as_writer);
+
+    // Connect a bidirectional port to a signal pair using the net name
+    template <typename signal_type, typename port_in_type, typename port_out_type>
+    void connect_bi(port_in_type &p_in, port_out_type &p_out, const string& net_name);
+
+    ~ParseTreeCreationHelper()
+    {}
+};
+
+/** ******************************************* **/
+/**  Non-specialized template implementations   **/
+/** ******************************************* **/
+
+template <typename signal_type, typename port_type>
+void ParseTreeCreationHelper::connect_uni(port_type &port, const string& net_name, bool as_writer)
+{
+    assert(pt->nets.find(net_name) != pt->nets.end());
+    const auto &net = pt->nets.at(net_name);
+
+    // Get the signal to be written or read
+    signal_type *sig = nullptr;
+    if ( !net.bidirectional())
+    {
+        auto sig_raw = circuit_signals.at(net_name)[0].get();
+        sig = dynamic_cast<signal_type *>(sig_raw);
+    }
+    else
+    {
+        int i_write = pt->nets.at(net_name).m_connect_count;
+        int i_read = (i_write + 1) % 2;
+        int i = as_writer ? i_write : i_read;
+
+        auto sig_raw = circuit_signals.at(net_name)[i].get();
+        sig = dynamic_cast<signal_type *>(sig_raw);
+    }
+
+    // Check it could correctly be cast to requested type
+    if (!sig)
+    {
+        cerr << "Wrong signal type for " << sig << " connected to "
+             << net_name << endl;
+        exit(1);
+    }
+
+    // Connect the port to the signal
+    port.bind(*sig);
+
+    // Update connection count of the net
+    pt->nets[net_name].m_connect_count++;
+    if (as_writer)
+        pt->nets[net_name].m_connect_writer_count++;
+    else
+        pt->nets[net_name].m_connect_reader_count++;
+}
+
+template <typename signal_type, typename port_in_type, typename port_out_type>
+void ParseTreeCreationHelper::connect_bi(port_in_type &p_in, port_out_type &p_out, const string& net_name)
+{
+    assert(pt->nets.find(net_name) != pt->nets.end());
+    const auto &net = pt->nets.at(net_name);
+
+    if (net.bidirectional())
+    {
+
+        // First get the signal to be written or read (in the right order)
+        int i_write = pt->nets.at(net_name).m_connect_count;
+        int i_read = (i_write + 1) % 2;
+
+        auto sig_writeable_raw = circuit_signals.at(net_name)[i_write].get();
+        auto sig_readable_raw = circuit_signals.at(net_name)[i_read].get();
+        auto sig_writeable = dynamic_cast<signal_type *>(sig_writeable_raw);
+        auto sig_readable = dynamic_cast<signal_type *>(sig_readable_raw);
+
+        // Check they could correctly be cast to requested type
+        if (!sig_writeable)
+        {
+            cerr << "Wrong signal type for " << sig_writeable << " connected to "
+                 << net_name << endl;
+            exit(1);
+        }
+        if (!sig_readable)
+        {
+            cerr << "Wrong signal type for " << sig_readable << " connected to "
+                 << net_name << endl;
+            exit(1);
+        }
+
+        // Connect ports to both signals
+        p_out.bind(*sig_writeable);
+        p_in.bind(*sig_readable);
+
+        // Update connection count of the net
+        pt->nets[net_name].m_connect_count++;
+        pt->nets[net_name].m_connect_writer_count++;
+        pt->nets[net_name].m_connect_reader_count++;
+    }
+    else
+    {
+        cerr << "Expected a bidirectional net for " << net_name << endl;
+        exit(1);
+    }
+}
\ No newline at end of file
diff --git a/src/parser/parser.l b/src/parser/parser.l
new file mode 100644
index 0000000..ca689a3
--- /dev/null
+++ b/src/parser/parser.l
@@ -0,0 +1,438 @@
+ALPHA [[:alpha:]]
+DIGIT [0-9]
+ALPHA_NUM {ALPHA}|{DIGIT}
+ALPHA_PLUS {ALPHA}|[_]
+ALPHA_PLUS_NUM {ALPHA}|[_]|{DIGIT}
+D {DIGIT}
+
+DOUBLE (({D}+)|({D}*\.{D}+))([eE][-+]?[0-9]+)?
+
+BIDIR_SPECIFIER [&]
+BIN_OPERATOR [,=\*/\+\-\^]
+PAR_OPERATOR [\{\}\(\)\[\]<>]
+OPERATOR {BIN_OPERATOR}|{PAR_OPERATOR}|{BIDIR_SPECIFIER}
+
+
+WS [  \t]
+WS_BREAK (?:[^{WS}])
+
+/* EOL_DOS \r\n */
+/* EOL_UNIX \n */
+/* EOL_OLD_MAC \n */
+EOL_PORTABLE \r?\n
+EOL {EOL_PORTABLE}
+
+%option warn
+%option yylineno
+%option noyywrap
+%option caseless
+%option reentrant
+%option bison-bridge
+%option stack
+
+%{
+#include <string>
+#include <sstream> // for conversions of numbers from str
+#include <cstring> // for strcpy
+#include <vector>
+#include "parse_tree.h"
+
+#include "parser.tab.h"
+
+using std::string;
+using std::vector;
+
+#define YY_NO_INPUT
+#define YY_NO_UNPUT
+#define YY_EXTRA_TYPE void*
+
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size, yyscan_t scanner);
+void yypush_buffer_state ( YY_BUFFER_STATE buffer, yyscan_t scanner);
+void yypop_buffer_state ( yyscan_t scanner );
+int yyget_lineno ( yyscan_t scanner );
+int yyget_column ( yyscan_t scanner );
+void yyset_extra ( YY_EXTRA_TYPE user_defined, yyscan_t scanner );
+YY_EXTRA_TYPE yyget_extra ( yyscan_t scanner );
+
+int yylerror(yyscan_t scanner, const char *p)
+{
+    cerr << "error (line " << yyget_lineno(scanner) << "): " << p << endl;
+    string * str = (string *)yyget_extra(scanner);
+    if (str)
+        cerr << "\twhile parsing line: " << *str << endl;
+    return 3;
+}
+
+ParseTree *cur_pt = nullptr;
+
+static int internal_subckt_count = 0;
+static size_t delete_me_npos = 0;
+
+template<typename T>
+static T from_string(const string &str)
+{
+    std::stringstream ss(str);
+    T ret;
+    ss >> ret;
+    return ret;
+}
+
+%}
+
+/*** States ***/
+/* %x IN_DQUOTES */
+%x INCLUDE
+%s SUBCKT_DECLARATION
+%x SUBCKT_DEFINITION
+/*Quoted string (returns char[]) (capture until next '"' and throw error on newline)*/
+%x IN_DQUOTES
+
+
+
+/* To ignore case: (?i:xxx) */
+
+%%  /*** Rules section ***/
+
+^\.include  {yy_push_state(INCLUDE, yyscanner);}
+<INCLUDE>{WS}*      /* eat the whitespace */
+<INCLUDE>[^ ;\t\n\r]+   { /* got the include file name */
+        yyin = fopen( yytext, "r" );
+
+        if ( ! yyin )
+        {
+            cerr << "Error: included file not found \"" << yytext << "\"" << endl;
+            exit(1);
+        }
+        cout << "Including file: " << yytext << endl;
+        yypush_buffer_state(yy_create_buffer( yyin, YY_BUF_SIZE, yyscanner), yyscanner);
+
+        //yy_push_state(INITIAL, yyscanner);
+        BEGIN(INITIAL);
+        }
+
+<IN_DQUOTES>\" {
+    yy_pop_state(yyscanner);
+    // cout << "leaving dquotes mode" << endl;
+    return '"';
+    }
+<IN_DQUOTES>{EOL} { exit(yylerror(yyscanner, "Unmatched double quote")); }
+<IN_DQUOTES>[^\"\r\n]* {
+    // cout << "found quoted string: " << yytext << endl;
+    yylval_param->s_ptr = new string(yytext);
+    return T_STR;
+    }
+
+<SUBCKT_DECLARATION>{EOL} {
+    // end of subcircuit declaration line (.subckt name node1 node2...)
+    // go into subckt_definition state, which copies all text to a string
+    // until the corresponding .ends is reached
+    yylval_param->s_ptr = new string;
+    internal_subckt_count = 0;
+    delete_me_npos = 0;
+    // cout << endl << "going to subckt definition mode" << endl;
+    BEGIN(SUBCKT_DEFINITION); //needs BEGIN and not yy_push_state
+}
+
+<SUBCKT_DEFINITION>^\.SUBCKT {
+    // cout << "hello2" << endl;
+    // increase internal count for keeping track of included subcircuits
+    internal_subckt_count++;
+    // but reject the rule and go to the next matching pattern
+    // (i.e. save the line to the string)
+    REJECT;
+}
+
+<SUBCKT_DEFINITION>^\.ENDS {
+    if (internal_subckt_count)
+    {
+        // found .ends of included subcircuit
+        // decrease internal count
+        --internal_subckt_count;
+        // but reject the rule and go to the next matching pattern
+        // (i.e. save the line to the string)
+        REJECT;
+    }
+    else
+    {
+        // found .ends of current subcircuit
+        // go back to normal parsing
+        //BEGIN(INITIAL);
+        yy_pop_state(yyscanner);
+        // return .ends token so that the subcircuit string is recorded
+        return T_DIRECTIVE_ENDS;
+    }
+}
+
+<SUBCKT_DEFINITION>. {
+    /* save characters to buffer as-is */
+    *yylval_param->s_ptr += yytext;
+}
+
+<SUBCKT_DEFINITION>{EOL} {
+    /* save characters to buffer */
+    *yylval_param->s_ptr += yytext;
+
+    // cout << "found subckt line: " << yylval_param->s_ptr->substr(delete_me_npos);
+    // delete_me_npos = yylval_param->s_ptr->size();
+}
+
+<SUBCKT_DEFINITION><<EOF>> {
+    cerr << "Reached end of file before end of subcircuit definition" << endl;
+    exit(1);
+}
+
+\" {
+    yy_push_state(IN_DQUOTES, yyscanner);
+    // cout << "entering dquotes mode" << endl;
+    return '"';
+    }
+
+[+-]?{D}+ {
+    /* signed integer number */
+    yylval_param->i_val = from_string<int>(yytext);
+    return T_INT;
+}
+
+[+-]?{DOUBLE} {
+    /* signed floating point number */
+    yylval_param->d_val = from_string<double>(yytext);
+    return T_NUM;
+}
+
+(;[^\n]*) {
+    /* inline comment starts with ; */
+    continue;
+}
+
+^(\*[^\n]*) {
+    /* full line comment starts with **/
+    continue;
+}
+
+^X({ALPHA_PLUS_NUM})+ {
+    /* subcircuit instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_X;
+}
+
+^WG({ALPHA_PLUS_NUM})+ {
+    /* waveguide instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_WG;
+}
+
+^MERGER({ALPHA_PLUS_NUM})+ {
+    /* merger instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_MERGER;
+}
+
+^SPLITTER({ALPHA_PLUS_NUM})+ {
+    /* merger instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_SPLITTER;
+}
+
+^COUPLER({ALPHA_PLUS_NUM})+ {
+    /* DC instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_COUPLER;
+}
+
+^PSHIFT({ALPHA_PLUS_NUM})+ {
+    /* PHASESHIFTER instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_PSHIFT;
+}
+
+^MZI({ALPHA_PLUS_NUM})+ {
+    /* MZI instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_MZI;
+}
+
+^CROSSING({ALPHA_PLUS_NUM})+ {
+    /* CROSSING instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_CROSSING;
+}
+
+^CWSRC({ALPHA_PLUS_NUM})+ {
+    /* Continuous-wave source instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_CWSRC;
+}
+
+^VLSRC({ALPHA_PLUS_NUM})+ {
+    /* Value-list source instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_VLSRC;
+}
+
+^EVLSRC({ALPHA_PLUS_NUM})+ {
+    /* Electric Value-list source instance name */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_EVLSRC;
+}
+
+^PROBE({ALPHA_PLUS_NUM})+ {
+    /* Probe instance */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_PROBE;
+}
+
+^MLPROBE({ALPHA_PLUS_NUM})+ {
+    /* Probe instance */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_MLPROBE;
+}
+
+^PDET({ALPHA_PLUS_NUM})+ {
+    /* Probe instance */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_PDET;
+}
+
+^PCMCELL({ALPHA_PLUS_NUM})+ {
+    /* Probe instance */
+    yylval_param->s_ptr = new string(yytext);
+    return T_ELEM_PCMCELL;
+}
+
+^\.ASSIGN { return T_LOCAL_ASSIGNMENT; }
+^\.PARAM { return T_LOCAL_ASSIGNMENT; }
+^\.SAVE { return T_DIRECTIVE_SAVE; }
+
+^\.OP { return T_ANALYSIS_OP; }
+^\.DC { return T_ANALYSIS_DC; }
+^\.TRAN { return T_ANALYSIS_TRAN; }
+
+^\.OPTIONS { return T_DIRECTIVE_OPTIONS; }
+^\.NODESET { return T_DIRECTIVE_NODESET; }
+^\.IC { exit(1); }
+^\.SUBCKT {
+    /* Subcircuit declaration */
+    // enter new parser state
+    yy_push_state(SUBCKT_DECLARATION, yyscanner);
+    // return token so bison can correctly parse the declaration
+    return T_DIRECTIVE_SUBCKT;
+}
+
+<INITIAL>^\.ENDS {
+    cerr << "Unexpeced '.ENDS' directive" << endl;
+    exit(1);
+}
+
+{ALPHA_PLUS}{ALPHA_PLUS_NUM}*/{WS}*= {
+    yylval_param->s_ptr = new string(yytext);
+
+    return T_ASSIGN_ID;
+}
+
+{ALPHA_PLUS}{ALPHA_PLUS_NUM}* {
+    yylval_param->s_ptr = new string(yytext);
+
+    /*
+    if (yylval_param->s_ptr == "null")
+        return T_NONE;
+    if (yylval_param->s_ptr == "true")
+    {
+        yylval_param->b_val = true;
+        return T_BOOL;
+    }
+    if (yylval_param->s_ptr == "false")
+    {
+        yylval_param->b_val = false;
+        return T_BOOL;
+    }
+    */
+    return T_STR;
+}
+
+{OPERATOR} {
+    yylval_param->c_val = yytext[0];
+    return yytext[0];
+}
+
+{WS} ;
+
+^.*/{EOL} {
+    string * str = (string *)yyget_extra(yyscanner);
+    if (!str)
+        str = new string;
+    *str = yytext;
+    yyset_extra((void *)str, yyscanner);
+    REJECT;
+}
+
+(?# the following lines are for compatibility with KiCad generated netlists)
+(?# they were added fast with relatively no checking for potential problems if)
+(?# the keywords are found in subcircuit files or included files)
+^\.TITLE({WS}.*)?/{EOL} {
+    // cout << "Found '.title' directive, ignoring." << endl;
+}
+^\.END {
+    // cout << "Found '.end' directive, ignoring." << endl;
+}
+
+(?# Ignore EOL followed by '+' -- line continuation)
+{EOL}\+ ;
+
+{EOL} { return '\n'; }
+
+<INITIAL,INCLUDE><<EOF>> {
+    yypop_buffer_state(yyscanner);
+
+        if ( !YY_CURRENT_BUFFER )
+        {
+        yyterminate();
+        }
+        return '\n';
+    }
+
+<SUBCKT_DECLARATION,IN_DQUOTES><<EOF>> {
+    exit(yylerror(yyscanner, "Unexpected end of file."));
+}
+
+<*>. {
+    stringstream msg;
+    msg << "Unexpected character: \"";
+    switch (yytext[0])
+    {
+        case '\r':
+            msg << "\\r";
+            break;
+        case '\n':
+            msg << "\\n";
+            break;
+        case '\t':
+            msg << "\\t";
+            break;
+        case '\b':
+            msg << "\\b";
+            break;
+        default:
+            msg << yytext[0];
+            break;
+    }
+    msg << "\"";
+    exit(yylerror(yyscanner, msg.str().c_str()));
+    }
+%%
+
+/* END */
+
+/* ^.OP(?:{WS}+) { return T_DIRECTIVE_OP; } */
+/* ^.DC(?:{WS}+) { return T_DIRECTIVE_DC; } */
+
+/* Quoted string with 2 strings on the same line (returns char [])
+\"[^\"\\]*\" {
+    int n = strlen(yytext) - 2;
+    yylval_param->sv = new char[n+1];
+    strncpy(yylval_param->sv, yytext + 1, n);
+    yylval_param->sv[n] = '\0';
+    return T_QUOTED_STR;
+}
+*/
+
+
diff --git a/src/parser/parser.y b/src/parser/parser.y
new file mode 100644
index 0000000..36be00f
--- /dev/null
+++ b/src/parser/parser.y
@@ -0,0 +1,961 @@
+%define api.pure full
+%param { yyscan_t scanner }
+
+
+%code requires{
+    typedef void * yyscan_t;
+    // char *yyget_text ( yyscan_t yyscanner );
+    // int yyget_lineno ( yyscan_t yyscanner );
+    // int yylex(YYSTYPE * yylval, yyscan_t scanner);
+
+    //extern int yylineno;
+    //extern char *yytext;
+}
+
+%{
+#include <iostream>
+#include <string>
+#include <vector>
+#include <cstring>
+#include <cmath>
+#include <memory>
+#include "parse_tree.h"
+#include "parse_element.h"
+#include "parse_analysis.h"
+#include "parse_directive.h"
+
+#include "../build/parser/parser.tab.h"
+#include "../build/parser/parser.yy.h"
+
+using std::string;
+using std::vector;
+using std::pow;
+
+extern ParseTree *cur_pt;
+
+/*int yyerror(yyscan_t scanner, ParseTree *pt, const char *err)
+{
+    (void)pt;
+    (void)p;
+    printf("Error in the netlist (line %u:\"%s\")\n", yylineno, yytext);
+    printf("-- Error at line %u:\n\t%s\n", yylineno, err);
+    return 0;
+}
+*/
+int yyerror(yyscan_t scanner, ParseTree *pt, const char *err);
+%}
+
+%union {
+    double                  d_val;
+    int                     i_val;
+    char                    c_val;
+    string                 *s_ptr;
+    char                   *c_ptr;
+    vector<double>         *vec_d_ptr;
+    pair<string, Variable> *assig_ptr;
+    Variable               *variable_ptr;
+    vector<Variable>       *vec_var_ptr;
+    pair<string, string>   *elemattr_ptr;
+    pair<string, pair<string, Variable>> *netval_assign_ptr;
+    pair<pair<string, string>, vector<double>> *cw_sweep_order_ptr;
+}
+
+// %define api.value.type {struct YYSTYPE}
+
+%token <d_val> T_NUM
+%token <i_val> T_INT
+%token <i_val> T_NONE
+%token <s_ptr> T_STR
+%token <s_ptr> T_ASSIGN_ID
+%token <s_ptr> T_ELEM_CWSRC T_ELEM_VLSRC T_ELEM_EVLSRC
+%token <s_ptr> T_ELEM_WG T_ELEM_COUPLER T_ELEM_MERGER T_ELEM_SPLITTER
+%token <s_ptr> T_ELEM_PSHIFT T_ELEM_MZI T_ELEM_CROSSING T_ELEM_PCMCELL
+%token <s_ptr> T_ELEM_PROBE T_ELEM_MLPROBE T_ELEM_PDET
+%token <s_ptr> T_ELEM_X
+%token <i_val> T_ANALYSIS_OP T_ANALYSIS_DC T_ANALYSIS_TRAN
+%token <i_val> T_DIRECTIVE_OPTIONS T_DIRECTIVE_NODESET
+%token <i_val> T_DIRECTIVE_SUBCKT
+%token <s_ptr> T_DIRECTIVE_ENDS
+%token <s_ptr> T_DIRECTIVE_SAVE
+%token <i_val> T_LOCAL_ASSIGNMENT
+%type <c_val> '='
+
+
+// Available circuit elements
+%type <i_val> element.wg
+%type <i_val> element.merger
+%type <i_val> element.splitter
+%type <i_val> element.coupler
+%type <i_val> element.pshift
+%type <i_val> element.mzi
+%type <i_val> element.crossing
+%type <i_val> element.pcm_cell
+%type <i_val> element.cwsrc
+%type <i_val> element.vlsrc
+%type <i_val> element.evlsrc
+%type <i_val> element.probe
+%type <i_val> element.mlprobe
+%type <i_val> element.pdet
+%type <i_val> element.x
+
+// Available analysis
+%type <i_val> analysis.op
+%type <i_val> analysis.dc
+%type <i_val> analysis.tran
+%type <cw_sweep_order_ptr> cw_sweep_order
+
+// Available directives
+%type <i_val> directive.options
+%type <i_val> directive.nodeset
+
+// Rules for circuit nets (value is index in PT elements)
+%type <s_ptr> net_name.base.str
+%type <s_ptr> net_name_base
+%type <s_ptr> net_name
+%type <s_ptr> net.oanalog net.eanalog net.edigital
+%type <s_ptr> net.oa.explicit_bidir
+%type <s_ptr> net.oa.bidir
+%type <s_ptr> net.oa.in
+%type <s_ptr> net.oa.out
+
+//%type <s_ptr> bus_name bus bus.oanalog bus.eanalog bus.edigital
+
+// Rules related to subcircuits
+%type <i_val> subcircuit
+%type <i_val> subcircuit.with_ports
+%type <i_val> subcircuit.with_assignments
+%type <s_ptr> port_name
+
+// Rules for circuit elements (value is index in PT elements arrays)
+%type <i_val> atomelement element
+%type <i_val> element.with_args element.with_kwargs
+%type <i_val> element.x.with_args element.x.with_kwargs
+
+// Rules for circuit analysis (value is ptr to ParseAnalysis)
+%type <i_val> atomanalysis analysis
+%type <i_val> analysis.with_args analysis.with_kwargs
+
+// Rules for simulator directives (value is ptr to ParseDirective)
+%type <i_val> atomdirective directive
+%type <i_val> directive.with_args directive.with_kwargs
+
+// For argument parsing
+%type <assig_ptr> assignment
+%type <variable_ptr> variable variable_base variable_or_empty
+%type <variable_ptr> variable.free_expr variable.delimited_expr
+//%type <variable_ptr> variable.str_without_quotes
+%type <netval_assign_ptr> netval_assignment
+%type <elemattr_ptr> element_attribute
+
+// For expression parsing
+%type <variable_ptr> expr term fact pow constant
+%type <variable_ptr> listvar.tail listvar.unbound listvar.bound //TODO: check
+
+// Add parse tree parameter to yyparse signature
+%parse-param {ParseTree *pt}
+//%verbose
+//%define parse.error detailed
+//%define parse.trace
+
+// On start, set current parse tree to the one passed in call to yyparse
+%initial-action {
+    cur_pt = pt;
+    if (!pt)
+        yyerror(scanner, pt, "Invalid parse tree pointer");
+}
+
+
+%%
+
+input: %empty
+     | input line '\n'
+;
+
+line: %empty
+    | element { /* cout << "Inserted element: " << cur_pt->elements[$1]->name << endl; */ }
+    | analysis { /* cout << "Registered analysis [...]" << endl; */ }
+    | directive { /* cout << "Registered directive [...]" << endl; */ }
+    | subcircuit { /* cout << "Parsed subcircuit [...]" << endl; */ }
+    | local_assignment { /* cout << "Processed local assignment [...]" << endl; */ }
+;
+
+local_assignment: T_LOCAL_ASSIGNMENT assignment
+                    {
+                        cur_pt->set_local_variable($2->first, $2->second);
+                    }
+                | local_assignment assignment
+                    {
+                        cur_pt->set_local_variable($2->first, $2->second);
+                    }
+;
+
+/* --------- Directives definitions parsing ----------- */
+
+directive.options: T_DIRECTIVE_OPTIONS { $$ = cur_pt->register_directive(new OPTIONSDirective); }
+;
+
+directive.nodeset: T_DIRECTIVE_NODESET { $$ = cur_pt->register_directive(new NODESETDirective); }
+                 | directive.nodeset netval_assignment
+                    {
+                        static_cast<NODESETDirective *>(cur_pt->directives[$1])->net_assignments[$2->first].push_back($2->second);
+                        $$ = $1;
+                    }
+;
+subcircuit.with_ports: T_DIRECTIVE_SUBCKT T_STR
+                    {
+                        // Register a new subcircuit in current parse tree
+                        $$ = cur_pt->register_subcircuit(*$2);
+                        delete $2;
+                    }
+                | subcircuit.with_ports port_name
+                    {
+                        if (!cur_pt->subcircuits[$1]->kwargs.empty())
+                        {
+                            cerr << "Expected keyword assignment in subcircuit declaration but got: " << *$2 << endl;
+                            exit(1);
+                        }
+                        // cout << *$2 << endl;
+                        cur_pt->subcircuits[$1]->register_port(*$2);
+                        $$ = $1;
+                        delete $2;
+                    }
+;
+subcircuit.with_assignments:
+  subcircuit.with_assignments assignment
+                        {
+                            cur_pt->subcircuits[$1]->kwargs[$2->first] = $2->second;
+
+                            $$ = $1;
+                            delete $2;
+                        }
+| subcircuit.with_ports
+;
+
+subcircuit: subcircuit.with_assignments T_DIRECTIVE_ENDS
+            {
+                // cout << "Parsed subcircuit " << cur_pt->subcircuits[$1]->name << endl;
+                cur_pt->subcircuits[$1]->netlist = *$2;
+                delete $2;
+            }
+;
+
+/* --------- Elements definitions parsing ----------- */
+
+element.wg: T_ELEM_WG net.oa.in net.oa.out
+            {
+                $$ = cur_pt->register_element(new WGElement(*$1, {*$2, *$3}));
+                delete $1;
+                delete $2;
+                delete $3;
+            }
+;
+
+element.merger: T_ELEM_MERGER net.oa.in net.oa.in net.oa.out
+            {
+                $$ = cur_pt->register_element(new MergerElement(*$1, {*$2, *$3, *$4}));
+                delete $1;
+                delete $2;
+                delete $3;
+                delete $4;
+            }
+;
+
+element.splitter: T_ELEM_SPLITTER net.oa.in net.oa.out net.oa.out
+            {
+                $$ = cur_pt->register_element(new SplitterElement(*$1, {*$2, *$3, *$4}));
+                delete $1;
+                delete $2;
+                delete $3;
+                delete $4;
+            }
+;
+
+element.coupler: T_ELEM_COUPLER net.oa.in net.oa.in net.oa.out net.oa.out
+            {
+                $$ = cur_pt->register_element(new DCElement(*$1, {*$2, *$3, *$4, *$5}));
+                delete $1;
+                delete $2;
+                delete $3;
+                delete $4;
+                delete $5;
+            }
+;
+
+element.pshift: T_ELEM_PSHIFT net.oa.in net.oa.out net.eanalog
+            {
+                $$ = cur_pt->register_element(new PhaseShifterElement(*$1, {*$2, *$3, *$4}));
+                delete $1;
+                delete $2;
+                delete $3;
+                delete $4;
+            }
+;
+
+element.mzi: T_ELEM_MZI net.oa.in net.oa.in net.oa.out net.oa.out net.eanalog
+            {
+                $$ = cur_pt->register_element(new MZIElement(*$1, {*$2, *$3, *$4, *$5, *$6}));
+                delete $1;
+                delete $2;
+                delete $3;
+                delete $4;
+                delete $5;
+                delete $6;
+            }
+;
+
+element.crossing: T_ELEM_CROSSING net.oa.in net.oa.in net.oa.out net.oa.out
+            {
+                $$ = cur_pt->register_element(new CrossingElement(*$1, {*$2, *$3, *$4, *$5}));
+                delete $1;
+                delete $2;
+                delete $3;
+                delete $4;
+                delete $5;
+            }
+;
+
+element.pcm_cell: T_ELEM_PCMCELL net.oa.in net.oa.out
+            {
+                $$ = cur_pt->register_element(new PCMCellElement(*$1, {*$2, *$3}));
+                delete $1;
+                delete $2;
+                delete $3;
+            }
+;
+
+element.cwsrc: T_ELEM_CWSRC net.oa.out
+            {
+                $$ = cur_pt->register_element(new CWSourceElement(*$1, {*$2}));
+                delete $1;
+                delete $2;
+            }
+;
+
+element.vlsrc: T_ELEM_VLSRC net.oa.out
+            {
+                $$ = cur_pt->register_element(new VLSourceElement(*$1, {*$2}));
+                delete $1;
+                delete $2;
+            }
+;
+
+element.evlsrc: T_ELEM_EVLSRC net.eanalog
+            {
+                $$ = cur_pt->register_element(new EVLSourceElement(*$1, {*$2}));
+                delete $1;
+                delete $2;
+            }
+;
+
+element.probe: T_ELEM_PROBE net.oa.in
+            {
+                $$ = cur_pt->register_element(new ProbeElement(*$1, {*$2}));
+                delete $1;
+                delete $2;
+            }
+;
+
+element.mlprobe: T_ELEM_MLPROBE net.oa.in
+            {
+                $$ = cur_pt->register_element(new MLProbeElement(*$1, {*$2}));
+                delete $1;
+                delete $2;
+            }
+;
+
+element.pdet: T_ELEM_PDET net.oa.in net.eanalog
+            {
+                $$ = cur_pt->register_element(new PhotodetectorElement(*$1, {*$2, *$3}));
+                delete $1;
+                delete $2;
+                delete $3;
+            }
+;
+
+element.x: T_ELEM_X
+            {
+                $$ = cur_pt->register_element(new XElement(*$1));
+                delete $1;
+            }
+;
+
+/* --------- Analyses definitions parsing ----------- */
+
+analysis.op: T_ANALYSIS_OP
+                { $$ = cur_pt->register_analysis(new OPAnalysis()); }
+;
+
+analysis.dc: T_ANALYSIS_DC
+                { $$ = cur_pt->register_analysis(new DCAnalysis()); }
+           | analysis.dc cw_sweep_order
+                {
+                    auto ana = dynamic_cast<DCAnalysis *>(cur_pt->analyses[$1]);
+                    if (ana->sweep_orders.size())
+                    {
+                        cerr << "Registering more than one DC sweep is not supported yet." << endl;
+                        exit(1);
+                    }
+                    ana->register_sweep_order(*$2);
+                    delete $2;
+                }
+;
+
+analysis.tran: T_ANALYSIS_TRAN
+                { $$ = cur_pt->register_analysis(new TRANAnalysis()); }
+;
+
+
+/* ---------- Directives arguments parsing ----------- */
+
+atomdirective: directive.options { $$ = $1; }
+             | directive.nodeset { $$ = $1; }
+;
+
+directive.with_args:
+  directive.with_args variable
+            {
+                // cout << "found positional arg: " << $2->get_str() << endl;
+                if (!cur_pt->directives[$1]->kwargs.empty())
+                    yyerror(scanner, pt, "positional arguments cannot follow keyword arguments");
+                cur_pt->directives[$1]->args.emplace_back(*$2);
+                $$ = $1;
+                delete $2;
+            }
+| atomdirective { $$ = $1; }
+;
+
+directive.with_kwargs:
+  directive.with_kwargs assignment
+            {
+                // cout << "found keyword arg: " << $2->second.get_str() << endl;
+                cur_pt->directives[$1]->kwargs[$2->first] = $2->second;
+                $$ = $1;
+                delete $2;
+            }
+| directive.with_args
+;
+
+directive: directive.with_kwargs
+;
+
+/* --------- Elements arguments parsing ----------- */
+
+atomelement: element.wg { $$ = $1; }
+           | element.merger { $$ = $1; }
+           | element.splitter { $$ = $1; }
+           | element.coupler { $$ = $1; }
+           | element.pshift { $$ = $1; }
+           | element.mzi { $$ = $1; }
+           | element.crossing { $$ = $1; }
+           | element.pcm_cell { $$ = $1; }
+           | element.cwsrc { $$ = $1; }
+           | element.vlsrc { $$ = $1; }
+           | element.evlsrc { $$ = $1; }
+           | element.probe { $$ = $1; }
+           | element.mlprobe { $$ = $1; }
+           | element.pdet { $$ = $1; }
+;
+
+element.with_args:
+  element.with_args variable
+            {
+                // cout << "found positional arg: " << $2->get_str() << endl;
+                if (!cur_pt->elements[$1]->kwargs.empty())
+                    yyerror(scanner, pt, "positional arguments cannot follow keyword arguments");
+                cur_pt->elements[$1]->args.emplace_back(*$2);
+                $$ = $1;
+
+                // TODO: for X element only, nets are stored as args
+                // Xnnnn n1 n2 n3 ... sub_name **sub_kwargs
+                // because the number of nets is not known when reading n1 n2 n3...
+                // [n1 n2 n3 ... subname] are also args
+                // when the  time an arg is found, the previous one (if it exists), can be considered a net
+                // and therefore added to the element's nets array and discarded from args
+                // this will ensure that args will contain only [sub_name]
+                // for this to work, the X element cannot have args beyond sub_name (only kwargs)
+                if (cur_pt->elements[$1]->args.size() == 2)
+                {
+                    // check if the args[0] is a valid net name
+                    // create net with name args[0] (by default with type NONE)
+                    // add args[0] to nets
+                    // delete args[0] from args
+                }
+
+                delete $2;
+            }
+| atomelement { $$ = $1; }
+;
+
+element.with_kwargs:
+  element.with_kwargs assignment
+            {
+                // cout << "found keyword arg: " << $2->second.get_str() << endl;
+                cur_pt->elements[$1]->kwargs[$2->first] = $2->second;
+                $$ = $1;
+                delete $2;
+            }
+| element.with_args
+;
+
+element.x.with_args:
+  element.x.with_args net_name_base
+            {
+                // cout << "found positional arg: " << $2->get_str() << endl;
+                if (!cur_pt->elements[$1]->kwargs.empty())
+                    yyerror(scanner, pt, "positional arguments cannot follow keyword arguments");
+                cur_pt->elements[$1]->args.emplace_back(Variable(*$2));
+                $$ = $1;
+
+                // TODO: for X element only, nets are stored as args
+                // Xnnnn n1 n2 n3 ... sub_name **sub_kwargs
+                // because the number of nets is not known when reading n1 n2 n3...
+                // [n1 n2 n3 ... subname] are also args
+                // when the  time an arg is found, the previous one (if it exists), can be considered a net
+                // and therefore added to the element's nets array and discarded from args
+                // this will ensure that args will contain only [sub_name]
+                // for this to work, the X element cannot have args beyond sub_name (only kwargs)
+                if (cur_pt->elements[$1]->args.size() == 2)
+                {
+                    // check if the args[0] is a valid net name
+                    // create net with name args[0] (by default with type NONE)
+                    // add args[0] to nets
+                    // delete args[0] from args
+                }
+
+                delete $2;
+            }
+| element.x { $$ = $1; }
+;
+
+element.x.with_kwargs:
+  element.x.with_kwargs assignment
+            {
+                // cout << "found keyword arg: " << $2->second.get_str() << endl;
+                cur_pt->elements[$1]->kwargs[$2->first] = $2->second;
+                $$ = $1;
+                delete $2;
+            }
+| element.x.with_args
+;
+
+element:
+  element.with_kwargs
+| element.x.with_kwargs
+;
+
+/* ---------- Analysis arguments parsing ----------- */
+
+atomanalysis: analysis.op { $$ = $1; }
+            | analysis.dc { $$ = $1; }
+            | analysis.tran { $$ = $1; }
+;
+
+analysis.with_args:
+  analysis.with_args variable
+            {
+                // cout << "found positional arg: " << $2->get_str() << endl;
+                if (!cur_pt->analyses[$1]->kwargs.empty())
+                    yyerror(scanner, pt, "positional arguments cannot follow keyword arguments");
+                cur_pt->analyses[$1]->args.emplace_back(*$2);
+                $$ = $1;
+                delete $2;
+            }
+| atomanalysis { $$ = $1; }
+;
+
+analysis.with_kwargs:
+  analysis.with_kwargs assignment
+            {
+                // cout << "found keyword arg: " << $2->second.get_str() << endl;
+                cur_pt->analyses[$1]->kwargs[$2->first] = $2->second;
+                $$ = $1;
+                delete $2;
+            }
+| analysis.with_args
+;
+
+analysis: analysis.with_kwargs
+
+/* --------- NET type parsing ----------- */
+
+net.oanalog: net_name
+                {
+                    bool ok = cur_pt->nets[*$1].setType(ParseNet::OANALOG);
+                    if (!ok)
+                    {
+                        stringstream ret;
+                        ret << "Error creating net '" + *$1 + "': net already exists with a different type" << endl;
+                        ret << "\t (new type: " << "OANALOG" << ", old type: " << cur_pt->nets[*$1].type_str() << ")" << endl;
+                        yyerror(scanner, pt, ret.str().c_str());
+                    }
+                    cur_pt->nets[*$1].m_ports_count++;
+                    $$ = $1;
+                }
+;
+
+net.oa.explicit_bidir:
+  net.oanalog '&'
+    {
+        // this net will be both written to and read from by the new device
+        // so increment both reader and writer count
+        // and set the explicit "bidirectional" flag to true
+        cur_pt->nets[*$1].m_bidirectional = true;
+        cur_pt->nets[*$1].m_readers_count++;
+        cur_pt->nets[*$1].m_writers_count++;
+        $$ = $1;
+    }
+;
+
+net.oa.bidir:
+  net.oa.explicit_bidir
+| net.oanalog
+    {
+        // this net will be both written to and read from by the new device
+        // so increment both reader and writer count
+        cur_pt->nets[*$1].m_readers_count++;
+        cur_pt->nets[*$1].m_writers_count++;
+        $$ = $1;
+    }
+;
+
+net.oa.in:
+  net.oanalog
+    {
+    // this net will only be read from by the new device
+    // so increment only reader count
+    cur_pt->nets[*$1].m_readers_count++;
+    $$ = $1;
+    }
+| net.oa.explicit_bidir
+    {
+    // bidir already got a writer and reader increment, but
+    // this net will only be read from by the new device
+    // so decrement writer count
+    cur_pt->nets[*$1].m_writers_count--;
+    $$ = $1;
+    }
+;
+
+net.oa.out:
+  net.oanalog
+    {
+    // this net will only be written to by the new device
+    // so increment only writer count
+    cur_pt->nets[*$1].m_writers_count++;
+    $$ = $1;
+    }
+| net.oa.explicit_bidir
+    {
+    // bidir already got a writer and reader increment, but
+    // this net will only be written to by the new device
+    // so decrement reader count
+    cur_pt->nets[*$1].m_readers_count--;
+    $$ = $1;
+    }
+;
+
+net.eanalog: net_name
+                {
+                    bool ok = cur_pt->nets[*$1].setType(ParseNet::EANALOG);
+                    if (!ok)
+                    {
+                        stringstream ret;
+                        ret << "Error creating net '" + *$1 + "': net already exists with a different type" << endl;
+                        ret << "\t (new type: " << "EANALOG" << ", old type: " << cur_pt->nets[*$1].type_str() << ")" << endl;
+                        yyerror(scanner, pt, ret.str().c_str());
+                    }
+                    $$ = $1;
+                }
+
+net.edigital: net_name
+                {
+                    bool ok = cur_pt->nets[*$1].setType(ParseNet::EDIGITAL);
+                    if (!ok)
+                    {
+                        stringstream ret;
+                        ret << "Error creating net '" + *$1 + "': net already exists with a different type" << endl;
+                        ret << "\t (new type: " << "EDIGITAL" << ", old type: " << cur_pt->nets[*$1].type_str() << ")";
+                        yyerror(scanner, pt, ret.str().c_str());
+                    }
+                    $$ = $1;
+                }
+;
+
+/* --------- BUS type parsing ----------- */
+
+/*
+bus.oanalog: bus_name
+                {
+                    cur_pt->nets[*$1].m_type = ParseNet::OANALOG;
+                    $$ = $1;
+                }
+;
+
+bus.eanalog: bus_name
+                {
+                    cur_pt->nets[*$1].m_type = ParseNet::EANALOG;
+                    $$ = $1;
+                }
+;
+
+bus.edigital: bus_name
+                {
+                    cur_pt->nets[*$1].m_type = ParseNet::EDIGITAL;
+                    $$ = $1;
+                }
+;
+bus: bus.oanalog { $$ = $1; }
+   | bus.eanalog { $$ = $1; }
+   | bus.edigital { $$ = $1; }
+;
+*/
+/* --------- NET and BUS name parsing ----------- */
+
+net_name.base.str:
+              T_STR { $$ = $1; }
+            | '/' T_STR
+                {
+                    $$ = $2;
+                    *$2 = "/" + *$2;
+                }
+            | '/' T_INT
+                {
+                    stringstream ss;
+                    ss << "/" << $2;
+                    $$ = new string(ss.str());
+                }
+            | net_name.base.str '-' T_STR
+                {
+                    $$ = $1;
+                    *$1 += "-" + *$3;
+                    delete $3;
+                }
+;
+
+net_name_base: T_INT { $$ = new string(ParseNet::name_from_id($1)); }
+             | net_name.base.str { $$ = $1; }
+;
+
+net_name: net_name_base
+            {
+                $$ = new string(cur_pt->get_or_create_net(*$1));
+                delete $1;
+            }
+;
+
+/*
+bus_name: net_name { $$ = $1; }
+        | net_name_base '<' T_INT '>'
+            {
+                $$ = new string(cur_pt->get_or_create_net(*$1, $3));
+                delete $1;
+            }
+;
+*/
+port_name: net_name_base { $$ = $1; }
+;
+
+/* --------- Assignment and variable ----------- */
+
+netval_assignment: '/' net_name '/' T_STR '=' variable.delimited_expr
+                    {
+                        $$ = new pair<string, pair<string, Variable>>(
+                                *$2,
+                                pair<string, Variable>(*$4, *$6)
+                                );
+                        delete $2;
+                        delete $4;
+                        delete $6;
+                    }
+;
+
+cw_sweep_order: element_attribute variable_base variable_base variable_base
+                {
+                    // cout << $1->first << "->" << $1->second;
+                    // cout << " = [" << $2->as_double();
+                    // cout << ":" << $4->as_double();
+                    // cout << ":" << $3->as_double() << "]" << endl;
+                    $$ = new pair<pair<string, string>, vector<double>>(*$1, {$2->as_double(), $3->as_double(), $4->as_double()});
+                    delete $1;
+                    delete $2;
+                    delete $3;
+                    delete $4;
+                }
+;
+
+element_attribute: '/' T_STR '/' T_STR
+                {
+                    // cout << *$2 << "->" << *$4 << endl;
+                    $$ = new pair<string, string>(*$2,*$4);
+                    delete $2;
+                    delete $4;
+                }
+;
+
+assignment: T_ASSIGN_ID '=' variable
+            {
+                $$ = new pair<string, Variable>(*$1, *$3);
+                delete $1;
+                delete $3;
+            }
+;
+
+variable_base:
+          T_INT
+            {
+                $$ = new Variable($1);
+            }
+        | T_NUM
+            {
+                $$ = new Variable($1);
+            }
+        | T_NONE
+            {
+                $$ = new Variable(Variable::NONE);
+            }
+        | '{' T_STR '}'
+            {
+                $$ = new Variable(cur_pt->get_variable(*$2));
+                delete $2;
+            }
+        | '"' T_STR '"'
+            {
+                $$ = new Variable(*$2);
+                delete $2;
+            }
+        | listvar.bound
+            {
+                $$ = $1;
+            }
+;
+
+variable.delimited_expr:
+  '{' expr '}'
+    {
+        $$ = $2;
+    }
+| variable_base;
+;
+
+variable.free_expr:
+  expr
+    {
+        $$ = $1;
+    }
+;
+
+variable:
+  variable.free_expr
+;
+
+/*
+variable.str_without_quotes:
+  T_STR
+    {
+        if (*$1 == "None")
+            $$ = new Variable(Variable::NONE);
+        else
+            $$ = new Variable(*$1);
+        delete $1;
+    }
+| variable;
+;
+*/
+
+variable_or_empty:
+  variable
+  | %empty
+    {
+        $$ = new Variable(Variable::NONE);
+    }
+;
+
+/* ------------ Expression parsing ------------- */
+
+constant: variable_base { $$ = $1; }
+;
+
+expr:
+  expr '+' term { $$ = $1; *$$ += *$3; delete $3; }
+| expr '-' term { $$ = $1; *$$ -= *$3; delete $3; }
+| term { $$ = $1; }
+;
+
+term:
+  term '*' fact { $$ = $1; *$$ *= *$3; delete $3; }
+| term '/' fact { $$ = $1; *$$ /= *$3; delete $3; }
+| fact { $$ = $1; }
+;
+
+fact:
+  fact '^' pow { $$ = $1; *$$ ^= *$3; delete $3; }
+| pow { $$ = $1; }
+;
+
+pow:
+  constant
+| '(' expr ')' { $$ = $2; }
+;
+
+// --------------- variables list (elements can have different types)
+listvar.tail: variable_or_empty
+                {
+                    $$ = new Variable(Variable::LIST);
+                    $$->vec.insert($$->vec.begin(), *$1);
+                    delete $1;
+                }
+;
+
+listvar.unbound: variable_or_empty ',' listvar.tail
+                    {
+                        $3->vec.insert($3->vec.begin(), *$1);
+                        $$ = $3;
+                        delete $1;
+                    }
+               | variable_or_empty ',' listvar.unbound
+                    {
+                        $3->vec.insert($3->vec.begin(), *$1);
+                        $$ = $3;
+                        delete $1;
+                    }
+;
+
+listvar.bound: '[' listvar.tail ']' { $$ = $2; }
+             | '[' listvar.unbound ']' { $$ = $2; }
+;
+
+%%
+
+int yyerror(yyscan_t scanner, ParseTree *pt, const char *err)
+{
+    (void)pt;
+    (void)scanner;
+    string token = yyget_text(scanner);
+    stringstream ss;
+    for (char c : token)
+    {
+        switch (c)
+        {
+            case '\r':
+                ss << "\\r";
+                break;
+            case '\n':
+                ss << "\\n";
+                break;
+            case '\t':
+                ss << "\\t";
+                break;
+            case '\b':
+                ss << "\\b";
+                break;
+            default:
+                ss << c;
+                break;
+        }
+    }
+    string token_escaped = ss.str();
+    printf("-- Error in the netlist (line %u): %s\n", yyget_lineno(scanner), err);
+    printf("-- \"%s\"\n", token_escaped.c_str());
+    //cerr << err << endl;
+    exit(1);
+}
diff --git a/src/specs.cpp b/src/specs.cpp
new file mode 100644
index 0000000..2b9727d
--- /dev/null
+++ b/src/specs.cpp
@@ -0,0 +1,383 @@
+#include "bitstream_source.h"
+#include "optical_signal.h"
+#include "sysc_utils.h"
+#include <specs.h>
+#include "spx_module.h"
+#include "value_list_source.h"
+#include "electrical_value_list_source.h"
+
+#include <systemc.h>
+#include <optical_output_port.h>
+#include <spx_module.h>
+#include <cw_source.h>
+#include <probe.h>
+#include <detector.h>
+#include <generic_transmission_device.h>
+
+using std::string;
+
+SPECSConfig specsGlobalConfig { "SPX" };
+
+SPECSConfig::SPECSConfig(sc_module_name name)
+    : sc_module(name)
+{
+    drop_all_events = false;
+    // Simulation options
+    engine_timescale = HUNDRED_FS;
+    simulation_mode = OpticalOutputPortMode::DEFAULT;
+    analysis_type = AnalysisType::TIME_DOMAIN;
+
+    // Port options
+    default_abstol = 1e-8;
+    default_reltol = 1e-4;
+    default_resolution_multiplier = 1;
+
+    // Trace options
+    trace_filename = "traces/delete_me";
+    default_trace_file = nullptr;
+    trace_all_optical_nets = 1;
+}
+
+void SPECSConfig::runAnalysis()
+{
+    applyEngineResolution();
+    prepareSimulation();
+
+    switch (analysis_type) {
+        case CW_OPERATING_POINT:
+            runOPAnalysis();
+            break;
+        case CW_SWEEP:
+            runDCAnalysis();
+            break;
+        case TIME_DOMAIN:
+            runTRANAnalysis();
+            break;
+        default:
+            cerr << "Undefined Analysis type";
+            sc_stop();
+    }
+}
+
+void SPECSConfig::runOPAnalysis()
+{
+    auto all_probes = sc_get_all_module_by_type<Probe>();
+    auto all_mlprobes = sc_get_all_module_by_type<MLambdaProbe>();
+    auto all_photodetectors = sc_get_all_module_by_type<Detector>();
+    auto all_oop = sc_get_all_module_by_type<OpticalOutputPort>();
+    auto all_cws = sc_get_all_module_by_type<CWSource>();
+
+    // Run to initialize all threads and register first values
+    sc_start();
+
+    // Set values of signals according to NODESET directive
+    for (auto &nodeset_order : nodeset_orders)
+    {
+        nodeset_order.second.first->write(nodeset_order.second.second);
+    }
+
+    // Disable probes for OP point
+    for (auto probe: all_probes) {
+        probe->enable = sc_logic(0);
+    }
+
+    // Disable ML probes for OP point
+    for (auto mlprobe: all_mlprobes) {
+        mlprobe->enable = sc_logic(0);
+    }
+
+    // Disable photodetectors
+    for (auto pdet: all_photodetectors) {
+        pdet->enable = sc_logic(0);
+    }
+
+    // Set all ports mode to NO_DELAY
+    for (auto oop: all_oop) {
+        oop->m_mode = OpticalOutputPortMode::NO_DELAY;
+    }
+
+    // Activate all CW sources
+    for (auto cws: all_cws)
+        cws->enable = sc_logic(1);
+
+    // Run operating point simulation
+    sc_start();
+
+    // Print results on the command line
+    printOPAnalysisResult();
+}
+
+void SPECSConfig::runDCAnalysis()
+{
+    auto all_probes = sc_get_all_module_by_type<Probe>();
+    auto all_mlprobes = sc_get_all_module_by_type<MLambdaProbe>();
+    auto all_photodetectors = sc_get_all_module_by_type<Detector>();
+    auto all_oop = sc_get_all_module_by_type<OpticalOutputPort>();
+    auto all_sig = sc_get_all_object_by_type<sc_signal<OpticalSignal, SC_MANY_WRITERS>>();
+    auto all_cws = sc_get_all_module_by_type<CWSource>();
+
+    // Run to initialize all threads and register first values
+    sc_start();
+
+    // Enable normal probes
+    for (auto probe: all_probes) {
+        probe->enable = sc_logic(1);
+    }
+
+    // Disable ML probes
+    for (auto mlprobe: all_mlprobes) {
+        mlprobe->enable = sc_logic(0);
+    }
+
+    // Enable photodetectors
+    for (auto pdet: all_photodetectors) {
+        // Remark: Photodetectors could in fact be left enabled ?
+        // Would that serve any purpose though...?
+        pdet->enable = sc_logic(0);
+    }
+
+    // Set all ports mode to NO_DELAY
+    for (auto oop: all_oop) {
+        oop->m_mode = OpticalOutputPortMode::NO_DELAY;
+    }
+
+    // Activate CW sources
+    for (auto cws: all_cws) {
+        cws->enable = sc_logic(1);
+    }
+
+    const auto &order = *cw_sweep_orders.begin();
+    wavelengths_vector.reserve(order.second.second.size());
+    cout << "Starting sweep on " << order.first;
+    cout << " (" << order.second.second.size() << " points)" << endl;
+    for (const auto &val : order.second.second)
+    {
+        // Apply sweep param
+        order.second.first(val);
+
+        //cout << order.first << " = " << val << endl;
+
+        // Reset OOP and set internal signals to new wavelength
+        for (auto oop: all_oop) {
+            #if 1 // reset OOP
+            oop->reset();
+            // TODO: also reset photodetectors?
+            #elif 0 // remove previous wavelengths from OOP but keep value
+            if (wavelengths_vector.size() >= 2)
+            {
+                oop->swap_wavelengths(wavelengths_vector.size()-1, wavelengths_vector.size()-2);
+                oop->delete_wavelength(wavelengths_vector.size()-2);
+                oop->m_skip_next_convergence_check = true;
+            }
+            #else
+            // do nothing
+            #endif
+        }
+
+        // run simulation and advance one tick
+        sc_start(sc_time::from_value(1));
+
+        // Reset CW sources
+        for (auto cws: all_cws)
+        {
+            cws->reset.write(sc_logic(1));
+        }
+
+        //printOPAnalysisResult();
+    }
+}
+
+void SPECSConfig::runTRANAnalysis()
+{
+    auto all_probes = sc_get_all_module_by_type<Probe>();
+    auto all_mlprobes = sc_get_all_module_by_type<MLambdaProbe>();
+    auto all_photodetectors = sc_get_all_module_by_type<Detector>();
+    auto all_oop = sc_get_all_module_by_type<OpticalOutputPort>();
+    auto all_vl_src = sc_get_all_module_by_type<VLSource>();
+    auto all_evl_src = sc_get_all_module_by_type<EVLSource>();
+
+    // Run OP analysis
+    runOPAnalysis();
+
+    // Set values of signals according to IC directive
+    for (auto &ic_order : ic_orders)
+    {
+        //ic_order.second.first->write(ic_order.second.second);
+    }
+
+    // Enable probes
+    for (auto probe: all_probes) {
+        probe->enable = sc_logic(1);
+    }
+
+    // Enable ML probes
+    for (auto mlprobe: all_mlprobes) {
+        mlprobe->enable = sc_logic(1);
+    }
+
+    // Enable photodetectors
+    for (auto pdet: all_photodetectors) {
+        pdet->enable = sc_logic(1);
+    }
+
+    // Re-apply configuration of all ports
+    for (auto oop: all_oop) {
+        oop->applyConfig();
+    }
+
+    // Activate TRAN sources
+    for (auto src: all_vl_src)
+        src->enable = sc_logic(1);
+    for (auto src: all_evl_src)
+        src->enable = sc_logic(1);
+
+    // Strart TRAN simulation
+    if (isfinite(tran_duration))
+        sc_start(tran_duration, SC_SEC);
+    else
+        sc_start();
+
+    cout << "Simulated " << sc_time_stamp() << endl;
+}
+
+void SPECSConfig::applyDefaultOpticalOutputPortConfig() {
+    //assert(!oop_configs.empty());
+    auto oop_default_config = make_shared<OpticalOutputPortConfig>();
+    oop_default_config->m_mode = simulation_mode;
+    oop_default_config->m_abstol = default_abstol;
+    oop_default_config->m_reltol = default_reltol;
+    oop_default_config->m_timestep_value = default_resolution_multiplier; // relative to systemc timestep
+
+    // apply default config to all optical output ports which don't have one
+    auto all_oop = sc_get_all_module_by_type<OpticalOutputPort>();
+    for (auto oop: all_oop) {
+        if(!oop->getConfig().get())
+            oop->setConfig(oop_default_config);
+        // FIXME: only works for first call to sc_start !!
+    }
+}
+
+void SPECSConfig::applyDefaultTraceFileToAllSignals() {
+    if (!default_trace_file)
+        return;
+
+    auto all_probes = sc_get_all_object_by_type<Probe>();
+    for (auto p: all_probes) {
+        p->setTraceFile(default_trace_file);
+    }
+
+    // auto all_mlprobes = sc_get_all_object_by_type<MLambdaProbe>();
+    // for (auto p: all_mlprobes) {
+    //     p->m_Tf = default_trace_file;
+    //     p->prepare();
+    // }
+
+    auto all_mlambda_probes = sc_get_all_object_by_type<MLambdaProbe>();
+    for (auto p: all_mlambda_probes) {
+        p->setTraceFile(default_trace_file);
+    }
+
+    if (trace_all_optical_nets)
+    {
+        auto all_optical_sigs = sc_get_all_object_by_type<sc_signal<OpticalSignal, SC_MANY_WRITERS>>();
+        for (auto &sig: all_optical_sigs) {
+            string signame = sig->name();
+
+            // Check if the signal is explicitly marked as uninteresting
+            stringstream ss (signame);
+            string base_signame;
+            while (getline (ss, base_signame, '/')) {}
+            if (base_signame.empty() || base_signame[0] == '_')
+                continue;
+            //cout << signame << endl;
+
+            auto p = make_shared<Probe>(("PROBE{" + signame + "}").c_str(), true, true, true, true);
+            p->setTraceFile(default_trace_file);
+            p->p_in(*sig);
+            additional_objects.push_back(p);
+        }
+    }
+    // TODO: refactor ↓
+    auto all_pdets = sc_get_all_object_by_type<Detector>();
+    for (auto &pdet: all_pdets) {
+        string detname = pdet->name();
+        cout << detname << endl;
+        pdet->trace(default_trace_file);
+        //sc_trace(default_trace_file, , (string(pdet->name()) + ".readout").c_str());
+    }
+}
+
+string SPECSConfig::analysisTypeDesc() const
+{
+    switch (analysis_type) {
+        case CW_OPERATING_POINT:
+            return "CW OPERATING POINT";
+        case CW_SWEEP:
+            return "CW SWEEP";
+        case TIME_DOMAIN:
+            return "TIME DOMAIN";
+        default:
+            return "UNDEFINED";
+    }
+}
+
+void SPECSConfig::printConfig() const
+{
+    cout << "Current SPECS config: " << endl;
+    cout << "- simulation mode: " << oopPortMode2str(simulation_mode) << endl;
+    cout << "- analysis type: " << analysisTypeDesc() << endl;
+    cout << "- engine timescale (log10 of s): " << engine_timescale << endl;
+    cout << "- abstol: " << default_abstol << endl;
+    cout << "- default reltol: " << default_reltol << endl;
+    cout << "- resolution multiplier: " << default_resolution_multiplier << endl;
+    cout << "- trace all optical nets: " << trace_all_optical_nets << endl;
+}
+
+void SPECSConfig::printOPAnalysisResult() const
+{
+    cout << "╔═══════════════════╗" << endl;
+    cout << "║  OPERATING POINT  ║" << endl;
+    cout << "╠═══════════════════╣" << endl;
+    cout << "║                   ╨───┄┄" << endl;
+    auto all_optical_sigs = sc_get_all_object_by_type<sc_signal<OpticalSignal, SC_MANY_WRITERS>>();
+    for (auto &sig: all_optical_sigs) {
+        string signame = sig->name();
+        cout << "║ ";
+        cout << "- " << signame << " (OPTICAL)" << " = " << sig->read() << endl;
+    }
+    cout << "║                   ╥───┄┄" << endl;
+    cout << "╚═══════════════════╝" << endl;
+}
+
+void SPECSConfig::prepareSimulation() {
+    auto all_spx_mod = sc_get_all_object_by_type<spx_module>();
+    for (auto &mod : all_spx_mod)
+        mod->init();
+    printConfig();
+    verifyConfig();
+
+    { // open default trace_file
+        if (!default_trace_file && trace_filename.size())
+            default_trace_file = sc_create_vcd_trace_file(trace_filename.c_str());
+
+        default_trace_file->set_time_unit(std::pow(10, 15 + engine_timescale), SC_FS);
+    }
+
+    applyDefaultOpticalOutputPortConfig();
+    applyDefaultTraceFileToAllSignals();
+    if (default_trace_file)
+        sc_trace(default_trace_file, *this, "");
+}
+
+inline void sc_trace(sc_trace_file *tf, const SPECSConfig &s, string parent_tree)
+{
+    parent_tree += (parent_tree.size() ? "." : "");
+    sc_trace(tf, s.default_abstol, parent_tree + "abstol");
+    sc_trace(tf, s.default_reltol, parent_tree + "reltol");
+    sc_trace(tf, s.default_resolution_multiplier, parent_tree + "resolution_multiplier");
+    sc_trace(tf, s.engine_timescale, parent_tree + "engine_timescale");
+    sc_trace(tf, s.simulation_mode, parent_tree + "simulation_mode");
+    sc_trace(tf, s.analysis_type, parent_tree + "analysis_type");
+    sc_trace(tf, s.trace_all_optical_nets, parent_tree + "trace_all_optical_nets");
+    sc_trace(tf, s.verbose_component_initialization, parent_tree + "verbose_component_initialization");
+}
\ No newline at end of file
diff --git a/src/specs.h b/src/specs.h
new file mode 100644
index 0000000..fe56d6a
--- /dev/null
+++ b/src/specs.h
@@ -0,0 +1,159 @@
+#pragma once
+
+#include <sysc_utils.h>
+#include "optical_signal.h"
+#include "optical_output_port.h"
+
+#include <systemc.h>
+#include <vector>
+#include <map>
+#include <utility>
+#include <functional>
+
+using std::vector;
+using std::map;
+using std::pair;
+using std::make_shared;
+using std::shared_ptr;
+using std::string;
+using std::function;
+
+namespace spx {
+    // Value types
+    typedef OpticalSignal oa_value_type;
+    typedef double ea_value_type;
+    typedef sc_logic ed_value_type;
+
+    // Signal types
+    typedef sc_signal<oa_value_type, SC_MANY_WRITERS> oa_signal_type;
+    typedef sc_signal<ea_value_type, SC_MANY_WRITERS> ea_signal_type;
+    typedef sc_signal<ed_value_type, SC_MANY_WRITERS> ed_signal_type;
+    typedef sc_signal<sc_lv_base, SC_MANY_WRITERS> ed_bus_type;
+
+    // Optical analog IF type
+    typedef sc_signal_in_if<oa_value_type> oa_if_in_type;
+    typedef sc_signal_out_if<oa_value_type> oa_if_out_type;
+    typedef sc_signal_inout_if<oa_value_type> oa_if_inout_type;
+
+    // Electrical analog IF type
+    typedef sc_signal_in_if<ea_value_type> ea_if_in_type;
+    typedef sc_signal_out_if<ea_value_type> ea_if_out_type;
+    typedef sc_signal_inout_if<ea_value_type> ea_if_inout_type;
+
+    // Optical analog ports
+    typedef sc_port<oa_if_in_type, 0, SC_ZERO_OR_MORE_BOUND> oa_port_in_type;
+    typedef sc_port<oa_if_out_type> oa_port_out_type;
+    typedef sc_port<oa_if_inout_type> oa_port_inout_type;
+
+    // Electrical analog ports
+    typedef sc_port<ea_if_in_type, 0, SC_ZERO_OR_MORE_BOUND> ea_port_in_type;
+    typedef sc_port<ea_if_out_type> ea_port_out_type;
+    typedef sc_port<ea_if_inout_type> ea_port_inout_type;
+};
+
+class SPECSConfig : public sc_module {
+public:
+    enum EngineTimescale {
+        ONE_SEC     = 0,
+        HUNDRED_MS  = -1,
+        TEN_MS      = -2,
+        ONE_MS      = -3,
+        HUNDRED_US  = -4,
+        TEN_US      = -5,
+        ONE_US      = -6,
+        HUNDRED_NS  = -7,
+        TEN_NS      = -8,
+        ONE_NS      = -9,
+        HUNDRED_PS  = -10,
+        TEN_PS      = -11,
+        ONE_PS      = -12,
+        HUNDRED_FS  = -13,
+        TEN_FS      = -14,
+        ONE_FS      = -15,
+    };
+
+    enum AnalysisType {
+        ANALYSIS_TYPE_MINVAL,
+        CW_OPERATING_POINT,
+        CW_SWEEP,
+        TIME_DOMAIN,
+        ANALYSIS_TYPE_MAXVAL,
+
+        // aliases
+        DEFAULT   = TIME_DOMAIN,
+        OP        = CW_OPERATING_POINT,
+        DC        = CW_SWEEP,
+        TRAN      = TIME_DOMAIN,
+        UNDEFINED = ANALYSIS_TYPE_MAXVAL,
+    };
+
+    // Hold simulation objects
+    vector<shared_ptr<sc_object>> additional_objects;
+    map<string, pair<sc_signal<OpticalSignal, SC_MANY_WRITERS> *, OpticalSignal>> ic_orders;
+    map<string, pair<sc_signal<OpticalSignal, SC_MANY_WRITERS> *, OpticalSignal>> nodeset_orders;
+
+    // Simulation options
+    EngineTimescale engine_timescale = ONE_FS;
+    OpticalOutputPortMode simulation_mode;
+    AnalysisType analysis_type;
+    map<string, pair<function<void(double)>, vector<double>>> cw_sweep_orders;
+    double tran_duration = std::numeric_limits<double>::infinity();
+
+    // Port options
+    double default_abstol = 1e-8;
+    double default_reltol = 1e-4;
+    sc_time::value_type default_resolution_multiplier = 1;
+
+    // For multi-wavelength support
+    vector<double> wavelengths_vector;
+
+    // Trace options
+    string trace_filename = "";
+    sc_trace_file *default_trace_file = nullptr;
+    bool trace_all_optical_nets = 1;
+
+    // other
+    sc_signal<bool, SC_MANY_WRITERS> drop_all_events;
+    bool verbose_component_initialization = true;
+
+    SPECSConfig(sc_module_name name);
+
+    ~SPECSConfig() {}
+
+    virtual void before_end_of_elaboration()
+    {}
+
+    void runAnalysis();
+    void runOPAnalysis();
+    void runDCAnalysis();
+    void runTRANAnalysis();
+
+    void applyEngineResolution() {
+        // set engine time resolution
+        sc_set_time_resolution(std::pow(10, 15+engine_timescale), SC_FS);
+    }
+    void applyDefaultOpticalOutputPortConfig();
+    void traceSettings();
+    void applyDefaultTraceFileToAllSignals();
+    void verifyConfig()
+    {
+        assert(default_abstol > 0);
+        assert(default_reltol > 0);
+        assert(default_resolution_multiplier >= 1);
+        assert(ONE_FS <= engine_timescale && engine_timescale <= ONE_SEC);
+        assert(PORT_MODE_MINVAL < simulation_mode && simulation_mode < PORT_MODE_MAXVAL);
+        assert(ANALYSIS_TYPE_MINVAL < analysis_type && analysis_type < ANALYSIS_TYPE_MAXVAL);
+    }
+    string analysisTypeDesc() const;
+    void printConfig() const;
+    void printOPAnalysisResult() const;
+    void prepareSimulation();
+    inline void register_object(shared_ptr<sc_object> object) {
+        additional_objects.push_back(object);
+    }
+
+    inline friend void
+    sc_trace(sc_trace_file *tf, const SPECSConfig &s, string parent_tree);
+};
+
+extern SPECSConfig specsGlobalConfig;
\ No newline at end of file
diff --git a/src/tb/alltestbenches.cpp b/src/tb/alltestbenches.cpp
new file mode 100644
index 0000000..107dfdc
--- /dev/null
+++ b/src/tb/alltestbenches.cpp
@@ -0,0 +1,28 @@
+#include <map>
+#include <tb/alltestbenches.h>
+
+#if defined(BUILD_TB) && BUILD_TB == 1
+std::map<std::string, tb_func_t> tb_map = {
+    { "wg", wg_tb_run },
+    { "waveguide", wg_tb_run },
+    { "merg", Merger_tb_run },
+    { "merger", Merger_tb_run },
+    { "dc", DirectionalCoupler_tb_run },
+    { "directional_coupler", DirectionalCoupler_tb_run },
+    { "spli", Splitter_tb_run },
+    { "splitter", Splitter_tb_run },
+    { "det", Detector_tb_run },
+    { "detector", Detector_tb_run },
+    { "pcm", PCMElement_tb_run },
+    { "mzi", MZI_tb_run },
+    { "ring", Ring_tb_run },
+    { "ac_add_drop", freqsweep_tb_run_add_drop },
+    { "ac_crow", crow_tb_run },
+    { "lambda", lambda_tb_run },
+    { "phaseshifter", ps_tb_run },
+    { "ps", ps_tb_run },
+    { "mesh", mesh_tb_run },
+};
+#else
+std::map<std::string, tb_func_t> tb_map = {};
+#endif
diff --git a/src/tb/alltestbenches.h b/src/tb/alltestbenches.h
new file mode 100644
index 0000000..49043bb
--- /dev/null
+++ b/src/tb/alltestbenches.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <tb/detector_tb.h>
+#include <tb/directional_coupler_tb.h>
+#include <tb/merger_tb.h>
+#include <tb/pcm_device_tb.h>
+#include <tb/splitter_tb.h>
+#include <tb/wg_tb.h>
+#include "tb/mzi_tb.h"
+#include "tb/ring_tb.h"
+#include "tb/freqsweep_tb.h"
+#include "tb/crow_tb.h"
+#include "tb/lambda_tb.h"
+#include "tb/phase_shifter_tb.h"
+#include "mesh_tb.h"
+
+#include <map>
+#include <string>
+
+typedef void (*tb_func_t)();
+
+extern std::map<std::string, tb_func_t> tb_map;
diff --git a/src/tb/crow_tb.cpp b/src/tb/crow_tb.cpp
new file mode 100644
index 0000000..91a816c
--- /dev/null
+++ b/src/tb/crow_tb.cpp
@@ -0,0 +1,216 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/crow_tb.h>
+
+#include <cstdlib>
+#include <unistd.h>
+#include <chrono>
+
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <probe.h>
+#include <crow.h>
+#include <specs.h>
+#include "time_monitor.h"
+
+#include "general_utils.h"
+
+using namespace std;
+using namespace std::chrono;
+
+
+/* ----------------------------------------------------------------------------- *
+    This testbench is called freqsweep because it is capable of this
+    type of simulation, but it is also possible to set it as a time-domain
+    simulation depending on the mode chosen when calling SPECS. Example:
+
+    specs -t ac_add_drop -m fd     -> will perform the frequency sweep
+    specs -t ac_add_drop -m td     -> will perform the time domain simulation
+
+/  ----------------------------------------------------------------------------- */
+
+// ---------------- Use this variable to change the size of the CROW -----------
+                            size_t nrings_crow = 3;
+// -----------------------------------------------------------------------------
+
+void crow_tb::run_td()
+{
+    bool verbose = true;
+    if (specsGlobalConfig.simulation_mode == OpticalOutputPortMode::TIME_DOMAIN)
+    {
+        int npulses = 4;
+        double lambda = 1554.3719e-9;
+        lambda = 1.561931948453715e-6;
+        lambda = 1538.3277504e-9;
+        lambda = 1543e-9;
+        lambda = 1556.5742279e-9;
+        lambda = 1556.32782563158025368466e-9;
+        lambda = 1556e-9;
+        lambda = 1553e-9;
+        //lambda = 1550e-9;
+        double tpulse = 1e-9;
+        double deadtime = tpulse;
+
+        
+        // Wait one tick that all sc_threads are started and on their first `wait` call
+        wait(SC_ZERO_TIME);
+
+        if (verbose)
+        {
+            cout << "----------------------------" <<endl;
+            cout << "Starting time-domain simulation" << endl;
+        }
+        for (int i = 0; i < npulses; ++i)
+        {
+            IN->write(OpticalSignal(1, lambda));
+            wait(tpulse, SC_SEC);
+            // //ADD.write(OpticalSignal(polar<double>(1, M_PI_2), lambda));
+            // //ADD.write(OpticalSignal(polar<double>(0,0), lambda));
+            IN->write(OpticalSignal(0, lambda));
+            // ADD.write(OpticalSignal(0, lambda));
+            wait(deadtime, SC_SEC);
+        }
+    }
+    
+    while (true) { wait(); }
+}
+
+void crow_tb::run_fd()
+{
+    bool verbose = true;
+    if (specsGlobalConfig.simulation_mode == OpticalOutputPortMode::FREQUENCY_DOMAIN)
+    {
+        auto lambda_center = 1550e-9;
+        auto lambda_span = 2e-9;
+        auto dlambda = 0.001e-9;
+        auto lambda_min = lambda_center - lambda_span/2;
+        auto lambda_max = lambda_center + lambda_span/2;
+        // lambda_min = 1545e-9;
+        // lambda_max = 1569e-9;
+        lambda_min = 299792458.0/195e12;
+        lambda_max = 299792458.0/190e12;
+        lambda_min = 1556e-9;
+        lambda_span = lambda_max - lambda_min;
+        dlambda = lambda_span / 10000;
+        
+        // Wait one tick that all sc_threads are started and on their first `wait` call
+        wait(SC_ZERO_TIME);
+        //wait(lambda_min, SC_SEC);
+
+        auto tic = high_resolution_clock::now();
+        auto toc = high_resolution_clock::now();
+
+        if (verbose)
+        {
+            cout << "----------------------------" <<endl;
+            cout << "Starting sweep" << endl;
+        }
+        int i = 0;
+        int n = ceil(lambda_span / dlambda);
+        for (auto lambda = lambda_min; lambda < lambda_max + dlambda; lambda += dlambda)
+        {
+            ++i;
+            if (true || (verbose && i % (int)(n/20) == 0))
+            {
+                toc = high_resolution_clock::now();
+                auto duration = duration_cast<microseconds>(toc - tic);
+                tic = toc;
+                cout << duration.count()/1000.0 << "ms" << endl;
+                cout << endl;
+                cout << fixed << setprecision(1) << (lambda-lambda_min)/lambda_span * 100.0 << "%" << endl;
+                cout << setprecision(20) << lambda * 1e9 << "nm" << endl;
+            }
+            IN->write(OpticalSignal(sqrt(1), lambda));
+            ADD->write(OpticalSignal(0, lambda));
+            //ADD.write(OpticalSignal(polar<double>(0, 0), lambda));
+            //ADD.write(OpticalSignal(polar<double>(sqrt(0.5), -M_PI_2), lambda));
+            wait(dlambda, SC_SEC);
+        }
+        if (verbose)
+        {
+            cout << "----------------------------" <<endl;
+            cout << "Sweep over (" << n << " points)" << endl;
+        }
+    }
+    while (true) { wait(); }
+}
+
+void crow_tb::monitor()
+{
+    unsigned long long event_counter = 0;
+    while(true)
+    {
+        wait();
+        continue;
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN:      " << IN->read() << std::endl
+            << "\tADD:     " << ADD->read() << std::endl
+            << "\tTHROUGH: " << THROUGH->read() << std::endl
+            << "\tDROP:    " << DROP->read() << std::endl
+            << "\tCOUNT:   " << event_counter << std::endl;
+    }
+
+}
+
+void crow_tb_run()
+{
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN("IN"), THROUGH("THROUGH"), DROP("DROP"), ADD("ADD");
+
+    crow_tb tb1("tb1");
+    tb1.IN(IN);
+    tb1.ADD(ADD);
+    tb1.THROUGH(THROUGH);
+    tb1.DROP(DROP);
+
+    // pid_t pid = fork();
+    CROW *pc;
+    // if(pid)
+    pc = new CROW("crow", nrings_crow);
+    // else
+    //     pc = new Crow("crow", 5);
+    pc->p_in(IN);
+    pc->p_add(ADD);
+    pc->p_out_t(THROUGH);
+    pc->p_out_d(DROP);
+
+    pc->setRingLength(2*30e-6);
+    pc->m_loss_db_cm = 2.0;
+    pc->m_coupling_through = 1 - pow(0.83645, 2.0);
+    // pc->m_coupling_through = 0.5;
+    pc->m_neff = 2.6391;
+    pc->m_ng = 4.3416;
+    
+    pc->m_ring_length = 500.0*1.55e-6 + 1.55e-6/2.0;
+    pc->m_loss_db_cm = 2.0;
+    pc->m_coupling_through = 1 - 0.2;
+    pc->m_neff = 1;
+    pc->m_ng = 2;
+
+    pc->init(); //instantiating all nets
+
+    Probe pthrough("pthrough", true, true, false, true);
+    pthrough.p_in(THROUGH);
+    //
+    Probe pcross("pcross", true, true, false, false);
+    pcross.p_in(DROP);
+
+    specsGlobalConfig.trace_filename = "traces/crow_tb";
+
+    // Apply SPECS options specific to the testbench
+    // specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start(50e-9, SC_SEC);
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/crow_tb.h b/src/tb/crow_tb.h
new file mode 100644
index 0000000..473708d
--- /dev/null
+++ b/src/tb/crow_tb.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <specs.h>
+#include <systemc.h>
+
+class crow_tb : public sc_module {
+public:
+    spx::oa_port_out_type IN;
+    spx::oa_port_out_type ADD;
+    spx::oa_port_in_type THROUGH;
+    spx::oa_port_in_type DROP;
+
+    void run_fd();
+    void run_td();
+    void monitor();
+
+    SC_CTOR(crow_tb)
+    {
+        SC_THREAD(run_fd);
+        SC_THREAD(run_td);
+        SC_THREAD(monitor);
+        if (false)
+            sensitive << IN << ADD << THROUGH << DROP;
+    }
+};
+
+void crow_tb_run();
+
+extern size_t nrings_crow;
diff --git a/src/tb/detector_tb.cpp b/src/tb/detector_tb.cpp
new file mode 100644
index 0000000..e296d26
--- /dev/null
+++ b/src/tb/detector_tb.cpp
@@ -0,0 +1,127 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/detector_tb.h>
+
+#include "general_utils.h"
+
+void Detector_tb::run_1()
+{
+    IN->write(OpticalSignal(sqrt(1.0), 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(0, 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(sqrt(1.0), 1551e-9));
+
+
+
+    while (true) { wait(); }
+}
+
+void Detector_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 3;
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN: " << IN->read() << std::endl
+            << "\tREADOUT:  " << READOUT.read() << std::endl
+            << "\tREADOUT2:  " << READOUT2.read() << std::endl
+            << "\tCOUNT: " << event_counter << std::endl;
+
+        if(event_counter == 2)
+        {
+            if ((is_close(READOUT.read(), 1, 1e-3)) && (is_close(READOUT2.read(), 1, 1e-3)))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 1A as both output currents!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 4)
+        {
+            if ((is_close(READOUT.read(), 0, 1e-4)) && (is_close(READOUT2.read(), 0, 1e-4)))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0A as output currents!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 6)
+        {
+            if (!is_close(READOUT.read(), READOUT2.read(), 1e-7))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected slightly different currents (different noise seed)!" << std::endl;
+                std::cout << "Is the noise ON?" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            std::cout << "-----------------/! \\---------------" << std::endl;
+            std::cout << "Test finished!" << std::endl;
+            std::cout << "Success rate: " << success_counter << "/" << test_number << std::endl;
+            std::cout << "-----------------/! \\---------------" << std::endl;
+        }
+
+    }
+}
+
+void Detector_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN;
+    sc_signal<double> READOUT, READOUT2;
+
+    Detector uut("uut", 1, 100e-12, false);
+    uut.p_in(IN);
+    uut.p_readout(READOUT);
+
+    Detector uut2("uut2", 1, 100e-12, false);
+    uut2.p_in(IN);
+    uut2.p_readout(READOUT2);
+
+    Detector_tb tb("tb");
+    tb.IN(IN);
+    tb.READOUT(READOUT);
+    tb.READOUT2(READOUT2);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "detector_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    Probe probe_detector("probe_detector",specsGlobalConfig.default_trace_file);
+    probe_detector.p_in(IN);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // custom traces should come after prepareSimulation !!
+    sc_trace(specsGlobalConfig.default_trace_file, READOUT, "READOUT");
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/detector_tb.h b/src/tb/detector_tb.h
new file mode 100644
index 0000000..39b05dc
--- /dev/null
+++ b/src/tb/detector_tb.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <detector.h>
+#include <optical_signal.h>
+#include <systemc.h>
+#include <probe.h>
+#include <specs.h>
+#include <waveguide.h>
+
+SC_MODULE(Detector_tb)
+{
+public:
+    spx::oa_port_out_type IN;
+    sc_in<double> READOUT, READOUT2;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(Detector_tb)
+    {
+        SC_HAS_PROCESS(Detector_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << READOUT << READOUT2;
+    }
+};
+
+void Detector_tb_run();
+
diff --git a/src/tb/directional_coupler_tb.cpp b/src/tb/directional_coupler_tb.cpp
new file mode 100644
index 0000000..1954414
--- /dev/null
+++ b/src/tb/directional_coupler_tb.cpp
@@ -0,0 +1,150 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/directional_coupler_tb.h>
+
+#include "general_utils.h"
+#include "generic_2x2_coupler.h"
+
+void DirectionalCoupler_tb::run_1()
+{
+    IN1->write(OpticalSignal(1.0, 1550e-9));
+    wait(100, SC_MS);
+    IN2->write(OpticalSignal(1.0, 1550e-9));
+    wait(100, SC_MS);
+
+    while (true) { wait(); }
+}
+
+void DirectionalCoupler_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 3;
+
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN1:  " << IN1->read() << std::endl
+            << "\tIN2:  " << IN2->read() << std::endl
+            << "\tOUT1: " << OUT1->read() << std::endl
+            << "\tOUT2: " << OUT2->read() << std::endl
+            << "\tCOUNT: " << event_counter << std::endl;
+
+        if(event_counter == 2)
+        {
+            if (is_close(norm(OUT1->read().m_field), 0.05, 1e-4) && is_close(norm(OUT2->read().m_field), 0.45, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.05W/0.45 as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+            if (is_close(arg(OUT2->read().m_field), 1.5708, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected pi/2 as phase in OUT2!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 4)
+        {
+            if (is_close(arg(OUT1->read().m_field), 1.2490, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 1.2490 as phase in OUT1!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            std::cout << "-----------------/! \\---------------" << std::endl;
+            std::cout << "Test finished!" << std::endl;
+            std::cout << "Success rate: " << success_counter << "/" << test_number << std::endl;
+            std::cout << "-----------------/! \\---------------" << std::endl;
+        }
+    }
+}
+
+void DirectionalCoupler_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+
+    spx::oa_signal_type IN1, IN2, IN3, IN4, OUT1, OUT2;
+    spx::oa_signal_type TERM_r, TERM_w;
+
+    // Unidirectional variant
+    // DirectionalCoupler uut("uut", 0.5, 0);
+    // uut.m_dc_through_coupling_power = 0.1;
+    // uut.m_dc_loss = 3.0103;
+
+    // uut.p_in1(IN1);
+    // uut.p_in2(IN2);
+    // uut.p_out1(OUT1);
+    // uut.p_out2(OUT2);
+
+    // Bidirectional variant
+    DirectionalCouplerBi uut("uut", 0.5, 0);
+    uut.m_dc_through_coupling_power = 0.1;
+    uut.m_dc_loss = 3.0103;
+
+    uut.p0_in(IN1);
+    uut.p0_out(TERM_w);
+    uut.p1_in(IN2);
+    uut.p1_out(TERM_w);
+    uut.p2_in(TERM_r);
+    uut.p2_out(OUT1);
+    uut.p3_in(TERM_r);
+    uut.p3_out(OUT2);
+
+    // Generic bidirectional variant
+    // Generic2x2Coupler uut("uut", 1-0.1, 3.0103);
+    // uut.ports_in[0]->bind(IN1);
+    // uut.ports_in[1]->bind(IN2);
+    // uut.ports_in[2]->bind(TERM_r);
+    // uut.ports_in[3]->bind(TERM_r);
+    // uut.ports_out[0]->bind(TERM_w);
+    // uut.ports_out[1]->bind(TERM_w);
+    // uut.ports_out[2]->bind(OUT1);
+    // uut.ports_out[3]->bind(OUT2);
+
+    DirectionalCoupler_tb tb("tb");
+    tb.IN1(IN1);
+    tb.IN2(IN2);
+    tb.OUT1(OUT1);
+    tb.OUT2(OUT2);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "directional_coupler_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    Probe probe_dc_1("probe_dc_1",specsGlobalConfig.default_trace_file);
+    probe_dc_1.p_in(OUT1);
+    Probe probe_dc_2("probe_dc_2",specsGlobalConfig.default_trace_file);
+    probe_dc_2.p_in(OUT2);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/directional_coupler_tb.h b/src/tb/directional_coupler_tb.h
new file mode 100644
index 0000000..c137b31
--- /dev/null
+++ b/src/tb/directional_coupler_tb.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <directional_coupler.h>
+#include <optical_signal.h>
+#include <systemc.h>
+#include <probe.h> 
+#include <specs.h>
+
+SC_MODULE(DirectionalCoupler_tb)
+{
+public:
+    spx::oa_port_out_type IN1;
+    spx::oa_port_out_type IN2;
+    spx::oa_port_in_type OUT1;
+    spx::oa_port_in_type OUT2;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(DirectionalCoupler_tb)
+    {
+        SC_HAS_PROCESS(DirectionalCoupler_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN1 << IN2 << OUT1 << OUT2;
+    }
+};
+
+void DirectionalCoupler_tb_run();
+
diff --git a/src/tb/freqsweep_tb.cpp b/src/tb/freqsweep_tb.cpp
new file mode 100644
index 0000000..f44aa34
--- /dev/null
+++ b/src/tb/freqsweep_tb.cpp
@@ -0,0 +1,213 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/freqsweep_tb.h>
+
+#include <cstdlib>
+#include <unistd.h>
+
+#include "time_monitor.h"
+
+#include "general_utils.h"
+
+/* ----------------------------------------------------------------------------- *
+    This testbench is called freqsweep because it is capable of this
+    type of simulation, but it is also possible to set it as a time-domain
+    simulation depending on the mode chosen when calling SPECS. Example:
+
+    specs -t ac_add_drop -m fd     -> will perform the frequency sweep
+    specs -t ac_add_drop -m td     -> will perform the time domain simulation
+
+/  ----------------------------------------------------------------------------- */
+
+void freqsweep_tb::run_1()
+{
+    if (specsGlobalConfig.simulation_mode == OpticalOutputPortMode::FREQUENCY_DOMAIN)
+    {
+        auto lambda_center = 1550.3e-9;
+        auto lambda_span = 1e-9;
+        auto dlambda = 0.002e-9;
+        auto lambda_min = lambda_center - lambda_span/2;
+        auto lambda_max = lambda_center + lambda_span/2;
+        // lambda_min = 1550.250e-9;
+        // lambda_max = 1550.303e-9;
+        //wait(lambda_min * 1e9, SC_SEC);
+        
+        wait(SC_ZERO_TIME);
+        cout << "----------------------------" <<endl;
+        cout << "Starting sweep" << endl;
+        for (auto lambda = lambda_min; lambda < lambda_max + dlambda; lambda += dlambda)
+        {
+            cout << setprecision(7) << lambda * 1e9 << "nm" << endl;
+            IN->write(OpticalSignal(1, lambda));
+            wait(dlambda, SC_SEC);
+        }
+    } else {
+        for (int i = 0; i < 1; ++i)
+        {
+            auto lambda = 1550.302e-9;
+            IN->write(OpticalSignal(1,lambda));
+            wait(1, SC_NS);
+            IN->write(OpticalSignal(0, lambda));
+            wait(1, SC_NS);
+        }
+    }
+    
+    while (true) { wait(); }
+}
+
+void freqsweep_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 3;
+    while(true)
+    {
+        wait();
+        continue;
+    }
+}
+
+void freqsweep_tb_run_add_drop()
+{
+    specsGlobalConfig.applyEngineResolution();
+    //specsGlobalConfig.oop_configs[0]->m_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    //specsGlobalConfig.oop_configs[0]->m_mode = OpticalOutputPortMode::FREQUENCY_DOMAIN;
+
+    // First test for the LBR paper to DAC
+    // Single ring resonator, compare the response to theoretical
+    // Also compare time of simulation wrt photontorch for same ring.
+
+    // Characteristics:
+    // Add-drop ring
+    // Internal wg length (cm):
+    // Internal wg loss (dB/cm): 
+    // Internal wg neff:
+    // Internal wg ng: 
+    // DC ratio : 0.15 cross, 0.85 through
+    // DC coupling loss (dB) : 0
+    // Total length for resonance: lambda/2neff
+    double neff = 1.0;
+    double loss_db_cm = 1.0;
+    double coupling_through = 0.85;
+
+    spx::oa_signal_type IN, T_OUT, X_OUT, X_TERM;
+    spx::oa_signal_type INNER_RING[4];
+
+    freqsweep_tb tb1("tb1");
+    tb1.IN(IN);
+    tb1.OUT(X_OUT);
+
+    DirectionalCoupler dc1("dc1", coupling_through, 0);
+    dc1.p_in1(INNER_RING[0]);
+    dc1.p_out1(INNER_RING[1]);
+    dc1.p_in2(IN);
+    dc1.p_out2(T_OUT);
+
+    Waveguide wg1("wg1", 100.0*1550.0e-6/(2*neff), loss_db_cm, neff, neff);
+    wg1.p_in(INNER_RING[1]);
+    wg1.p_out(INNER_RING[2]);
+
+    Waveguide wg2("wg2", 100.0*1550.0e-6/(2*neff), loss_db_cm, neff, neff);
+    wg2.p_in(INNER_RING[3]);
+    wg2.p_out(INNER_RING[0]);
+
+    DirectionalCoupler dc2("dc2", coupling_through, 0);
+    dc2.p_in1(X_TERM);
+    dc2.p_out1(X_OUT);
+    dc2.p_in2(INNER_RING[2]);
+    dc2.p_out2(INNER_RING[3]);
+
+    Probe pthrough("ptrough");
+    pthrough.p_in(T_OUT);
+
+    Probe pcross("pcross");
+    pcross.p_in(X_OUT);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "freqsweep_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    // could have forced frequency domain like this, but taking command line input instead
+    // specsGlobalConfig.simulation_mode = OpticalOutputPortMode::FREQUENCY_DOMAIN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
+
+// void freqsweep_tb_run_crow()
+// {
+//     if (specsGlobalConfig.oop_configs[0]->m_mode == OpticalOutputPortMode::FREQUENCY_DOMAIN)
+//         specsGlobalConfig.engine_timescale = SPECSConfig::ONE_FS;
+
+//     specsGlobalConfig.applyEngineResolution();
+
+//     sc_signal<OpticalSignal> IN("IN"), T_OUT("T_OUT"), X_OUT("X_OUT"), ADD("ADD");
+
+//     freqsweep_tb tb1("tb1");
+//     tb1.IN(IN);
+//     tb1.IN(IN);
+//     tb1.OUT(T_OUT);
+
+//     // pid_t pid = fork();
+//     CROW *pc;
+//     // if(pid)
+//     pc = new CROW("crow", nrings);
+//     // else
+//     //     pc = new CROW("crow", 5);
+//     pc->p_in(IN);
+//     pc->p_add(ADD);
+//     pc->p_out_t(T_OUT);
+//     pc->p_out_d(X_OUT);
+
+//     Probe pthrough("ptrough");
+//     pthrough.p_in(T_OUT);
+//     //
+//     Probe pcross("pcross");
+//     pcross.p_in(X_OUT);
+
+//     // shared_ptr<TimeMonitor> tm;
+//     // if (specsGlobalConfig.oop_configs[0]->m_mode == OpticalOutputPortMode::FREQUENCY_DOMAIN)
+//     //     tm = make_shared<TimeMonitor>("TM", 0, 0.01);
+//     // else
+//     //     tm = make_shared<TimeMonitor>("TM", 1e-14, 0.5);
+
+//     // // Open Trace file
+//     // sc_trace_file *Tf;
+//     // std::time_t now = std::time(nullptr);
+//     // char mbstr[100];
+//     // std::strftime(mbstr, sizeof(mbstr), "%F-%H-%M-%S-", std::localtime(&now));
+//     //
+//     // std::string trace_filename = "traces/";
+//     // //trace_filename += mbstr;
+//     // trace_filename += "freqsweep_tb";
+    
+//     // auto engineTime = std::pow(10, 15+specsGlobalConfig.engine_timescale);
+//     // Tf = sc_create_vcd_trace_file(trace_filename.c_str());
+//     // ((sc_trace_file *)Tf)->set_time_unit(engineTime, SC_FS);
+//     // sc_trace(Tf, IN, "IN");
+//     // sc_trace(Tf, X_OUT, "X_OUT");
+//     // sc_trace(Tf, T_OUT, "T_OUT");
+
+//     if (specsGlobalConfig.trace_filename.empty())
+//         specsGlobalConfig.trace_filename = "traces/crow_tb";
+
+//     // Start simulation
+//     specsGlobalConfig.prepareSimulation();
+//     sc_start(); // run until sc_stop()
+
+//     std::cout << std::endl << std::endl;
+//     std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+//     sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+// }
diff --git a/src/tb/freqsweep_tb.h b/src/tb/freqsweep_tb.h
new file mode 100644
index 0000000..d5a328c
--- /dev/null
+++ b/src/tb/freqsweep_tb.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <systemc.h>
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <probe.h>
+#include <crow.h>
+#include <specs.h>
+
+SC_MODULE(freqsweep_tb)
+{
+public:
+    spx::oa_port_out_type IN;
+    spx::oa_port_in_type OUT;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(freqsweep_tb)
+    {
+        SC_HAS_PROCESS(freqsweep_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << OUT;
+    }
+};
+
+//void freqsweep_tb_run();
+void freqsweep_tb_run_add_drop();
+void freqsweep_tb_run_crow();
+
diff --git a/src/tb/lambda_tb.cpp b/src/tb/lambda_tb.cpp
new file mode 100644
index 0000000..96a5084
--- /dev/null
+++ b/src/tb/lambda_tb.cpp
@@ -0,0 +1,102 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/lambda_tb.h>
+
+#include "general_utils.h"
+#include "devices/generic_waveguide.h"
+
+void lambda_tb::run_1()
+{
+    // IN1.write(OpticalSignal(sqrt(2.0), 1550e-9));
+    // wait(0, SC_FS);
+    // IN2.write(OpticalSignal(sqrt(2.0), 1660e-9));
+    // while(true) {wait();}
+    wait(1,SC_SEC);
+    sc_stop();
+}
+
+void lambda_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 0;
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tOUT: " << OUT.read() << std::endl
+            << "\tCOUNT: " << event_counter << std::endl;
+    }
+
+}
+
+void lambda_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type I1, I2, YOUT, WGOUT;
+    spx::oa_signal_type DCO1, DCO2, DCI1, DCI2;
+
+    CWSource cw1("cw1");
+    cw1.setWavelength(1550e-9);
+    cw1.setPower(2);
+    cw1.enable.write(SC_LOGIC_1);
+    cw1.p_out(I1);
+
+    CWSource cw2("cw2");
+    cw2.setWavelength(1660e-9);
+    cw2.setPower(2);
+    cw2.enable.write(SC_LOGIC_1);
+    cw2.p_out(I2);
+
+    Merger merg1("merg1");
+    merg1.p_in1(I1);
+    merg1.p_in2(I2);
+    merg1.p_out(YOUT);
+
+    Waveguide wg1("wg1", 0.1, 0, 1, 1);
+    wg1.m_attenuation_dB_cm = 0;
+    wg1.p_in(YOUT);
+    wg1.p_out(DCI1);
+
+    DirectionalCoupler dc1("dc1");
+    dc1.p_in1(DCI1);
+    dc1.p_in2(DCI2);
+    dc1.p_out1(DCO1);
+    dc1.p_out2(DCO2);
+
+    Waveguide wg2("wg2", 100*1001*1550e-9/(2), 0, 1, 1);
+    wg2.p_in(DCO2);
+    wg2.p_out(DCI2);
+
+    lambda_tb tb("tb");
+    tb.OUT(DCO1);
+    // tb.IN1(I1);
+    // tb.IN2(I2);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "lambda_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    MLambdaProbe probe("probe_lambda", {1550e-9, 1650e-9, 1660e-9});
+    // Probe probe("test_probe",specsGlobalConfig.default_trace_file);
+    probe.p_in(DCO1);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/lambda_tb.h b/src/tb/lambda_tb.h
new file mode 100644
index 0000000..a5dc203
--- /dev/null
+++ b/src/tb/lambda_tb.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <systemc.h>
+#include <waveguide.h>
+#include <merger.h>
+#include <directional_coupler.h>
+#include <cw_source.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(lambda_tb)
+{
+public:
+    sc_in<OpticalSignal> OUT;
+    // sc_out<OpticalSignal> IN1, IN2;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(lambda_tb)
+    {
+        SC_HAS_PROCESS(lambda_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << OUT;
+    }
+};
+
+void lambda_tb_run();
diff --git a/src/tb/merger_tb.cpp b/src/tb/merger_tb.cpp
new file mode 100644
index 0000000..1c86643
--- /dev/null
+++ b/src/tb/merger_tb.cpp
@@ -0,0 +1,126 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/merger_tb.h>
+
+#include "general_utils.h"
+
+void Merger_tb::run_1()
+{
+    IN1->write(OpticalSignal(1.0, 1550e-9));
+    wait(100, SC_MS);
+    IN2->write(OpticalSignal(1.0, 1550e-9));
+    wait(100, SC_MS);
+    IN1->write(OpticalSignal(sqrt(2.0), 1550e-9));
+    IN2->write(OpticalSignal(sqrt(2.0), 1550e-9));
+    wait(100, SC_MS);
+}
+
+void Merger_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 4;
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+                << "\tIN1:  " << IN1->read() << std::endl
+                << "\tIN2:  " << IN2->read() << std::endl
+                << "\tOUT: " << OUT->read() << std::endl
+                << "\tCOUNT: " << event_counter << std::endl;
+        if(event_counter == 2)
+        {
+            if (is_close(norm(OUT->read().m_field), 0.5, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.5W as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+            if (is_close(arg(OUT->read().m_field), 0, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0 as output phase!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 4)
+        {
+            if (is_close(norm(OUT->read().m_field), 2, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 2W as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 6)
+        {
+            if (is_close(norm(OUT->read().m_field), 4, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 2W as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            std::cout << "-----------------/! \\---------------" << std::endl;
+            std::cout << "Test finished!" << std::endl;
+            std::cout << "Success rate: " << success_counter << "/" << test_number << std::endl;
+            std::cout << "-----------------/! \\---------------" << std::endl;
+        }
+    }
+}
+
+void Merger_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN1, IN2, OUT;
+
+    Merger uut("uut", 3.0103);
+    uut.m_attenuation_dB = 0;
+    uut.p_in1(IN1);
+    uut.p_in2(IN2);
+    uut.p_out(OUT);
+
+    Merger_tb tb("tb");
+    tb.IN1(IN1);
+    tb.IN2(IN2);
+    tb.OUT(OUT);
+
+    // Open Trace file
+    // sc_trace_file *Tf;
+    std::string trace_filename = "traces/";
+    trace_filename += "merger_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    Probe probe_merger("probe_merger",specsGlobalConfig.default_trace_file);
+    probe_merger.p_in(OUT);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/merger_tb.h b/src/tb/merger_tb.h
new file mode 100644
index 0000000..a71fd2a
--- /dev/null
+++ b/src/tb/merger_tb.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <merger.h>
+#include <optical_signal.h>
+#include <systemc.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(Merger_tb)
+{
+public:
+    spx::oa_port_out_type IN1;
+    spx::oa_port_out_type IN2;
+    spx::oa_port_in_type OUT;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(Merger_tb)
+    {
+        SC_HAS_PROCESS(Merger_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN1 << IN2 << OUT;
+    }
+};
+
+void Merger_tb_run();
+
diff --git a/src/tb/mesh_tb.cpp b/src/tb/mesh_tb.cpp
new file mode 100644
index 0000000..9effd11
--- /dev/null
+++ b/src/tb/mesh_tb.cpp
@@ -0,0 +1,130 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/mesh_tb.h>
+
+#include "general_utils.h"
+
+void mesh_tb::run_1()
+{
+    IN->write(OpticalSignal(sqrt(1.0), 1550e-9));
+    vtheta.write(M_PI);
+    vphi.write(1);
+    wait(1, SC_NS);
+    // vtheta.write(M_PI_2);
+    // wait(1, SC_NS);
+    // vtheta.write(M_PI);
+    // wait(1, SC_NS);
+    // vphi.write(1);
+    // wait(1, SC_NS);
+
+    while (true) { wait(); }
+}
+
+void mesh_tb::monitor()
+{
+    while(true)
+    {
+        wait();
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN:  " << IN->read() << std::endl
+            << "\tPHI: " << vphi.read() << std::endl
+            << "\tTHETA: " << vtheta.read() << std::endl
+            << "\tOUT1: " << OUT1->read() << std::endl
+            << "\tOUT2: " << OUT2->read() << std::endl
+            << "\tOUT3: " << OUT3->read() << std::endl
+            << "\tOUT4: " << OUT4->read() << std::endl
+            << "\tOUT5: " << OUT5->read() << std::endl;
+    }
+
+}
+
+void mesh_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type SIG, ZERO, OUT1, OUT2, OUT3, OUT4, OUT5;
+    sc_signal<double> vphi,vtheta,e_zero;
+
+    Clements mesh1("mesh1", 5, 1, 0, 0, 0, 0, 1);
+    mesh1.p_in[0]->bind(SIG);
+    mesh1.p_in[1]->bind(SIG);
+    mesh1.p_in[2]->bind(SIG);
+    mesh1.p_in[3]->bind(SIG);
+    mesh1.p_in[4]->bind(SIG);
+    mesh1.p_out[0]->bind(OUT1);
+    mesh1.p_out[1]->bind(OUT2);
+    mesh1.p_out[2]->bind(OUT3);
+    mesh1.p_out[3]->bind(OUT4);
+    mesh1.p_out[4]->bind(OUT5);
+
+    mesh1.p_vphi[0]->bind(e_zero);
+    mesh1.p_vtheta[0]->bind(vtheta);
+
+    mesh1.p_vphi[1]->bind(e_zero);
+    mesh1.p_vtheta[1]->bind(e_zero);
+
+    mesh1.p_vphi[2]->bind(e_zero);
+    mesh1.p_vtheta[2]->bind(vtheta);
+
+    mesh1.p_vphi[3]->bind(e_zero);
+    mesh1.p_vtheta[3]->bind(e_zero);
+
+    mesh1.p_vphi[4]->bind(e_zero);
+    mesh1.p_vtheta[4]->bind(e_zero);
+
+    mesh1.p_vphi[5]->bind(e_zero);
+    mesh1.p_vtheta[5]->bind(e_zero);
+
+    mesh1.p_vphi[6]->bind(e_zero);
+    mesh1.p_vtheta[6]->bind(e_zero);
+
+    mesh1.p_vphi[7]->bind(e_zero);
+    mesh1.p_vtheta[7]->bind(e_zero);
+
+    mesh1.p_vphi[8]->bind(e_zero);
+    mesh1.p_vtheta[8]->bind(e_zero);
+
+    mesh1.p_vphi[9]->bind(e_zero);
+    mesh1.p_vtheta[9]->bind(e_zero);
+                      
+    mesh1.init();
+
+    mesh_tb tb("tb");
+    tb.IN(SIG);
+    tb.OUT1(OUT1);
+    tb.OUT2(OUT2);
+    tb.OUT3(OUT3);
+    tb.OUT4(OUT4);
+    tb.OUT5(OUT5);
+    tb.vphi(vphi);
+    tb.vtheta(vtheta);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "mesh_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+    
+
+    Probe probe_mzi_1("probe_mzi_1",specsGlobalConfig.default_trace_file);
+    probe_mzi_1.p_in(OUT1);
+    Probe probe_mzi_2("probe_mzi_2",specsGlobalConfig.default_trace_file);
+    probe_mzi_2.p_in(OUT2);
+    Probe probe_in("probe_in",specsGlobalConfig.default_trace_file);
+    probe_in.p_in(SIG);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/mesh_tb.h b/src/tb/mesh_tb.h
new file mode 100644
index 0000000..1e7e3dd
--- /dev/null
+++ b/src/tb/mesh_tb.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <systemc.h>
+#include <probe.h>
+#include <specs.h>
+#include <clements.h>
+
+SC_MODULE(mesh_tb)
+{
+public:
+    spx::oa_port_out_type IN;
+    spx::oa_port_in_type OUT1, OUT2, OUT3, OUT4, OUT5;
+    sc_out<double> vphi,vtheta;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(mesh_tb)
+    {
+        SC_HAS_PROCESS(mesh_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << OUT1 << OUT2 << OUT3 << OUT4 << OUT5 << vphi << vtheta;
+    }
+};
+
+void mesh_tb_run();
diff --git a/src/tb/mzi_tb.cpp b/src/tb/mzi_tb.cpp
new file mode 100644
index 0000000..2b9905a
--- /dev/null
+++ b/src/tb/mzi_tb.cpp
@@ -0,0 +1,86 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/mzi_tb.h>
+
+#include "general_utils.h"
+
+void mzi_tb::run_1()
+{
+    IN->write(OpticalSignal(sqrt(1.0), 1550e-9));
+    wait(1, SC_NS);
+    vtheta.write(M_PI_2);
+    wait(1, SC_NS);
+    vtheta.write(M_PI);
+    wait(1, SC_NS);
+    vphi.write(1);
+    wait(1, SC_NS);
+
+    while (true) { wait(); }
+}
+
+void mzi_tb::monitor()
+{
+    while(true)
+    {
+        wait();
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN:  " << IN->read() << std::endl
+            << "\tPHI: " << vphi.read() << std::endl
+            << "\tTHETA: " << vtheta.read() << std::endl
+            << "\tOUT1: " << OUT1->read() << std::endl
+            << "\tOUT2: " << OUT2->read() << std::endl;
+    }
+
+}
+
+void MZI_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN1, IN2, OUT1, OUT2;
+    spx::ea_signal_type vphi,vtheta;
+
+    MZI mzi1("mzi1",0,0,0,0,0,1);
+    mzi1.p_in1(IN1);
+    mzi1.p_in2(IN2);
+    mzi1.p_out1(OUT1);
+    mzi1.p_out2(OUT2);
+    mzi1.p_vphi(vphi);
+    mzi1.p_vtheta(vtheta);
+
+    mzi_tb tb("tb");
+    tb.IN(IN1);
+    tb.OUT1(OUT1);
+    tb.OUT2(OUT2);
+    tb.vphi(vphi);
+    tb.vtheta(vtheta);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "mzi_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+
+    Probe probe_mzi_1("probe_mzi_1",specsGlobalConfig.default_trace_file);
+    probe_mzi_1.p_in(OUT1);
+    Probe probe_mzi_2("probe_mzi_2",specsGlobalConfig.default_trace_file);
+    probe_mzi_2.p_in(OUT2);
+    Probe probe_in("probe_in",specsGlobalConfig.default_trace_file);
+    probe_in.p_in(IN1);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/mzi_tb.h b/src/tb/mzi_tb.h
new file mode 100644
index 0000000..16ed624
--- /dev/null
+++ b/src/tb/mzi_tb.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <systemc.h>
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <mzi.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(mzi_tb)
+{
+public:
+    spx::oa_port_out_type IN;
+    spx::oa_port_in_type OUT1, OUT2;
+    sc_out<double> vphi,vtheta;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(mzi_tb)
+    {
+        SC_HAS_PROCESS(mzi_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << OUT1 << OUT2 << vphi << vtheta;
+    }
+};
+
+void MZI_tb_run();
diff --git a/src/tb/pcm_device_tb.cpp b/src/tb/pcm_device_tb.cpp
new file mode 100644
index 0000000..b279e6c
--- /dev/null
+++ b/src/tb/pcm_device_tb.cpp
@@ -0,0 +1,129 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/pcm_device_tb.h>
+
+#include "general_utils.h"
+
+void PCMElement_tb::run_1()
+{
+    IN->write(OpticalSignal(sqrt(1.0e-3), 1.55e-6));
+    wait(10, SC_MS);
+    IN->write(OpticalSignal(sqrt(2*1e-3), 1.55e-6)); // to 2W
+    wait(10, SC_MS);
+    IN->write(OpticalSignal(0, 1.55e-6));
+    wait(10, SC_MS);
+    IN->write(OpticalSignal(sqrt(1.0e-3), 1.55e-6));
+    wait(10, SC_MS);
+    IN->write(OpticalSignal(sqrt(2*1.0e-3), 1.55e-6));
+    wait(10, SC_MS);
+    IN->write(OpticalSignal(0, 1.55e-6));
+    wait(10, SC_MS);
+    IN->write(OpticalSignal(sqrt(1.0e-3), 1.55e-6));
+
+
+    while (true) { wait(); }
+}
+
+void PCMElement_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 3;
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN:  " << IN->read() << std::endl
+            << "\tOUT: " << OUT->read() << std::endl
+            << "\tCOUNT: " << event_counter << std::endl;
+
+        if(event_counter == 2)
+        {
+            if (is_close(norm(OUT->read().m_field), 0.000850, 1e-8))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.850mW as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 8)
+        {
+            if (is_close(norm(OUT->read().m_field), 0.000854758, 1e-8))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.854mW as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 14)
+        {
+            if (is_close(norm(OUT->read().m_field), 0.000859495, 1e-8))
+                success_counter++; 
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.859mW as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            std::cout << "-----------------/! \\---------------" << std::endl;
+            std::cout << "Test finished!" << std::endl;
+            std::cout << "Success rate: " << success_counter << "/" << test_number << std::endl;
+            std::cout << "-----------------/! \\---------------" << std::endl;
+        }
+    }
+}
+
+void PCMElement_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN, OUT;
+
+    PCMElement pcm("pcm", 25e-6, 63, 0);
+    pcm.p_in(IN);
+    pcm.p_out(OUT);
+
+    PCMElement_tb tb("tb");
+    tb.IN(IN);
+    tb.OUT(OUT);
+
+    // Open Trace file
+
+    std::string trace_filename = "traces/";
+    trace_filename += "pcm_device_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    Probe probe_in("in",specsGlobalConfig.default_trace_file);
+    probe_in.p_in(IN);
+
+    Probe probe_out("out",specsGlobalConfig.default_trace_file);
+    probe_out.p_in(OUT);
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // extra traces should come after prepareSimulation
+    sc_trace(specsGlobalConfig.default_trace_file, pcm.m_state, "STATE");
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/pcm_device_tb.h b/src/tb/pcm_device_tb.h
new file mode 100644
index 0000000..a9b7195
--- /dev/null
+++ b/src/tb/pcm_device_tb.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <systemc.h>
+
+#include <optical_signal.h>
+#include <pcm_device.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(PCMElement_tb)
+{
+public:
+    spx::oa_port_out_type IN;
+    spx::oa_port_in_type OUT;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(PCMElement_tb)
+    {
+        SC_HAS_PROCESS(PCMElement_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << OUT;
+    }
+};
+
+void PCMElement_tb_run();
diff --git a/src/tb/phase_shifter_tb.cpp b/src/tb/phase_shifter_tb.cpp
new file mode 100644
index 0000000..5369e7c
--- /dev/null
+++ b/src/tb/phase_shifter_tb.cpp
@@ -0,0 +1,129 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/phase_shifter_tb.h>
+
+#include "general_utils.h"
+#include "specs.h"
+
+void ps_tb::run_1()
+{
+    V_PS.write(1.0);
+    wait(SC_ZERO_TIME);
+    IN1->write(OpticalSignal(sqrt(1.0), 1550e-9));
+    IN2->write(OpticalSignal(sqrt(1.0), 1660e-9));
+    wait(100,SC_MS);
+    V_PS.write(2.0);
+    wait(100, SC_MS);
+
+    while (true) { wait(); }
+}
+
+void ps_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 3;
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN1:  " << IN1->read() << std::endl
+            << "\tIN2:  " << IN2->read() << std::endl
+            << "\tOUT: " << OUT->read() << std::endl
+            << "\tCOUNT: " << event_counter << std::endl;
+
+        if(event_counter == 2)
+        {
+            if (is_close(abs(OUT->read().m_field), 0.630210, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.630210W as output field!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 4)
+        {
+            if (is_close(arg(OUT->read().m_field), 2, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 2 rad as output phase!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 5)
+        {
+            if (is_close(arg(OUT->read().m_field), 2, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 2 as output phase!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            std::cout << "-----------------/! \\---------------" << std::endl;
+            std::cout << "Test finished!" << std::endl;
+            std::cout << "Success rate: " << success_counter << "/" << test_number << std::endl;
+            std::cout << "-----------------/! \\---------------" << std::endl;
+        }
+    }
+
+}
+
+void ps_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN1, IN2, OUT, YOUT;
+    spx::ea_signal_type V_PS;
+
+    Merger merg1("merg1");
+    merg1.p_in1(IN1);
+    merg1.p_in2(IN2);
+    merg1.p_out(YOUT);
+
+    PhaseShifter ps1("ps1", 1);
+    ps1.p_in(YOUT);
+    ps1.p_vin(V_PS);
+    ps1.p_out(OUT);
+
+    // Connect testbench to uut
+    ps_tb tb("tb");
+    tb.IN1(IN1);
+    tb.IN2(IN2);
+    tb.OUT(OUT);
+    tb.V_PS(V_PS);
+
+    // Attach probes
+    MLambdaProbe probe_out("out", {1550e-9, 1660e-9});
+    probe_out.p_in(OUT);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "ps_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/phase_shifter_tb.h b/src/tb/phase_shifter_tb.h
new file mode 100644
index 0000000..a59538d
--- /dev/null
+++ b/src/tb/phase_shifter_tb.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <systemc.h>
+#include <waveguide.h>
+#include <phaseshifter.h>
+#include <merger.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(ps_tb)
+{
+public:
+    spx::oa_port_out_type IN1;
+    spx::oa_port_out_type IN2;
+    sc_out<double> V_PS;
+    spx::oa_port_in_type OUT;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(ps_tb)
+    {
+        SC_HAS_PROCESS(ps_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN1 << IN2 << OUT;
+    }
+};
+
+void ps_tb_run();
diff --git a/src/tb/ring_tb.cpp b/src/tb/ring_tb.cpp
new file mode 100644
index 0000000..cc3aaf2
--- /dev/null
+++ b/src/tb/ring_tb.cpp
@@ -0,0 +1,85 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/ring_tb.h>
+
+#include "general_utils.h"
+
+void ring_tb::run_1()
+{
+    IN.write(OpticalSignal(sqrt(1.0), 1550e-9));
+    wait(10, SC_NS);
+    IN.write(OpticalSignal(0, 1550e-9));
+    wait(10, SC_NS);
+
+    IN.write(OpticalSignal(sqrt(1.0), 1550e-9));
+    wait(10, SC_NS);
+    IN.write(OpticalSignal(0, 1550e-9));
+    wait(10, SC_NS);
+
+    while(true)
+    {
+        wait();
+    }
+}
+
+void ring_tb::monitor()
+{
+    while(true)
+    {
+        wait();
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN:  " << IN.read() << std::endl
+            << "\tOUT: " << OUT.read() << std::endl;
+    }
+
+}
+
+void Ring_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    double neff = 1.0;
+    double loss_db_cm = 0;
+    double coupling_through = 0.85;
+
+    spx::oa_signal_type IN, OUT;
+    spx::oa_signal_type RING1, RING2;
+
+    DirectionalCoupler dc1("dc1", coupling_through, 0);
+    dc1.p_in1(IN);
+    dc1.p_out1(OUT);
+    dc1.p_in2(RING1);
+    dc1.p_out2(RING2);
+
+    Waveguide wg1("wg1", 1*100.0*1550.0e-6/(2*neff), loss_db_cm, neff, neff);
+    wg1.p_in(RING2);
+    wg1.p_out(RING1);
+
+    ring_tb tb("tb");
+    tb.IN(IN);
+    tb.OUT(OUT);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "ring_tb";
+    specsGlobalConfig.trace_filename = trace_filename;    
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    Probe probe_ring("probe_ring",specsGlobalConfig.default_trace_file);
+    probe_ring.p_in(OUT);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/ring_tb.h b/src/tb/ring_tb.h
new file mode 100644
index 0000000..b995513
--- /dev/null
+++ b/src/tb/ring_tb.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <systemc.h>
+#include <waveguide.h>
+#include <directional_coupler.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(ring_tb)
+{
+public:
+    sc_out<OpticalSignal> IN;
+    sc_in<OpticalSignal> OUT;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(ring_tb)
+    {
+        SC_HAS_PROCESS(ring_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << OUT;
+    }
+};
+
+void Ring_tb_run();
diff --git a/src/tb/splitter_tb.cpp b/src/tb/splitter_tb.cpp
new file mode 100644
index 0000000..eeb3420
--- /dev/null
+++ b/src/tb/splitter_tb.cpp
@@ -0,0 +1,123 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/splitter_tb.h>
+
+#include "general_utils.h"
+
+void Splitter_tb::run_1()
+{
+    IN->write(OpticalSignal(sqrt(1.0), 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(-sqrt(1.0), 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(sqrt(2.0), 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(-sqrt(2.0), 1550e-9));
+    wait(10, SC_PS);
+    IN->write(OpticalSignal(sqrt(3.0), 1550e-9));
+    wait(100, SC_MS);
+
+    wait(OUT1->value_changed_event());
+    wait(1, SC_SEC);
+    sc_stop();
+}
+
+void Splitter_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 3;
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+                << "\tIN: " << IN->read() << std::endl
+                << "\tOUT1:  " << OUT1->read() << std::endl
+                << "\tOUT2:  " << OUT2->read() << std::endl
+                << "\tCOUNT: " << event_counter << std::endl;
+
+        if(event_counter == 10)
+        {
+            if (is_close(norm(OUT1->read().m_field), 0.75, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.75W as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            if (is_close(norm(OUT1->read().m_field), norm(OUT2->read().m_field), 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected same power in both ends!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            if (is_close(arg(OUT1->read().m_field), 0, 1e-4) && is_close(arg(OUT2->read().m_field), 0, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected zero phase in both ends!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            std::cout << "-----------------/! \\---------------" << std::endl;
+            std::cout << "Test finished!" << std::endl;
+            std::cout << "Success rate: " << success_counter << "/" << test_number << std::endl;
+            std::cout << "-----------------/! \\---------------" << std::endl;
+        }
+    }
+}
+
+void Splitter_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN, OUT1, OUT2;
+
+    Splitter uut("uut");
+    uut.m_attenuation_dB = 3.0103;
+    uut.p_in(IN);
+    uut.p_out1(OUT1);
+    uut.p_out2(OUT2);
+
+    Splitter_tb tb("tb");
+    tb.IN(IN);
+    tb.OUT1(OUT1);
+    tb.OUT2(OUT2);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "splitter_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    Probe probe_splitter_1("probe_splitter_1",specsGlobalConfig.default_trace_file);
+    probe_splitter_1.p_in(OUT1);
+
+    Probe probe_splitter_2("probe_splitter_2",specsGlobalConfig.default_trace_file);
+    probe_splitter_2.p_in(OUT2);
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/splitter_tb.h b/src/tb/splitter_tb.h
new file mode 100644
index 0000000..68d2a8d
--- /dev/null
+++ b/src/tb/splitter_tb.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <splitter.h>
+#include <systemc.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(Splitter_tb)
+{
+public:
+    spx::oa_port_out_type IN;
+    spx::oa_port_in_type OUT1;
+    spx::oa_port_in_type OUT2;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(Splitter_tb)
+    {
+        SC_HAS_PROCESS(Splitter_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << OUT1 << OUT2;
+    }
+};
+
+void Splitter_tb_run();
diff --git a/src/tb/wg_tb.cpp b/src/tb/wg_tb.cpp
new file mode 100644
index 0000000..7ccebf5
--- /dev/null
+++ b/src/tb/wg_tb.cpp
@@ -0,0 +1,143 @@
+#include <ctime>
+#include <iomanip>
+#include <tb/wg_tb.h>
+
+#include "general_utils.h"
+#include "devices/generic_waveguide.h"
+#include "specs.h"
+
+void wg_tb::run_1()
+{
+    IN->write(OpticalSignal(sqrt(1.0), 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(0, 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(sqrt(2.0), 1550e-9));
+    wait(100, SC_MS);
+    IN->write(OpticalSignal(0, 1550e-9));
+    wait(10, SC_PS);
+    IN->write(OpticalSignal(sqrt(3.0), 1550e-9));
+    wait(100, SC_MS);
+
+    while (true) { wait(); }
+}
+
+void wg_tb::monitor()
+{
+    unsigned int event_counter = 0;
+    unsigned int success_counter = 0;
+    const unsigned int test_number = 3;
+    while(true)
+    {
+        wait();
+        event_counter++;
+        std::cout << sc_time_stamp() << ":" << std::endl
+            << "\tIN:  " << IN->read() << std::endl
+            << "\tOUT: " << OUT->read() << std::endl
+            << "\tCOUNT: " << event_counter << std::endl;
+
+        if(event_counter == 2)
+        {
+            if (is_close(norm(OUT->read().m_field), 0.5, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 0.5W as output power!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 6)
+        {
+            if (is_close(arg(OUT->read().m_field), -2.4322, 1e-4))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected -2.4322 rad as output phase!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+        }
+        if(event_counter == 10)
+        {
+            if (is_close(norm(OUT->read().m_field), 1.5, 1e-4) && (is_close(arg(OUT->read().m_field), -2.4322, 1e-4)))
+                success_counter++;
+            else
+            {
+                std::cout << "-----------------/! \\---------------" << std::endl;
+                std::cout << "Failure!" << std::endl;
+                std::cout << "Expected 1.5W as output power and -2.4322 as output phase!" << std::endl;
+                std::cout << "-----------------/! \\---------------" << std::endl;
+            }
+
+            std::cout << "-----------------/! \\---------------" << std::endl;
+            std::cout << "Test finished!" << std::endl;
+            std::cout << "Success rate: " << success_counter << "/" << test_number << std::endl;
+            std::cout << "-----------------/! \\---------------" << std::endl;
+        }
+    }
+
+}
+
+void wg_tb_run()
+{
+    // Apply SPECS resolution before creating any device
+    specsGlobalConfig.applyEngineResolution();
+
+    spx::oa_signal_type IN("sig_in"), OUT("sig_out");
+    spx::oa_signal_type TERM_r, TERM_w;
+
+    // Unidirectional variant
+    // Waveguide uut("uut", 1, 0, 1, 1);
+    // uut.m_attenuation_dB_cm = 3.0103;
+    // uut.p_in(IN);
+    // uut.p_out(OUT);
+
+    // Bidirectional variant
+    WaveguideBi uut("uut", 1, 0, 1, 1);
+    uut.m_attenuation_dB_cm = 3.0103;
+    uut.p0_in(IN);
+    uut.p0_out(TERM_w);
+    uut.p1_in(TERM_r);
+    uut.p1_out(OUT);
+
+    // GenericWaveguide uut("uut",3.0103*100,1,1,0.01);
+    // uut.ports_in[0]->bind(IN);
+    // uut.ports_in[1]->bind(TERM_r);
+    // uut.ports_out[0]->bind(TERM_w);
+    // uut.ports_out[1]->bind(OUT);
+
+    // Connect testbench to uut
+    wg_tb tb("tb");
+    tb.IN(IN);
+    tb.OUT(OUT);
+
+    // Attach probes
+    Probe probe_in("in");
+    probe_in.p_in(IN);
+
+    Probe probe_out("out");
+    probe_out.p_in(OUT);
+
+    // Open Trace file
+    std::string trace_filename = "traces/";
+    trace_filename += "waveguide_tb";
+    specsGlobalConfig.trace_filename = trace_filename;
+
+    // Apply SPECS options specific to the testbench
+    specsGlobalConfig.simulation_mode = OpticalOutputPortMode::EVENT_DRIVEN;
+    specsGlobalConfig.trace_all_optical_nets = 0;
+
+    // Run SPECS pre-simulation code
+    specsGlobalConfig.prepareSimulation();
+
+    // Start simulation
+    sc_start();
+
+    std::cout << std::endl << std::endl;
+    std::cout << ".vcd trace file: " << specsGlobalConfig.trace_filename << std::endl;
+
+    sc_close_vcd_trace_file(specsGlobalConfig.default_trace_file);
+}
diff --git a/src/tb/wg_tb.h b/src/tb/wg_tb.h
new file mode 100644
index 0000000..5d0a84f
--- /dev/null
+++ b/src/tb/wg_tb.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <optical_signal.h>
+#include <systemc.h>
+#include <waveguide.h>
+#include <probe.h>
+#include <specs.h>
+
+SC_MODULE(wg_tb)
+{
+public:
+    spx::oa_port_out_type IN;
+    spx::oa_port_in_type OUT;
+
+    void run_1();
+    void monitor();
+    SC_CTOR(wg_tb)
+    {
+        SC_HAS_PROCESS(wg_tb);
+
+        SC_THREAD(run_1);
+
+        SC_THREAD(monitor);
+        sensitive << IN << OUT;
+    }
+};
+
+void wg_tb_run();
diff --git a/src/utils/general_utils.cpp b/src/utils/general_utils.cpp
new file mode 100644
index 0000000..0ba55be
--- /dev/null
+++ b/src/utils/general_utils.cpp
@@ -0,0 +1 @@
+#include "general_utils.h"
diff --git a/src/utils/general_utils.h b/src/utils/general_utils.h
new file mode 100644
index 0000000..14757a9
--- /dev/null
+++ b/src/utils/general_utils.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cmath>
+#include <vector>
+#include <iostream>
+
+using std::abs;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+template <typename T1, typename T2>
+inline bool is_close(const T1& x1, const T2& x2, const double &precision = 1e-12)
+{
+    return abs(x1-x2) < precision;
+}
+
+//double linspace(double minval, double maxval, double npoints);
+
+template <typename T>
+vector<T> range(const T &minval, const T &maxval, const T &step)
+{
+    vector<T> ret;
+    if (maxval <= minval || step <= 0)
+    {
+        cerr << "Invalid range parameters" << endl;
+        // because i don't have time to cover all cases
+        exit(1);
+    }
+    int n = floor((maxval - minval) / step);
+    ret.reserve(n);
+    for (T val = minval; val < maxval; val += step)
+        ret.push_back(val);
+    return ret;
+}
\ No newline at end of file
diff --git a/src/utils/pqueue.h b/src/utils/pqueue.h
new file mode 100644
index 0000000..4ec5dfd
--- /dev/null
+++ b/src/utils/pqueue.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <queue>
+#include <vector>
+
+using std::priority_queue;
+using std::vector;
+using std::greater;
+using std::size_t;
+
+template <class T>
+class PQueue: public priority_queue<T, vector<T>, greater<T>>{
+public:
+    public:
+    typedef typename
+        std::priority_queue<T>::container_type::iterator iterator;
+    typedef typename
+        std::priority_queue<T>::container_type::const_iterator const_iterator;
+
+    iterator begin() {
+        return this->c.begin();
+    }
+    iterator end() {
+        return this->c.end();
+    }
+    const_iterator cbegin() const {
+        return this->c.cbegin();
+    }
+    const_iterator cend() const {
+        return this->c.cend();
+    }
+    size_t size() const {
+        return this->c.size();
+    }
+};
diff --git a/src/utils/strutils.h b/src/utils/strutils.h
new file mode 100644
index 0000000..94e7ab7
--- /dev/null
+++ b/src/utils/strutils.h
@@ -0,0 +1,79 @@
+#pragma once
+
+#include <algorithm> // std::transform
+#include <string>
+
+namespace strutils {
+// trim from start (in place)
+inline void ltrim(std::string &s)
+{
+    s.erase(s.begin(),
+            std::find_if(s.begin(), s.end(), [](int ch) { return !std::isspace(ch); }));
+}
+
+// trim from end (in place)
+inline void rtrim(std::string &s)
+{
+    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) { return !std::isspace(ch); })
+                .base(),
+            s.end());
+}
+
+// trim from both ends (in place)
+inline void trim(std::string &s)
+{
+    ltrim(s);
+    rtrim(s);
+}
+
+// trim from start (copying)
+inline std::string ltrim_copy(std::string s)
+{
+    ltrim(s);
+    return s;
+}
+
+// trim from end (copying)
+inline std::string rtrim_copy(std::string s)
+{
+    rtrim(s);
+    return s;
+}
+
+// trim from both ends (copying)
+inline std::string trim_copy(std::string s)
+{
+    trim(s);
+    return s;
+}
+// trim from end (in place)
+inline void rtrim_comments(std::string &s, const std::string &comment_tokens)
+{
+    size_t pos = s.find_first_of(comment_tokens);
+    if (pos != s.npos)
+        s.erase(pos);
+}
+inline void toupper(std::string &s)
+{
+    std::transform(s.begin(), s.end(), s.begin(), ::toupper);
+}
+
+inline bool strcontains(const std::string &s, const std::string &sub)
+{
+    return s.find(sub) != std::string::npos;
+}
+
+inline bool streq(const std::string &s1, const std::string &s2)
+{
+    return s1 == s2;
+}
+
+inline bool iequals(const std::string& a, const std::string& b)
+{
+    return std::equal(a.begin(), a.end(),
+                      b.begin(), b.end(),
+                      [](char a, char b) {
+                          return tolower(a) == tolower(b);
+                      });
+}
+};
diff --git a/src/utils/sysc_utils.cpp b/src/utils/sysc_utils.cpp
new file mode 100644
index 0000000..9b63632
--- /dev/null
+++ b/src/utils/sysc_utils.cpp
@@ -0,0 +1,70 @@
+#include <sysc_utils.h>
+
+#include <string>
+
+
+inline bool sc_object_is_module(const sc_object &obj) {
+    return strcmp(obj.kind(), "sc_module") == 0;
+}
+
+// Return vector containing all children objects (expanded) of obj
+set<sc_object *> sc_collect_children_object(sc_object* obj)
+{
+    auto v = obj->get_child_objects();
+    auto children = set<sc_object *>(v.begin(), v.end());
+    auto all_children = children;
+    for (auto child : children)
+        if ( child )
+        {
+            auto children_children = sc_collect_children_object(child);
+            for (auto child_child : children_children)
+                all_children.insert(child_child);
+        }
+    return all_children;
+}
+
+// Return vector containing all children objects (expanded) of obj
+set<sc_module *> sc_collect_children_module(sc_module* obj)
+{
+    auto v = obj->get_child_objects();
+    auto children = set<sc_object *>(v.begin(), v.end());
+    set<sc_module *> all_children;
+    for (auto obj: children)
+    {
+        auto mod = dynamic_cast<sc_module *>(obj);
+        if(mod) {
+            all_children.insert(mod);
+            auto children2 = sc_collect_children_module(mod);
+            all_children.insert(children2.begin(), children2.end());
+        }
+    }
+    return all_children;
+}
+
+set<sc_module *> sc_get_all_module() {
+    set<sc_module *> all_modules;
+
+    for ( auto obj : sc_get_top_level_objects() ) {
+        auto mod = dynamic_cast<sc_module *>(obj);
+        if (mod)
+        {
+            all_modules.insert(mod);
+            auto all_children = sc_collect_children_module(mod);
+            for (auto child : all_children)
+                all_modules.insert(child);
+        }
+    }
+    return all_modules;
+}
+
+set<sc_object *> sc_get_all_object() {
+    set<sc_object *> all_objects;
+
+    for ( auto obj : sc_get_top_level_objects() ) {
+        all_objects.insert(obj);
+        auto all_children = sc_collect_children_object(obj);
+        for (auto child : all_children)
+            all_objects.insert(child);
+    }
+    return all_objects;
+}
\ No newline at end of file
diff --git a/src/utils/sysc_utils.h b/src/utils/sysc_utils.h
new file mode 100644
index 0000000..be275a0
--- /dev/null
+++ b/src/utils/sysc_utils.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <systemc.h>
+
+#include <vector>
+#include <set>
+
+using std::vector;
+using std::set;
+
+bool sc_object_is_module(const sc_object &obj);
+
+// Return vector containing all children objects (expanded) of obj
+set<sc_object *> sc_collect_children_object(sc_object* obj);
+
+// Return vector containing all children objects (expanded) of obj
+set<sc_module *> sc_collect_children_module(sc_module* obj);
+
+// Return vector containing all sc_module registered with engine
+set<sc_module *> sc_get_all_module();
+
+// Return vector containing all sc_object registered with engine
+set<sc_object *> sc_get_all_object();
+
+// Return vector containing all sc_module of a certain type
+template<typename T>
+set<T *> sc_get_all_module_by_type();
+
+// Return vector containing all sc_object of a certain type
+template<typename T>
+set<T *> sc_get_all_object_by_type();
+
+////////////////////////////////////////
+// Definition of template functions
+////////////////////////////////////////
+
+
+template<typename T>
+set<T *> sc_get_all_module_by_type() {
+    set<sc_module *> all_modules = sc_get_all_module();
+    set<T *> all_requested;
+    for (auto mod : all_modules)
+    {
+        // cout << mod->name() << endl;
+        auto requested = dynamic_cast<T *>(mod);
+        if (requested)
+            all_requested.insert(requested);
+    }
+    return all_requested;
+}
+
+template<typename T>
+set<T *> sc_get_all_object_by_type() {
+    set<sc_object *> all_objects = sc_get_all_object();
+    set<T *> all_requested;
+
+    for (auto obj : all_objects)
+    {
+        //cout << obj->name() << endl;
+        auto requested = dynamic_cast<T *>(obj);
+        if (requested) {
+            //cout << "\\__( WE WANT IT )" << endl;
+            all_requested.insert(requested);
+        }
+    }
+    return all_requested;
+}
\ No newline at end of file