PNS::DP_MEANDER_PLACER Class Reference

Differential Pair length-matching/meandering tool. More...

#include <pns_dp_meander_placer.h>

Inheritance diagram for PNS::DP_MEANDER_PLACER:

Public Types
enum	TUNING_STATUS { TOO_SHORT = 0, TOO_LONG, TUNED }
	< Result of the length tuning operation More...

Public Member Functions
	DP_MEANDER_PLACER (ROUTER *aRouter)
	~DP_MEANDER_PLACER ()
bool	Start (const VECTOR2I &aP, ITEM *aStartItem) override
	Start routing a single track at point aP, taking item aStartItem as anchor (unless NULL). More...
bool	Move (const VECTOR2I &aP, ITEM *aEndItem) override
	Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL). More...
bool	FixRoute (const VECTOR2I &aP, ITEM *aEndItem, bool aForceFinish=false) override
	Commit the currently routed track to the parent node, taking aP as the final end point and aEndItem as the final anchor (if provided). More...
bool	CommitPlacement () override
bool	AbortPlacement () override
bool	HasPlacedAnything () const override
const LINE	Trace () const
NODE *	CurrentNode (bool aLoopsRemoved=false) const override
	Return the most recent world state. More...
const ITEM_SET	Traces () override
	Function Traces() More...
const VECTOR2I &	CurrentEnd () const override
	Function CurrentEnd() More...
const std::vector< int >	CurrentNets () const override
	Function CurrentNets() More...
int	CurrentLayer () const override
	Function CurrentLayer() More...
long long int	totalLength ()
const wxString	TuningInfo (EDA_UNITS aUnits) const override
	Return a string describing the status and length of the tuned traces. More...
TUNING_STATUS	TuningStatus () const override
	Return the tuning status (too short, too long, etc.) of the trace(s) being tuned. More...
bool	CheckFit (MEANDER_SHAPE *aShape) override
	Checks if it's OK to place the shape aShape (i.e. More...
virtual void	AmplitudeStep (int aSign)
	Increase/decreases the current meandering amplitude by one step. More...
virtual void	SpacingStep (int aSign)
	Increase/decrease the current meandering spacing by one step. More...
virtual const MEANDER_SETTINGS &	MeanderSettings () const
	Return the current meandering configuration. More...
virtual void	UpdateSettings (const MEANDER_SETTINGS &aSettings)
int	GetTotalPadToDieLength (const LINE &aLine) const
virtual bool	UnfixRoute ()
virtual bool	ToggleVia (bool aEnabled)
	Function ToggleVia() More...
virtual bool	IsPlacingVia () const
	Function IsPlacingVia() More...
virtual bool	SetLayer (int aLayer)
	Function SetLayer() More...
virtual void	FlipPosture ()
	Function FlipPosture() More...
virtual void	UpdateSizes (const SIZES_SETTINGS &aSizes)
	Function UpdateSizes() More...
virtual void	SetOrthoMode (bool aOrthoMode)
	Function SetOrthoMode() More...
virtual void	GetModifiedNets (std::vector< int > &aNets) const
	Function GetModifiedNets. More...
ROUTER *	Router () const
	Return current router settings. More...
ROUTING_SETTINGS &	Settings () const
	Return the logger object, allowing to dump geometry to a file. More...
virtual LOGGER *	Logger ()
void	SetLogger (LOGGER *aLogger)
void	SetDebugDecorator (DEBUG_DECORATOR *aDecorator)
	Assign a debug decorator allowing this algo to draw extra graphics for visual debugging. More...
DEBUG_DECORATOR *	Dbg () const
const BOX2I &	VisibleViewArea () const

Protected Member Functions
void	cutTunedLine (const SHAPE_LINE_CHAIN &aOrigin, const VECTOR2I &aTuneStart, const VECTOR2I &aCursorPos, SHAPE_LINE_CHAIN &aPre, SHAPE_LINE_CHAIN &aTuned, SHAPE_LINE_CHAIN &aPost)
	Extract the part of a track to be meandered, depending on the starting point and the cursor position. More...
void	tuneLineLength (MEANDERED_LINE &aTuned, long long int aElongation)
	Take a set of meanders in aTuned and tunes their length to extend the original line length by aElongation. More...
int	compareWithTolerance (long long int aValue, long long int aExpected, long long int aTolerance=0) const
	Compare aValue against aExpected with given tolerance. More...
VECTOR2I	getSnappedStartPoint (LINKED_ITEM *aStartItem, VECTOR2I aStartPoint)
	Pointer to world to search colliding items. More...

Protected Attributes
NODE *	m_world
	Total length added by pad to die size. More...
int	m_padToDieLenth
	Width of the meandered trace(s). More...
int	m_currentWidth
	Meander settings. More...
MEANDER_SETTINGS	m_settings
	The current end point. More...
VECTOR2I	m_currentEnd
DEBUG_DECORATOR *	m_debugDecorator
ROUTER *	m_router
LOGGER *	m_logger

Private Member Functions
void	meanderSegment (const SEG &aBase)
const SEG	baselineSegment (const DIFF_PAIR::COUPLED_SEGMENTS &aCoupledSegs)
bool	pairOrientation (const DIFF_PAIR::COUPLED_SEGMENTS &aPair)
void	setWorld (NODE *aWorld)
void	release ()
long long int	origPathLength () const
	Current routing start point (end of tail, beginning of head). More...

Private Attributes
VECTOR2I	m_currentStart
	Current world state. More...
NODE *	m_currentNode
DIFF_PAIR	m_originPair
DIFF_PAIR::COUPLED_SEGMENTS_VEC	m_coupledSegments
LINE	m_currentTraceN
LINE	m_currentTraceP
ITEM_SET	m_tunedPath
ITEM_SET	m_tunedPathP
ITEM_SET	m_tunedPathN
SHAPE_LINE_CHAIN	m_finalShapeP
SHAPE_LINE_CHAIN	m_finalShapeN
MEANDERED_LINE	m_result
LINKED_ITEM *	m_initialSegment
long long int	m_lastLength
int	m_padToDieP
int	m_padToDieN
TUNING_STATUS	m_lastStatus

Friends
class	MEANDER_SHAPE

Detailed Description

Differential Pair length-matching/meandering tool.

Definition at line 48 of file pns_dp_meander_placer.h.

Member Enumeration Documentation

TUNING_STATUS

enum PNS::MEANDER_PLACER_BASE::TUNING_STATUS

inherited

< Result of the length tuning operation

Enumerator
TOO_SHORT
TOO_LONG
TUNED

Definition at line 51 of file pns_meander_placer_base.h.

                       {
        TOO_SHORT = 0,
        TOO_LONG,
        TUNED
    };

Constructor & Destructor Documentation

DP_MEANDER_PLACER()

PNS::DP_MEANDER_PLACER::DP_MEANDER_PLACER

(

ROUTER *

aRouter

)

