| \b Id | + *\b Type | + *\b Local | + *\b Global | + *\b Action | + *
| \e 1 | + *\c Minimize | + *\e yes | + *\e no | + *try to fit into a hole | + *
| \e 2 | + *\c DogLeg | + *\e yes | + *\e no | + *Dogleg : analyse overlap and try to solve it by breaking (self) | + *
| \e 3 | + *\c Desalignate | + *\e yes | + *\e yes | + *on a set of alignated \TrackSegment, suppress the + * alignment constraints, thus making then independants + * | + *
| \e 4 | + *\c Slacken | + *\e yes | + *\e yes | + *if the target/source constraint is less than the + * GCell, adds perpandicular straps to free the \TrackSegment. + * This occurs to free from terminal constraints + * | + *
| \e 5 | + *\c ConflictSolve1 | + *\e yes | + *\e yes | + *try to find in the history a reccurent dislodger, + * and break (self) to accomodate it + * | + *
| \e 6 | + *\c ConflictSolve2 | + *\e no | + *\e yes | + *try to find a Track on which we can dislodge + * an other \TrackSegment + * | + *
| \e 7 | + *\c MoveUp | + *\e no | + *\e yes | + *try to go on upper layer. + * | + *
| \e 8 | + *\c Unimplemented | + *\e no | + *\e yes | + *we failed to place this \TrackSegment + * | + *
[begin:end] defines
+ * the range of indexes of overlaping \TrackSegment in \c track.
+ * Displace TrackSegment that are perpandicular to those overlaping,
+ * remove them from their \c Track if needed and issue an associated \RoutingEvent
+ * with an updated bound constraint. Note that the overlaping \TrackSegment
+ * themselves are not removed from the \c track.
+ *
+ * A note on implementation :
+ * lhs < rhs, see \ref secTrackCostOrdering.
+ */
+
+
+ /*! \class TrackCost::CompareByDelta
+ * \brief Partial compare function for \TrackCost.
+ *
+ * Allow \TrackCost sorting on the \c _delta criterion alone.
+ */
+
+ } // End of Kite namespace.
diff --git a/kite/doc/TrackSegment.dox b/kite/doc/TrackSegment.dox
new file mode 100644
index 00000000..cb68db85
--- /dev/null
+++ b/kite/doc/TrackSegment.dox
@@ -0,0 +1,170 @@
+
+ // -*- C++ -*-
+
+
+ namespace Kite {
+
+ /*! \typedef SegmentOverlapCostCB
+ * Prototype of overlap cost callback functions.
+ *
+ * \see TrackSegment::setOverlapCostCB(), TrackSegment::getOverlapCost().
+ */
+
+ /*! \class TrackSegment
+ * \brief Derived Katabatic::AutoSegment for the router.
+ *
+ * We create one TrackSegment per aligned Katabatic::AutoSegment set,
+ * the TrackSegment is associated to the canonical one of the set.
+ *
+ * To provide some speedup, the full extention of the aligned segment
+ * set is computed once and stored in the TrackSegment itself.
+ * The drawback beeing that whenever one segment from the aligned
+ * set has it's extention modified, the full extention must be
+ * recomputed.
+ */
+
+
+ /*! \name Constructors & Destructors
+ */
+ // \{
+
+ /*! \function static TrackSegment* TrackSegment::create ( AutoSegment* segment, Track* track, bool& created );
+ * \param segment The Katabatic AutoSegment to decorate.
+ * \param track A Track into which insert the TrackSegment (may be \NULL).
+ * \param created This flag is sets is a new TrackSegment has be created.
+ * \return A TrackSegment wrapped around an AutoSegment.
+ *
+ * Constructor mainly used at loading time to decorate the Katabatic
+ * data-base with the router attributes.
+ */
+
+ // \}
+
+
+ /*! \name Predicates
+ */
+ // \{
+
+ /*! \function bool TrackSegment::isLocked () const;
+ * \Return \True if the TrackSegment is locked (cannot be deleted from the
+ * Track).
+ */
+
+ // \}
+
+
+ /*! \name Callback modifier
+ */
+ // \{
+
+ /*! \function SegmentOverlapCostCB* TrackSegment::setOverlapCostCB ( SegmentOverlapCostCB* cb );
+ * \param cb the new overlap cost callback.
+ * \return the previous overlap cost callback.
+ *
+ * sets the overlap callback.
+ */
+
+ // \}
+
+
+ /*! \name Accessors
+ */
+ // \{
+
+ /*! \function Track* TrackSegment::getTrack () const;
+ * \Return The Track in which this TrackSegment is inserted (can be \NULL).
+ */
+
+ /*! \function size_t TrackSegment::getIndex () const;
+ * \Return Index of the TrackSegment inside the Track's vector. set to
+ * Track::NPOS if not inserted in any Track.
+ */
+
+ /*! \function unsigned long TrackSegment::getArea () const;
+ * \Return The priority value used for TrackSegment sorting. Currently,
+ * the slack of the AutoSegment.
+ */
+
+ /*! \function TrackSegment* TrackSegment::getNext () const;
+ * \Return The next TrackSegment in the Track (can be \NULL).
+ *
+ * \see Track::getNext().
+ */
+
+ /*! \function TrackSegment* TrackSegment::getPrevious () const;
+ * \Return The previous TrackSegment in the Track (can be \NULL).
+ *
+ * \see Track::getPrevious().
+ */
+
+ /*! \function Interval TrackSegment::getFreeInterval () const;
+ * \Return The free interval around this TrackSegment in the Track.
+ */
+
+ /*! \function DbU::Unit TrackSegment::getSourceCanonical () const;
+ * \Return The leftmost position of the associated aligned segment set.
+ */
+
+ /*! \function DbU::Unit TrackSegment::getTargetCanonical () const;
+ * \Return The rightmost position of the associated aligned segment set.
+ */
+
+ /*! \function DbU::Unit TrackSegment::getCanonicalInterval () const;
+ * \Return The canonical interval of the associated aligned segment set.
+ */
+
+ /* \function DbU::Unit TrackSegment::getOverlapCost ( Interval interval, Net* net ) const;
+ * \param interval the overlaping interval.
+ * \param net the \Net owning the overlaping interval.
+ * \return The cost of overlaping the TrackSegment with \e interval from \Net \e net.
+ */
+
+ // \}
+
+
+ /*! \name Modifiers
+ */
+ // \{
+
+ /*! \function void TrackSegment::setLock ( bool state );
+ * \param state set the Track locking state.
+ */
+
+ /*! \function void TrackSegment::setTrack ( Track* track );
+ * \param track The Track the TrackSegment is assigned to.
+ */
+
+ /*! \function void TrackSegment::setIndex ( size_t index );
+ * \param index The index of TrackSegment in the Track's vector.
+ */
+
+ /*! \function void TrackSegment::setArea ();
+ * compute the the sorting criterion used as priority, for
+ * now it's simply the AutoSegment's slack.
+ */
+
+ /*! \function void TrackSegment::detach ();
+ * remove the TrackSegment from the Track.
+ *
+ * \important This function do not update the Track itself. The
+ * program must take care of it under penalty of introducing
+ * incoherencies.
+ *
+ * \see Track::detach().
+ */
+
+ /* \function void TrackSegment::autoInvalidate ();
+ * add \e this TrackSegment to the Kite level update Session.
+ * Something maybe buggy here, or at least not very clean.
+ */
+
+ /* \function void TrackSegment::refreshCanonical ();
+ * Recompute the letfmost & rightmost position of the collapsed set.
+ * Must be done after each modification of the TrackSegment.
+ * Dealt by the TrackSession mechanism.
+ *
+ */
+
+ // \}
+
+ }
diff --git a/kite/doc/TrackSegmentCost.dox b/kite/doc/TrackSegmentCost.dox
new file mode 100644
index 00000000..9d1435bd
--- /dev/null
+++ b/kite/doc/TrackSegmentCost.dox
@@ -0,0 +1,118 @@
+
+ // -*- C++ -*-
+
+
+ namespace Kite {
+
+ /*! \class TrackSegmentCost
+ * \brief The cost calculator of a TrackSegment.
+ *
+ * \section secMiscAttributes Miscellaneous attributes
+ *
+ * Net instead of \TrackSegment : what we will access the most is the
+ * \TrackSegment owner, so it's it we keep as an attribute. The consequence
+ * beeing that the update member function should be given the \TrackSegment
+ * as argument.
+ *
+ *
+ * \section secBoundInterval Bound interval cost component
+ *
+ * This is the minimal interval to which the \TrackSegment can be
+ * shrunk without breaking the net's connexity. The interval is
+ * computed by AutoSegment::getTopologicalInfos(). And the computation
+ * is as follow :
+ * \@2:19 is a right attractor.
+ * left \@7:6 and
+ * right \@7:16.
+ * punctual \@14:10
+ * (i.e. not one for each extremity).
+ * \@23:4 is a left attractor.
+ * | Generated by doxygen $doxygenversion on $date | +Return to top of page | +
| Kite - Detailed Router | +Copyright © 2008-2009 LIP6. All rights reserved | +