luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Renamed device model -> device abstract

This commit is contained in:
Matthias Koefferlein 2019-01-21 22:37:13 +01:00
parent d79a448eaa
commit 81bf47688e
21 changed files with 184 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/db/db/db.pro
View File

@ -161,8 +161,8 @@ SOURCES = \
dbPin.cc \
dbLayoutToNetlistReader.cc \
dbLayoutToNetlistWriter.cc \
dbDeviceModel.cc \
dbLayoutToNetlistFormatDefs.cc
dbLayoutToNetlistFormatDefs.cc \
dbDeviceAbstract.cc
HEADERS = \
dbArray.h \
@ -288,8 +288,8 @@ HEADERS = \
dbSubCircuit.h \
dbLayoutToNetlistReader.h \
dbLayoutToNetlistWriter.h \
dbDeviceModel.h \
dbLayoutToNetlistFormatDefs.h
dbLayoutToNetlistFormatDefs.h \
dbDeviceAbstract.h
!equals(HAVE_QT, "0") {

8
src/db/db/dbCircuit.cc
View File

@ -330,13 +330,13 @@ void Circuit::translate_device_classes (const std::map<const DeviceClass *, Devi
}
}
void Circuit::translate_device_models (const std::map<const DeviceModel *, DeviceModel *> &map)
void Circuit::translate_device_abstracts (const std::map<const DeviceAbstract *, DeviceAbstract *> &map)
{
for (device_iterator i = m_devices.begin (); i != m_devices.end (); ++i) {
if (i->device_model ()) {
std::map<const DeviceModel *, DeviceModel *>::const_iterator m = map.find (i->device_model ());
if (i->device_abstract ()) {
std::map<const DeviceAbstract *, DeviceAbstract *>::const_iterator m = map.find (i->device_abstract ());
tl_assert (m != map.end ());
i->set_device_model (m->second);
i->set_device_abstract (m->second);
}
}
}

2
src/db/db/dbCircuit.h
View File

@ -620,7 +620,7 @@ private:
void translate_circuits (const std::map<const Circuit *, Circuit *> &map);
void translate_device_classes (const std::map<const DeviceClass *, DeviceClass *> &map);
void translate_device_models (const std::map<const DeviceModel *, DeviceModel *> &map);
void translate_device_abstracts (const std::map<const DeviceAbstract *, DeviceAbstract *> &map);
void set_netlist (Netlist *netlist);
bool combine_parallel_devices (const db::DeviceClass &cls);
bool combine_serial_devices (const db::DeviceClass &cls);

12
src/db/db/dbDevice.cc
View File

@ -31,7 +31,7 @@ namespace db
// Device class implementation
Device::Device ()
: mp_device_class (0), mp_device_model (0), m_id (0), mp_circuit (0)
: mp_device_class (0), mp_device_abstract (0), m_id (0), mp_circuit (0)
{
// .. nothing yet ..
}
@ -46,19 +46,19 @@ Device::~Device ()
}
Device::Device (DeviceClass *device_class, const std::string &name)
: mp_device_class (device_class), mp_device_model (0), m_name (name), m_id (0), mp_circuit (0)
: mp_device_class (device_class), mp_device_abstract (0), m_name (name), m_id (0), mp_circuit (0)
{
// .. nothing yet ..
}
Device::Device (DeviceClass *device_class, DeviceModel *device_model, const std::string &name)
: mp_device_class (device_class), mp_device_model (device_model), m_name (name), m_id (0), mp_circuit (0)
Device::Device (DeviceClass *device_class, DeviceAbstract *device_abstract, const std::string &name)
: mp_device_class (device_class), mp_device_abstract (device_abstract), m_name (name), m_id (0), mp_circuit (0)
{
// .. nothing yet ..
}
Device::Device (const Device &other)
: tl::Object (other), mp_device_class (0), mp_device_model (0), m_id (0), mp_circuit (0)
: tl::Object (other), mp_device_class (0), mp_device_abstract (0), m_id (0), mp_circuit (0)
{
operator= (other);
}
@ -70,7 +70,7 @@ Device &Device::operator= (const Device &other)
m_position = other.m_position;
m_parameters = other.m_parameters;
mp_device_class = other.mp_device_class;
mp_device_model = other.mp_device_model;
mp_device_abstract = other.mp_device_abstract;
}
return *this;
}

18
src/db/db/dbDevice.h
View File