Definition at line 36 of file pns_dp_meander_placer.cpp.

                                                      :
    MEANDER_PLACER_BASE( aRouter )
{
    m_world       = NULL;
    m_currentNode = NULL;

    m_padToDieP = 0;
    m_padToDieN = 0;

    // Init temporary variables (do not leave uninitialized members)
    m_initialSegment = NULL;
    m_lastLength     = 0;
    m_lastStatus     = TOO_SHORT;
}

References m_currentNode, m_initialSegment, m_lastLength, m_lastStatus, m_padToDieN, m_padToDieP, PNS::MEANDER_PLACER_BASE::m_world, NULL, and PNS::MEANDER_PLACER_BASE::TOO_SHORT.

~DP_MEANDER_PLACER()

PNS::DP_MEANDER_PLACER::~DP_MEANDER_PLACER

(

)

Definition at line 52 of file pns_dp_meander_placer.cpp.

{
}

Member Function Documentation

AbortPlacement()

bool PNS::DP_MEANDER_PLACER::AbortPlacement ( )

overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 319 of file pns_dp_meander_placer.cpp.

{
    m_world->KillChildren();
    return true;
}

References PNS::NODE::KillChildren(), and PNS::MEANDER_PLACER_BASE::m_world.

AmplitudeStep()

void PNS::MEANDER_PLACER_BASE::AmplitudeStep ( int  aSign )

virtualinherited

Increase/decreases the current meandering amplitude by one step.

Parameters

aSign

direction (negative = decrease, positive = increase).

Definition at line 44 of file pns_meander_placer_base.cpp.

{
    int a = m_settings.m_maxAmplitude + aSign * m_settings.m_step;
    a = std::max( a,  m_settings.m_minAmplitude );

    m_settings.m_maxAmplitude = a;
}

References PNS::MEANDER_SETTINGS::m_maxAmplitude, PNS::MEANDER_SETTINGS::m_minAmplitude, PNS::MEANDER_PLACER_BASE::m_settings, and PNS::MEANDER_SETTINGS::m_step.

baselineSegment()

const SEG PNS::DP_MEANDER_PLACER::baselineSegment ( const DIFF_PAIR::COUPLED_SEGMENTS &  aCoupledSegs )

private

Definition at line 146 of file pns_dp_meander_placer.cpp.

{
    const VECTOR2I a( ( aCoupledSegs.coupledP.A + aCoupledSegs.coupledN.A ) / 2 );
    const VECTOR2I b( ( aCoupledSegs.coupledP.B + aCoupledSegs.coupledN.B ) / 2 );

    return SEG( a, b );
}

References SEG::A, SEG::B, PNS::DIFF_PAIR::COUPLED_SEGMENTS::coupledN, and PNS::DIFF_PAIR::COUPLED_SEGMENTS::coupledP.

Referenced by Move().

CheckFit()

bool PNS::DP_MEANDER_PLACER::CheckFit ( MEANDER_SHAPE *  aShape )

overridevirtual

Checks if it's OK to place the shape aShape (i.e.

if it doesn't cause DRC violations or collide with other meanders).

Parameters

aShape

the shape to check.

Returns

true if the shape fits.

Reimplemented from PNS::MEANDER_PLACER_BASE.

Definition at line 343 of file pns_dp_meander_placer.cpp.

{
    LINE l1( m_originPair.PLine(), aShape->CLine( 0 ) );
    LINE l2( m_originPair.NLine(), aShape->CLine( 1 ) );

    if( m_currentNode->CheckColliding( &l1 ) )
        return false;

    if( m_currentNode->CheckColliding( &l2 ) )
        return false;

    int w = aShape->Width();
    int clearance = w + m_settings.m_spacing;

    return m_result.CheckSelfIntersections( aShape, clearance );
}

References PNS::NODE::CheckColliding(), PNS::MEANDERED_LINE::CheckSelfIntersections(), PNS::MEANDER_SHAPE::CLine(), m_currentNode, m_originPair, m_result, PNS::MEANDER_PLACER_BASE::m_settings, PNS::MEANDER_SETTINGS::m_spacing, PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), and PNS::MEANDER_SHAPE::Width().

CommitPlacement()

bool PNS::DP_MEANDER_PLACER::CommitPlacement ( )

overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 333 of file pns_dp_meander_placer.cpp.

{
    if( m_currentNode )
        Router()->CommitRouting( m_currentNode );

    m_currentNode = NULL;
    return true;
}

References PNS::ROUTER::CommitRouting(), m_currentNode, NULL, and PNS::ALGO_BASE::Router().

Referenced by FixRoute().

compareWithTolerance()

int PNS::MEANDER_PLACER_BASE::compareWithTolerance ( long long int  aValue, long long int  aExpected, long long int  aTolerance = 0  ) const

protectedinherited

Compare aValue against aExpected with given tolerance.

Definition at line 228 of file pns_meander_placer_base.cpp.

{
    if( aValue < aExpected - aTolerance )
        return -1;
    else if( aValue > aExpected + aTolerance )
        return 1;
    else
        return 0;
}

Referenced by PNS::MEANDER_PLACER::doMove(), and Move().

CurrentEnd()

const VECTOR2I & PNS::DP_MEANDER_PLACER::CurrentEnd ( ) const

overridevirtual

Function CurrentEnd()

Returns the current end of the line(s) being placed/tuned. It may not be equal to the cursor position due to collisions.

Implements PNS::PLACEMENT_ALGO.

Definition at line 375 of file pns_dp_meander_placer.cpp.

{
    return m_currentEnd;
}

References PNS::MEANDER_PLACER_BASE::m_currentEnd.

CurrentLayer()

int PNS::DP_MEANDER_PLACER::CurrentLayer ( ) const

overridevirtual

Function CurrentLayer()

Returns the layer of currently routed track.

Implements PNS::PLACEMENT_ALGO.

Definition at line 381 of file pns_dp_meander_placer.cpp.

{
    return m_initialSegment->Layers().Start();
}

References PNS::ITEM::Layers(), m_initialSegment, and LAYER_RANGE::Start().

CurrentNets()

const std::vector< int > PNS::DP_MEANDER_PLACER::CurrentNets ( ) const

overridevirtual

Function CurrentNets()

Returns the net code(s) of currently routed track(s).

Implements PNS::PLACEMENT_ALGO.

Definition at line 422 of file pns_dp_meander_placer.cpp.

{
    std::vector<int> rv;
    rv.push_back( m_originPair.NetP() );
    rv.push_back( m_originPair.NetN() );
    return rv;
}

References m_originPair, PNS::DIFF_PAIR::NetN(), and PNS::DIFF_PAIR::NetP().

CurrentNode()

NODE * PNS::DP_MEANDER_PLACER::CurrentNode ( bool  aLoopsRemoved = false ) const

overridevirtual

Return the most recent world state.

Implements PNS::PLACEMENT_ALGO.

Definition at line 63 of file pns_dp_meander_placer.cpp.

{
    if( !m_currentNode )
        return m_world;

    return m_currentNode;
}

