oaParasiticNetwork Class Reference
Inheritance diagram for oaParasiticNetwork:
 |
 |
|
Public Methods |
| void | load (oaBoolean allPartitions=false) |
| void | destroy () |
| void | unload () |
| void | setName (const oaString &name) |
| void | getName (oaString &name) const |
| void | setBBox (const oaBox &bBox) |
| void | getBBox (oaBox &bBox) const |
| oaBoolean | isLoaded () |
| oaBoolean | isParent () |
| oaParasiticNetwork * | getParent () |
| oaDomain | getDomain () const |
| oaDesignObject * | getNet () const |
| oaCollection< oaNode, oaParasiticNetwork > | getNodes () const |
| oaCollection< oaDevice, oaParasiticNetwork > | getDevices () const |
| oaCollection< oaAnalysisPoint, oaParasiticNetwork > | getAnalysisPoints () const |
| oaCollection< oaDesignObject, oaParasiticNetwork > | getCoupledNets () const |
| oaCollection< oaNode, oaParasiticNetwork > | getConnNodes (const oaDesignObject *conn) const |
| oaCollection< oaSubNetwork, oaParasiticNetwork > | getSubNetworks () const |
| oaCollection< oaParasiticNetwork, oaParasiticNetwork > | getPartitions () const |
Static Public Methods |
| oaParasiticNetwork * | create (oaDesignObject *net, oaAnalysisPoint *ap) |
| oaParasiticNetwork * | create (oaDesignObject *net, const oaAnalysisPointArray &aps) |
| oaParasiticNetwork * | create (oaDesignObject *net, oaUInt4 numAPs, oaAnalysisPoint **aps) |
| oaParasiticNetwork * | create (oaParasiticNetwork *parent) |
| oaParasiticNetwork * | create (oaParasiticNetwork *parent, const oaString &name) |
| oaParasiticNetwork * | load (const oaDesignObject *net, const oaAnalysisPoint *ap, oaBoolean allPartitions=false) |
| oaParasiticNetwork * | find (const oaDesignObject *net, const oaAnalysisPoint *ap) |
| oaParasiticNetwork * | find (const oaParasiticNetwork *parent, const oaString &name) |
| oaBoolean | exists (const oaDesignObject *net, const oaAnalysisPoint *ap) |
| void | destroy (oaDesignObject *net, const oaAnalysisPoint *ap) |
| void | destroy (oaDesign *design, const oaAnalysisPoint *ap) |
| void | destroy (oaDesignObject *net) |
| void | destroy (oaDesign *design) |
Public Types |
| enum | { dtIndex = oacParasiticNetworkDataType
} |
| enum | { domain = oacNoDomain
} |
Detailed Description
The oaParasiticNetwork class represents the parasitic elements for a particular net and analysis point pair as a graph containing nodes and devices. Each analysis point can have a separate parasitic network, or values associated with several analysis points can be annotated on a shared parasitic network common to those analysis points.
Parasitic networks can be associated with nets in the block and occurrence domains. These networks are generally created by an extractor that analyzes the geometry of the nets to create the parasitics. If the extraction runs hierarchically one block at a time it will create a parasitic network on an oaNet. If it runs on an expanded hierarchy it will write the parasitic network on an oaOccNet.
A caller accesses existing oaParasiticNetwork objects by calling the load() function, which loads the network from disk, if necessary. Several different callers can access the same parasitic network at the same time. A reference count is kept to ensure that the parasitic network remains in memory at least until the last caller signals that it is done with the network by calling the unload() function.
Note, however, that pointers to the oaParasiticNetwork and to any objects within the network are only valid between a given caller's load() and unload() calls. After calling unload() for a parasitic network, the caller should assume that all of the pointers to that parasitic network's objects are no longer valid (even though the network remains in memory for other callers who have loaded but not yet unloaded the network. Each caller also should assume that the values of the object pointers change each time the same parasitic network is reloaded.
Changes made to a parasitic network are preserved across subsequent calls to unload() and load(). As with other design data, changes to parasitic networks do not affect the primary on-disk representation of the design until the changes are saved using oaDesign::save(). Saving a design that contains parasitic networks creates or updates an oaDMFile, detailed_rc.oa, that is a follower of the primary oaDesign database within the oaCellView.
When the create() function is used to build a new parasitic network, the data for that network remains in memory until the unload() function is called.
Undo, properties, and groups are not supported for oaParasiticNetwork. Extensions on oaParasiticNetwork (and interPointer extensions that refer to an oaParasiticNetwork) are accessible only while the oaParasiticNetwork is loaded.
Note: Any change to the connectivity of the net that the ParasiticNetwork is on will cause the ParasiticNetwork to be destroyed. This includes creating, destroying, or moving Terminals or InstTerms.
For nets with exceptionally large parasitic graphs, the ParasiticNetwork may be split into a set of partitions. This technique allows selected partitions rather than the entire network to be loaded into memory. Typically, parasitic network partitioning is used for power and ground nets.
If partitions are used, the parasitics for a given net and analysis point are represented by a tree of oaParasiticNetworks. There is a top ParasiticNetwork, which has a set of child networks. Each of these child networks, in turn, may have child networks, and so on down the tree. When a child network is in memory, all of its parent partitions also must be in memory, but its siblings need not be.
Note that a 2-node device that crosses partitions within a given net may reference a node in one partition, and another node in one of its ancestor partitions, but not in other partitions. Such a device will be stored in the lower of the two partitions. The node in the higher (parent) partition is required to have an id. Therefore a node that is connected to devices in multiple partitions must be created in a common ancestor to those partitions.
Also note that unloading a parent network, whose reference count equals 0, also will unload any of its loaded child networks even if the reference count of one or more child networks is greater than 0.
The oaParasiticNetwork class can be observed by deriving from oaObserver<oaParasiticNetwork>.
Member Function Documentation
| oaParasiticNetwork * oaParasiticNetwork::create |
( |
oaParasiticNetwork * |
parent, |
|
|
const oaString & |
name |
|
) |
[static] |
|
|
|
This create function is used when the parasitics are to be partitioned. It creates a partition with the specified name with the specified parent oaParasiticNetwork as its parent partition. An exception will be thrown if the partition with the specified name already exists in the specified parent parasitic network.
- Exceptions:
-
|
| oaParasiticNetwork * oaParasiticNetwork::create |
( |
oaParasiticNetwork * |
parent |
) |
[static] |
|
|
|
This create function is used when the parasitics are to be partitioned. It creates a partition with the specified parent oaParasiticNetwork as its parent partition. This parasitic network partition will have a generated name. |
|
|
This function creates a parasitic network for the specified net, where each node and device in the network have numAPs values, one for each of the analysis points in the aps array. The specified net must be either an oaNet, or an oaOccNet.
- Exceptions:
-
|
|
|
This function creates a parasitic network for the specified net or occNet, where each node and device in the network will have one value for each of the analysis points in the aps array. An oacParasiticNetworkExists exception will be thrown if a parasitic network already exists for any of the analysis points in the aps array.
- Parameters:
-
| net | The oaNet or oaOccNet for which the oaParasiticNetwork will be created. |
| aps | An array of oaAnalysisPoints. Each node and device will have the same number of values as there are oaAnalysisPoints in the array. |
- Exceptions:
-
|
|
|
This function creates a parasitic network for the specified net, where each node and device in the network have a single value corresponding to the ap analysis point. An exception is thrown if a parasitic network already exists for the specified analysis point. The specified net must be either an oaNet, or an oaOccNet.
- Exceptions:
-
|
| void oaParasiticNetwork::destroy |
( |
|
) |
|
|
|
|
This function destroys this parasiticNetwork object, including data for all analysis points that share this parasiticNetwork. |
| void oaParasiticNetwork::destroy |
( |
oaDesign * |
design |
) |
[static] |
|
|
|
This function destroys all parasitic networks for all analysis points for all nets in the specified design. |
|
|
This function destroys all parasitic networks for all analysis points for the specified net.
- Exceptions:
-
|
|
|
This function destroys the parasitic network data associated with the ap analysis point for all nets in the specified design. For parasitic networks that represent other analysis points in addition to ap, this function will also destroy the data for the other analysis points. |
|
|
This function destroys the parasitic network data associated with the ap analysis point for the specified net. This function will also destroy the data for any other analysis points represented by the same parasitic network.
- Exceptions:
-
|
|
|
This function determines if a parasitic network exists for the specified net and analysis point pair, regardless of whether the parasitic network is currently loaded.
- Exceptions:
-
|
| oaParasiticNetwork * oaParasiticNetwork::find |
( |
const oaParasiticNetwork * |
parent, |
|
|
const oaString & |
name |
|
) |
[static] |
|
|
|
This function finds a parasitic network partition for the specified parasitic network with the specified name. This function does not change the reference count for the parasitic network. NULL will be returned if the parasitic network partition does not exists or is not fully loaded.
- Parameters:
-
| parent | The parent parasitic network to search for the partition |
| name | The name of the partition network |
|
|
|
This function finds a parasitic network for the specified net or occNet that has already been loaded into memory. This function does not change the reference count for the parasitic network. NULL will be returned if the parasitic network is not currently loaded or if no parasitic network exists for the specified net and analysis point.
- Parameters:
-
| net | The oaNet object to search for the parasitic network |
| ap | The oaAnalysisPoint object to search for the parasitic network |
- Exceptions:
-
|
| oaCollection oaParasiticNetwork::getAnalysisPoints |
( |
|
) |
const |
|
|
|
This function returns a collection of all the analysis points in this parasitic network. |
| void oaParasiticNetwork::getBBox |
( |
oaBox & |
bBox |
) |
const |
|
|
|
This function returns the bounding box of this parasiticNetwork. A bounding box on a parasitic network is provided for use in partitioned networks.
- Parameters:
-
| bBox | The returned bounding box |
|
|
|
This function returns a collection of all the nodes in this parasitic network that are connected to the specified object. The object must be an instTerm or a bitTerm for parasitic networks that are on oaNets, or must be an occInstTerm or an occBitTerm for parasitic networks that are on occNets.
- Exceptions:
-
|
|
|
This function returns a collection containing the nets to which this net is coupled, through either a coupling capacitor or a mutual inductor. |
|
|
This function returns a collection of all the devices belonging to this parasiticNetwork. |
| oaDomain oaParasiticNetwork::getDomain |
( |
|
) |
const |
|
|
|
This function returns the domain of this parasitic network, which is the same domain of the net that this parasitic network associates with. The domain will either be oacBlockDomain or oacOccDomain.
Reimplemented from oaObject. |
| void oaParasiticNetwork::getName |
( |
oaString & |
name |
) |
const |
|
|
|
This function returns the name of this parasiticNetwork. |
|
|
This function returns the net to which this parasitic network belongs. It will either be an oaNet or an oaOccNet. |
|
|
This function returns a collection of all the nodes belonging to this parasiticNetwork. |
| oaParasiticNetwork * oaParasiticNetwork::getParent |
( |
|
) |
|
|
|
|
This function returns the parent parasitic network of this parasitic network. Null is returned if this parasitic network does not have a parent. |
| oaCollection< oaParasiticNetwork, oaParasiticNetwork > oaParasiticNetwork::getPartitions |
( |
|
) |
const |
|
|
|
This function can be used if parasitics are partitioned. It returns a collection of ParasiticNetworks that represent the child partitions of this parent partition. These collections can be returned repeatedly to descend the tree of partitions until a bottom level partition returns an empty collection.
When a child partition is first returned by a getNext() call on this collection, it is not yet loaded. The child oaParasiticNetwork may be used to check its name and BBox. That child must be loaded with a call to load(oaBoolean) before any objects in that network can be accessed. |
|
|
This function returns a collection of all the subNetworks belonging to this oaParasiticNetwork. |
|
|
This function returns a boolean indicating whether or not this parasitic network has been loaded.
Note that oaParasiticNetwork pointers returned by load() or create() are loaded when they are returned by those calls. Only for child partitions of a partitioned parasitic network can there be valid pointers to unloaded oaParasiticNetworks. At the time that such a pointer is first returned by a getNext() call on the collection returned by getPartitions(), the pointer is not yet loaded, and load() must be called before accessing the objects in that network. |
|
|
This function returns a boolean indicating whether or not this parasitic network is a parent of the parasitic network partitions. |
| void oaParasiticNetwork::load |
( |
oaBoolean |
allPartitions = false |
) |
|
|
|
|
This function loads this parasitic network if it has not been loaded. This call is only applicable to partitioned parasitic networks. The reference count for the parasitic network is incremented. If allPartitions is true and this is a parent, all of the descendant partitions will be loaded, and the reference count of each partition will be incremented.
Note that an oaParasiticNetwork is not yet loaded when its pointer is first returned from a getPartitions() collection.
- Parameters:
-
| allPartitions | Specifies whether or not to load all partitions. |
|
|
|
This function loads a parasitic network for the specified net or occNet into memory if it is not already loaded. The reference count for the parasitic network is incremented. If allPartitions is true, all partitions of this parasitic network will loaded, and the reference count of each partition will be incremented. An exception will be thrown if the parasitic network does not exist.
- Parameters:
-
| net | The oaNet or oaOccNet in which to search for the parasitic network |
| ap | The analysis point in which to search for the parasitic network |
| allPartitions | Specifies whether or not to load all partitions |
- Exceptions:
-
|
| void oaParasiticNetwork::setBBox |
( |
const oaBox & |
bBox |
) |
|
|
|
|
This function sets the bounding box of this parasitic network.
Note that this BBox is not automatically maintained by OpenAccess. This attribute is provided for partitioned networks. Applications creating partitioned networks generally will break the entire design area into smaller regions that delimit the parasitic devices that will be assigned to a given partition. The bounding box of each region will be stored on its partition.
- Parameters:
-
| bBox | The bounding box to set |
|
| void oaParasiticNetwork::setName |
( |
const oaString & |
name |
) |
|
|
|
|
This function sets the name of this parasitic network. |
| void oaParasiticNetwork::unload |
( |
|
) |
|
|
|
|
This function unloads a parasitic network for the specified net and decrements a reference count for the parasitic network. Once the reference count becomes zero, the database is free to page the parasitic network out from memory at any time. After calling unload(), a caller must not continue to use the pointer to this parasiticNetwork object or pointers to any objects within the network.
Note that a partitioned parent network will be unloaded when its refCount is 0, even if the refCount kept on any of its loaded child networks is greater than 0. |
Member Enumeration Documentation
The documentation for this class was generated from the following files:
Return to top of page
Copyright © 2002 - 2010 Cadence Design Systems, Inc.
All Rights Reserved.
