coriolis/deprecated/kite/doc/TrackCost.dox

131 lines
4.8 KiB
Plaintext
Raw Normal View History

// -*- C++ -*-
namespace Kite {
/*! \class TrackCost
* \brief Insertion cost of a \TrackSegment in a \Track.
*
*
* The \TrackCost is not computed by itself. It has to be build by
* whoever has created it. For example Track::getOverlapCost().
*
*
* \section secTrackCostOrdering Sorting Track costs
*
* The \TrackCost is composed of the following criterions :
* <ol>
* <li>boolean \c _infinite : infinite.
* <li>count \c _terminals : number of terminals.
* <li>length \c _delta : overlap between requested interval and
* \TrackSegment of the \Track.
* <li>length \c _deltaPerpand : length of perpandicular wiring needed to
* connect to this \Track.
* </ol>
* Criterions are listed above in decreasing lexicographical weigh order.
*
* There is also special partial ordering functor : TrackCost::CompareByDelta.
*/
/*! \function TrackCost::TrackCost ( Track* track, const Interval& interval, size_t begin, size_t end );
* \param track The track on which the cost is performed.
* \param interval The interval for which we want a cost.
* \param begin The index of the first overlaping \TrackSegment in the \Track.
* \param end The index of the last overlaping \TrackSegment in the \Track.
*
* Create a \TrackCost object. Constructor parameters cannot be changed
* after creation.
*
* \remark The cost is not computed by the constructor. It is computed afterward
* by any flavor of Track::getOverlapCost().
*/
/*! \function bool TrackCost::isInfinite () const;
* \Return The overlap include a \TrackSegment from a \GCellRoutingSet of
* higher priority, must'nt be overlaped.
*/
/*! \function bool TrackCost::isHardOverlap () const;
* \Return The overlaped \TrackSegment cannot be shrunk to create a sufficent
* free space. See the bound interval of \TrackSegmentCost.
*/
/*! \function bool TrackCost::isOverlap () const;
* \Return The overlaped \TrackSegment could be shrunk to create a suitable
* free space.
*/
/*! \function bool TrackCost::isFree () const;
* \Return There is enough free space to insert the \TrackSegment.
*/
/*! \function Track* TrackCost::getTrack () const;
* \Return The associated \Track.
*/
/*! \function const Interval& TrackCost::getInterval () const;
* \Return The interval for which we want to compute a cost.
*/
/*! \function size_t TrackCost::getBegin () const;
* \Return The index of the first overlaping \TrackSegment in \Track.
*/
/*! \function size_t TrackCost::getEnd () const;
* \Return The index of the last overlaping \TrackSegment in \Track.
*/
/*! \function unsigned int TrackCost::getTerminals () const;
* \Return The number of terminal in the interval, see TrackSegmentCost::getTerminals().
*/
/*! \function DbU::Unit TrackCost::getDelta () const;
* \Return The amount of overlaping between the interval and the \TrackSegments
* already in the \Track.
*/
/*! \function DbU::Unit TrackCost::getDeltaPerpand () const;
* \Return The amount of perpandicular wirelength needed to put the to be
* inserted \TrackSegment in this \Track.
*/
/*! \function void TrackCost::setInfinite ();
* Raise the infinite flag.
*/
/*! \function void TrackCost::setHardOverlap ();
* Raise the hard overlap flag.
*/
/*! \function void TrackCost::setOverlap ();
* Raise the soft overlap flag.
*/
/*! \function void TrackCost::incTerminals ( unsigned int number );
* \param number The number of terminal to adds.
*/
/*! \function void TrackCost::incDelta ( DbU::Unit delta );
* \param delta The amount of length to add to the overlap.
*/
/*! \function void TrackCost::incDeltaPerpand ( DbU::Unit delta );
* \param delta Increments the perpandicular delta.
*/
/*! \function bool operator< ( const TrackCost& lhs, const TrackCost& rhs );
* \param lhs the left hand side operand.
* \param rhs the right hand side operand.
* \return \true if <code>lhs < rhs</code>, 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.