References m_currentNode, and PNS::MEANDER_PLACER_BASE::m_world.

cutTunedLine()

void PNS::MEANDER_PLACER_BASE::cutTunedLine ( const SHAPE_LINE_CHAIN &  aOrigin, const VECTOR2I &  aTuneStart, const VECTOR2I &  aCursorPos, SHAPE_LINE_CHAIN &  aPre, SHAPE_LINE_CHAIN &  aTuned, SHAPE_LINE_CHAIN &  aPost  )

protectedinherited

Extract the part of a track to be meandered, depending on the starting point and the cursor position.

Parameters

aOrigin	the original line.
aTuneStart	point where we start meandering (start click coordinates).
aCursorPos	current cursor position.
aPre	part before the beginning of meanders.
aTuned	part to be meandered.
aPost	part after the end of meanders.

Definition at line 68 of file pns_meander_placer_base.cpp.

{
    VECTOR2I cp ( aCursorPos );

    if( cp == aTuneStart ) // we don't like tuning segments with 0 length
    {
        int idx = aOrigin.FindSegment( cp );

        if( idx >= 0 )
        {
            const SEG& s = aOrigin.CSegment( idx );
            cp += (s.B - s.A).Resize(2);
        }
        else
        {
            cp += VECTOR2I (2, 5); // some arbitrary value that is not 45 degrees oriented
        }
    }

    VECTOR2I n = aOrigin.NearestPoint( cp, false );
    VECTOR2I m = aOrigin.NearestPoint( aTuneStart, false );

    SHAPE_LINE_CHAIN l( aOrigin );
    l.Split( n );
    l.Split( m );

    int i_start = l.Find( m );
    int i_end = l.Find( n );

    if( i_start > i_end )
    {
        l = l.Reverse();
        i_start = l.Find( m );
        i_end = l.Find( n );
    }

    aPre = l.Slice( 0, i_start );
    aPost = l.Slice( i_end, -1 );
    aTuned = l.Slice( i_start, i_end );

    aTuned.Simplify();
}

References SEG::A, SEG::B, SHAPE_LINE_CHAIN::CSegment(), SHAPE_LINE_CHAIN::Find(), SHAPE_LINE_CHAIN::FindSegment(), SHAPE_LINE_CHAIN::NearestPoint(), SHAPE_LINE_CHAIN::Reverse(), SHAPE_LINE_CHAIN::Simplify(), SHAPE_LINE_CHAIN::Slice(), and SHAPE_LINE_CHAIN::Split().

Referenced by PNS::MEANDER_PLACER::doMove(), and Move().

Dbg()

DEBUG_DECORATOR* PNS::ALGO_BASE::Dbg ( ) const

inlineinherited

Definition at line 78 of file pns_algo_base.h.

    {
        return m_debugDecorator;
    }

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::MEANDER_PLACER::doMove(), PNS::COMPONENT_DRAGGER::Drag(), PNS::MEANDER_SKEW_PLACER::Move(), Move(), PNS::SHOVE::onCollidingArc(), PNS::SHOVE::onCollidingLine(), PNS::SHOVE::onCollidingSegment(), PNS::SHOVE::onCollidingSolid(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::SHOVE::replaceLine(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::SHOVE::runOptimizer(), PNS::SHOVE::shoveIteration(), PNS::SHOVE::ShoveLines(), PNS::SHOVE::shoveLineToHullSet(), PNS::SHOVE::ShoveObstacleLine(), PNS::WALKAROUND::singleStep(), PNS::DRAGGER::Start(), and PNS::DRAGGER::tryWalkaround().

FixRoute()

bool PNS::DP_MEANDER_PLACER::FixRoute ( const VECTOR2I &  aP, ITEM *  aEndItem, bool  aForceFinish = false  )

overridevirtual

Commit the currently routed track to the parent node, taking aP as the final end point and aEndItem as the final anchor (if provided).

Returns

true if route has been committed. May return false if the routing result is violating design rules. In such cases, the track is only committed if Settings.CanViolateDRC() is on.

Implements PNS::PLACEMENT_ALGO.

Definition at line 305 of file pns_dp_meander_placer.cpp.

{
    LINE lP( m_originPair.PLine(), m_finalShapeP );
    LINE lN( m_originPair.NLine(), m_finalShapeN );

    m_currentNode->Add( lP );
    m_currentNode->Add( lN );

    CommitPlacement();

    return true;
}

References PNS::NODE::Add(), CommitPlacement(), m_currentNode, m_finalShapeN, m_finalShapeP, m_originPair, PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

FlipPosture()

virtual void PNS::PLACEMENT_ALGO::FlipPosture ( )

inlinevirtualinherited

Function FlipPosture()

Toggles the current posture (straight/diagonal) of the trace head.

Reimplemented in PNS::LINE_PLACER, and PNS::DIFF_PAIR_PLACER.

Definition at line 160 of file pns_placement_algo.h.

    {
    }

GetModifiedNets()

virtual void PNS::PLACEMENT_ALGO::GetModifiedNets ( std::vector< int > &  aNets ) const

inlinevirtualinherited

Function GetModifiedNets.

Returns the net codes of all currently routed trace(s)

Reimplemented in PNS::LINE_PLACER, and PNS::DIFF_PAIR_PLACER.

Definition at line 191 of file pns_placement_algo.h.

    {
    }

getSnappedStartPoint()

VECTOR2I PNS::MEANDER_PLACER_BASE::getSnappedStartPoint ( LINKED_ITEM *  aStartItem, VECTOR2I  aStartPoint  )

protectedinherited

Pointer to world to search colliding items.

Definition at line 240 of file pns_meander_placer_base.cpp.

{
    if( aStartItem->Kind() == ITEM::SEGMENT_T )
    {
        return static_cast<SEGMENT*>( aStartItem )->Seg().NearestPoint( aStartPoint );
    }
    else
    {
        wxASSERT( aStartItem->Kind() == ITEM::ARC_T );
        ARC* arc = static_cast<ARC*>( aStartItem );

        if( ( VECTOR2I( arc->Anchor( 0 ) - aStartPoint ) ).SquaredEuclideanNorm() <=
            ( VECTOR2I( arc->Anchor( 1 ) - aStartPoint ) ).SquaredEuclideanNorm() )
        {
            return arc->Anchor( 0 );
        }
        else
        {
            return arc->Anchor( 1 );
        }
    }
}

References PNS::ITEM::ARC_T, PNS::ITEM::Kind(), and PNS::ITEM::SEGMENT_T.

Referenced by PNS::MEANDER_SKEW_PLACER::Start(), PNS::MEANDER_PLACER::Start(), and Start().

GetTotalPadToDieLength()

int PNS::MEANDER_PLACER_BASE::GetTotalPadToDieLength ( const LINE &  aLine ) const

inherited

Definition at line 184 of file pns_meander_placer_base.cpp.

{
    int   length = 0;
    JOINT start;
    JOINT end;

    m_world->FindLineEnds( aLine, start, end );

    // Extract the length of the pad to die for start and end pads
    for( auto& link : start.LinkList() )
    {
        if( const SOLID* solid = dynamic_cast<const SOLID*>( link.item ) )
        {
            // If there are overlapping pads, choose the first with a non-zero length
            if( solid->GetPadToDie() > 0 )
            {
                length += solid->GetPadToDie();
                break;
            }
        }
    }

    for( auto& link : end.LinkList() )
    {
        if( const SOLID* solid = dynamic_cast<const SOLID*>( link.item ) )
        {
            if( solid->GetPadToDie() > 0 )
            {
                length += solid->GetPadToDie();
                break;
            }
        }
    }

    return length;
}

References PNS::NODE::FindLineEnds(), PNS::JOINT::LinkList(), and PNS::MEANDER_PLACER_BASE::m_world.

Referenced by PNS::MEANDER_SKEW_PLACER::Start(), PNS::MEANDER_PLACER::Start(), and Start().

HasPlacedAnything()

bool PNS::DP_MEANDER_PLACER::HasPlacedAnything ( ) const

overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 326 of file pns_dp_meander_placer.cpp.

{
     return m_originPair.CP().SegmentCount() > 0 ||
             m_originPair.CN().SegmentCount() > 0;
}

References PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), m_originPair, and SHAPE_LINE_CHAIN::SegmentCount().

IsPlacingVia()

virtual bool PNS::PLACEMENT_ALGO::IsPlacingVia ( ) const

inlinevirtualinherited

Function IsPlacingVia()

Returns true if the placer is placing a via (or more vias).

Reimplemented in PNS::LINE_PLACER, and PNS::DIFF_PAIR_PLACER.

Definition at line 104 of file pns_placement_algo.h.

    {
        return false;
    }

Logger()

LOGGER * PNS::ALGO_BASE::Logger ( )

virtualinherited

Reimplemented in PNS::SHOVE.

Definition at line 34 of file pns_algo_base.cpp.

{
    return NULL;
}

References NULL.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::DRAGGER::Start(), and PNS::DRAGGER::tryWalkaround().

meanderSegment()

void PNS::DP_MEANDER_PLACER::meanderSegment ( const SEG &  aBase )

private

MeanderSettings()

const MEANDER_SETTINGS & PNS::MEANDER_PLACER_BASE::MeanderSettings ( ) const

virtualinherited

Return the current meandering configuration.

Returns

the settings

Definition at line 222 of file pns_meander_placer_base.cpp.

{
    return m_settings;
}

References PNS::MEANDER_PLACER_BASE::m_settings.

Referenced by PNS::MEANDER_SHAPE::makeMiterShape(), LENGTH_TUNER_TOOL::meanderSettingsDialog(), PNS::MEANDER_SHAPE::Settings(), and PNS::MEANDERED_LINE::Settings().

Move()

bool PNS::DP_MEANDER_PLACER::Move ( const VECTOR2I &  aP, ITEM *  aEndItem  )

overridevirtual

Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL).

