ext/dsent/model/optical/SWSRLink.cc - amd/gem5 - Git at Google


            
            /* Copyright (c) 2012 Massachusetts Institute of Technology

            
             *

            
             * Permission is hereby granted, free of charge, to any person obtaining a copy

            
             * of this software and associated documentation files (the "Software"), to deal

            
             * in the Software without restriction, including without limitation the rights

            
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

            
             * copies of the Software, and to permit persons to whom the Software is

            
             * furnished to do so, subject to the following conditions:

            
             *

            
             * The above copyright notice and this permission notice shall be included in

            
             * all copies or substantial portions of the Software.

            
             *

            
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

            
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

            
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

            
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

            
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

            
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

            
             * THE SOFTWARE.

            
             */


            #include "model/optical/SWSRLink.h"


            #include "model/ModelGen.h"

            
            #include "model/PortInfo.h"

            
            #include "model/TransitionInfo.h"

            
            #include "model/EventInfo.h"

            
            #include "model/optical_graph/OpticalGraph.h"

            
            #include "model/optical_graph/OpticalWaveguide.h"

            
            #include "model/optical/RingModulator.h"

            
            #include "model/optical/RingFilter.h"

            
            #include "model/optical/RingDetector.h"

            
            #include "model/optical/LaserSource.h"

            
            #include "model/optical/ThrottledLaserSource.h"


            namespace DSENT

            
            {

            
                SWSRLink::SWSRLink(const String& instance_name_, const TechModel* tech_model_)

            
                    : OpticalModel(instance_name_, tech_model_)

            
                {

            
                    initParameters();

            
                    initProperties();

            
                }


                SWSRLink::~SWSRLink()

            
                {}


                void SWSRLink::initParameters()

            
                {

            
                    addParameterName("NumberBits");

            
                    addParameterName("CoreDataRate");

            
                    addParameterName("LinkDataRate");


                    addParameterName("LaserType");

            
                    addParameterName("RingTuningMethod");

            
                    addParameterName("OptimizeLoss", "TRUE");


                    return;

            
                }


                void SWSRLink::initProperties()

            
                {

            
                    addPropertyName("Length");

            
            		addPropertyName("OptUtil", 0.5);        // default to 50% utilization (a new word 50% of the time)

            
                    addPropertyName("ExtinctionRatio", 6);  // default properties

            
                    addPropertyName("InsertionLoss", 2);    // default properties

            
                    return;

            
                }


                void SWSRLink::constructModel()

            
                {

            
                    // Get parameters

            
                    unsigned int number_bits = getParameter("NumberBits");

            
                    double core_data_rate = getParameter("CoreDataRate");

            
                    double link_data_rate = getParameter("LinkDataRate");


                    // Get directly propagated parameters

            
                    const String& ring_tuning_method = getParameter("RingTuningMethod");


                    // Calculate number of wavelengths needed

            
                    unsigned int number_wavelengths = (unsigned int)((double) number_bits * core_data_rate / link_data_rate);


                    // Set some generated properties

            
                    getGenProperties()->set("NumberWavelengths", number_wavelengths);


                    // Create electrical ports

            
                    createInputPort("LinkCK");

            
                    createInputPort("In", makeNetIndex(0, number_bits-1));

            
                    createOutputPort("Out", makeNetIndex(0, number_bits-1));


                    // Create Waveguides

            
                    // Temporarily assume its all on one waveguide

            
                    createWaveguide("LaserToMod", makeWavelengthGroup(0, number_wavelengths-1));

            
                    createWaveguide("ModToDetector", makeWavelengthGroup(0, number_wavelengths-1));


                    // Add area results

            
                    addAreaResult(new Result("Photonic"));

            
                    createElectricalResults();

            
                    // Setup idle event

            
                    getEventInfo("Idle")->setStaticTransitionInfos();

            
                    // Create a waveguide area result

            
                    addAreaResult(new AtomicResult("Waveguide"));

            
                    getAreaResult("Photonic")->addSubResult(getAreaResult("Waveguide"), "Waveguide", 1.0);

            
                    // Add results

            
                    addNddPowerResult(new Result("Laser"));

            
                    addNddPowerResult(new Result("RingTuning"));

            
                    // Add event result

            
                    createElectricalEventResult("Send");


                    // Create Tx, Rx backends

            
                    // Create Tx electrical backend

            
                    ElectricalModel* tx_backend = (ElectricalModel*) ModelGen::createModel("OpticalLinkBackendTx", "OpticalLinkBackendTx", getTechModel());

            
                    tx_backend->setParameter("InBits", number_bits);

            
                    tx_backend->setParameter("CoreDataRate", core_data_rate);

            
                    tx_backend->setParameter("LinkDataRate", link_data_rate);

            
                    tx_backend->setParameter("RingTuningMethod", ring_tuning_method);

            
                    tx_backend->setParameter("BitDuplicate", "TRUE");

            
                    tx_backend->construct();


                    // Create Rx electrical backend

            
                    ElectricalModel* rx_backend = (ElectricalModel*) ModelGen::createModel("OpticalLinkBackendRx", "OpticalLinkBackendRx", getTechModel());

            
                    rx_backend->setParameter("OutBits", number_bits);

            
                    rx_backend->setParameter("CoreDataRate", core_data_rate);

            
                    rx_backend->setParameter("LinkDataRate", link_data_rate);

            
                    rx_backend->setParameter("RingTuningMethod", ring_tuning_method);

            
                    rx_backend->setParameter("BitDuplicate", "TRUE");

            
                    rx_backend->construct();


                    // Connect ports

            
                    createNet("TxBackendToTx", makeNetIndex(0, number_wavelengths-1));

            
                    createNet("RxToRxBackend", makeNetIndex(0, number_wavelengths-1));

            
                    portConnect(tx_backend, "In", "In");

            
                    portConnect(tx_backend, "Out", "TxBackendToTx");

            
                    portConnect(tx_backend, "LinkCK", "LinkCK");

            
                    portConnect(rx_backend, "In", "RxToRxBackend");

            
                    portConnect(rx_backend, "Out", "Out");

            
                    portConnect(rx_backend, "LinkCK", "LinkCK");


                    // Add instances

            
                    addSubInstances(tx_backend, 1.0);

            
                    addSubInstances(rx_backend, 1.0);


                    // Add electrical results

            
                    addElectricalSubResults(tx_backend, 1.0);

            
                    addElectricalSubResults(rx_backend, 1.0);


                    // Add tuning power result

            
                    getNddPowerResult("RingTuning")->addSubResult(tx_backend->getNddPowerResult("RingTuning"), "OpticalLinkBackendTx", 1.0);

            
                    getNddPowerResult("RingTuning")->addSubResult(rx_backend->getNddPowerResult("RingTuning"), "OpticalLinkBackendRx", 1.0);


                    // Add event results

            
                    getEventInfo("Send")->setTransitionInfo("LinkCK", TransitionInfo(0.0, (double) link_data_rate / (core_data_rate * 2.0), 0.0));


                    getEventResult("Send")->addSubResult(tx_backend->getEventResult("ProcessBits"), "OpticalLinkBackendTx", 1.0);

            
                    getEventResult("Send")->addSubResult(rx_backend->getEventResult("ProcessBits"), "OpticalLinkBackendRx", 1.0);


                    buildLaser();

            
                    buildModulator();

            
                    buildDetector();


                    return;

            
                }


                void SWSRLink::updateModel()

            
                {

            
                    // Get parameters

            
                    double link_data_rate = getParameter("LinkDataRate");


                    // Get properties

            
                    double length = getProperty("Length");

            
                    const String& extinction_ratio = getProperty("ExtinctionRatio");

            
                    const String& insertion_loss = getProperty("InsertionLoss");

            
            		const double opt_util = getProperty("OptUtil");


                    // Calculate loss for waveguide

            
                    double waveguide_loss = getTechModel()->get("Waveguide->LossPerMeter").toDouble() * length;

            
                    // Set loss of the waveguide

            
                    getWaveguide("ModToDetector")->setLoss(waveguide_loss);

            
                    // Calculate waveguide area

            
                    double waveguide_area = length * getTechModel()->get("Waveguide->Pitch").toDouble();

            
                    getAreaResult("Waveguide")->setValue(waveguide_area);


                    // Update the laser

            
                    Model* laser = getSubInstance("Laser");

            
                    laser->setProperty("LaserEventTime", 1.0 / link_data_rate);

            
            		laser->setProperty("OptUtil", opt_util);

            
                    laser->update();


                    // Update the modulator

            
                    Model* modulator = getSubInstance("Modulator");

            
                    modulator->setProperty("ExtinctionRatio", extinction_ratio);

            
                    modulator->setProperty("InsertionLoss", insertion_loss);

            
                    modulator->update();


                    Model* detector = getSubInstance("Detector");

            
                    detector->update();


                    Model* tx_backend = getSubInstance("OpticalLinkBackendTx");

            
                    tx_backend->update();


                    Model* rx_backend = getSubInstance("OpticalLinkBackendRx");

            
                    rx_backend->update();


                    return;

            
                }


                void SWSRLink::propagateTransitionInfo()

            
                {

            
                    // Get parameters

            
                    const String& laser_type = getParameter("LaserType");


                    // Propagate transition info to tx backend

            
                    OpticalModel* tx_backend = (OpticalModel*) getSubInstance("OpticalLinkBackendTx");

            
                    propagatePortTransitionInfo(tx_backend, "In", "In");

            
                    propagatePortTransitionInfo(tx_backend, "LinkCK", "LinkCK");

            
                    tx_backend->use();


                    // Set transition info for the modulator

            
                    OpticalModel* modulator = (OpticalModel*) getSubInstance("Modulator");

            
                    propagatePortTransitionInfo(modulator, "In", tx_backend, "Out");

            
                    modulator->use();


                    // Modulator out transition info

            
                    const TransitionInfo& mod_out_transitions = modulator->getOpticalOutputPort("Out")->getTransitionInfo();


                    // Set transition info for the receiver

            
                    OpticalModel* detector = (OpticalModel*) getSubInstance("Detector");

            
                    detector->getOpticalInputPort("In")->setTransitionInfo(mod_out_transitions);

            
                    detector->use();


                    // Propagate transition info to tx backend

            
                    OpticalModel* rx_backend = (OpticalModel*) getSubInstance("OpticalLinkBackendRx");

            
                    propagatePortTransitionInfo(rx_backend, "In", detector, "Out");

            
                    propagatePortTransitionInfo(rx_backend, "LinkCK", "LinkCK");

            
                    rx_backend->use();


                    // Propagate output transition info to output

            
                    propagatePortTransitionInfo("Out", rx_backend, "Out");


                    // Set enable signals for the laser, if applicable

            
                    if (laser_type == "Throttled")

            
                    {

            
                        // Figure out how many cycles the laser needs to be on

            
                        double cycles = getInputPort("In")->getTransitionInfo().getFrequencyMultiplier();


                        OpticalModel* laser = (OpticalModel*) getSubInstance("Laser");

            
                        laser->getInputPort("LaserEnable")->setTransitionInfo(TransitionInfo(0.0, 1.0, cycles - 1.0));

            
                        laser->use();

            
                    }


                    return;

            
                }


                void SWSRLink::buildLaser()

            
                {

            
                    // Get parameters

            
                    unsigned int number_wavelengths = getGenProperties()->get("NumberWavelengths");

            
                    const String& laser_type = getParameter("LaserType");


                    // Create laser

            
                    OpticalModel* laser = NULL;

            
                    if (laser_type == "Throttled") laser = new ThrottledLaserSource("Laser", getTechModel());

            
                    else if (laser_type == "Standard") laser = new LaserSource("Laser", getTechModel());

            
                    else ASSERT(false, "[Error] " + getInstanceName() + " -> Unknown laser type '" + laser_type + "'!");


                    laser->setParameter("OutStart", 0);

            
                    laser->setParameter("OutEnd", number_wavelengths-1);

            
                    laser->setParameter("MaxDetectors", 1);

            
                    laser->setParameter("MinDetectors", 1);

            
                    laser->construct();


                    addSubInstances(laser, 1.0);

            
                    getAreaResult("Photonic")->addSubResult(laser->getAreaResult("Photonic"), "Laser", 1.0);

            
                    // Connect laser output port

            
                    opticalPortConnect(laser, "Out", "LaserToMod");


                    // Without laser gating, laser is pure NDD power

            
                    if (laser_type == "Standard") getNddPowerResult("Laser")->addSubResult(laser->getNddPowerResult("Laser"), "Laser", 1.0);

            
                    // With laser power gating, laser is an event

            
                    else getEventResult("Send")->addSubResult(laser->getEventResult("Laser1"), "Laser", 1.0);


                    return;

            
                }


                void SWSRLink::buildModulator()

            
                {

            
                    // Get parameters

            
                    double link_data_rate = getParameter("LinkDataRate");

            
                    const String& optimize_loss = getParameter("OptimizeLoss");

            
                    unsigned int number_wavelengths = getGenProperties()->get("NumberWavelengths");


                    // Create modulator

            
                    RingModulator* modulator = new RingModulator("Modulator", getTechModel());

            
                    modulator->setParameter("DataRate", link_data_rate);

            
                    modulator->setParameter("InStart", 0);

            
                    modulator->setParameter("InEnd", number_wavelengths-1);

            
                    modulator->setParameter("ModStart", 0);

            
                    modulator->setParameter("ModEnd", number_wavelengths-1);

            
                    modulator->setParameter("OptimizeLoss", optimize_loss);

            
                    modulator->construct();

            
                    addSubInstances(modulator, 1.0);

            
                    getAreaResult("Photonic")->addSubResult(modulator->getAreaResult("Photonic"), "Modulator", 1.0);

            
                    addElectricalSubResults(modulator, 1.0);


                    // Connect electrical port

            
                    portConnect(modulator, "In", "TxBackendToTx");

            
                    // Connect modulator input, output port

            
                    opticalPortConnect(modulator, "In", "LaserToMod");

            
                    opticalPortConnect(modulator, "Out", "ModToDetector");


                    // Add modulator energy event for send events

            
                    getEventResult("Send")->addSubResult(modulator->getEventResult("Modulate"), "Modulator", 1.0);

            
                    return;

            
                }


                void SWSRLink::buildDetector()

            
                {

            
                    // Get parameters

            
                    double link_data_rate = getParameter("LinkDataRate");

            
                    unsigned int number_wavelengths = getGenProperties()->get("NumberWavelengths");


                    // Create resonant ring detector

            
                    RingDetector* detector = new RingDetector("Detector", getTechModel());

            
                    detector->setParameter("DataRate", link_data_rate);

            
                    detector->setParameter("InStart", 0);

            
                    detector->setParameter("InEnd", number_wavelengths-1);

            
                    detector->setParameter("DetStart", 0);

            
                    detector->setParameter("DetEnd", number_wavelengths-1);

            
                    detector->setParameter("DropAll", "TRUE");

            
                    detector->setParameter("Topology", RingDetector::INTEGRATINGSENSEAMP);

            
                    detector->construct();

            
                    addSubInstances(detector, 1.0);

            
                    getAreaResult("Photonic")->addSubResult(detector->getAreaResult("Photonic"), "Detector", 1.0);

            
                    addElectricalSubResults(detector, 1.0);


                    // connect to electrical port

            
                    portConnect(detector, "Out", "RxToRxBackend");

            
                    // connect optical input, output port

            
                    opticalPortConnect(detector, "In", "ModToDetector");


                    // Add receiver energy

            
                    getEventResult("Send")->addSubResult(detector->getEventResult("Receive"), "Detector", 1.0);


                    return;

            
                }


            } // namespace DSENT
	/* Copyright (c) 2012 Massachusetts Institute of Technology
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	* THE SOFTWARE.
	*/

	#include "model/optical/SWSRLink.h"

	#include "model/ModelGen.h"
	#include "model/PortInfo.h"
	#include "model/TransitionInfo.h"
	#include "model/EventInfo.h"
	#include "model/optical_graph/OpticalGraph.h"
	#include "model/optical_graph/OpticalWaveguide.h"
	#include "model/optical/RingModulator.h"
	#include "model/optical/RingFilter.h"
	#include "model/optical/RingDetector.h"
	#include "model/optical/LaserSource.h"
	#include "model/optical/ThrottledLaserSource.h"

	namespace DSENT
	{
	SWSRLink::SWSRLink(const String& instance_name_, const TechModel* tech_model_)
	: OpticalModel(instance_name_, tech_model_)
	{
	initParameters();
	initProperties();
	}

	SWSRLink::~SWSRLink()
	{}

	void SWSRLink::initParameters()
	{
	addParameterName("NumberBits");
	addParameterName("CoreDataRate");
	addParameterName("LinkDataRate");

	addParameterName("LaserType");
	addParameterName("RingTuningMethod");
	addParameterName("OptimizeLoss", "TRUE");

	return;
	}

	void SWSRLink::initProperties()
	{
	addPropertyName("Length");
	addPropertyName("OptUtil", 0.5); // default to 50% utilization (a new word 50% of the time)
	addPropertyName("ExtinctionRatio", 6); // default properties
	addPropertyName("InsertionLoss", 2); // default properties
	return;
	}

	void SWSRLink::constructModel()
	{
	// Get parameters
	unsigned int number_bits = getParameter("NumberBits");
	double core_data_rate = getParameter("CoreDataRate");
	double link_data_rate = getParameter("LinkDataRate");

	// Get directly propagated parameters
	const String& ring_tuning_method = getParameter("RingTuningMethod");

	// Calculate number of wavelengths needed
	unsigned int number_wavelengths = (unsigned int)((double) number_bits * core_data_rate / link_data_rate);

	// Set some generated properties
	getGenProperties()->set("NumberWavelengths", number_wavelengths);

	// Create electrical ports
	createInputPort("LinkCK");
	createInputPort("In", makeNetIndex(0, number_bits-1));
	createOutputPort("Out", makeNetIndex(0, number_bits-1));

	// Create Waveguides
	// Temporarily assume its all on one waveguide
	createWaveguide("LaserToMod", makeWavelengthGroup(0, number_wavelengths-1));
	createWaveguide("ModToDetector", makeWavelengthGroup(0, number_wavelengths-1));

	// Add area results
	addAreaResult(new Result("Photonic"));
	createElectricalResults();
	// Setup idle event
	getEventInfo("Idle")->setStaticTransitionInfos();
	// Create a waveguide area result
	addAreaResult(new AtomicResult("Waveguide"));
	getAreaResult("Photonic")->addSubResult(getAreaResult("Waveguide"), "Waveguide", 1.0);
	// Add results
	addNddPowerResult(new Result("Laser"));
	addNddPowerResult(new Result("RingTuning"));
	// Add event result
	createElectricalEventResult("Send");

	// Create Tx, Rx backends
	// Create Tx electrical backend
	ElectricalModel* tx_backend = (ElectricalModel*) ModelGen::createModel("OpticalLinkBackendTx", "OpticalLinkBackendTx", getTechModel());
	tx_backend->setParameter("InBits", number_bits);
	tx_backend->setParameter("CoreDataRate", core_data_rate);
	tx_backend->setParameter("LinkDataRate", link_data_rate);
	tx_backend->setParameter("RingTuningMethod", ring_tuning_method);
	tx_backend->setParameter("BitDuplicate", "TRUE");
	tx_backend->construct();

	// Create Rx electrical backend
	ElectricalModel* rx_backend = (ElectricalModel*) ModelGen::createModel("OpticalLinkBackendRx", "OpticalLinkBackendRx", getTechModel());
	rx_backend->setParameter("OutBits", number_bits);
	rx_backend->setParameter("CoreDataRate", core_data_rate);
	rx_backend->setParameter("LinkDataRate", link_data_rate);
	rx_backend->setParameter("RingTuningMethod", ring_tuning_method);
	rx_backend->setParameter("BitDuplicate", "TRUE");
	rx_backend->construct();

	// Connect ports
	createNet("TxBackendToTx", makeNetIndex(0, number_wavelengths-1));
	createNet("RxToRxBackend", makeNetIndex(0, number_wavelengths-1));
	portConnect(tx_backend, "In", "In");
	portConnect(tx_backend, "Out", "TxBackendToTx");
	portConnect(tx_backend, "LinkCK", "LinkCK");
	portConnect(rx_backend, "In", "RxToRxBackend");
	portConnect(rx_backend, "Out", "Out");
	portConnect(rx_backend, "LinkCK", "LinkCK");

	// Add instances
	addSubInstances(tx_backend, 1.0);
	addSubInstances(rx_backend, 1.0);

	// Add electrical results
	addElectricalSubResults(tx_backend, 1.0);
	addElectricalSubResults(rx_backend, 1.0);

	// Add tuning power result
	getNddPowerResult("RingTuning")->addSubResult(tx_backend->getNddPowerResult("RingTuning"), "OpticalLinkBackendTx", 1.0);
	getNddPowerResult("RingTuning")->addSubResult(rx_backend->getNddPowerResult("RingTuning"), "OpticalLinkBackendRx", 1.0);

	// Add event results
	getEventInfo("Send")->setTransitionInfo("LinkCK", TransitionInfo(0.0, (double) link_data_rate / (core_data_rate * 2.0), 0.0));

	getEventResult("Send")->addSubResult(tx_backend->getEventResult("ProcessBits"), "OpticalLinkBackendTx", 1.0);
	getEventResult("Send")->addSubResult(rx_backend->getEventResult("ProcessBits"), "OpticalLinkBackendRx", 1.0);

	buildLaser();
	buildModulator();
	buildDetector();

	return;
	}

	void SWSRLink::updateModel()
	{
	// Get parameters
	double link_data_rate = getParameter("LinkDataRate");

	// Get properties
	double length = getProperty("Length");
	const String& extinction_ratio = getProperty("ExtinctionRatio");
	const String& insertion_loss = getProperty("InsertionLoss");
	const double opt_util = getProperty("OptUtil");

	// Calculate loss for waveguide
	double waveguide_loss = getTechModel()->get("Waveguide->LossPerMeter").toDouble() * length;
	// Set loss of the waveguide
	getWaveguide("ModToDetector")->setLoss(waveguide_loss);
	// Calculate waveguide area
	double waveguide_area = length * getTechModel()->get("Waveguide->Pitch").toDouble();
	getAreaResult("Waveguide")->setValue(waveguide_area);

	// Update the laser
	Model* laser = getSubInstance("Laser");
	laser->setProperty("LaserEventTime", 1.0 / link_data_rate);
	laser->setProperty("OptUtil", opt_util);
	laser->update();

	// Update the modulator
	Model* modulator = getSubInstance("Modulator");
	modulator->setProperty("ExtinctionRatio", extinction_ratio);
	modulator->setProperty("InsertionLoss", insertion_loss);
	modulator->update();

	Model* detector = getSubInstance("Detector");
	detector->update();

	Model* tx_backend = getSubInstance("OpticalLinkBackendTx");
	tx_backend->update();

	Model* rx_backend = getSubInstance("OpticalLinkBackendRx");
	rx_backend->update();

	return;
	}

	void SWSRLink::propagateTransitionInfo()
	{
	// Get parameters
	const String& laser_type = getParameter("LaserType");

	// Propagate transition info to tx backend
	OpticalModel* tx_backend = (OpticalModel*) getSubInstance("OpticalLinkBackendTx");
	propagatePortTransitionInfo(tx_backend, "In", "In");
	propagatePortTransitionInfo(tx_backend, "LinkCK", "LinkCK");
	tx_backend->use();

	// Set transition info for the modulator
	OpticalModel* modulator = (OpticalModel*) getSubInstance("Modulator");
	propagatePortTransitionInfo(modulator, "In", tx_backend, "Out");
	modulator->use();

	// Modulator out transition info
	const TransitionInfo& mod_out_transitions = modulator->getOpticalOutputPort("Out")->getTransitionInfo();

	// Set transition info for the receiver
	OpticalModel* detector = (OpticalModel*) getSubInstance("Detector");
	detector->getOpticalInputPort("In")->setTransitionInfo(mod_out_transitions);
	detector->use();

	// Propagate transition info to tx backend
	OpticalModel* rx_backend = (OpticalModel*) getSubInstance("OpticalLinkBackendRx");
	propagatePortTransitionInfo(rx_backend, "In", detector, "Out");
	propagatePortTransitionInfo(rx_backend, "LinkCK", "LinkCK");
	rx_backend->use();

	// Propagate output transition info to output
	propagatePortTransitionInfo("Out", rx_backend, "Out");

	// Set enable signals for the laser, if applicable
	if (laser_type == "Throttled")
	{
	// Figure out how many cycles the laser needs to be on
	double cycles = getInputPort("In")->getTransitionInfo().getFrequencyMultiplier();

	OpticalModel* laser = (OpticalModel*) getSubInstance("Laser");
	laser->getInputPort("LaserEnable")->setTransitionInfo(TransitionInfo(0.0, 1.0, cycles - 1.0));
	laser->use();
	}


	return;
	}

	void SWSRLink::buildLaser()
	{
	// Get parameters
	unsigned int number_wavelengths = getGenProperties()->get("NumberWavelengths");
	const String& laser_type = getParameter("LaserType");

	// Create laser
	OpticalModel* laser = NULL;
	if (laser_type == "Throttled") laser = new ThrottledLaserSource("Laser", getTechModel());
	else if (laser_type == "Standard") laser = new LaserSource("Laser", getTechModel());
	else ASSERT(false, "[Error] " + getInstanceName() + " -> Unknown laser type '" + laser_type + "'!");

	laser->setParameter("OutStart", 0);
	laser->setParameter("OutEnd", number_wavelengths-1);
	laser->setParameter("MaxDetectors", 1);
	laser->setParameter("MinDetectors", 1);
	laser->construct();

	addSubInstances(laser, 1.0);
	getAreaResult("Photonic")->addSubResult(laser->getAreaResult("Photonic"), "Laser", 1.0);
	// Connect laser output port
	opticalPortConnect(laser, "Out", "LaserToMod");

	// Without laser gating, laser is pure NDD power
	if (laser_type == "Standard") getNddPowerResult("Laser")->addSubResult(laser->getNddPowerResult("Laser"), "Laser", 1.0);
	// With laser power gating, laser is an event
	else getEventResult("Send")->addSubResult(laser->getEventResult("Laser1"), "Laser", 1.0);

	return;
	}

	void SWSRLink::buildModulator()
	{
	// Get parameters
	double link_data_rate = getParameter("LinkDataRate");
	const String& optimize_loss = getParameter("OptimizeLoss");
	unsigned int number_wavelengths = getGenProperties()->get("NumberWavelengths");

	// Create modulator
	RingModulator* modulator = new RingModulator("Modulator", getTechModel());
	modulator->setParameter("DataRate", link_data_rate);
	modulator->setParameter("InStart", 0);
	modulator->setParameter("InEnd", number_wavelengths-1);
	modulator->setParameter("ModStart", 0);
	modulator->setParameter("ModEnd", number_wavelengths-1);
	modulator->setParameter("OptimizeLoss", optimize_loss);
	modulator->construct();
	addSubInstances(modulator, 1.0);
	getAreaResult("Photonic")->addSubResult(modulator->getAreaResult("Photonic"), "Modulator", 1.0);
	addElectricalSubResults(modulator, 1.0);

	// Connect electrical port
	portConnect(modulator, "In", "TxBackendToTx");
	// Connect modulator input, output port
	opticalPortConnect(modulator, "In", "LaserToMod");
	opticalPortConnect(modulator, "Out", "ModToDetector");

	// Add modulator energy event for send events
	getEventResult("Send")->addSubResult(modulator->getEventResult("Modulate"), "Modulator", 1.0);
	return;
	}

	void SWSRLink::buildDetector()
	{
	// Get parameters
	double link_data_rate = getParameter("LinkDataRate");
	unsigned int number_wavelengths = getGenProperties()->get("NumberWavelengths");

	// Create resonant ring detector
	RingDetector* detector = new RingDetector("Detector", getTechModel());
	detector->setParameter("DataRate", link_data_rate);
	detector->setParameter("InStart", 0);
	detector->setParameter("InEnd", number_wavelengths-1);
	detector->setParameter("DetStart", 0);
	detector->setParameter("DetEnd", number_wavelengths-1);
	detector->setParameter("DropAll", "TRUE");
	detector->setParameter("Topology", RingDetector::INTEGRATINGSENSEAMP);
	detector->construct();
	addSubInstances(detector, 1.0);
	getAreaResult("Photonic")->addSubResult(detector->getAreaResult("Photonic"), "Detector", 1.0);
	addElectricalSubResults(detector, 1.0);

	// connect to electrical port
	portConnect(detector, "Out", "RxToRxBackend");
	// connect optical input, output port
	opticalPortConnect(detector, "In", "ModToDetector");

	// Add receiver energy
	getEventResult("Send")->addSubResult(detector->getEventResult("Receive"), "Detector", 1.0);

	return;
	}

	} // namespace DSENT