.TH "LoadGlobalRouting" 3 "Thu Nov 12 2020" "Version 1.0" "Katabatic - Routing Toolbox" \" -*- nroff -*-
.ad l
.nh
.SH NAME
LoadGlobalRouting \- Translation rules to build detailed routing from global\&.  

.SH SYNOPSIS
.br
.PP
.SS "Classes"

.in +1c
.ti -1c
.RI "class \fBGCellTopology\fP"
.br
.RI "Build the wiring for a Net inside a GCell (\fBinternal\fP)\&. "
.in -1c
.SS "Enumerations"

.in +1c
.ti -1c
.RI "enum \fBLocalFunctionFlag\fP { \fBNoFlags\fP = 0x00000000, \fBHAccess\fP = 0x00000002, \fBVSmall\fP = 0x00000004, \fBHSmall\fP = 0x00000008, \fBPunctual\fP = 0x00000010, \fBDoSourceContact\fP = 0x00000100, \fBDoTargetContact\fP = 0x00000200 }"
.br
.in -1c
.SS "Functions"

.in +1c
.ti -1c
.RI "unsigned int \fBcheckRoutingPadSize\fP (\fBComponent\fP *anchor)"
.br
.ti -1c
.RI "static void \fBdoRp_AutoContacts\fP (\fBGCell\fP *, \fBComponent\fP *, \fBAutoContact\fP *&source, \fBAutoContact\fP *&target, unsigned int flags)"
.br
.ti -1c
.RI "static \fBAutoContact\fP * \fBdoRp_Access\fP (\fBGCell\fP *, \fBComponent\fP *, unsigned int flags)"
.br
.ti -1c
.RI "static \fBAutoContact\fP * \fBdoRp_AccessPad\fP (\fBRoutingPad\fP *, unsigned int flags)"
.br
.ti -1c
.RI "static void \fBdoRp_StairCaseH\fP (\fBGCell\fP *, \fBComponent\fP *rp1, \fBComponent\fP *rp2)"
.br
.ti -1c
.RI "static void \fBdoRp_StairCaseV\fP (\fBGCell\fP *, \fBComponent\fP *rp1, \fBComponent\fP *rp2)"
.br
.ti -1c
.RI "void \fB_do_xG_1Pad\fP ()"
.br
.ti -1c
.RI "void \fB_do_xG\fP ()"
.br
.ti -1c
.RI "void \fB_do_1G_1M1\fP ()"
.br
.ti -1c
.RI "void \fB_do_1G_xM1\fP ()"
.br
.ti -1c
.RI "void \fB_do_xG_1M1_1M2\fP ()"
.br
.ti -1c
.RI "void \fB_do_xG_xM1_xM3\fP ()"
.br
.ti -1c
.RI "void \fB_do_xG_xM2\fP ()"
.br
.ti -1c
.RI "void \fB_do_1G_1M3\fP ()"
.br
.ti -1c
.RI "void \fB_do_xG_xM3\fP ()"
.br
.ti -1c
.RI "void \fBsingleGCell\fP (\fBKatabaticEngine\fP *ktbt, \fBNet\fP *net)"
.br
.in -1c
.SH "Detailed Description"
.PP 
Translation rules to build detailed routing from global\&. 