Implements PNS::PLACEMENT_ALGO.

Definition at line 165 of file pns_dp_meander_placer.cpp.

{
//    return false;

    DIFF_PAIR::COUPLED_SEGMENTS_VEC coupledSegments;

    if( m_currentNode )
        delete m_currentNode;

    m_currentNode = m_world->Branch();

    SHAPE_LINE_CHAIN preP, tunedP, postP;
    SHAPE_LINE_CHAIN preN, tunedN, postN;

    cutTunedLine( m_originPair.CP(), m_currentStart, aP, preP, tunedP, postP );
    cutTunedLine( m_originPair.CN(), m_currentStart, aP, preN, tunedN, postN );

    DIFF_PAIR tuned( m_originPair );

    tuned.SetShape( tunedP, tunedN );

    tuned.CoupledSegmentPairs( coupledSegments );

    if( coupledSegments.size() == 0 )
        return false;

    //Router()->DisplayDebugLine( tuned.CP(), 5, 20000 );
    //Router()->DisplayDebugLine( tuned.CN(), 4, 20000 );

    //Router()->DisplayDebugLine( m_originPair.CP(), 5, 20000 );
    //Router()->DisplayDebugLine( m_originPair.CN(), 4, 20000 );

    m_result = MEANDERED_LINE( this, true );
    m_result.SetWidth( tuned.Width() );

    int offset = ( tuned.Gap() + tuned.Width() ) / 2;

    if( pairOrientation( coupledSegments[0] ) )
        offset *= -1;

    m_result.SetBaselineOffset( offset );

    for( const ITEM* item : m_tunedPathP.CItems() )
    {
        if( const LINE* l = dyn_cast<const LINE*>( item ) )
            Dbg()->AddLine( l->CLine(), 5, 10000 );
    }

    for( const ITEM* item : m_tunedPathN.CItems() )
    {
        if( const LINE* l = dyn_cast<const LINE*>( item ) )
            Dbg()->AddLine( l->CLine(), 5, 10000 );
    }

    int curIndexP = 0, curIndexN = 0;

    for( const DIFF_PAIR::COUPLED_SEGMENTS& sp : coupledSegments )
    {
        SEG base = baselineSegment( sp );

        Dbg()->AddSegment( base, 3 );

        while( sp.indexP >= curIndexP )
        {
            m_result.AddCorner( tunedP.CPoint( curIndexP ), tunedN.CPoint( curIndexN ) );
            curIndexP++;
        }

        while( sp.indexN >= curIndexN )
        {
            m_result.AddCorner( tunedP.CPoint( sp.indexP ), tunedN.CPoint( curIndexN ) );
            curIndexN++;
        }

        m_result.MeanderSegment( base );
    }

    while( curIndexP < tunedP.PointCount() )
        m_result.AddCorner( tunedP.CPoint( curIndexP++ ), tunedN.CPoint( curIndexN ) );

    while( curIndexN < tunedN.PointCount() )
        m_result.AddCorner( tunedP.CPoint( -1 ), tunedN.CPoint( curIndexN++ ) );

    long long int dpLen = origPathLength();

    m_lastStatus = TUNED;

    if( dpLen - m_settings.m_targetLength > m_settings.m_lengthTolerance )
    {
        m_lastStatus = TOO_LONG;
        m_lastLength = dpLen;
    }
    else
    {
        m_lastLength = dpLen - std::max( tunedP.Length(), tunedN.Length() );
        tuneLineLength( m_result, m_settings.m_targetLength - dpLen );
    }

    if( m_lastStatus != TOO_LONG )
    {
        tunedP.Clear();
        tunedN.Clear();

        for( MEANDER_SHAPE* m : m_result.Meanders() )
        {
            if( m->Type() != MT_EMPTY )
            {
                tunedP.Append( m->CLine( 0 ) );
                tunedN.Append( m->CLine( 1 ) );
            }
        }

        m_lastLength += std::max( tunedP.Length(), tunedN.Length() );

        int comp = compareWithTolerance( m_lastLength - m_settings.m_targetLength, 0, m_settings.m_lengthTolerance );

        if( comp > 0 )
            m_lastStatus = TOO_LONG;
        else if( comp < 0 )
            m_lastStatus = TOO_SHORT;
        else
            m_lastStatus = TUNED;
    }

    m_finalShapeP.Clear();
    m_finalShapeP.Append( preP );
    m_finalShapeP.Append( tunedP );
    m_finalShapeP.Append( postP );
    m_finalShapeP.Simplify();

    m_finalShapeN.Clear();
    m_finalShapeN.Append( preN );
    m_finalShapeN.Append( tunedN );
    m_finalShapeN.Append( postN );
    m_finalShapeN.Simplify();

    return true;
}

