KiCad PCB EDA Suite
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:
PNS::MEANDER_PLACER_BASE PNS::PLACEMENT_ALGO PNS::ALGO_BASE

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
 
NODECurrentNode (bool aLoopsRemoved=false) const override
 Return the most recent world state. More...
 
const ITEM_SET Traces () override
 Function Traces() More...
 
const VECTOR2ICurrentStart () const override
 Function CurrentStart() More...
 
const VECTOR2ICurrentEnd () 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 int Clearance ()
 Return the clearance of the track(s) being length tuned. More...
 
virtual const MEANDER_SETTINGSMeanderSettings () 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...
 
ROUTERRouter () const
 Return current router settings. More...
 
ROUTING_SETTINGSSettings () const
 Return the logger object, allowing to dump geometry to a file. More...
 
virtual LOGGERLogger ()
 
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_DECORATORDbg () const
 
const BOX2IVisibleViewArea () 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)
 
long long int lineLength (const ITEM_SET &aLine, const SOLID *aStartPad, const SOLID *aEndPad) const
 Calculate the total length of the line represented by an item set (tracks and vias) More...
 

Protected Attributes

NODEm_world
 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
 
SOLIDm_startPad_p
 
SOLIDm_endPad_p
 
SOLIDm_startPad_n
 
SOLIDm_endPad_n
 
DEBUG_DECORATORm_debugDecorator
 
ROUTERm_router
 
LOGGERm_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...
 
NODEm_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_ITEMm_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

< Result of the length tuning operation

Enumerator
TOO_SHORT 
TOO_LONG 
TUNED 

Definition at line 49 of file pns_meander_placer_base.h.

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.

36 :
37 MEANDER_PLACER_BASE( aRouter )
38{
39 m_world = nullptr;
40 m_currentNode = nullptr;
41
42 m_padToDieP = 0;
43 m_padToDieN = 0;
44
45 // Init temporary variables (do not leave uninitialized members)
46 m_initialSegment = nullptr;
47 m_lastLength = 0;
49}
NODE * m_world
Width of the meandered trace(s).

References m_currentNode, m_initialSegment, m_lastLength, m_lastStatus, m_padToDieN, m_padToDieP, PNS::MEANDER_PLACER_BASE::m_world, 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.

53{
54}

Member Function Documentation

◆ AbortPlacement()

bool PNS::DP_MEANDER_PLACER::AbortPlacement ( )
overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 374 of file pns_dp_meander_placer.cpp.

375{
377 return true;
378}
void KillChildren()
Definition: pns_node.cpp:1467

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
aSigndirection (negative = decrease, positive = increase).

Definition at line 49 of file pns_meander_placer_base.cpp.

50{
52 a = std::max( a, m_settings.m_minAmplitude );
53
55}
MEANDER_SETTINGS m_settings
The current end point.
int m_minAmplitude
Maximum meandering amplitude.
Definition: pns_meander.h:78
int m_step
Length PadToDie.
Definition: pns_meander.h:87
int m_maxAmplitude
Meandering period/spacing (see dialog picture for explanation).
Definition: pns_meander.h:81

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 145 of file pns_dp_meander_placer.cpp.

146{
147 const VECTOR2I a( ( aCoupledSegs.coupledP.A + aCoupledSegs.coupledN.A ) / 2 );
148 const VECTOR2I b( ( aCoupledSegs.coupledP.B + aCoupledSegs.coupledN.B ) / 2 );
149
150 return SEG( a, b );
151}
Definition: seg.h:42

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
aShapethe shape to check.
Returns
true if the shape fits.

Reimplemented from PNS::MEANDER_PLACER_BASE.

Definition at line 397 of file pns_dp_meander_placer.cpp.

398{
399 LINE l1( m_originPair.PLine(), aShape->CLine( 0 ) );
400 LINE l2( m_originPair.NLine(), aShape->CLine( 1 ) );
401
402 if( m_currentNode->CheckColliding( &l1 ) )
403 return false;
404
405 if( m_currentNode->CheckColliding( &l2 ) )
406 return false;
407
408 int w = aShape->Width();
409 int clearance = w + m_settings.m_spacing;
410
411 return m_result.CheckSelfIntersections( aShape, clearance );
412}
const SHAPE_LINE_CHAIN & CLine() const
Definition: pns_line.h:142
bool CheckSelfIntersections(MEANDER_SHAPE *aShape, int aClearance)
Check if the given shape is intersecting with any other meander in the current line.
int m_spacing
Amplitude/spacing adjustment step.
Definition: pns_meander.h:84
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Check if the item collides with anything else in the world, and if found, returns the obstacle.
Definition: pns_node.cpp:472

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().

◆ Clearance()

int PNS::MEANDER_PLACER_BASE::Clearance ( )
virtualinherited

Return the clearance of the track(s) being length tuned.

Returns
clearance value in internal units

Definition at line 67 of file pns_meander_placer_base.cpp.

68{
69 // Assumption: All tracks are part of the same net class.
70 // It shouldn't matter which track we pick. They should all have the same clearance if
71 // they are part of the same net class. Therefore, pick the first one on the list.
72 ITEM* itemToCheck = Traces().CItems().front().item;
73 PNS::CONSTRAINT constraint;
74
76 nullptr, CurrentLayer(), &constraint );
77
78 wxCHECK_MSG( constraint.m_Value.HasMin(), m_currentWidth, wxT( "No minimum clearance?" ) );
79
80 return constraint.m_Value.Min();
81}
T Min() const
Definition: minoptmax.h:33
bool HasMin() const
Definition: minoptmax.h:37
ROUTER * Router() const
Return current router settings.
Definition: pns_algo_base.h:54
const ENTRIES & CItems() const
Definition: pns_itemset.h:136
int m_currentWidth
Meander settings.
virtual const ITEM_SET Traces()=0
Function Traces()
virtual int CurrentLayer() const =0
Function CurrentLayer()
RULE_RESOLVER * GetRuleResolver() const
Definition: pns_router.h:176
virtual bool QueryConstraint(CONSTRAINT_TYPE aType, const PNS::ITEM *aItemA, const PNS::ITEM *aItemB, int aLayer, PNS::CONSTRAINT *aConstraint)=0
MINOPTMAX< int > m_Value
Definition: pns_node.h:70