@ -36,7 +36,7 @@ namespace db
class Circuit;
class DeviceClass;
class DeviceModel;
class DeviceAbstract;
/**
* @brief An actual device
@ -67,7 +67,7 @@ public:
/**
* @brief The constructor
*/
Device (DeviceClass *device_class, DeviceModel *device_model, const std::string &name = std::string ());
Device (DeviceClass *device_class, DeviceAbstract *device_abstract, const std::string &name = std::string ());
/**
* @brief Copy constructor
@ -101,19 +101,19 @@ public:
}
/**
* @brief Gets the device model
* @brief Gets the device abstract
*/
const DeviceModel *device_model () const
const DeviceAbstract *device_abstract () const
{
return mp_device_model;
return mp_device_abstract;
}
/**
* @brief Sets the device model
* @brief Sets the device abstract
*/
void set_device_model (DeviceModel *dm)
void set_device_abstract (DeviceAbstract *dm)
{
mp_device_model = dm;
mp_device_abstract = dm;
}
/**
@ -233,7 +233,7 @@ private:
friend class Net;
DeviceClass *mp_device_class;
DeviceModel *mp_device_model;
DeviceAbstract *mp_device_abstract;
std::string m_name;
db::DPoint m_position;
std::vector<Net::terminal_iterator> m_terminal_refs;

28
src/db/db/dbDeviceAbstract.cc
View File

@ -20,7 +20,7 @@
*/
#include "dbDeviceModel.h"
#include "dbDeviceAbstract.h"
#include "dbCircuit.h"
#include "dbNetlist.h"
@ -28,32 +28,32 @@ namespace db
{
// --------------------------------------------------------------------------------
// DeviceModel class implementation
// DeviceAbstract class implementation
DeviceModel::DeviceModel ()
DeviceAbstract::DeviceAbstract ()
: m_name (), mp_device_class (0), m_cell_index (std::numeric_limits<db::cell_index_type>::max ()), mp_netlist (0)
{
// .. nothing yet ..
}
DeviceModel::~DeviceModel ()
DeviceAbstract::~DeviceAbstract ()
{
// .. nothing yet ..
}
DeviceModel::DeviceModel (db::DeviceClass *device_class, const std::string &name)
DeviceAbstract::DeviceAbstract (db::DeviceClass *device_class, const std::string &name)
: m_name (name), mp_device_class (device_class), m_cell_index (std::numeric_limits<db::cell_index_type>::max ()), mp_netlist (0)
{
// .. nothing yet ..
}
DeviceModel::DeviceModel (const DeviceModel &other)
DeviceAbstract::DeviceAbstract (const DeviceAbstract &other)
: tl::Object (other), mp_device_class (0), m_cell_index (std::numeric_limits<db::cell_index_type>::max ()), mp_netlist (0)
{
operator= (other);
}
DeviceModel &DeviceModel::operator= (const DeviceModel &other)
DeviceAbstract &DeviceAbstract::operator= (const DeviceAbstract &other)
{
if (this != &other) {
m_name = other.m_name;
@ -64,33 +64,33 @@ DeviceModel &DeviceModel::operator= (const DeviceModel &other)
return *this;
}
void DeviceModel::set_netlist (Netlist *netlist)
void DeviceAbstract::set_netlist (Netlist *netlist)
{
mp_netlist = netlist;
}
void DeviceModel::set_name (const std::string &n)
void DeviceAbstract::set_name (const std::string &n)
{
m_name = n;
if (mp_netlist) {
mp_netlist->m_device_model_by_name.invalidate ();
mp_netlist->m_device_abstract_by_name.invalidate ();
}
}
void DeviceModel::set_cell_index (db::cell_index_type ci)
void DeviceAbstract::set_cell_index (db::cell_index_type ci)
{
m_cell_index = ci;
if (mp_netlist) {
mp_netlist->m_device_model_by_cell_index.invalidate ();
mp_netlist->m_device_abstract_by_cell_index.invalidate ();
}
}
size_t DeviceModel::cluster_id_for_terminal (size_t terminal_id) const
size_t DeviceAbstract::cluster_id_for_terminal (size_t terminal_id) const
{
return terminal_id < m_terminal_cluster_ids.size () ? m_terminal_cluster_ids [terminal_id] : 0;
}
void DeviceModel::set_cluster_id_for_terminal (size_t terminal_id, size_t cluster_id)
void DeviceAbstract::set_cluster_id_for_terminal (size_t terminal_id, size_t cluster_id)
{
if (m_terminal_cluster_ids.size () <= terminal_id) {
m_terminal_cluster_ids.resize (terminal_id + 1, 0);

24
src/db/db/dbDeviceAbstract.h
View File

@ -20,8 +20,8 @@
*/
#ifndef _HDR_dbDeviceModel
#define _HDR_dbDeviceModel
#ifndef _HDR_dbDeviceAbstract
#define _HDR_dbDeviceAbstract
#include "dbCommon.h"
#include "dbNet.h"
@ -37,39 +37,39 @@ namespace db
class Netlist;
/**
* @brief A device model
* @brief A device abstract
*
* A device model represents the geometrical properties of a device. It basically links
* A device abstract represents the geometrical properties of a device. It basically links
* to a cell and clusters for indicating the terminal geometry of the device.
*/
class DB_PUBLIC DeviceModel
class DB_PUBLIC DeviceAbstract
: public tl::Object
{
public:
/**
* @brief Default constructor
*/
DeviceModel ();
DeviceAbstract ();
/**
* @brief The constructor
*/
DeviceModel (db::DeviceClass *device_class, const std::string &name = std::string ());
DeviceAbstract (db::DeviceClass *device_class, const std::string &name = std::string ());
/**
* @brief Copy constructor
*/
DeviceModel (const DeviceModel &other);
DeviceAbstract (const DeviceAbstract &other);
/**
* @brief Assignment
*/
DeviceModel &operator= (const DeviceModel &other);
DeviceAbstract &operator= (const DeviceAbstract &other);
/**
* @brief Destructor
*/
~DeviceModel ();
~DeviceAbstract ();
/**
* @brief Gets the device class
@ -89,7 +89,7 @@ public:
/**
* @brief Gets the netlist the device lives in (const version)
* This pointer is 0 if the device model isn't added to a netlist
* This pointer is 0 if the device abstract isn't added to a netlist
*/
const Netlist *netlist () const
{
@ -98,7 +98,7 @@ public:
/**
* @brief Gets the netlist the device lives in (non-const version)
* This pointer is 0 if the device model isn't added to a netlist
* This pointer is 0 if the device abstract isn't added to a netlist
*/
Netlist *netlist ()
{

6
src/db/db/dbLayoutToNetlist.cc
View File

@ -354,7 +354,7 @@ db::CellMapping LayoutToNetlist::cell_mapping_into (db::Layout &layout, db::Cell
std::set<db::cell_index_type> device_cells;
if (! with_device_cells && mp_netlist.get ()) {
for (db::Netlist::device_model_iterator i = mp_netlist->begin_device_models (); i != mp_netlist->end_device_models (); ++i) {
for (db::Netlist::device_abstract_iterator i = mp_netlist->begin_device_abstracts (); i != mp_netlist->end_device_abstracts (); ++i) {
device_cells.insert (i->cell_index ());
}
}
@ -448,7 +448,7 @@ static bool deliver_shapes_of_net_nonrecursive (const db::Netlist *nl, const db:
for (db::recursive_cluster_shape_iterator<db::PolygonRef> rci (clusters, layer_id, ci, cid); !rci.at_end (); ) {
db::cell_index_type cci = rci.cell_index ();
if (cci != prev_ci && cci != ci && (! nl || nl->circuit_by_cell_index (cci) || nl->device_model_by_cell_index (cci))) {
if (cci != prev_ci && cci != ci && (! nl || nl->circuit_by_cell_index (cci) || nl->device_abstract_by_cell_index (cci))) {
rci.skip_cell ();
@ -563,7 +563,7 @@ LayoutToNetlist::build_net_rec (db::cell_index_type ci, size_t cid, db::Layout &
if (cm == cmap.end ()) {
const char *name_prefix = 0;
if (mp_netlist->device_model_by_cell_index (subci)) {
if (mp_netlist->device_abstract_by_cell_index (subci)) {
name_prefix = device_cell_name_prefix;
} else {
name_prefix = circuit_cell_name_prefix;

4
src/db/db/dbLayoutToNetlist.h
View File

@ -398,7 +398,7 @@ public:
* Recursive mode is picked when a cell name prefix is given. The new cells will be
* named like cell_name_prefix + circuit name.
*
* If a device cell name prefix is given, cells will be produced for each device model
* If a device cell name prefix is given, cells will be produced for each device abstract
* using a name like device_cell_name_prefix + device name.
*
* @param target The target layout
@ -427,7 +427,7 @@ public:
* * Subnet hierarchy (circuit_cell_name_prefix != 0): for each root net, a full hierarchy is built
* to accomodate the subnets (see build_net in recursive mode).
*
* If a device cell name prefix is given, cells will be produced for each device model
* If a device cell name prefix is given, cells will be produced for each device abstract
* using a name like device_cell_name_prefix + device name.
*
* @param cmap The mapping of internal layout to target layout for the circuit mapping

14
src/db/db/dbLayoutToNetlistReader.cc
View File

@ -289,9 +289,9 @@ void LayoutToNetlistStandardReader::do_read (db::LayoutToNetlist *l2n)
std::string name;
read_word_or_quoted (name);
db::DeviceModel *dm = new db::DeviceModel ();
db::DeviceAbstract *dm = new db::DeviceAbstract ();
dm->set_name (name);
l2n->netlist ()->add_device_model (dm);
l2n->netlist ()->add_device_abstract (dm);
db::cell_index_type ci = l2n->internal_layout ()->add_cell (name.c_str ());
dm->set_cell_index (ci);
@ -441,20 +441,20 @@ LayoutToNetlistStandardReader::read_device (db::LayoutToNetlist *l2n, db::Circui
std::string dmname;
read_word_or_quoted (dmname);
db::DeviceModel *dm = 0;
for (db::Netlist::device_model_iterator i = l2n->netlist ()->begin_device_models (); i != l2n->netlist ()->end_device_models (); ++i) {
db::DeviceAbstract *dm = 0;
for (db::Netlist::device_abstract_iterator i = l2n->netlist ()->begin_device_abstracts (); i != l2n->netlist ()->end_device_abstracts (); ++i) {
if (i->name () == dmname) {
dm = i.operator-> ();
}
}
if (! dm) {
throw tl::Exception (tl::to_string (tr ("Not a valid device model name: ")) + dmname);
throw tl::Exception (tl::to_string (tr ("Not a valid device abstract name: ")) + dmname);
}
db::Device *device = new db::Device ();
device->set_device_class (const_cast<db::DeviceClass *> (dm->device_class ()));
device->set_device_model (dm);
device->set_device_abstract (dm);
device->set_name (name);
circuit->add_device (device);
@ -656,7 +656,7 @@ LayoutToNetlistStandardReader::read_subcircuit (db::LayoutToNetlist *l2n, db::Ci
}
void
LayoutToNetlistStandardReader::read_abstract_terminal (db::LayoutToNetlist *l2n, db::DeviceModel *dm, db::DeviceClass *dc)
LayoutToNetlistStandardReader::read_abstract_terminal (db::LayoutToNetlist *l2n, db::DeviceAbstract *dm, db::DeviceClass *dc)
{
Brace br (this);

4
src/db/db/dbLayoutToNetlistReader.h
View File

@ -38,7 +38,7 @@ namespace l2n_std_reader {
class LayoutToNetlist;
class Circuit;
class Cell;
class DeviceModel;
class DeviceAbstract;
class DeviceClass;
class Region;
@ -99,7 +99,7 @@ private:
void read_pin (db::LayoutToNetlist *l2n, db::Circuit *circuit);
db::CellInstArray read_device (db::LayoutToNetlist *l2n, db::Circuit *circuit, std::list<Connections> &refs);
db::CellInstArray read_subcircuit (db::LayoutToNetlist *l2n, db::Circuit *circuit, std::list<Connections> &refs);
void read_abstract_terminal (db::LayoutToNetlist *l2n, db::DeviceModel *dm, db::DeviceClass *dc);
void read_abstract_terminal (db::LayoutToNetlist *l2n, db::DeviceAbstract *dm, db::DeviceClass *dc);
std::pair<unsigned int, db::PolygonRef> read_geometry (db::LayoutToNetlist *l2n);
};

18
src/db/db/dbLayoutToNetlistWriter.cc
View File

@ -48,7 +48,7 @@ private:
void write (const db::LayoutToNetlist *l2n, const db::Net &net);
void write (const db::LayoutToNetlist *l2n, const db::SubCircuit &subcircuit);
void write (const db::LayoutToNetlist *l2n, const db::Device &device);
void write (const db::LayoutToNetlist *l2n, const db::DeviceModel &device_model);
void write (const db::LayoutToNetlist *l2n, const db::DeviceAbstract &device_abstract);
void write (const db::PolygonRef *s, const db::ICplxTrans &tr, const std::string &lname);
};
@ -144,11 +144,11 @@ void std_writer_impl<Keys>::write (const db::LayoutToNetlist *l2n)
}
if (nl->begin_device_models () != nl->end_device_models () && ! Keys::is_short ()) {
if (nl->begin_device_abstracts () != nl->end_device_abstracts () && ! Keys::is_short ()) {
*mp_stream << endl << "# Device abstracts section" << endl;
*mp_stream << "# Device abstracts list the pin shapes of the devices." << endl;
}
for (db::Netlist::const_device_model_iterator m = nl->begin_device_models (); m != nl->end_device_models (); ++m) {
for (db::Netlist::const_abstract_model_iterator m = nl->begin_device_abstracts (); m != nl->end_device_abstracts (); ++m) {
if (m->device_class ()) {
*mp_stream << Keys::device_key << "(" << tl::to_word_or_quoted_string (m->name ()) << " " << tl::to_word_or_quoted_string (m->device_class ()->name ()) << endl;
write (l2n, *m);
@ -276,7 +276,7 @@ void std_writer_impl<Keys>::write (const db::LayoutToNetlist *l2n, const db::Net
// vanish in "purge" but the clusters will still be there we need to recursive into clusters from
// unknown cells.
db::cell_index_type ci = si.cell_index ();
if (ci != prev_ci && ci != cci && (l2n->netlist ()->circuit_by_cell_index (ci) || l2n->netlist ()->device_model_by_cell_index (ci))) {
if (ci != prev_ci && ci != cci && (l2n->netlist ()->circuit_by_cell_index (ci) || l2n->netlist ()->device_abstract_by_cell_index (ci))) {
si.skip_cell ();
@ -359,9 +359,9 @@ void std_writer_impl<Keys>::write (const db::LayoutToNetlist *l2n, const db::Sub
}
template <class Keys>
void std_writer_impl<Keys>::write (const db::LayoutToNetlist *l2n, const db::DeviceModel &device_model)
void std_writer_impl<Keys>::write (const db::LayoutToNetlist *l2n, const db::DeviceAbstract &device_abstract)
{
const std::vector<db::DeviceTerminalDefinition> &td = device_model.device_class ()->terminal_definitions ();
const std::vector<db::DeviceTerminalDefinition> &td = device_abstract.device_class ()->terminal_definitions ();
const db::hier_clusters<db::PolygonRef> &clusters = l2n->net_clusters ();
const db::Connectivity &conn = l2n->connectivity ();
@ -372,7 +372,7 @@ void std_writer_impl<Keys>::write (const db::LayoutToNetlist *l2n, const db::Dev
for (db::Connectivity::layer_iterator l = conn.begin_layers (); l != conn.end_layers (); ++l) {
const db::local_cluster<db::PolygonRef> &lc = clusters.clusters_per_cell (device_model.cell_index ()).cluster_by_id (device_model.cluster_id_for_terminal (t->id ()));
const db::local_cluster<db::PolygonRef> &lc = clusters.clusters_per_cell (device_abstract.cell_index ()).cluster_by_id (device_abstract.cluster_id_for_terminal (t->id ()));
for (db::local_cluster<db::PolygonRef>::shape_iterator s = lc.begin (*l); ! s.at_end (); ++s) {
*mp_stream << indent2;
@ -396,8 +396,8 @@ void std_writer_impl<Keys>::write (const db::LayoutToNetlist *l2n, const db::Dev
*mp_stream << indent1 << Keys::device_key << "(" << tl::to_word_or_quoted_string (device.expanded_name ());
tl_assert (device.device_model () != 0);
*mp_stream << " " << tl::to_word_or_quoted_string (device.device_model ()->name ()) << endl;
tl_assert (device.device_abstract () != 0);
*mp_stream << " " << tl::to_word_or_quoted_string (device.device_abstract ()->name ()) << endl;
*mp_stream << indent2 << Keys::location_key << "(" << device.position ().x () / dbu << " " << device.position ().y () / dbu << ")" << endl;

44
src/db/db/dbNetlist.cc
View File

@ -34,32 +34,32 @@ Netlist::Netlist ()
: m_valid_topology (false), m_lock_count (0),
m_circuit_by_name (this, &Netlist::begin_circuits, &Netlist::end_circuits),
m_circuit_by_cell_index (this, &Netlist::begin_circuits, &Netlist::end_circuits),
m_device_model_by_name (this, &Netlist::begin_device_models, &Netlist::end_device_models),
m_device_model_by_cell_index (this, &Netlist::begin_device_models, &Netlist::end_device_models)
m_device_abstract_by_name (this, &Netlist::begin_device_abstracts, &Netlist::end_device_abstracts),
m_device_abstract_by_cell_index (this, &Netlist::begin_device_abstracts, &Netlist::end_device_abstracts)
{
m_circuits.changed ().add (this, &Netlist::invalidate_topology);
m_circuits.changed ().add (this, &Netlist::circuits_changed);
m_device_models.changed ().add (this, &Netlist::device_models_changed);
m_device_abstracts.changed ().add (this, &Netlist::device_abstracts_changed);
}
Netlist::Netlist (const Netlist &other)
: gsi::ObjectBase (other), tl::Object (other), m_valid_topology (false), m_lock_count (0),
m_circuit_by_name (this, &Netlist::begin_circuits, &Netlist::end_circuits),
m_circuit_by_cell_index (this, &Netlist::begin_circuits, &Netlist::end_circuits),
m_device_model_by_name (this, &Netlist::begin_device_models, &Netlist::end_device_models),
m_device_model_by_cell_index (this, &Netlist::begin_device_models, &Netlist::end_device_models)
m_device_abstract_by_name (this, &Netlist::begin_device_abstracts, &Netlist::end_device_abstracts),
m_device_abstract_by_cell_index (this, &Netlist::begin_device_abstracts, &Netlist::end_device_abstracts)
{
operator= (other);
m_circuits.changed ().add (this, &Netlist::invalidate_topology);
m_circuits.changed ().add (this, &Netlist::circuits_changed);
m_device_models.changed ().add (this, &Netlist::device_models_changed);
m_device_abstracts.changed ().add (this, &Netlist::device_abstracts_changed);
}
Netlist::~Netlist ()
{
m_circuits.changed ().remove (this, &Netlist::invalidate_topology);
m_circuits.changed ().remove (this, &Netlist::circuits_changed);
m_device_models.changed ().remove (this, &Netlist::device_models_changed);
m_device_abstracts.changed ().remove (this, &Netlist::device_abstracts_changed);
}
Netlist &Netlist::operator= (const Netlist &other)
@ -75,18 +75,18 @@ Netlist &Netlist::operator= (const Netlist &other)
m_device_classes.push_back (dc_new);
}
std::map<const DeviceModel *, DeviceModel *> dmt;
for (const_device_model_iterator dm = other.begin_device_models (); dm != other.end_device_models (); ++dm) {
DeviceModel *dm_new = new DeviceModel (*dm);
std::map<const DeviceAbstract *, DeviceAbstract *> dmt;
for (const_abstract_model_iterator dm = other.begin_device_abstracts (); dm != other.end_device_abstracts (); ++dm) {
DeviceAbstract *dm_new = new DeviceAbstract (*dm);
dmt [dm.operator-> ()] = dm_new;
m_device_models.push_back (dm_new);
m_device_abstracts.push_back (dm_new);
}
std::map<const Circuit *, Circuit *> ct;
for (const_circuit_iterator i = other.begin_circuits (); i != other.end_circuits (); ++i) {
Circuit *ct_new = new Circuit (*i);
ct_new->translate_device_classes (dct);
ct_new->translate_device_models (dmt);
ct_new->translate_device_abstracts (dmt);
ct [i.operator-> ()] = ct_new;
add_circuit (ct_new);
}
@ -105,10 +105,10 @@ void Netlist::circuits_changed ()
m_circuit_by_name.invalidate ();
}
void Netlist::device_models_changed ()
void Netlist::device_abstracts_changed ()
{
m_device_model_by_cell_index.invalidate ();
m_device_model_by_name.invalidate ();
m_device_abstract_by_cell_index.invalidate ();
m_device_abstract_by_name.invalidate ();
}
void Netlist::invalidate_topology ()
@ -353,7 +353,7 @@ Netlist::const_bottom_up_circuit_iterator Netlist::end_bottom_up () const
void Netlist::clear ()
{
m_device_classes.clear ();
m_device_models.clear ();
m_device_abstracts.clear ();
m_circuits.clear ();
}
@ -381,16 +381,16 @@ void Netlist::remove_device_class (DeviceClass *device_class)
m_device_classes.erase (device_class);
}
void Netlist::add_device_model (DeviceModel *device_model)
void Netlist::add_device_abstract (DeviceAbstract *device_abstract)
{
m_device_models.push_back (device_model);
device_model->set_netlist (this);
m_device_abstracts.push_back (device_abstract);
device_abstract->set_netlist (this);
}
void Netlist::remove_device_model (DeviceModel *device_model)
void Netlist::remove_device_abstract (DeviceAbstract *device_abstract)
{
device_model->set_netlist (0);
m_device_models.erase (device_model);
device_abstract->set_netlist (0);
m_device_abstracts.erase (device_abstract);
}
void Netlist::purge_nets ()

82
src/db/db/dbNetlist.h
View File

@ -26,7 +26,7 @@
#include "dbCommon.h"
#include "dbCircuit.h"
#include "dbDeviceClass.h"
#include "dbDeviceModel.h"
#include "dbDeviceAbstract.h"
#include "tlVector.h"
@ -52,9 +52,9 @@ public:
typedef tl::shared_collection<DeviceClass> device_class_list;
typedef device_class_list::const_iterator const_device_class_iterator;
typedef device_class_list::iterator device_class_iterator;
typedef tl::shared_collection<DeviceModel> device_model_list;
typedef device_model_list::const_iterator const_device_model_iterator;
typedef device_model_list::iterator device_model_iterator;
typedef tl::shared_collection<DeviceAbstract> device_abstract_list;
typedef device_abstract_list::const_iterator const_abstract_model_iterator;
typedef device_abstract_list::iterator device_abstract_iterator;
typedef tl::vector<Circuit *>::const_iterator top_down_circuit_iterator;
typedef tl::vector<const Circuit *>::const_iterator const_top_down_circuit_iterator;
typedef tl::vector<Circuit *>::const_reverse_iterator bottom_up_circuit_iterator;
@ -306,87 +306,87 @@ public:
}
/**
* @brief Adds a device model to this netlist
* @brief Adds a device abstract to this netlist
*
* The netlist takes over ownership of the object.
*/
void add_device_model (DeviceModel *device_model);
void add_device_abstract (DeviceAbstract *device_abstract);
/**
* @brief Deletes a device model from the netlist
* @brief Deletes a device abstract from the netlist
*/
void remove_device_model (DeviceModel *device_model);
void remove_device_abstract (DeviceAbstract *device_abstract);
/**
* @brief Begin iterator for the device models of the netlist (non-const version)
* @brief Begin iterator for the device abstracts of the netlist (non-const version)
*/
device_model_iterator begin_device_models ()
device_abstract_iterator begin_device_abstracts ()
{
return m_device_models.begin ();
return m_device_abstracts.begin ();
}
/**
* @brief End iterator for the device models of the netlist (non-const version)
* @brief End iterator for the device abstracts of the netlist (non-const version)
*/
device_model_iterator end_device_models ()
device_abstract_iterator end_device_abstracts ()
{
return m_device_models.end ();
return m_device_abstracts.end ();
}
/**
* @brief Begin iterator for the device models of the netlist (const version)
* @brief Begin iterator for the device abstracts of the netlist (const version)
*/
const_device_model_iterator begin_device_models () const
const_abstract_model_iterator begin_device_abstracts () const
{
return m_device_models.begin ();
return m_device_abstracts.begin ();
}
/**
* @brief End iterator for the device models of the netlist (const version)
* @brief End iterator for the device abstracts of the netlist (const version)
*/
const_device_model_iterator end_device_models () const
const_abstract_model_iterator end_device_abstracts () const
{
return m_device_models.end ();
return m_device_abstracts.end ();
}
/**
* @brief Gets the device model with the given name
* @brief Gets the device abstract with the given name
*
* If no device model with that name exists, null is returned.
* If no device abstract with that name exists, null is returned.
*/
DeviceModel *device_model_by_name (const std::string &name)
DeviceAbstract *device_abstract_by_name (const std::string &name)
{
return m_device_model_by_name.object_by (name);
return m_device_abstract_by_name.object_by (name);
}
/**
* @brief Gets the device model with the given name (const version)
* @brief Gets the device abstract with the given name (const version)
*
* If no device model with that name exists, null is returned.
* If no device abstract with that name exists, null is returned.
*/
const DeviceModel *device_model_by_name (const std::string &name) const
const DeviceAbstract *device_abstract_by_name (const std::string &name) const
{
return m_device_model_by_name.object_by (name);
return m_device_abstract_by_name.object_by (name);
}
/**
* @brief Gets the device model with the given cell index
* @brief Gets the device abstract with the given cell index
*
* If no device model with that cell index exists, null is returned.
* If no device abstract with that cell index exists, null is returned.
*/
DeviceModel *device_model_by_cell_index (db::cell_index_type cell_index)
DeviceAbstract *device_abstract_by_cell_index (db::cell_index_type cell_index)
{
return m_device_model_by_cell_index.object_by (cell_index);
return m_device_abstract_by_cell_index.object_by (cell_index);
}
/**
* @brief Gets the device model with the given cell index (const version)
* @brief Gets the device abstract with the given cell index (const version)
*
* If no device model with that cell index exists, null is returned.
* If no device abstract with that cell index exists, null is returned.
*/
const DeviceModel *device_model_by_cell_index (db::cell_index_type cell_index) const
const DeviceAbstract *device_abstract_by_cell_index (db::cell_index_type cell_index) const
{
return m_device_model_by_cell_index.object_by (cell_index);
return m_device_abstract_by_cell_index.object_by (cell_index);
}
/**
@ -423,11 +423,11 @@ public:
private:
friend class Circuit;
friend class DeviceModel;
friend class DeviceAbstract;
circuit_list m_circuits;
device_class_list m_device_classes;
device_model_list m_device_models;
device_abstract_list m_device_abstracts;
bool m_valid_topology;
int m_lock_count;
tl::vector<Circuit *> m_top_down_circuits;
@ -436,13 +436,13 @@ private:
size_t m_top_circuits;
object_by_attr<Netlist, Netlist::circuit_iterator, name_attribute<Circuit> > m_circuit_by_name;
object_by_attr<Netlist, Netlist::circuit_iterator, cell_index_attribute<Circuit> > m_circuit_by_cell_index;
object_by_attr<Netlist, Netlist::device_model_iterator, name_attribute<DeviceModel> > m_device_model_by_name;
object_by_attr<Netlist, Netlist::device_model_iterator, cell_index_attribute<DeviceModel> > m_device_model_by_cell_index;
object_by_attr<Netlist, Netlist::device_abstract_iterator, name_attribute<DeviceAbstract> > m_device_abstract_by_name;
object_by_attr<Netlist, Netlist::device_abstract_iterator, cell_index_attribute<DeviceAbstract> > m_device_abstract_by_cell_index;
void invalidate_topology ();
void validate_topology ();
void circuits_changed ();
void device_models_changed ();
void device_abstracts_changed ();
const tl::vector<Circuit *> &child_circuits (Circuit *circuit);
const tl::vector<Circuit *> &parent_circuits (Circuit *circuit);

10
src/db/db/dbNetlistDeviceExtractor.cc
View File

@ -169,7 +169,7 @@ void NetlistDeviceExtractor::extract_without_initialize (db::Layout &layout, db:
for (std::set<db::cell_index_type>::const_iterator ci = called_cells.begin (); ci != called_cells.end (); ++ci) {
// skip device cells from previous extractions
if (m_netlist->device_model_by_cell_index (*ci)) {
if (m_netlist->device_abstract_by_cell_index (*ci)) {
continue;
}
@ -254,14 +254,14 @@ void NetlistDeviceExtractor::push_new_devices ()
db::PropertiesRepository::properties_set ps;
std::map<DeviceCellKey, std::pair<db::cell_index_type, db::DeviceModel *> >::iterator c = m_device_cells.find (key);
std::map<DeviceCellKey, std::pair<db::cell_index_type, db::DeviceAbstract *> >::iterator c = m_device_cells.find (key);
if (c == m_device_cells.end ()) {
std::string cell_name = "D$" + mp_device_class->name ();
db::Cell &device_cell = mp_layout->cell (mp_layout->add_cell (cell_name.c_str ()));
db::DeviceModel *dm = new db::DeviceModel (mp_device_class, mp_layout->cell_name (device_cell.cell_index ()));
m_netlist->add_device_model (dm);
db::DeviceAbstract *dm = new db::DeviceAbstract (mp_device_class, mp_layout->cell_name (device_cell.cell_index ()));
m_netlist->add_device_abstract (dm);
dm->set_cell_index (device_cell.cell_index ());
c = m_device_cells.insert (std::make_pair (key, std::make_pair (device_cell.cell_index (), dm))).first;
@ -295,7 +295,7 @@ void NetlistDeviceExtractor::push_new_devices ()
}
// make the cell index known to the device
device->set_device_model (c->second.second);
device->set_device_abstract (c->second.second);
// Build a property set for the device ID
ps.clear ();

2
src/db/db/dbNetlistDeviceExtractor.h
View File

@ -508,7 +508,7 @@ private:
std::vector<unsigned int> m_layers;
error_list m_errors;
std::map<size_t, geometry_per_terminal_type> m_new_devices;
std::map<DeviceCellKey, std::pair<db::cell_index_type, db::DeviceModel *> > m_device_cells;
std::map<DeviceCellKey, std::pair<db::cell_index_type, db::DeviceAbstract *> > m_device_cells;
// no copying
NetlistDeviceExtractor (const NetlistDeviceExtractor &);

10
src/db/db/dbNetlistExtractor.cc
View File

@ -71,10 +71,10 @@ NetlistExtractor::extract_nets (const db::DeepShapeStore &dss, const db::Connect
continue;
}
db::DeviceModel *dm = nl.device_model_by_cell_index (*cid);
db::DeviceAbstract *dm = nl.device_abstract_by_cell_index (*cid);
if (dm) {
// make the terminal to cluster ID connections for the device model from the device cells
make_device_model_connections (dm, clusters);
// make the terminal to cluster ID connections for the device abstract from the device cells
make_device_abstract_connections (dm, clusters);
continue;
}
@ -129,9 +129,9 @@ NetlistExtractor::extract_nets (const db::DeepShapeStore &dss, const db::Connect
}
void
NetlistExtractor::make_device_model_connections (db::DeviceModel *dm, const connected_clusters_type &clusters)
NetlistExtractor::make_device_abstract_connections (db::DeviceAbstract *dm, const connected_clusters_type &clusters)
{
// make the terminal to cluster ID connections for the device model from the device cells
// make the terminal to cluster ID connections for the device abstract from the device cells
if (m_terminal_annot_name_id.first) {

6
src/db/db/dbNetlistExtractor.h
View File

@ -37,7 +37,7 @@ class Circuit;
class SubCircuit;
class Net;
class Device;
class DeviceModel;
class DeviceAbstract;
/**
* @brief The Netlist Extractor
@ -154,9 +154,9 @@ private:
db::Net *net);
/**
* @brief Makes the terminal to cluster ID connections of the device model
* @brief Makes the terminal to cluster ID connections of the device abstract
*/
void make_device_model_connections (db::DeviceModel *dm, const connected_clusters_type &clusters);
void make_device_abstract_connections (db::DeviceAbstract *dm, const connected_clusters_type &clusters);
};

24
src/db/db/gsiDeclDbNetlist.cc
View File

@ -136,27 +136,27 @@ Class<db::Device> decl_dbDevice ("db", "Device",
#if 0
// TODO: activate once the geometry API is opened (clusters at al.)
Class<db::DeviceModel> decl_dbDeviceModel ("db", "DeviceModel",
gsi::method ("netlist", (db::Netlist *(db::DeviceModel::*) ()) &db::DeviceModel::netlist,
"@brief Gets the netlist the device model lives in."
Class<db::DeviceAbstract> decl_dbDeviceAbstract ("db", "DeviceAbstract",
gsi::method ("netlist", (db::Netlist *(db::DeviceAbstract::*) ()) &db::DeviceAbstract::netlist,
"@brief Gets the netlist the device abstract lives in."
) +
gsi::method ("name=", &db::DeviceModel::set_name, gsi::arg ("name"),
"@brief Sets the name of the device model.\n"
"Device names are used to name a device model inside a netlist file. "
gsi::method ("name=", &db::DeviceAbstract::set_name, gsi::arg ("name"),
"@brief Sets the name of the device abstract.\n"
"Device names are used to name a device abstract inside a netlist file. "
"Device names should be unique within a netlist."
) +
gsi::method ("name", &db::DeviceModel::name,
"@brief Gets the name of the device model.\n"
gsi::method ("name", &db::DeviceAbstract::name,
"@brief Gets the name of the device abstract.\n"
) +
gsi::method ("cell_index", &db::DeviceModel::cell_index,
"@brief Gets the cell index of the device model.\n"
gsi::method ("cell_index", &db::DeviceAbstract::cell_index,
"@brief Gets the cell index of the device abstract.\n"
"This is the cell that represents the device."
) +
gsi::method ("cluster_id_for_terminal", &db::DeviceModel::cluster_id_for_terminal, gsi::arg ("terminal_id"),
gsi::method ("cluster_id_for_terminal", &db::DeviceAbstract::cluster_id_for_terminal, gsi::arg ("terminal_id"),
"@brief Gets the cluster ID for the given terminal.\n"
"The cluster ID links the terminal to geometrical shapes within the clusters of the cell (see \\cell_index)"
),
"@brief A geometrical device model\n"
"@brief A geometrical device abstract\n"
"This class represents the geometrical model for the device. It links into the extracted layout "
"to a cell which holds the terminal shapes for the device.\n"
"\n"

4
src/db/unit_tests/dbNetlistExtractorTests.cc
View File

@ -93,7 +93,7 @@ static void dump_nets_to_layout (const db::Netlist &nl, const db::hier_clusters<
for (db::Circuit::const_device_iterator d = c->begin_devices (); d != c->end_devices (); ++d) {
db::cell_index_type dci = d->device_model ()->cell_index ();
db::cell_index_type dci = d->device_abstract ()->cell_index ();
if (device_cells_seen.find (dci) != device_cells_seen.end ()) {
continue;
@ -114,7 +114,7 @@ static void dump_nets_to_layout (const db::Netlist &nl, const db::hier_clusters<
const std::vector<db::DeviceTerminalDefinition> &td = d->device_class ()->terminal_definitions ();
for (std::vector<db::DeviceTerminalDefinition>::const_iterator t = td.begin (); t != td.end (); ++t) {
const db::local_cluster<db::PolygonRef> &dc = clusters.clusters_per_cell (dci).cluster_by_id (d->device_model ()->cluster_id_for_terminal (t->id ()));
const db::local_cluster<db::PolygonRef> &dc = clusters.clusters_per_cell (dci).cluster_by_id (d->device_abstract ()->cluster_id_for_terminal (t->id ()));
for (std::map<unsigned int, unsigned int>::const_iterator m = lmap.begin (); m != lmap.end (); ++m) {
db::Shapes &target = device_cell.shapes (m->second);

40
src/db/unit_tests/dbNetlistTests.cc
View File

@ -125,8 +125,8 @@ static std::string netlist2 (const db::Circuit &c)
pins += net ? net->name () : std::string ("(null)");
}
res += " D" + d->name ();
if (d->device_model ()) {
res += "/" + d->device_model ()->name ();
if (d->device_abstract ()) {
res += "/" + d->device_abstract ()->name ();
}
res += ":" + pins + "\n";
}
@ -501,13 +501,13 @@ TEST(4_NetlistSubcircuits)
dc->add_terminal_definition (db::DeviceTerminalDefinition ("B", ""));
nl->add_device_class (dc);
db::DeviceModel *dm = new db::DeviceModel ();
db::DeviceAbstract *dm = new db::DeviceAbstract ();
dm->set_device_class (dc);
EXPECT_EQ (dm->device_class () == dc, true);
dm->set_name ("dm2");
dm->set_cell_index (42);
dm->set_cluster_id_for_terminal (0, 17);
nl->add_device_model (dm);
nl->add_device_abstract (dm);
db::Circuit *c1 = new db::Circuit ();
c1->set_cell_index (17);
@ -540,7 +540,7 @@ TEST(4_NetlistSubcircuits)
db::Device *d = new db::Device (dc, dm, "D");
c2->add_device (d);
EXPECT_EQ (d->device_model ()->name (), "dm2");
EXPECT_EQ (d->device_abstract ()->name (), "dm2");
EXPECT_EQ (refs2string (c2), "");
db::SubCircuit *sc1 = new db::SubCircuit (c2);
@ -1042,24 +1042,24 @@ TEST(12_NetlistTopology)
EXPECT_EQ (bu2string (nl.get ()), "c2,c3,c1");
}
TEST(13_DeviceModel)
TEST(13_DeviceAbstract)
{
db::Netlist nl;
db::DeviceModel *dm = new db::DeviceModel (0, "name");
nl.add_device_model (dm);
db::DeviceAbstract *dm = new db::DeviceAbstract (0, "name");
nl.add_device_abstract (dm);
EXPECT_EQ (dm->netlist () == &nl, true);
EXPECT_EQ (dm->device_class () == 0, true);
EXPECT_EQ (dm->name (), "name");
EXPECT_EQ (nl.device_model_by_name ("name") == dm, true);
EXPECT_EQ (nl.device_model_by_name ("name2") == 0, true);
EXPECT_EQ (nl.device_model_by_name ("does_not_exist") == 0, true);
EXPECT_EQ (nl.device_abstract_by_name ("name") == dm, true);
EXPECT_EQ (nl.device_abstract_by_name ("name2") == 0, true);
EXPECT_EQ (nl.device_abstract_by_name ("does_not_exist") == 0, true);
dm->set_name ("name2");
EXPECT_EQ (dm->name (), "name2");
EXPECT_EQ (nl.device_model_by_name ("name") == 0, true);
EXPECT_EQ (nl.device_model_by_name ("name2") == dm, true);
EXPECT_EQ (nl.device_model_by_name ("does_not_exist") == 0, true);
EXPECT_EQ (nl.device_abstract_by_name ("name") == 0, true);
EXPECT_EQ (nl.device_abstract_by_name ("name2") == dm, true);
EXPECT_EQ (nl.device_abstract_by_name ("does_not_exist") == 0, true);
dm->set_cluster_id_for_terminal (1, 17);
dm->set_cluster_id_for_terminal (0, 42);
@ -1067,14 +1067,14 @@ TEST(13_DeviceModel)
EXPECT_EQ (dm->cluster_id_for_terminal (1), size_t (17));
dm->set_cell_index (5);
EXPECT_EQ (nl.device_model_by_cell_index (5) == dm, true);
EXPECT_EQ (nl.device_model_by_cell_index (17) == 0, true);
EXPECT_EQ (nl.device_abstract_by_cell_index (5) == dm, true);
EXPECT_EQ (nl.device_abstract_by_cell_index (17) == 0, true);
EXPECT_EQ (dm->cell_index (), db::cell_index_type (5));
EXPECT_EQ (nl.begin_device_models () == nl.end_device_models (), false);
EXPECT_EQ (nl.begin_device_models ()->name (), "name2");
EXPECT_EQ (nl.begin_device_abstracts () == nl.end_device_abstracts (), false);
EXPECT_EQ (nl.begin_device_abstracts ()->name (), "name2");
nl.remove_device_model (dm);
nl.remove_device_abstract (dm);
EXPECT_EQ (nl.begin_device_models () == nl.end_device_models (), true);
EXPECT_EQ (nl.begin_device_abstracts () == nl.end_device_abstracts (), true);
}