c1aecc05e6
This patch extensively modifies DSENT so that it can be accessed using Python. To access the Python interface, DSENT needs to compiled as a shared library. For this purpose a CMakeLists.txt file has been added. Some of the code that is not required is being removed.
349 lines
15 KiB
C++
349 lines
15 KiB
C++
/* 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
|
|
|