References PNS::ITEM_SET::CItems(), PNS::CT_CLEARANCE, PNS::PLACEMENT_ALGO::CurrentLayer(), PNS::ROUTER::GetRuleResolver(), MINOPTMAX< T >::HasMin(), PNS::MEANDER_PLACER_BASE::m_currentWidth, PNS::CONSTRAINT::m_Value, MINOPTMAX< T >::Min(), PNS::RULE_RESOLVER::QueryConstraint(), PNS::ALGO_BASE::Router(), and PNS::PLACEMENT_ALGO::Traces().

Referenced by PNS::MEANDER_SHAPE::spacing(), and PNS::MEANDER_PLACER_BASE::SpacingStep().

◆ CommitPlacement()

bool PNS::DP_MEANDER_PLACER::CommitPlacement ( )
overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 387 of file pns_dp_meander_placer.cpp.

388{
389 if( m_currentNode )
391
392 m_currentNode = nullptr;
393 return true;
394}
void CommitRouting()
Definition: pns_router.cpp:895

References PNS::ROUTER::CommitRouting(), m_currentNode, 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 344 of file pns_meander_placer_base.cpp.

346{
347 if( aValue < aExpected - aTolerance )
348 return -1;
349 else if( aValue > aExpected + aTolerance )
350 return 1;
351 else
352 return 0;
353}

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 435 of file pns_dp_meander_placer.cpp.

436{
437 return m_currentEnd;
438}

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 441 of file pns_dp_meander_placer.cpp.

442{
443 return m_initialSegment->Layers().Start();
444}
int Start() const
Definition: pns_layerset.h:82
const LAYER_RANGE & Layers() const
Definition: pns_item.h:156

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 483 of file pns_dp_meander_placer.cpp.

484{
485 std::vector<int> rv;
486 rv.push_back( m_originPair.NetP() );
487 rv.push_back( m_originPair.NetN() );
488 return rv;
489}
int NetN() const
int NetP() const

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.

64{
65 if( !m_currentNode )
66 return m_world;
67
68 return m_currentNode;
69}

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

◆ CurrentStart()

const VECTOR2I & PNS::DP_MEANDER_PLACER::CurrentStart ( ) const
overridevirtual

Function CurrentStart()

Returns the current start of the line(s) being placed/tuned.

Implements PNS::PLACEMENT_ALGO.

Definition at line 429 of file pns_dp_meander_placer.cpp.

430{
431 return m_currentStart;
432}
VECTOR2I m_currentStart
Current world state.

References m_currentStart.

◆ 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
aOriginthe original line.
aTuneStartpoint where we start meandering (start click coordinates).
aCursorPoscurrent cursor position.
aPrepart before the beginning of meanders.
aTunedpart to be meandered.
aPostpart after the end of meanders.

Definition at line 90 of file pns_meander_placer_base.cpp.

93{
94 VECTOR2I cp ( aCursorPos );
95
96 if( cp == aTuneStart ) // we don't like tuning segments with 0 length
97 {
98 int idx = aOrigin.FindSegment( cp );
99
100 if( idx >= 0 )
101 {
102 const SEG& s = aOrigin.CSegment( idx );
103 cp += ( s.B - s.A ).Resize( 2 );
104 }
105 else
106 {
107 cp += VECTOR2I( 2, 5 ); // some arbitrary value that is not 45 degrees oriented
108 }
109 }
110
111 VECTOR2I n = aOrigin.NearestPoint( cp, false );
112 VECTOR2I m = aOrigin.NearestPoint( aTuneStart, false );
113
114 SHAPE_LINE_CHAIN l( aOrigin );
115 l.Split( n );
116 l.Split( m );
117
118 int i_start = l.Find( m );
119 int i_end = l.Find( n );
120
121 if( i_start > i_end )
122 {
123 l = l.Reverse();
124 i_start = l.Find( m );
125 i_end = l.Find( n );
126 }
127
128 aPre = l.Slice( 0, i_start );
129 aPost = l.Slice( i_end, -1 );
130 aTuned = l.Slice( i_start, i_end );
131
132 aTuned.Simplify();
133}
VECTOR2I A
Definition: seg.h:49
VECTOR2I B
Definition: seg.h:50
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
SHAPE_LINE_CHAIN & Simplify(bool aRemoveColinear=true)
Simplify the line chain by removing colinear adjacent segments and duplicate vertices.
int FindSegment(const VECTOR2I &aP, int aThreshold=1) const
Search for segment containing point aP.
const SHAPE_LINE_CHAIN Slice(int aStartIndex, int aEndIndex=-1) const
Return a subset of this line chain containing the [start_index, end_index] range of points.
const VECTOR2I NearestPoint(const VECTOR2I &aP, bool aAllowInternalShapePoints=true) const
Find a point on the line chain that is closest to point aP.
const SEG CSegment(int aIndex) const
Return a constant copy of the aIndex segment in the line chain.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:618

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.