This module documents how the global routing built by \fCKnik\fP is loaded into the \fC\fBKatabatic\fP\fP data-base\&. It is intented for developpers only\&. 
.SH "Enumeration Type Documentation"
.PP 
.SS "enum \fBLocalFunctionFlag\fP"
A set of flags for all functions of the LoadGrByNet module\&. They can be combined to form the \fIflags\fP argument of functions\&. the functions will ignore flags that are not intended to them\&.
.PP
For \fCHSmall\fP, \fCVSmall\fP & \fCPunctual\fP see \fBcheckRoutingPadSize()\fP\&. 
.PP
\fBEnumerator\fP
.in +1c
.TP
\fB\fINoFlags \fP\fP
A simple alias over zero to explicitly tell that no flag at all is passed to the function\&. 
.TP
\fB\fIHAccess \fP\fP
The constructed topology will be accessed through an horizontal segment\&. The absence of this flag tell that the access will be done trough a vertical\&. 
.TP
\fB\fIVSmall \fP\fP
The RoutingPad vertically covers a very small number of access points, so it is likely overconstrained for direct horizontal connexion\&. 
.TP
\fB\fIHSmall \fP\fP
The RoutingPad horizontally covers a very small number of access points, so it is likely overconstrained for direct vertical connexion\&. 
.TP
\fB\fIPunctual \fP\fP
The RoutingPad covers only an access point in either direction\&. 
.TP
\fB\fIDoSourceContact \fP\fP
When creating \fBKatabatic::AutoContactTerminal\fP on non-punctual RoutingPad, this flag request the creation of a contact \fIon the source point\fP\&. 
.TP
\fB\fIDoTargetContact \fP\fP
When creating \fBKatabatic::AutoContactTerminal\fP on non-punctual RoutingPad, this flag request the creation of a contact \fIon the target point\fP\&. 
.SH "Function Documentation"
.PP 
.SS "unsigned int checkRoutingPadSize (\fBComponent\fP * rp)"
Look at the geometrical size of the Component and assess if it's span is too narrow either horizontally or vertically\&. Return a combination of flags indicating it's state:
.IP "\(bu" 2
HSmall : less than 3 pitches in horizontal direction\&.
.IP "\(bu" 2
VSmall : less than 3 pitches in vertical direction\&.
.IP "\(bu" 2
Punctual : one pitch in either directions\&.
.PP
.PP
The component can be a RoutingPad, a Vertical or an Horizontal\&.
.PP
checkRoutingPadSize() 
.PP
References Component::getLayer(), anonymous_namespace{LoadGrByNet\&.cpp}::HSmall, anonymous_namespace{LoadGrByNet\&.cpp}::Punctual, toLambda(), and anonymous_namespace{LoadGrByNet\&.cpp}::VSmall\&.
.PP
Referenced by GCellTopology::doRp_Access()\&.
.SS "void doRp_AutoContacts (\fBGCell\fP * gcell, \fBComponent\fP * rp, \fBAutoContact\fP *& source, \fBAutoContact\fP *& target, unsigned int flags)\fC [static]\fP"

.PP
\fBParameters:\fP
.RS 4
\fIgcell\fP The GCell into which create the AutoContact\&. 
.br
\fIrp\fP The Component we want to access\&. 
.br
\fIsource\fP The AutoContact created on the \fCsource\fP (\fIreturned\fP)\&. 
.br
\fItarget\fP The AutoContact created on the \fCtarget\fP (\fIreturned\fP)\&. 
.br
\fIflags\fP Managed by this function:
.IP "\(bu" 2
LocalFunctionFlag::DoSourceContact
.IP "\(bu" 2
LocalFunctionFlag::DoTargetContact
.PP
.RE
.PP
Create the AutoContact directly anchored on the Component (terminal)\&. Three cases are manageds:
.IP "1." 4
\fBOrdinary (non-punctual) \fCMETAL1\fP terminal\fP: an AutoContactTerminal is anchored on the RoutingPad\&.
.IP "2." 4
\fBPunctual \fCMETAL1\fP terminal\fP, the access must never be blocked by other routing\&. To ensure it, we create a fixed AutoSegment (anchored on two AutoContactTerminal) to cover it\&. The \fInormal\fP AutoContactTerminal is also created\&.
.IP "3." 4
\fBnon \fCMETAL1\fP terminal\fP, as for the punctual \fCMETAL1\fP, a fixed protection is added over the RoutingPad\&. If we access horizontally a vertical RoutingPad or vertically an horizontal one, an extra AutoContactTerminal is added (to allow is displacement along the RoutingPad)\&.
.PP
.PP
To avoid creating a fixed protection over a RoutingPad multiple times, the RoutingPad and it's associated protection is stored in a static \fCmap\fP : \fC__routingPadAutoSegments\fP\&.
.PP
Conversely, because an AutoContactTerminal can only be connected to one segment, each time this function is called a new terminal will be created (or maybe two in case of non-punctual terminals)\&. If only one AutoContact is requested, it is created centered on the RoutingPad\&. The initial position of AutoContact \fIdo not prevent them to move afterwards\fP, even those created on source/target on a non-punctual RoutingPad\&.
.PP
\fBRemark: For clarity we describe the layer management of this function in term\fP
.RS 4
of \fCMETAL\fP, but it is the RoutingGauge depth which is actually used\&.
.RE
.PP
doRp_AutoContacts() 
.PP
References Katabatic::CntFixed, AutoContactTerminal::create(), AutoSegment::create(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet\&.cpp}::DoTargetContact, Session::getContactLayer(), Grid< GCellT >::getGCell(), KatabaticEngine::getGCellGrid(), Session::getKatabatic(), Component::getLayer(), Katabatic::KbHorizontal, Katabatic::SegFixed, and AutoSegment::setFlags()\&.
.PP
Referenced by GCellTopology::_do_1G_1M3(), GCellTopology::_do_xG_1M1_1M2(), GCellTopology::_do_xG_xM1_xM3(), GCellTopology::_do_xG_xM2(), GCellTopology::_do_xG_xM3(), GCellTopology::doRp_Access(), GCellTopology::doRp_StairCaseH(), GCellTopology::doRp_StairCaseV(), and anonymous_namespace{LoadGrByNet\&.cpp}::singleGCell()\&.
.SS "\fBAutoContact\fP * doRp_Access (\fBGCell\fP * gcell, \fBComponent\fP * rp, unsigned int flags)\fC [static]\fP"