References PNS::MEANDERED_LINE::AddCorner(), PNS::DEBUG_DECORATOR::AddLine(), PNS::DEBUG_DECORATOR::AddSegment(), SHAPE_LINE_CHAIN::Append(), baselineSegment(), PNS::NODE::Branch(), PNS::ITEM_SET::CItems(), SHAPE_LINE_CHAIN::Clear(), PNS::DIFF_PAIR::CN(), PNS::MEANDER_PLACER_BASE::compareWithTolerance(), PNS::DIFF_PAIR::CP(), PNS::MEANDER_PLACER_BASE::cutTunedLine(), PNS::ALGO_BASE::Dbg(), m_currentNode, m_currentStart, m_finalShapeN, m_finalShapeP, m_lastLength, m_lastStatus, PNS::MEANDER_SETTINGS::m_lengthTolerance, m_originPair, m_result, PNS::MEANDER_PLACER_BASE::m_settings, PNS::MEANDER_SETTINGS::m_targetLength, m_tunedPathN, m_tunedPathP, PNS::MEANDER_PLACER_BASE::m_world, PNS::MEANDERED_LINE::Meanders(), PNS::MEANDERED_LINE::MeanderSegment(), PNS::MT_EMPTY, origPathLength(), pairOrientation(), PNS::MEANDERED_LINE::SetBaselineOffset(), PNS::MEANDERED_LINE::SetWidth(), SHAPE_LINE_CHAIN::Simplify(), PNS::MEANDER_PLACER_BASE::TOO_LONG, PNS::MEANDER_PLACER_BASE::TOO_SHORT, PNS::MEANDER_PLACER_BASE::TUNED, and PNS::MEANDER_PLACER_BASE::tuneLineLength().

origPathLength()

long long int PNS::DP_MEANDER_PLACER::origPathLength ( ) const

private

Current routing start point (end of tail, beginning of head).

Definition at line 124 of file pns_dp_meander_placer.cpp.

{
    long long int totalP = m_padToDieLenth;
    long long int totalN = m_padToDieLenth;

    for( const ITEM* item : m_tunedPathP.CItems() )
    {
        if( const LINE* l = dyn_cast<const LINE*>( item ) )
            totalP += l->CLine().Length();

    }

    for( const ITEM* item : m_tunedPathN.CItems() )
    {
        if( const LINE* l = dyn_cast<const LINE*>( item ) )
            totalN += l->CLine().Length();
    }

    return std::max( totalP, totalN );
}

References PNS::ITEM_SET::CItems(), PNS::MEANDER_PLACER_BASE::m_padToDieLenth, m_tunedPathN, and m_tunedPathP.

Referenced by Move().

pairOrientation()

bool PNS::DP_MEANDER_PLACER::pairOrientation ( const DIFF_PAIR::COUPLED_SEGMENTS &  aPair )

private

Definition at line 155 of file pns_dp_meander_placer.cpp.

{
    VECTOR2I midp = ( aPair.coupledP.A + aPair.coupledN.A ) / 2;

    //DrawDebugPoint(midp, 6);

    return aPair.coupledP.Side( midp ) > 0;
}

References SEG::A, PNS::DIFF_PAIR::COUPLED_SEGMENTS::coupledN, PNS::DIFF_PAIR::COUPLED_SEGMENTS::coupledP, and SEG::Side().

Referenced by Move().

release()

void PNS::DP_MEANDER_PLACER::release ( )

private

Definition at line 119 of file pns_dp_meander_placer.cpp.

{
}

Router()

ROUTER* PNS::ALGO_BASE::Router ( ) const

inlineinherited

Return current router settings.

Definition at line 54 of file pns_algo_base.h.

References PNS::ALGO_BASE::m_router.

Referenced by PNS::DIFF_PAIR_PLACER::attemptWalk(), PNS::MEANDER_PLACER::CommitPlacement(), CommitPlacement(), PNS::DIFF_PAIR_PLACER::CommitPlacement(), PNS::LINE_PLACER::CommitPlacement(), PNS::COMPONENT_DRAGGER::FixRoute(), PNS::DRAGGER::FixRoute(), PNS::DIFF_PAIR_PLACER::initPlacement(), PNS::LINE_PLACER::initPlacement(), PNS::SHOVE::onCollidingSolid(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::MEANDER_SKEW_PLACER::Start(), PNS::MEANDER_PLACER::Start(), Start(), PNS::DRAGGER::Start(), PNS::DIFF_PAIR_PLACER::Start(), and PNS::DRAGGER::tryWalkaround().

SetDebugDecorator()

void PNS::ALGO_BASE::SetDebugDecorator ( DEBUG_DECORATOR *  aDecorator )

inlineinherited

Assign a debug decorator allowing this algo to draw extra graphics for visual debugging.

Definition at line 73 of file pns_algo_base.h.

    {
        m_debugDecorator = aDecorator;
    }

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::SHOVE::SHOVE(), and PNS::DRAGGER::tryWalkaround().

SetLayer()

virtual bool PNS::PLACEMENT_ALGO::SetLayer ( int  aLayer )

inlinevirtualinherited

Function SetLayer()

Sets the current routing layer.

Reimplemented in PNS::LINE_PLACER, and PNS::DIFF_PAIR_PLACER.

Definition at line 114 of file pns_placement_algo.h.

    {
        return false;
    }

SetLogger()

void PNS::ALGO_BASE::SetLogger ( LOGGER *  aLogger )

inlineinherited

Definition at line 65 of file pns_algo_base.h.

    {
        m_logger = aLogger;
    }

References PNS::ALGO_BASE::m_logger.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), and PNS::DRAGGER::tryWalkaround().

SetOrthoMode()

virtual void PNS::PLACEMENT_ALGO::SetOrthoMode ( bool  aOrthoMode )

inlinevirtualinherited

Function SetOrthoMode()

Forces the router to place a straight 90/45 degree trace (with the end as near to the cursor as possible) instead of a standard 135 degree two-segment bend.

Reimplemented in PNS::LINE_PLACER, and PNS::DIFF_PAIR_PLACER.

Definition at line 182 of file pns_placement_algo.h.

    {
    }

Settings()

ROUTING_SETTINGS & PNS::ALGO_BASE::Settings ( ) const

inherited