79 {
80 return m_debugDecorator;
81 }
DEBUG_DECORATOR * m_debugDecorator
Definition: pns_algo_base.h:86

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::LINE_PLACER::buildInitialLine(), PNS::LINE_PLACER::clipAndCheckCollisions(), PNS::MEANDER_PLACER::doMove(), PNS::COMPONENT_DRAGGER::Drag(), PNS::DRAGGER::dragShove(), PNS::DRAGGER::dragWalkaround(), PNS::SHOVE::fixupViaCollisions(), PNS::LINE_PLACER::handlePullback(), PNS::LINE_PLACER::mergeHead(), Move(), PNS::MEANDER_SKEW_PLACER::Move(), PNS::SHOVE::onCollidingArc(), PNS::SHOVE::onCollidingLine(), PNS::SHOVE::onCollidingSegment(), PNS::SHOVE::onCollidingSolid(), PNS::SHOVE::onCollidingVia(), PNS::SHOVE::onReverseCollidingVia(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::LINE_PLACER::optimizeTailHeadTransition(), PNS::SHOVE::pushLineStack(), PNS::SHOVE::pushOrShoveVia(), PNS::LINE_PLACER::reduceTail(), PNS::LINE_PLACER::removeLoops(), PNS::SHOVE::replaceLine(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkBase(), PNS::LINE_PLACER::rhWalkOnly(), PNS::LINE_PLACER::routeStep(), PNS::SHOVE::runOptimizer(), PNS::SHOVE::shoveIteration(), PNS::SHOVE::ShoveLines(), PNS::SHOVE::shoveLineToHullSet(), PNS::SHOVE::shoveMainLoop(), PNS::SHOVE::ShoveMultiLines(), PNS::SHOVE::ShoveObstacleLine(), PNS::WALKAROUND::singleStep(), PNS::LINE_PLACER::splitHeadTail(), PNS::LINE_PLACER::Start(), PNS::DRAGGER::Start(), PNS::LINE_PLACER::Trace(), PNS::DRAGGER::tryWalkaround(), and PNS::SHOVE::unwindLineStack().

◆ 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 360 of file pns_dp_meander_placer.cpp.

361{
364
365 m_currentNode->Add( lP );
366 m_currentNode->Add( lN );
367
369
370 return true;
371}
bool Add(std::unique_ptr< SEGMENT > aSegment, bool aAllowRedundant=false)
Add an item to the current node.
Definition: pns_node.cpp:664

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::DIFF_PAIR_PLACER, and PNS::LINE_PLACER.

Definition at line 167 of file pns_placement_algo.h.

168 {
169 }

◆ 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::DIFF_PAIR_PLACER, and PNS::LINE_PLACER.

Definition at line 198 of file pns_placement_algo.h.

199 {
200 }

◆ getSnappedStartPoint()

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

Definition at line 356 of file pns_meander_placer_base.cpp.

357{
358 if( aStartItem->Kind() == ITEM::SEGMENT_T )
359 {
360 return static_cast<SEGMENT*>( aStartItem )->Seg().NearestPoint( aStartPoint );
361 }
362 else
363 {
364 wxASSERT( aStartItem->Kind() == ITEM::ARC_T );
365 ARC* arc = static_cast<ARC*>( aStartItem );
366
367 if( ( VECTOR2I( arc->Anchor( 0 ) - aStartPoint ) ).SquaredEuclideanNorm() <=
368 ( VECTOR2I( arc->Anchor( 1 ) - aStartPoint ) ).SquaredEuclideanNorm() )
369 {
370 return arc->Anchor( 0 );
371 }
372 else
373 {
374 return arc->Anchor( 1 );
375 }
376 }
377}
@ SEGMENT_T
Definition: pns_item.h:66

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

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

◆ GetTotalPadToDieLength()

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

Definition at line 300 of file pns_meander_placer_base.cpp.

301{
302 int length = 0;
303 JOINT start;
304 JOINT end;
305
306 m_world->FindLineEnds( aLine, start, end );
307
308 // Extract the length of the pad to die for start and end pads
309 for( auto& link : start.LinkList() )
310 {
311 if( const SOLID* solid = dynamic_cast<const SOLID*>( link.item ) )
312 {
313 // If there are overlapping pads, choose the first with a non-zero length
314 if( solid->GetPadToDie() > 0 )
315 {
316 length += solid->GetPadToDie();
317 break;
318 }
319 }
320 }
321
322 for( auto& link : end.LinkList() )
323 {
324 if( const SOLID* solid = dynamic_cast<const SOLID*>( link.item ) )
325 {
326 if( solid->GetPadToDie() > 0 )
327 {
328 length += solid->GetPadToDie();
329 break;
330 }
331 }
332 }
333
334 return length;
335}
void FindLineEnds(const LINE &aLine, JOINT &aA, JOINT &aB)
Destroy all child nodes. Applicable only to the root node.
Definition: pns_node.cpp:1085

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

◆ HasPlacedAnything()

bool PNS::DP_MEANDER_PLACER::HasPlacedAnything ( ) const
overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 381 of file pns_dp_meander_placer.cpp.

382{
383 return m_originPair.CP().SegmentCount() > 0 || m_originPair.CN().SegmentCount() > 0;
384}
const SHAPE_LINE_CHAIN & CN() const
const SHAPE_LINE_CHAIN & CP() const
int SegmentCount() const
Return the number of segments in this line chain.

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::DIFF_PAIR_PLACER, and PNS::LINE_PLACER.

Definition at line 104 of file pns_placement_algo.h.

105 {
106 return false;
107 }

◆ lineLength()

long long int PNS::MEANDER_PLACER_BASE::lineLength ( const ITEM_SET aLine,
const SOLID aStartPad,
const SOLID aEndPad 
) const
protectedinherited

Calculate the total length of the line represented by an item set (tracks and vias)

Parameters
aLine
Returns
Pointer to world to search colliding items.

If there is a start pad but the pad's layers do not overlap the first track layer, then there must be a fanout via on the line. If there isn't, we still need to have the via back to the pad, so count the distance in the line tuning

Definition at line 380 of file pns_meander_placer_base.cpp.

381{
382 long long int total = 0;
383
384 if( aLine.Empty() )
385 return 0;
386
387 const ITEM* start_item = aLine[0];
388 const ITEM* end_item = aLine[aLine.Size() - 1];
389 bool start_via = false;
390 bool end_via = false;
391
392
398 start_via = aStartPad && ( !aStartPad->LayersOverlap( start_item ) );
399 end_via = aEndPad && ( !aEndPad->LayersOverlap( end_item ) );
400
401 for( int idx = 0; idx < aLine.Size(); idx++ )
402 {
403 const ITEM* item = aLine[idx];
404
405 if( const LINE* l = dyn_cast<const LINE*>( item ) )
406 {
407 total += l->CLine().Length();
408 }
409 else if( item->OfKind( ITEM::VIA_T ) && idx > 0 && idx < aLine.Size() - 1 )
410 {
411 int layerPrev = aLine[idx - 1]->Layer();
412 int layerNext = aLine[idx + 1]->Layer();
413
414 if( layerPrev != layerNext )
415 total += m_router->GetInterface()->StackupHeight( layerPrev, layerNext );
416 }
417 }
418
419 if( start_via )
420 {
421 int layerPrev = aStartPad->Layer();
422 int layerNext = start_item->Layer();
423
424 total += m_router->GetInterface()->StackupHeight( layerPrev, layerNext );
425 }
426
427 if( end_via )
428 {
429 int layerPrev = end_item->Layer();
430 int layerNext = aEndPad->Layer();
431
432 total += m_router->GetInterface()->StackupHeight( layerPrev, layerNext );
433 }
434
435 return total;
436}
ROUTER * m_router
Definition: pns_algo_base.h:87
virtual int StackupHeight(int aFirstLayer, int aSecondLayer) const =0
ROUTER_IFACE * GetInterface() const
Definition: pns_router.h:214

References PNS::ITEM_SET::Empty(), PNS::ROUTER::GetInterface(), PNS::ITEM::Layer(), PNS::ITEM::LayersOverlap(), PNS::ALGO_BASE::m_router, PNS::ITEM::OfKind(), PNS::ITEM_SET::Size(), PNS::ROUTER_IFACE::StackupHeight(), and PNS::ITEM::VIA_T.

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

◆ Logger()

LOGGER * PNS::ALGO_BASE::Logger ( )
virtualinherited

Reimplemented in PNS::SHOVE.

Definition at line 34 of file pns_algo_base.cpp.

35{
36 return nullptr;
37}

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkBase(), 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

◆ 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 164 of file pns_dp_meander_placer.cpp.

165{
166// return false;
167
168 DIFF_PAIR::COUPLED_SEGMENTS_VEC coupledSegments;
169
170 if( m_currentNode )
171 delete m_currentNode;
172
174
175 SHAPE_LINE_CHAIN preP, tunedP, postP;
176 SHAPE_LINE_CHAIN preN, tunedN, postN;
177
178 cutTunedLine( m_originPair.CP(), m_currentStart, aP, preP, tunedP, postP );
179 cutTunedLine( m_originPair.CN(), m_currentStart, aP, preN, tunedN, postN );
180
181 auto updateStatus =
182 [&]()
183 {
186
187 if( comp > 0 )
189 else if( comp < 0 )
191 else
193 };
194
195 DIFF_PAIR tuned( m_originPair );
196
197 tuned.SetShape( tunedP, tunedN );
198
199 tuned.CoupledSegmentPairs( coupledSegments );
200
201 if( coupledSegments.size() == 0 )
202 {
203 // Tuning started at an uncoupled area of the DP; we won't get a valid result until the
204 // cursor is moved far enough along a coupled area. Prevent the track from disappearing and
205 // the length from being zero by just using the original.
209 updateStatus();
210
211 return false;
212 }
213
214 m_result = MEANDERED_LINE( this, true );
215 m_result.SetWidth( tuned.Width() );
216
217 int offset = ( tuned.Gap() + tuned.Width() ) / 2;
218
219 if( pairOrientation( coupledSegments[0] ) )
220 offset *= -1;
221
222 m_result.SetBaselineOffset( offset );
223
224 for( const ITEM* item : m_tunedPathP.CItems() )
225 {
226 if( const LINE* l = dyn_cast<const LINE*>( item ) )
227 PNS_DBG( Dbg(), AddShape, &l->CLine(), YELLOW, 10000, wxT( "tuned-path-p" ) );
228 }
229
230 for( const ITEM* item : m_tunedPathN.CItems() )
231 {
232 if( const LINE* l = dyn_cast<const LINE*>( item ) )
233 PNS_DBG( Dbg(), AddShape, &l->CLine(), YELLOW, 10000, wxT( "tuned-path-n" ) );
234 }
235
236 int curIndexP = 0, curIndexN = 0;
237
238 for( const DIFF_PAIR::COUPLED_SEGMENTS& sp : coupledSegments )
239 {
240 SEG base = baselineSegment( sp );
241
242 PNS_DBG( Dbg(), AddShape, base, GREEN, 10000, wxT( "dp-baseline" ) );
243
244 while( sp.indexP >= curIndexP && curIndexP != -1 )
245 {
246 if( tunedP.IsArcSegment( curIndexP ) )
247 {
248 ssize_t arcIndex = tunedP.ArcIndex( curIndexP );
249
250 m_result.AddArcAndPt( tunedP.Arc( arcIndex ), tunedN.CPoint( curIndexN ) );
251 }
252 else
253 {
254 m_result.AddCorner( tunedP.CPoint( curIndexP ), tunedN.CPoint( curIndexN ) );
255 }
256
257 curIndexP = tunedP.NextShape( curIndexP );
258 }
259
260 while( sp.indexN >= curIndexN && curIndexN != -1 )
261 {
262 if( tunedN.IsArcSegment( curIndexN ) )
263 {
264 ssize_t arcIndex = tunedN.ArcIndex( curIndexN );
265
266 m_result.AddPtAndArc( tunedP.CPoint( sp.indexP ), tunedN.Arc( arcIndex ) );
267 }
268 else
269 {
270 m_result.AddCorner( tunedP.CPoint( sp.indexP ), tunedN.CPoint( curIndexN ) );
271 }
272
273 curIndexN = tunedN.NextShape( curIndexN );
274 }
275
276 m_result.MeanderSegment( base, base.Side( aP ) < 0 );
277 }
278
279 while( curIndexP < tunedP.PointCount() && curIndexP != -1 )
280 {
281 if( tunedP.IsArcSegment( curIndexP ) )
282 {
283 ssize_t arcIndex = tunedP.ArcIndex( curIndexP );
284
285 m_result.AddArcAndPt( tunedP.Arc( arcIndex ), tunedN.CPoint( curIndexN ) );
286 }
287 else
288 {
289 m_result.AddCorner( tunedP.CPoint( curIndexP ), tunedN.CPoint( curIndexN ) );
290 }
291
292 curIndexP = tunedP.NextShape( curIndexP );
293 }
294
295 while( curIndexN < tunedN.PointCount() && curIndexN != -1 )
296 {
297 if( tunedN.IsArcSegment( curIndexN ) )
298 {
299 ssize_t arcIndex = tunedN.ArcIndex( curIndexN );
300
301 m_result.AddPtAndArc( tunedP.CPoint( -1 ), tunedN.Arc( arcIndex ) );
302 }
303 else
304 {
305 m_result.AddCorner( tunedP.CPoint( -1 ), tunedN.CPoint( curIndexN ) );
306 }
307
308 curIndexN = tunedN.NextShape( curIndexN );
309 }
310
311 long long int dpLen = origPathLength();
312
314
316 {
318 m_lastLength = dpLen;
319 }
320 else
321 {
322 m_lastLength = dpLen - std::max( tunedP.Length(), tunedN.Length() );
324 }
325
326 if( m_lastStatus != TOO_LONG )
327 {
328 tunedP.Clear();
329 tunedN.Clear();
330
331 for( MEANDER_SHAPE* m : m_result.Meanders() )
332 {
333 if( m->Type() != MT_EMPTY )
334 {
335 tunedP.Append( m->CLine( 0 ) );
336 tunedN.Append( m->CLine( 1 ) );
337 }
338 }
339
340 m_lastLength += std::max( tunedP.Length(), tunedN.Length() );
341 updateStatus();
342 }
343
345 m_finalShapeP.Append( preP );
346 m_finalShapeP.Append( tunedP );
347 m_finalShapeP.Append( postP );
349
351 m_finalShapeN.Append( preN );
352 m_finalShapeN.Append( tunedN );
353 m_finalShapeN.Append( postN );
355
356 return true;
357}
DEBUG_DECORATOR * Dbg() const
Definition: pns_algo_base.h:78
std::vector< COUPLED_SEGMENTS > COUPLED_SEGMENTS_VEC
bool pairOrientation(const DIFF_PAIR::COUPLED_SEGMENTS &aPair)
const SEG baselineSegment(const DIFF_PAIR::COUPLED_SEGMENTS &aCoupledSegs)
long long int origPathLength() const
Current routing start point (end of tail, beginning of head).
void SetBaselineOffset(int aOffset)
Set the parallel offset between the base segment and the meandered line.
Definition: pns_meander.h:507
void SetWidth(int aWidth)
Set the line width.
Definition: pns_meander.h:492
void AddCorner(const VECTOR2I &aA, const VECTOR2I &aB=VECTOR2I(0, 0))
Create a dummy meander shape representing a line corner.
void MeanderSegment(const SEG &aSeg, bool aSide, int aBaseIndex=0)
Fit maximum amplitude meanders on a given segment and adds to the current line.
Definition: pns_meander.cpp:45
void AddArcAndPt(const SHAPE_ARC &aArc1, const VECTOR2I &aPt2)
Create a dummy meander shape representing an arc corner.
std::vector< MEANDER_SHAPE * > & Meanders()
Definition: pns_meander.h:515
void AddPtAndArc(const VECTOR2I &aPt1, const SHAPE_ARC &aArc2)
Create a dummy meander shape representing an arc corner.
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 aElonga...
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.
int compareWithTolerance(long long int aValue, long long int aExpected, long long int aTolerance=0) const
Compare aValue against aExpected with given tolerance.
long long int m_targetLength
Type of corners for the meandered line.
Definition: pns_meander.h:93
int m_lengthTolerance
Target skew value for diff pair de-skewing.
Definition: pns_meander.h:105
NODE * Branch()
Create a lightweight copy (called branch) of self that tracks the changes (added/removed items) wrs t...
Definition: pns_node.cpp:139
int Side(const VECTOR2I &aP) const
Determine on which side of directed line passing via segment ends point aP lies.
Definition: seg.h:143
const SHAPE_ARC & Arc(size_t aArc) const
int NextShape(int aPointIndex, bool aForwards=true) const
Return the vertex index of the next shape in the chain, or -1 if aPointIndex is the last shape.
int PointCount() const
Return the number of points (vertices) in this line chain.
ssize_t ArcIndex(size_t aSegment) const
Return the arc index for the given segment index.
void Clear()
Remove all points from the line chain.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
bool IsArcSegment(size_t aSegment) const
long long int Length() const
Return length of the line chain in Euclidean metric.
@ GREEN
Definition: color4d.h:57
@ YELLOW
Definition: color4d.h:67
@ MT_EMPTY
Definition: pns_meander.h:46
#define PNS_DBG(dbg, method,...)

References PNS::MEANDERED_LINE::AddArcAndPt(), PNS::MEANDERED_LINE::AddCorner(), PNS::MEANDERED_LINE::AddPtAndArc(), SHAPE_LINE_CHAIN::Append(), SHAPE_LINE_CHAIN::Arc(), SHAPE_LINE_CHAIN::ArcIndex(), baselineSegment(), PNS::NODE::Branch(), PNS::ITEM_SET::CItems(), SHAPE_LINE_CHAIN::Clear(), PNS::DIFF_PAIR::CN(), PNS::MEANDER_PLACER_BASE::compareWithTolerance(), PNS::DIFF_PAIR::CoupledSegmentPairs(), PNS::DIFF_PAIR::CP(), SHAPE_LINE_CHAIN::CPoint(), PNS::MEANDER_PLACER_BASE::cutTunedLine(), PNS::ALGO_BASE::Dbg(), PNS::DIFF_PAIR::Gap(), GREEN, SHAPE_LINE_CHAIN::IsArcSegment(), SHAPE_LINE_CHAIN::Length(), 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, SHAPE_LINE_CHAIN::NextShape(), origPathLength(), pairOrientation(), PNS_DBG, SHAPE_LINE_CHAIN::PointCount(), PNS::MEANDERED_LINE::SetBaselineOffset(), PNS::DIFF_PAIR::SetShape(), PNS::MEANDERED_LINE::SetWidth(), SEG::Side(), SHAPE_LINE_CHAIN::Simplify(), PNS::MEANDER_PLACER_BASE::TOO_LONG, PNS::MEANDER_PLACER_BASE::TOO_SHORT, PNS::MEANDER_PLACER_BASE::TUNED, PNS::MEANDER_PLACER_BASE::tuneLineLength(), PNS::DIFF_PAIR::Width(), and YELLOW.

◆ origPathLength()

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

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

Definition at line 137 of file pns_dp_meander_placer.cpp.

138{
139 long long int totalP = m_padToDieP + lineLength( m_tunedPathP, m_startPad_p, m_endPad_p );
140 long long int totalN = m_padToDieN + lineLength( m_tunedPathN, m_startPad_n, m_endPad_n );
141 return std::max( totalP, totalN );
142}
long long int lineLength(const ITEM_SET &aLine, const SOLID *aStartPad, const SOLID *aEndPad) const
Calculate the total length of the line represented by an item set (tracks and vias)

References PNS::MEANDER_PLACER_BASE::lineLength(), PNS::MEANDER_PLACER_BASE::m_endPad_n, PNS::MEANDER_PLACER_BASE::m_endPad_p, m_padToDieN, m_padToDieP, PNS::MEANDER_PLACER_BASE::m_startPad_n, PNS::MEANDER_PLACER_BASE::m_startPad_p, 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 154 of file pns_dp_meander_placer.cpp.

155{
156 VECTOR2I midp = ( aPair.coupledP.A + aPair.coupledN.A ) / 2;
157
158 //DrawDebugPoint(midp, 6);
159
160 return aPair.coupledP.Side( midp ) > 0;
161}

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 132 of file pns_dp_meander_placer.cpp.

133{
134}

◆ Router()

◆ 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.

74 {
75 m_debugDecorator = aDecorator;
76 }

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::SHOVE::onCollidingSolid(), PNS::LINE_PLACER::rhWalkBase(), 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::DIFF_PAIR_PLACER, and PNS::LINE_PLACER.

Definition at line 114 of file pns_placement_algo.h.

115 {
116 return false;
117 }

◆ SetLogger()

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

Definition at line 65 of file pns_algo_base.h.

66 {
67 m_logger = aLogger;
68 }
LOGGER * m_logger
Definition: pns_algo_base.h:88

References PNS::ALGO_BASE::m_logger.

Referenced by PNS::LINE_PLACER::rhWalkBase(), 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::DIFF_PAIR_PLACER, and PNS::LINE_PLACER.

Definition at line 189 of file pns_placement_algo.h.

190 {
191 }

◆ Settings()

◆ 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
aSigndirection (negative = decrease, positive = increase).

Definition at line 58 of file pns_meander_placer_base.cpp.

59{
60 int s = m_settings.m_spacing + aSign * m_settings.m_step;
61 s = std::max( s, m_currentWidth + Clearance() );
62
64}
virtual int Clearance()
Return the clearance of the track(s) being length tuned.

References PNS::MEANDER_PLACER_BASE::Clearance(), 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.

73{
74 if( !aStartItem || !aStartItem->OfKind( ITEM::SEGMENT_T | ITEM::ARC_T ) )
75 {
76 Router()->SetFailureReason( _( "Please select a track whose length you want to tune." ) );
77 return false;
78 }
79
80 m_initialSegment = static_cast<LINKED_ITEM*>( aStartItem );
81 m_currentNode = nullptr;
83
84 m_world = Router()->GetWorld()->Branch();
85
86 TOPOLOGY topo( m_world );
87
88 if( !topo.AssembleDiffPair( m_initialSegment, m_originPair ) )
89 {
90 Router()->SetFailureReason( _( "Unable to find complementary differential pair "
91 "net for length tuning. Make sure the names of the nets "
92 "belonging to a differential pair end with either _N/_P "
93 "or +/-." ) );
94 return false;
95 }
96
97 if( m_originPair.Gap() < 0 )
98 m_originPair.SetGap( Router()->Sizes().DiffPairGap() );
99
101 return false;
102
103 m_tunedPathP = topo.AssembleTuningPath( m_originPair.PLine().GetLink( 0 ), &m_startPad_p, &m_endPad_p );
104
105 m_padToDieP = 0;
106
107 if( m_startPad_p )
109
110 if( m_endPad_p )
112
113 m_tunedPathN = topo.AssembleTuningPath( m_originPair.NLine().GetLink( 0 ), &m_startPad_n, &m_endPad_n );
114
115 m_padToDieN = 0;
116
117 if( m_startPad_n )
119
120 if( m_endPad_n )
122
125
127
128 return true;
129}
int Width() const
int Gap() const
void SetGap(int aGap)
int SegmentCount() const
Definition: pns_line.h:144
VECTOR2I getSnappedStartPoint(LINKED_ITEM *aStartItem, VECTOR2I aStartPoint)
void Remove(ARC *aArc)
Remove an item from this branch.
Definition: pns_node.cpp:889
void SetFailureReason(const wxString &aReason)
Definition: pns_router.h:209
NODE * GetWorld() const
Definition: pns_router.h:160
int GetPadToDie() const
Definition: pns_solid.h:103
#define _(s)

References _, PNS::ITEM::ARC_T, PNS::TOPOLOGY::AssembleDiffPair(), PNS::TOPOLOGY::AssembleTuningPath(), PNS::NODE::Branch(), PNS::DIFF_PAIR::Gap(), PNS::LINK_HOLDER::GetLink(), PNS::SOLID::GetPadToDie(), PNS::MEANDER_PLACER_BASE::getSnappedStartPoint(), PNS::ROUTER::GetWorld(), m_currentNode, m_currentStart, PNS::MEANDER_PLACER_BASE::m_currentWidth, PNS::MEANDER_PLACER_BASE::m_endPad_n, PNS::MEANDER_PLACER_BASE::m_endPad_p, m_initialSegment, m_originPair, m_padToDieN, m_padToDieP, PNS::MEANDER_PLACER_BASE::m_startPad_n, PNS::MEANDER_PLACER_BASE::m_startPad_p, 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::DIFF_PAIR_PLACER, and PNS::LINE_PLACER.

Definition at line 94 of file pns_placement_algo.h.

95 {
96 return false;
97 }

◆ 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.

58{
59 return m_currentTraceP;
60}

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 415 of file pns_dp_meander_placer.cpp.

416{
419
420 ITEM_SET traces;
421
422 traces.Add( &m_currentTraceP );
423 traces.Add( &m_currentTraceN );
424
425 return traces;
426}

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 202 of file pns_meander_placer_base.cpp.

203{
204 long long int maxElongation = 0;
205 long long int minElongation = 0;
206 bool finished = false;
207
208 for( MEANDER_SHAPE* m : aTuned.Meanders() )
209 {
210 if( m->Type() != MT_CORNER && m->Type() != MT_ARC )
211 {
212 MEANDER_SHAPE end = *m;
213 MEANDER_TYPE endType;
214
215 if( m->Type() == MT_START || m->Type() == MT_SINGLE )
216 endType = MT_SINGLE;
217 else
218 endType = MT_FINISH;
219
220 end.SetType( endType );
221 end.Recalculate();
222
223 long long int maxEndElongation = end.CurrentLength() - end.BaselineLength();
224
225 if( maxElongation + maxEndElongation > aElongation )
226 {
227 if( !finished )
228 {
229 m->SetType( endType );
230 m->Recalculate();
231
232 if( endType == MT_SINGLE )
233 {
234 // Check if we need to fit this meander
235 long long int endMinElongation =
236 ( m->MinTunableLength() - m->BaselineLength() );
237
238 if( minElongation + endMinElongation >= aElongation )
239 m->MakeEmpty();
240 }
241
242 finished = true;
243 }
244 else
245 {
246 m->MakeEmpty();
247 }
248 }
249
250 maxElongation += m->CurrentLength() - m->BaselineLength();
251 minElongation += m->MinTunableLength() - m->BaselineLength();
252 }
253 }
254
255 long long int remainingElongation = aElongation;
256 int meanderCount = 0;
257
258 for( MEANDER_SHAPE* m : aTuned.Meanders() )
259 {
260 if( m->Type() != MT_CORNER && m->Type() != MT_ARC && m->Type() != MT_EMPTY )
261 {
262 remainingElongation -= m->CurrentLength() - m->BaselineLength();
263 meanderCount++;
264 }
265 }
266
267 long long int lenReductionLeft = -remainingElongation;
268 int meandersLeft = meanderCount;
269
270 if( lenReductionLeft < 0 || !meandersLeft )
271 return;
272
273 for( MEANDER_SHAPE* m : aTuned.Meanders() )
274 {
275 if( m->Type() != MT_CORNER && m->Type() != MT_ARC && m->Type() != MT_EMPTY )
276 {
277 long long int lenReductionHere = lenReductionLeft / meandersLeft;
278 long long int initialLen = m->CurrentLength();
279 int minAmpl = m->MinAmplitude();
280
281 int amp = findAmplitudeForLength( m, initialLen - lenReductionHere, minAmpl,
282 m->Amplitude() );
283
284 if( amp < minAmpl )
285 amp = minAmpl;
286
287 m->SetTargetBaselineLength( m->BaselineLength() );
288 m->Resize( amp );
289
290 lenReductionLeft -= initialLen - m->CurrentLength();
291 meandersLeft--;
292
293 if( !meandersLeft )
294 break;
295 }
296 }
297}
MEANDER_TYPE
Shapes of available meanders.
Definition: pns_meander.h:37
@ MT_ARC
Definition: pns_meander.h:45
@ MT_START
Definition: pns_meander.h:39
@ MT_FINISH
Definition: pns_meander.h:40
@ MT_CORNER
Definition: pns_meander.h:44
@ MT_SINGLE
Definition: pns_meander.h:38
int findAmplitudeForLength(MEANDER_SHAPE *m, int targetLength, int minAmp, int maxAmp)

References PNS::MEANDER_SHAPE::BaselineLength(), PNS::MEANDER_SHAPE::CurrentLength(), PNS::findAmplitudeForLength(), PNS::MEANDERED_LINE::Meanders(), PNS::MT_ARC, PNS::MT_CORNER, PNS::MT_EMPTY, PNS::MT_FINISH, PNS::MT_SINGLE, PNS::MT_START, PNS::MEANDER_SHAPE::Recalculate(), and PNS::MEANDER_SHAPE::SetType().

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 447 of file pns_dp_meander_placer.cpp.

448{
449 wxString status;
450
451 switch( m_lastStatus )
452 {
453 case TOO_LONG:
454 status = _( "Too long: " );
455 break;
456 case TOO_SHORT:
457 status = _("Too short: " );
458 break;
459 case TUNED:
460 status = _( "Tuned: " );
461 break;
462 default:
463 return _( "?" );
464 }
465
467 status += wxT( "/" );
469 status += wxT( " (gap: " );
471 status += wxT( ")" );
472
473 return status;
474}
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:109
wxString MessageTextFromValue(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnits, double aValue, bool aAddUnitsText=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE)
A helper to convert the double length aValue to a string in inches, millimeters, or unscaled units.
Definition: eda_units.cpp:326

References _, PNS::DIFF_PAIR::Gap(), m_lastLength, m_lastStatus, m_originPair, PNS::MEANDER_PLACER_BASE::m_settings, PNS::MEANDER_SETTINGS::m_targetLength, EDA_UNIT_UTILS::UI::MessageTextFromValue(), pcbIUScale, 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 477 of file pns_dp_meander_placer.cpp.

478{
479 return m_lastStatus;
480}

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.

81{ return false; };

◆ UpdateSettings()

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

◆ 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::DIFF_PAIR_PLACER, and PNS::LINE_PLACER.

Definition at line 178 of file pns_placement_algo.h.

179 {
180 }

◆ VisibleViewArea()

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

Definition at line 40 of file pns_algo_base.cpp.

41{
42 return m_router->VisibleViewArea();
43}
const BOX2I & VisibleViewArea() const
Definition: pns_router.h:217

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

Referenced by PNS::DRAGGER::optimizeAndUpdateDraggedLine(), and PNS::SHOVE::runOptimizer().

Friends And Related Function Documentation

◆ MEANDER_SHAPE

friend class MEANDER_SHAPE
friend

Definition at line 114 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 136 of file pns_dp_meander_placer.h.

◆ m_currentEnd

VECTOR2I PNS::MEANDER_PLACER_BASE::m_currentEnd
protectedinherited

◆ m_currentNode

NODE* PNS::DP_MEANDER_PLACER::m_currentNode
private

◆ m_currentStart

VECTOR2I PNS::DP_MEANDER_PLACER::m_currentStart
private

Current world state.

Definition at line 130 of file pns_dp_meander_placer.h.

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

◆ m_currentTraceN

LINE PNS::DP_MEANDER_PLACER::m_currentTraceN
private

Definition at line 138 of file pns_dp_meander_placer.h.

Referenced by Traces().

◆ m_currentTraceP

LINE PNS::DP_MEANDER_PLACER::m_currentTraceP
private

Definition at line 138 of file pns_dp_meander_placer.h.

Referenced by Trace(), and Traces().

◆ m_currentWidth

◆ 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_endPad_n

◆ m_endPad_p

◆ m_finalShapeN

SHAPE_LINE_CHAIN PNS::DP_MEANDER_PLACER::m_finalShapeN
private

Definition at line 141 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 141 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 143 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 145 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 148 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().

◆ m_originPair

DIFF_PAIR PNS::DP_MEANDER_PLACER::m_originPair
private

◆ m_padToDieN

int PNS::DP_MEANDER_PLACER::m_padToDieN
private

Definition at line 147 of file pns_dp_meander_placer.h.

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

◆ m_padToDieP

int PNS::DP_MEANDER_PLACER::m_padToDieP
private

Definition at line 146 of file pns_dp_meander_placer.h.

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

◆ m_result

MEANDERED_LINE PNS::DP_MEANDER_PLACER::m_result
private

Definition at line 142 of file pns_dp_meander_placer.h.

Referenced by CheckFit(), and Move().

◆ m_router

◆ m_settings

◆ m_startPad_n

◆ m_startPad_p

SOLID* PNS::MEANDER_PLACER_BASE::m_startPad_p
protectedinherited

◆ m_tunedPath

ITEM_SET PNS::DP_MEANDER_PLACER::m_tunedPath
private

Definition at line 139 of file pns_dp_meander_placer.h.

◆ m_tunedPathN

ITEM_SET PNS::DP_MEANDER_PLACER::m_tunedPathN
private

Definition at line 139 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 139 of file pns_dp_meander_placer.h.

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

◆ m_world


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