.PP
\fBParameters:\fP
.RS 4
\fIgcell\fP The GCell into which create the AutoContact\&. 
.br
\fIrp\fP The Component onto which anchor the access contact\&. 
.br
\fIflags\fP Relevant flags are:
.IP "\(bu" 2
HAccess, the terminal is to be accessed through an horizontal segment\&.
.IP "\(bu" 2
VSmall, force the terminal to be considered as small in the vertical direction\&.
.PP
.RE
.PP
If \fCHAccess\fP is set, the Component is to be accessed trough an horizontal segment\&. If unset, the access is done vertically\&.
.PP
Create an AutoContact to access a Component (terminal)\&. If the Component is not to be accessed through an horizontal segment, and do not cover a large span in the horizontal direction (flag \fCVSmall\fP), a local horizontal AutoSegment is added to slacken the vertical constraints\&.
.PP
doRp_Access() 
.PP
References anonymous_namespace{LoadGrByNet\&.cpp}::checkRoutingPadSize(), AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), Session::getContactLayer(), Component::getNet(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, anonymous_namespace{LoadGrByNet\&.cpp}::HSmall, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::VSmall\&.
.PP
Referenced by GCellTopology::_do_1G_1M1(), GCellTopology::_do_1G_xM1(), GCellTopology::_do_xG_xM1_xM3(), GCellTopology::_do_xG_xM2(), and GCellTopology::_do_xG_xM3()\&.
.SS "\fBAutoContact\fP * doRp_AccessPad (\fBRoutingPad\fP * rp, unsigned int flags)\fC [static]\fP"

.PP
\fBParameters:\fP
.RS 4
\fIrp\fP The Component onto which anchor the access contact\&. 
.br
\fIflags\fP Relevant flags are:
.IP "\(bu" 2
HAccess, the terminal is to be accessed through an horizontal segment\&.
.IP "\(bu" 2
VSmall, force the terminal to be considered as small in the vertical direction\&. 
.PP
.RE
.PP
\fBReturns:\fP
.RS 4
A \fBKatabatic::AutoContactTerminal\fP \&.
.RE
.PP
The Component \fCrp\fP is a RoutingPad which belongs to a pad cell\&. This case occurs when we are routing a complete chip\&. This method build, from the \fCrp\fP a stack of articulated punctual segments and contacts to reach the default H/V routing layers (usually \fCMETAL2\fP & \fCMETAL3\fP)\&. This may be needed when the pad terminal is in \fCMETAL5\fP, for instance\&.
.PP
The returned AutoContactTerminal is anchored on the last punctual segment build\&.
.PP
The GCell into which the AutoContactTerminal is created may be under the pads area\&. However, it will be right on the border of the GCell\&. The global router vertexes of GCell under the pad area are marked as blocked so will never be used for routing\&.
.PP
\fBRemark: The segments and contacts added to ensure the layer connexity are not\fP
.RS 4
put into the \fBKatabatic\fP database\&. They are plain Hurricane objects, invisibles from it\&. 
.RE
.PP

.PP
References Contact::create(), Horizontal::create(), Vertical::create(), AutoContactTerminal::create(), Hook::detach(), Component::getBodyHook(), RoutingPad::getBoundingBox(), RoutingPad::getCenter(), Session::getContactLayer(), Grid< GCellT >::getGCell(), KatabaticEngine::getGCellGrid(), Box::getHeight(), Session::getKatabatic(), RoutingPad::getLayer(), Component::getNet(), RoutingPad::getOccurrence(), Transformation::getOrientation(), Occurrence::getPath(), Session::getRoutingLayer(), Path::getTransformation(), Box::getWidth(), Box::getXMax(), Box::getXMin(), Box::getYMax(), Box::getYMin(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, Katabatic::KbHorizontal, Point::setX(), and Point::setY()\&.
.PP
Referenced by GCellTopology::_do_xG_1Pad()\&.
.SS "void doRp_StairCaseH (\fBGCell\fP * gcell, \fBComponent\fP * rp1, \fBComponent\fP * rp2)\fC [static]\fP"
Build the wiring to connect to horizontal Component\&. Two cases:
.IP "\(bu" 2
The Component are aligneds, then only a straight wire is created\&.
.IP "\(bu" 2
They are \fInot\fP aligned, then a complete dogleg is created\&.
.PP
.PP
doRp_StairCaseH() 
.PP
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet\&.cpp}::DoTargetContact, Session::getContactLayer(), Component::getLayer(), Component::getNet(), Component::getX(), AutoContact::getY(), Katabatic::KbHorizontal, and Katabatic::KbVertical\&.
.PP
Referenced by GCellTopology::_do_xG_xM2()\&.
.SS "void doRp_StairCaseV (\fBGCell\fP * gcell, \fBComponent\fP * rp1, \fBComponent\fP * rp2)\fC [static]\fP"
Build the wiring to connect to vertical Components\&. Two cases:
.IP "\(bu" 2
The Components are aligneds, then only a straight wire is created\&.
.IP "\(bu" 2
They are \fInot\fP aligned, then a complete dogleg is created\&.
.PP
.PP
doRp_StairCaseV() 
.PP
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet\&.cpp}::DoTargetContact, Session::getContactLayer(), Component::getLayer(), Component::getNet(), AutoContact::getX(), Component::getY(), Katabatic::KbHorizontal, and Katabatic::KbVertical\&.
.PP
Referenced by GCellTopology::_do_xG_xM3()\&.
.SS "void _do_xG_1Pad ()\fC [private]\fP"
Construct the topology, when there is only global wires and one local terminal, but coming from a Pad\&. As thoses connectors will always be on one border of the GCell they can be considered as a kind of global\&.
.PP
So this method mostly calls \fBGCellTopology::doRp_AccessPad()\fP to create the AutoContactTerminal, then calls \fBGCellTopology::_do_xG()\fP, except for straight lines which are managed directly\&. 
.PP
References GCellTopology::_do_xG(), AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AccessPad(), AutoContact::getBodyHook(), Session::getContactLayer(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SS "void _do_xG ()\fC [private]\fP"
Construct the topology, when there is only global wires (no local terminals)\&.
.PP
Some topology are not handled because they must not be managed by this function: 
.PD 0

.IP "\(bu" 2
One global: nonsensical because there also must be a terminal\&. 
.IP "\(bu" 2
Two aligned globals: in that case we do a straight wire without any AutoContact (handled by the source/target of the wire)\&. 
.PP
.PP
_do_xG() 
.PP
References AutoContactVTee::create(), AutoContactTurn::create(), AutoContactHTee::create(), AutoSegment::create(), Session::getContactLayer(), Katabatic::KbHorizontal, and Katabatic::KbVertical\&.
.PP
Referenced by GCellTopology::_do_xG_1Pad()\&.
.SS "void _do_1G_1M1 ()\fC [private]\fP"
Construct a topology where there is \fIone\fP global and one RoutingPad in \fCMETAL1\fP\&. The \fCMETAL1\fP is assumed to be vertical\&.
.PP
\fBRemark: When accessing the RoutingPad through an horizontal global segment\fP
.RS 4
and the vertical extension of the segment is small, the global is still directly attached to the terminal, inducing a high constraint on it\&. We left to job of slackening it to the router\&.
.RE
.PP
_do_1G_1M1() 
.PP
References GCellTopology::doRp_Access(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags, and anonymous_namespace{LoadGrByNet\&.cpp}::VSmall\&.
.SS "void _do_1G_xM1 ()\fC [private]\fP"
Construct a topology where there is \fIone\fP global and any number of RoutingPad in \fCMETAL1\fP\&. The \fCMETAL1\fP is assumed to be vertical\&.
.PP
The RoutingPads are linked together two by two\&. If the horizontal segments are not aligned by the router, part of the routage will be done through the RoutingPad itself\&. The global incoming segment will connected to the leftmost, rightmost or centermost RoutingPad according from wich side it comes from\&.
.PP
_do_1G_xM1() 
.PP
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_Access(), Component::getBoundingBox(), Session::getContactLayer(), Box::getHeight(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, Katabatic::KbHorizontal, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SS "void _do_xG_1M1_1M2 ()\fC [private]\fP"
Construct a topology where there is at least one global (and up to 4), one \fCMETAL1\fP RoutingPad (assumed V) and one \fCMETAL2\fP RoutingPad (assumed H)\&.
.PP
In this topology, we want to try to reuse the \fCMETAL2\fP RoutingPad as a feedtrough in the horizontal routage\&. Thus:
.IP "\(bu" 2
The \fCMETAL1\fP and \fCMETAL2\fP RoutingPad are connected through a separate wiring\&.
.IP "\(bu" 2
The south & west global wiring is attached to the leftmost contact of the \fCMETAL2\fP\&.
.IP "\(bu" 2
The north & east global wiring is attached to the rightmost contact of the \fCMETAL2\fP\&.
.PP
.PP
South/west and north/south can be build independantly\&. Depending on the number of globals, they can consist of:
.IP "\(bu" 2
Nothing (no south nor west)\&.
.IP "\(bu" 2
An AutoContact (west present)\&.
.IP "\(bu" 2
An horizontal plus a turn (south present)\&.
.IP "\(bu" 2
An horizontal plus a HTee (south & west present)\&.
.PP
.PP
\fBRemark: Not all configurations are represented below\&.\fP
.RS 4

.RE
.PP
_do_xG_1M1_1M2() 
.PP
References AutoContactTurn::create(), AutoContactHTee::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet\&.cpp}::DoTargetContact, Session::getContactLayer(), Session::getRoutingLayer(), Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SS "void _do_xG_xM1_xM3 ()\fC [private]\fP"
Construct a topology where there is at least one global (and up to 4), at least one \fCMETAL1\fP RoutingPad (assumed V) and at least one \fCMETAL3\fP RoutingPad (assumed V)\&.
.PP
In this topology, we want to try to reuse the \fCMETAL3\fP RoutingPad as a feedtrough in the vertical routage\&. Thus:
.IP "\(bu" 2
The \fCMETAL1\fP and \fCMETAL3\fP RoutingPad are connected through a separate wiring made of separate horizontals\&.
.IP "\(bu" 2
The south-west global wiring is attached to the leftmost RoutingPad if there isn't south or to the first \fCMETAL3\fP otherwise\&.
.IP "\(bu" 2
The north-east global wiring is attached to the rightmost RoutingPad if there isn't north or to the first \fCMETAL3\fP otherwise\&.
.PP
.PP
South/west and north/south can be build independantly\&. Depending on the number of globals, they can consist of:
.IP "\(bu" 2
Nothing (no south nor west)\&.
.IP "\(bu" 2
An AutoContact on the leftmost RoutingPad (west present)\&.
.IP "\(bu" 2
An AutoContact on the first \fCMETAL3\fP (only south present)\&.
.IP "\(bu" 2
An AutoContact plus a vertical plus a VTee (south & west present)\&.
.PP
.PP
_do_xG_xM1_xM3() 
.PP
References AutoContactVTee::create(), AutoContactTurn::create(), AutoContactHTee::create(), AutoSegment::create(), GCellTopology::doRp_Access(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet\&.cpp}::DoTargetContact, Component::getBoundingBox(), Session::getContactLayer(), Box::getHeight(), Session::getRoutingLayer(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SS "void _do_xG_xM2 ()\fC [private]\fP"
Construct a topology where there is at least one global (and up to 4), and any number of \fCMETAL2\fP RoutingPads (assumeds H)\&.
.PP
In this topology, we want to try to reuse the \fCMETAL2\fP RoutingPad as a feedtrough in the horizontal routage\&. Thus:
.IP "\(bu" 2
The RoutingPad are connecteds trough a separate staircase (or straight wire if aligneds)\&.
.IP "\(bu" 2
The south-west global wiring is attached to the leftmost RoutingPad if there isn't south or to the biggest horizontal RoutingPad otherwise\&.
.IP "\(bu" 2
The north-east global wiring is attached to the rightmost RoutingPad if there isn't south or to the biggest horizontal RoutingPad otherwise\&.
.PP
.PP
_do_xG_xM2() 
.PP
References AutoContactVTee::create(), AutoSegment::create(), GCellTopology::doRp_Access(), GCellTopology::doRp_AutoContacts(), GCellTopology::doRp_StairCaseH(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, Component::getBoundingBox(), Session::getContactLayer(), Box::getWidth(), Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SS "void _do_1G_1M3 ()\fC [private]\fP"
Construct a topology where there is one global and one \fCMETAL3\fP RoutingPad (assumeds V)\&.
.PP
In this topology, we reuse the \fCMETAL3\fP RoutingPad as a feedtrough in the vertical routage\&. Thus:
.IP "\(bu" 2
If the global is either north or south, we directly connect to the north end or south end of the RoutingPad\&. The vertical global will have no slack at all we assume that METAL3 terminals are only from blocks and are aligneds vertically\&.
.IP "\(bu" 2
If the global is east or west \fIand\fP the RoutingPad is sufficiently extended in the vertical direction, we connect an horizontal in the normal way\&.
.IP "\(bu" 2
If the global is not sufficiently extended, we add a turn to give some slack to the global\&.
.PP
.PP
_do_1G_1M3() 
.PP
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet\&.cpp}::DoTargetContact, Session::getContactLayer(), AutoContact::getX(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SS "void _do_xG_xM3 ()\fC [private]\fP"
Construct a topology where there at least one global and two \fCMETAL3\fP RoutingPad (assumed V)\&.
.PP
In this topology, we reuse the \fCMETAL3\fP RoutingPad as a feedtrough in the vertical routage\&. We assume that the most likely relative position of the RoutingPads is to be aligned vertically\&. Thus:
.IP "\(bu" 2
All RoutingPads are linked two by two trough vertical staircases\&.
.IP "\(bu" 2
The south-west global wiring is attached to the bottommost RoutingPad (without vertical slack)\&. If a misalignment is detected, then a dogleg is added\&.
.IP "\(bu" 2
The north-east global wiring is attached to the topmost RoutingPad (without vertical slack)\&.
.PP
.PP
South/west and north/south can be build independantly\&. Depending on the number of globals, they can consist of:
.IP "\(bu" 2
Nothing (no south nor west)\&.
.IP "\(bu" 2
An sliding AutoContact on the bottommost RoutingPad (west present)\&.
.IP "\(bu" 2
An fixed AutoContact on the bottommost RoutingPad (only south present)\&.
.IP "\(bu" 2
An fixed AutoContact plus a vertical plus a VTee (south & west present)\&.
.PP
.PP
_do_xG_xM3() 
.PP
References AutoContactVTee::create(), AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_Access(), GCellTopology::doRp_AutoContacts(), GCellTopology::doRp_StairCaseV(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet\&.cpp}::DoTargetContact, Session::getContactLayer(), DbU::getValueString(), AutoContact::getX(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SS "void singleGCell (\fBKatabaticEngine\fP * ktbt, \fBNet\fP * net)"
All the RoutingPads of the net are concentrated under a single GCell\&. This function assumes that all the terminals are in \fCMETAL1\fP (vertical), and link them two by two by horizontal wires\&. 
.PP
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet\&.cpp}::DoSourceContact, Session::getContactLayer(), Grid< GCellT >::getGCell(), KatabaticEngine::getGCellGrid(), RoutingGauge::getLayerDepth(), Session::getRoutingGauge(), Net::getRoutingPads(), Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags\&.
.SH "Author"
.PP 
Generated automatically by Doxygen for Katabatic - Routing Toolbox from the source code\&.