Return the logger object, allowing to dump geometry to a file.

Definition at line 28 of file pns_algo_base.cpp.

{
    return m_router->Settings();
}

References PNS::ALGO_BASE::m_router, and PNS::ROUTER::Settings().

Referenced by PNS::DIFF_PAIR_PLACER::attemptWalk(), PNS::LINE_PLACER::buildInitialLine(), PNS::DRAGGER::dragMarkObstacles(), PNS::DRAGGER::dragShove(), PNS::DRAGGER::dragWalkaround(), PNS::COMPONENT_DRAGGER::FixRoute(), PNS::DRAGGER::FixRoute(), PNS::DIFF_PAIR_PLACER::FixRoute(), PNS::LINE_PLACER::FixRoute(), PNS::DIFF_PAIR_PLACER::initPlacement(), PNS::LINE_PLACER::initPlacement(), PNS::LINE_PLACER::Move(), PNS::SHOVE::onCollidingSolid(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::LINE_PLACER::rhMarkObstacles(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::LINE_PLACER::routeStep(), PNS::SHOVE::runOptimizer(), PNS::SHOVE::shoveMainLoop(), PNS::DRAGGER::Start(), PNS::LINE_PLACER::Start(), and PNS::DRAGGER::tryWalkaround().

setWorld()

void PNS::DP_MEANDER_PLACER::setWorld ( NODE *  aWorld )

private

SpacingStep()

void PNS::MEANDER_PLACER_BASE::SpacingStep ( int  aSign )

virtualinherited

Increase/decrease the current meandering spacing by one step.

Parameters

aSign

direction (negative = decrease, positive = increase).

Definition at line 53 of file pns_meander_placer_base.cpp.

{
    int s = m_settings.m_spacing + aSign * m_settings.m_step;
    s = std::max( s, 2 * m_currentWidth );

    m_settings.m_spacing = s;
}

References PNS::MEANDER_PLACER_BASE::m_currentWidth, PNS::MEANDER_PLACER_BASE::m_settings, PNS::MEANDER_SETTINGS::m_spacing, and PNS::MEANDER_SETTINGS::m_step.

Start()

bool PNS::DP_MEANDER_PLACER::Start ( const VECTOR2I &  aP, ITEM *  aStartItem  )

overridevirtual

Start routing a single track at point aP, taking item aStartItem as anchor (unless NULL).

Implements PNS::PLACEMENT_ALGO.

Definition at line 72 of file pns_dp_meander_placer.cpp.

{
    if( !aStartItem || !aStartItem->OfKind( ITEM::SEGMENT_T | ITEM::ARC_T ) )
    {
        Router()->SetFailureReason( _( "Please select a track whose length you want to tune." ) );
        return false;
    }

    m_initialSegment = static_cast<LINKED_ITEM*>( aStartItem );
    m_currentNode    = nullptr;
    m_currentStart   = getSnappedStartPoint( m_initialSegment, aP );

    m_world = Router()->GetWorld()->Branch();

    TOPOLOGY topo( m_world );

    if( !topo.AssembleDiffPair( m_initialSegment, m_originPair ) )
    {
        Router()->SetFailureReason( _( "Unable to find complementary differential pair "
                                       "net for length tuning. Make sure the names of the nets belonging "
                                       "to a differential pair end with either _N/_P or +/-." ) );
        return false;
    }

    if( m_originPair.Gap() < 0 )
        m_originPair.SetGap( Router()->Sizes().DiffPairGap() );

    if( !m_originPair.PLine().SegmentCount() ||
        !m_originPair.NLine().SegmentCount() )
        return false;

    m_tunedPathP = topo.AssembleTrivialPath( m_originPair.PLine().GetLink( 0 ) );
    m_tunedPathN = topo.AssembleTrivialPath( m_originPair.NLine().GetLink( 0 ) );

    m_padToDieP = GetTotalPadToDieLength( m_originPair.PLine() );
    m_padToDieN = GetTotalPadToDieLength( m_originPair.NLine() );
    m_padToDieLenth = std::max( m_padToDieP, m_padToDieN );

    m_world->Remove( m_originPair.PLine() );
    m_world->Remove( m_originPair.NLine() );

    m_currentWidth = m_originPair.Width();

    return true;
}

References _, PNS::ITEM::ARC_T, PNS::TOPOLOGY::AssembleDiffPair(), PNS::TOPOLOGY::AssembleTrivialPath(), PNS::NODE::Branch(), PNS::DIFF_PAIR::Gap(), PNS::LINK_HOLDER::GetLink(), PNS::MEANDER_PLACER_BASE::getSnappedStartPoint(), PNS::MEANDER_PLACER_BASE::GetTotalPadToDieLength(), PNS::ROUTER::GetWorld(), m_currentNode, m_currentStart, PNS::MEANDER_PLACER_BASE::m_currentWidth, m_initialSegment, m_originPair, PNS::MEANDER_PLACER_BASE::m_padToDieLenth, m_padToDieN, m_padToDieP, m_tunedPathN, m_tunedPathP, PNS::MEANDER_PLACER_BASE::m_world, PNS::DIFF_PAIR::NLine(), PNS::ITEM::OfKind(), PNS::DIFF_PAIR::PLine(), PNS::NODE::Remove(), PNS::ALGO_BASE::Router(), PNS::ITEM::SEGMENT_T, PNS::LINE::SegmentCount(), PNS::ROUTER::SetFailureReason(), PNS::DIFF_PAIR::SetGap(), and PNS::DIFF_PAIR::Width().

ToggleVia()

virtual bool PNS::PLACEMENT_ALGO::ToggleVia ( bool  aEnabled )

inlinevirtualinherited

Function ToggleVia()

Enables/disables a via at the end of currently routed trace.

Reimplemented in PNS::LINE_PLACER, and PNS::DIFF_PAIR_PLACER.

Definition at line 94 of file pns_placement_algo.h.

    {
        return false;
    }

totalLength()

long long int PNS::DP_MEANDER_PLACER::totalLength

(

)

Trace()

const LINE PNS::DP_MEANDER_PLACER::Trace

(

)

const

Definition at line 57 of file pns_dp_meander_placer.cpp.

{
    return m_currentTraceP;
}

References m_currentTraceP.

Traces()

const ITEM_SET PNS::DP_MEANDER_PLACER::Traces ( )

overridevirtual

Function Traces()

Returns all routed/tuned traces.

Implements PNS::PLACEMENT_ALGO.

Definition at line 361 of file pns_dp_meander_placer.cpp.

{
    m_currentTraceP = LINE( m_originPair.PLine(), m_finalShapeP );
    m_currentTraceN = LINE( m_originPair.NLine(), m_finalShapeN );

    ITEM_SET traces;

    traces.Add( &m_currentTraceP );
    traces.Add( &m_currentTraceN );

    return traces;
}

References PNS::ITEM_SET::Add(), m_currentTraceN, m_currentTraceP, m_finalShapeN, m_finalShapeP, m_originPair, PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

tuneLineLength()

void PNS::MEANDER_PLACER_BASE::tuneLineLength ( MEANDERED_LINE &  aTuned, long long int  aElongation  )

protectedinherited

Take a set of meanders in aTuned and tunes their length to extend the original line length by aElongation.

Definition at line 114 of file pns_meander_placer_base.cpp.

{
    long long int remaining = aElongation;
    bool finished = false;

    for( MEANDER_SHAPE* m : aTuned.Meanders() )
    {
        if( m->Type() != MT_CORNER )
        {
            if( remaining >= 0 )
                remaining -= m->MaxTunableLength() - m->BaselineLength();

            if( remaining < 0 )
            {
                if( !finished )
                {
                    MEANDER_TYPE newType;

                    if( m->Type() == MT_START || m->Type() == MT_SINGLE )
                        newType = MT_SINGLE;
                    else
                        newType = MT_FINISH;

                    m->SetType( newType );
                    m->Recalculate();

                    finished = true;
                }
                else
                {
                    m->MakeEmpty();
                }
            }
        }
    }

    remaining = aElongation;
    int meanderCount = 0;

    for( MEANDER_SHAPE* m : aTuned.Meanders() )
    {
        if( m->Type() != MT_CORNER && m->Type() != MT_EMPTY )
        {
            if(remaining >= 0)
            {
                remaining -= m->MaxTunableLength() - m->BaselineLength();
                meanderCount ++;
            }
        }
    }

    long long int balance = 0;

    if( meanderCount )
        balance = -remaining / meanderCount;

    if( balance >= 0 )
    {
        for( MEANDER_SHAPE* m : aTuned.Meanders() )
        {
            if( m->Type() != MT_CORNER && m->Type() != MT_EMPTY )
            {
                m->Resize( std::max( m->Amplitude() - balance / 2,
                           (long long int) m_settings.m_minAmplitude ) );
            }
        }
    }
}

References PNS::MEANDER_SETTINGS::m_minAmplitude, PNS::MEANDER_PLACER_BASE::m_settings, PNS::MEANDERED_LINE::Meanders(), PNS::MT_CORNER, PNS::MT_EMPTY, PNS::MT_FINISH, PNS::MT_SINGLE, and PNS::MT_START.

Referenced by PNS::MEANDER_PLACER::doMove(), and Move().

TuningInfo()

const wxString PNS::DP_MEANDER_PLACER::TuningInfo ( EDA_UNITS  aUnits ) const

overridevirtual

Return a string describing the status and length of the tuned traces.

Implements PNS::MEANDER_PLACER_BASE.

Definition at line 387 of file pns_dp_meander_placer.cpp.

{
    wxString status;

    switch( m_lastStatus )
    {
    case TOO_LONG:
        status = _( "Too long: " );
        break;
    case TOO_SHORT:
        status = _("Too short: " );
        break;
    case TUNED:
        status = _( "Tuned: " );
        break;
    default:
        return _( "?" );
    }

    status += ::MessageTextFromValue( aUnits, m_lastLength );
    status += "/";
    status += ::MessageTextFromValue( aUnits, m_settings.m_targetLength );
    status += " (gap: ";
    status += ::MessageTextFromValue( aUnits, m_originPair.Gap() );
    status += ")";

    return status;
}

References _, PNS::DIFF_PAIR::Gap(), m_lastLength, m_lastStatus, m_originPair, PNS::MEANDER_PLACER_BASE::m_settings, PNS::MEANDER_SETTINGS::m_targetLength, MessageTextFromValue(), PNS::MEANDER_PLACER_BASE::TOO_LONG, PNS::MEANDER_PLACER_BASE::TOO_SHORT, and PNS::MEANDER_PLACER_BASE::TUNED.

TuningStatus()

DP_MEANDER_PLACER::TUNING_STATUS PNS::DP_MEANDER_PLACER::TuningStatus ( ) const

overridevirtual

Return the tuning status (too short, too long, etc.) of the trace(s) being tuned.

Implements PNS::MEANDER_PLACER_BASE.

Definition at line 417 of file pns_dp_meander_placer.cpp.

{
    return m_lastStatus;
}

References m_lastStatus.

UnfixRoute()

virtual bool PNS::PLACEMENT_ALGO::UnfixRoute ( )

inlinevirtualinherited

Reimplemented in PNS::LINE_PLACER.

Definition at line 81 of file pns_placement_algo.h.

{ return false; };

UpdateSettings()

void PNS::MEANDER_PLACER_BASE::UpdateSettings ( const MEANDER_SETTINGS &  aSettings )

virtualinherited

Definition at line 62 of file pns_meander_placer_base.cpp.

{
    m_settings = aSettings;
}

References PNS::MEANDER_PLACER_BASE::m_settings.

Referenced by LENGTH_TUNER_TOOL::meanderSettingsDialog().

UpdateSizes()

virtual void PNS::PLACEMENT_ALGO::UpdateSizes ( const SIZES_SETTINGS &  aSizes )

inlinevirtualinherited

Function UpdateSizes()

Performs on-the-fly update of the width, via diameter & drill size from a settings class. Used to dynamically change these parameters as the track is routed.

Reimplemented in PNS::LINE_PLACER, and PNS::DIFF_PAIR_PLACER.

Definition at line 171 of file pns_placement_algo.h.

    {
    }

VisibleViewArea()

const BOX2I & PNS::ALGO_BASE::VisibleViewArea ( ) const

inherited

Definition at line 39 of file pns_algo_base.cpp.

{
    auto bb = m_router->VisibleViewArea();
    return m_router->VisibleViewArea();
}

References PNS::ALGO_BASE::m_router, and PNS::ROUTER::VisibleViewArea().

Referenced by PNS::SHOVE::runOptimizer().

Friends And Related Function Documentation

MEANDER_SHAPE

friend class MEANDER_SHAPE

friend

Definition at line 110 of file pns_dp_meander_placer.h.

Member Data Documentation

m_coupledSegments

DIFF_PAIR::COUPLED_SEGMENTS_VEC PNS::DP_MEANDER_PLACER::m_coupledSegments

private

Definition at line 132 of file pns_dp_meander_placer.h.

m_currentEnd

VECTOR2I PNS::MEANDER_PLACER_BASE::m_currentEnd

protectedinherited

Definition at line 155 of file pns_meander_placer_base.h.

Referenced by PNS::MEANDER_PLACER::CurrentEnd(), CurrentEnd(), PNS::MEANDER_SKEW_PLACER::Start(), and PNS::MEANDER_PLACER::Start().

m_currentNode

NODE* PNS::DP_MEANDER_PLACER::m_currentNode

private

Definition at line 129 of file pns_dp_meander_placer.h.

Referenced by CheckFit(), CommitPlacement(), CurrentNode(), DP_MEANDER_PLACER(), FixRoute(), Move(), and Start().

m_currentStart

VECTOR2I PNS::DP_MEANDER_PLACER::m_currentStart

private

Current world state.

Definition at line 126 of file pns_dp_meander_placer.h.

Referenced by Move(), and Start().

m_currentTraceN

LINE PNS::DP_MEANDER_PLACER::m_currentTraceN

private

Definition at line 134 of file pns_dp_meander_placer.h.

Referenced by Traces().

m_currentTraceP

LINE PNS::DP_MEANDER_PLACER::m_currentTraceP

private

Definition at line 134 of file pns_dp_meander_placer.h.

Referenced by Trace(), and Traces().

m_currentWidth

int PNS::MEANDER_PLACER_BASE::m_currentWidth

protectedinherited

Meander settings.

Definition at line 149 of file pns_meander_placer_base.h.

Referenced by PNS::MEANDER_PLACER_BASE::MEANDER_PLACER_BASE(), PNS::MEANDER_PLACER_BASE::SpacingStep(), PNS::MEANDER_SKEW_PLACER::Start(), PNS::MEANDER_PLACER::Start(), and Start().

m_debugDecorator

DEBUG_DECORATOR* PNS::ALGO_BASE::m_debugDecorator

protectedinherited

Definition at line 86 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::Dbg(), and PNS::ALGO_BASE::SetDebugDecorator().

m_finalShapeN

SHAPE_LINE_CHAIN PNS::DP_MEANDER_PLACER::m_finalShapeN

private

Definition at line 137 of file pns_dp_meander_placer.h.

Referenced by FixRoute(), Move(), and Traces().

m_finalShapeP

SHAPE_LINE_CHAIN PNS::DP_MEANDER_PLACER::m_finalShapeP

private

Definition at line 137 of file pns_dp_meander_placer.h.

Referenced by FixRoute(), Move(), and Traces().

m_initialSegment

LINKED_ITEM* PNS::DP_MEANDER_PLACER::m_initialSegment

private

Definition at line 139 of file pns_dp_meander_placer.h.

Referenced by CurrentLayer(), DP_MEANDER_PLACER(), and Start().

m_lastLength

long long int PNS::DP_MEANDER_PLACER::m_lastLength

private

Definition at line 141 of file pns_dp_meander_placer.h.

Referenced by DP_MEANDER_PLACER(), Move(), and TuningInfo().

m_lastStatus

TUNING_STATUS PNS::DP_MEANDER_PLACER::m_lastStatus

private

Definition at line 144 of file pns_dp_meander_placer.h.

Referenced by DP_MEANDER_PLACER(), Move(), TuningInfo(), and TuningStatus().

m_logger

LOGGER* PNS::ALGO_BASE::m_logger

protectedinherited

Definition at line 88 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::SetLogger(), and PNS::WALKAROUND::singleStep().

m_originPair

DIFF_PAIR PNS::DP_MEANDER_PLACER::m_originPair

private

Definition at line 131 of file pns_dp_meander_placer.h.

Referenced by CheckFit(), CurrentNets(), FixRoute(), HasPlacedAnything(), Move(), Start(), Traces(), and TuningInfo().

m_padToDieLenth

int PNS::MEANDER_PLACER_BASE::m_padToDieLenth

protectedinherited

Width of the meandered trace(s).

Definition at line 146 of file pns_meander_placer_base.h.

Referenced by PNS::MEANDER_SKEW_PLACER::itemsetLength(), PNS::MEANDER_PLACER_BASE::MEANDER_PLACER_BASE(), PNS::MEANDER_PLACER::origPathLength(), origPathLength(), PNS::MEANDER_SKEW_PLACER::Start(), PNS::MEANDER_PLACER::Start(), and Start().

m_padToDieN

int PNS::DP_MEANDER_PLACER::m_padToDieN

private

Definition at line 143 of file pns_dp_meander_placer.h.

Referenced by DP_MEANDER_PLACER(), and Start().

m_padToDieP

int PNS::DP_MEANDER_PLACER::m_padToDieP

private

Definition at line 142 of file pns_dp_meander_placer.h.

Referenced by DP_MEANDER_PLACER(), and Start().

m_result

MEANDERED_LINE PNS::DP_MEANDER_PLACER::m_result

private

Definition at line 138 of file pns_dp_meander_placer.h.

Referenced by CheckFit(), and Move().

m_router

ROUTER* PNS::ALGO_BASE::m_router

protectedinherited

Definition at line 87 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::Router(), PNS::ALGO_BASE::Settings(), PNS::DIFF_PAIR_PLACER::updateLeadingRatLine(), PNS::LINE_PLACER::updateLeadingRatLine(), and PNS::ALGO_BASE::VisibleViewArea().

m_settings

MEANDER_SETTINGS PNS::MEANDER_PLACER_BASE::m_settings

protectedinherited

The current end point.

Definition at line 152 of file pns_meander_placer_base.h.

Referenced by PNS::MEANDER_PLACER_BASE::AmplitudeStep(), PNS::MEANDER_PLACER::CheckFit(), CheckFit(), PNS::MEANDER_PLACER::doMove(), PNS::MEANDER_PLACER_BASE::MeanderSettings(), PNS::MEANDER_SKEW_PLACER::Move(), PNS::MEANDER_PLACER::Move(), Move(), PNS::MEANDER_PLACER_BASE::SpacingStep(), PNS::MEANDER_PLACER_BASE::tuneLineLength(), PNS::MEANDER_SKEW_PLACER::TuningInfo(), PNS::MEANDER_PLACER::TuningInfo(), TuningInfo(), and PNS::MEANDER_PLACER_BASE::UpdateSettings().

m_tunedPath

ITEM_SET PNS::DP_MEANDER_PLACER::m_tunedPath

private

Definition at line 135 of file pns_dp_meander_placer.h.

m_tunedPathN

ITEM_SET PNS::DP_MEANDER_PLACER::m_tunedPathN

private

Definition at line 135 of file pns_dp_meander_placer.h.

Referenced by Move(), origPathLength(), and Start().

m_tunedPathP

ITEM_SET PNS::DP_MEANDER_PLACER::m_tunedPathP

private

Definition at line 135 of file pns_dp_meander_placer.h.

Referenced by Move(), origPathLength(), and Start().

m_world

NODE* PNS::MEANDER_PLACER_BASE::m_world

protectedinherited

Total length added by pad to die size.

Definition at line 143 of file pns_meander_placer_base.h.

Referenced by PNS::MEANDER_PLACER::AbortPlacement(), AbortPlacement(), PNS::MEANDER_PLACER::CurrentNode(), CurrentNode(), PNS::MEANDER_PLACER::doMove(), DP_MEANDER_PLACER(), PNS::MEANDER_PLACER_BASE::GetTotalPadToDieLength(), PNS::MEANDER_PLACER_BASE::MEANDER_PLACER_BASE(), Move(), PNS::MEANDER_SKEW_PLACER::Start(), PNS::MEANDER_PLACER::Start(), and Start().

---

The documentation for this class was generated from the following files:

• pns_dp_meander_placer.h
• pns_dp_meander_placer.cpp