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 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
 Calculate the total length of the line represented by an item set (tracks and vias) More...
 

Protected Attributes

NODEm_world
 Total length added by pad to die size. More...
 
int m_padToDieLength
 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_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
Total length added by pad to die size.

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

365 {
367  return true;
368 }
void KillChildren()
Definition: pns_node.cpp:1388
NODE * m_world
Total length added by pad to die size.

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

45 {
46  int a = m_settings.m_maxAmplitude + aSign * m_settings.m_step;
47  a = std::max( a, m_settings.m_minAmplitude );
48 
50 }
int m_minAmplitude
Maximum meandering amplitude.
Definition: pns_meander.h:77
int m_step
Length PadToDie.
Definition: pns_meander.h:86
MEANDER_SETTINGS m_settings
The current end point.
int m_maxAmplitude
Meandering period/spacing (see dialog picture for explanation).
Definition: pns_meander.h:80

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

151 {
152  const VECTOR2I a( ( aCoupledSegs.coupledP.A + aCoupledSegs.coupledN.A ) / 2 );
153  const VECTOR2I b( ( aCoupledSegs.coupledP.B + aCoupledSegs.coupledN.B ) / 2 );
154 
155  return SEG( a, b );
156 }
Definition: seg.h:40

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

388 {
389  LINE l1( m_originPair.PLine(), aShape->CLine( 0 ) );
390  LINE l2( m_originPair.NLine(), aShape->CLine( 1 ) );
391 
392  if( m_currentNode->CheckColliding( &l1 ) )
393  return false;
394 
395  if( m_currentNode->CheckColliding( &l2 ) )
396  return false;
397 
398  int w = aShape->Width();
399  int clearance = w + m_settings.m_spacing;
400 
401  return m_result.CheckSelfIntersections( aShape, clearance );
402 }
const SHAPE_LINE_CHAIN & CLine() const
Definition: pns_line.h:137
bool CheckSelfIntersections(MEANDER_SHAPE *aShape, int aClearance)
Check if the given shape is intersecting with any other meander in the current line.
MEANDER_SETTINGS m_settings
The current end point.
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:450
int m_spacing
Amplitude/spacing adjustment step.
Definition: pns_meander.h:83

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

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

378 {
379  if( m_currentNode )
381 
382  m_currentNode = nullptr;
383  return true;
384 }
ROUTER * Router() const
Return current router settings.
Definition: pns_algo_base.h:54
void CommitRouting()
Definition: pns_router.cpp:695

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

247 {
248  if( aValue < aExpected - aTolerance )
249  return -1;
250  else if( aValue > aExpected + aTolerance )
251  return 1;
252  else
253  return 0;
254 }

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

420 {
421  return m_currentEnd;
422 }

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

426 {
427  return m_initialSegment->Layers().Start();
428 }
int Start() const
Definition: pns_layerset.h:82
const LAYER_RANGE & Layers() const
Definition: pns_item.h:152

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

467 {
468  std::vector<int> rv;
469  rv.push_back( m_originPair.NetP() );
470  rv.push_back( m_originPair.NetN() );
471  return rv;
472 }
int NetP() const
int NetN() 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 }
NODE * m_world
Total length added by pad to die size.

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

88 {
89  VECTOR2I cp ( aCursorPos );
90 
91  if( cp == aTuneStart ) // we don't like tuning segments with 0 length
92  {
93  int idx = aOrigin.FindSegment( cp );
94 
95  if( idx >= 0 )
96  {
97  const SEG& s = aOrigin.CSegment( idx );
98  cp += (s.B - s.A).Resize(2);
99  }
100  else
101  {
102  cp += VECTOR2I (2, 5); // some arbitrary value that is not 45 degrees oriented
103  }
104  }
105 
106  VECTOR2I n = aOrigin.NearestPoint( cp, false );
107  VECTOR2I m = aOrigin.NearestPoint( aTuneStart, false );
108 
109  SHAPE_LINE_CHAIN l( aOrigin );
110  l.Split( n );
111  l.Split( m );
112 
113  int i_start = l.Find( m );
114  int i_end = l.Find( n );
115 
116  if( i_start > i_end )
117  {
118  l = l.Reverse();
119  i_start = l.Find( m );
120  i_end = l.Find( n );
121  }
122 
123  aPre = l.Slice( 0, i_start );
124  aPost = l.Slice( i_end, -1 );
125  aTuned = l.Slice( i_start, i_end );
126 
127  aTuned.Simplify();
128 }
SHAPE_LINE_CHAIN & Simplify(bool aRemoveColinear=true)
Simplify the line chain by removing colinear adjacent segments and duplicate vertices.
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.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
int FindSegment(const VECTOR2I &aP, int aThreshold=1) const
Search for segment containing point aP.
const VECTOR2I NearestPoint(const VECTOR2I &aP, bool aAllowInternalShapePoints=true) const
Find a point on the line chain that is closest to point aP.
Definition: seg.h:40
const SEG CSegment(int aIndex) const
Return a constant copy of the aIndex segment in the line chain.
Represent a polyline (an zero-thickness chain of connected line segments).
VECTOR2I A
Definition: seg.h:48
VECTOR2I B
Definition: seg.h:49

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

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

351 {
354 
355  m_currentNode->Add( lP );
356  m_currentNode->Add( lN );
357 
358  CommitPlacement();
359 
360  return true;
361 }
bool Add(std::unique_ptr< SEGMENT > aSegment, bool aAllowRedundant=false)
Add an item to the current node.
Definition: pns_node.cpp:638

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.

161  {
162  }

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

192  {
193  }

◆ getSnappedStartPoint()

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

Definition at line 257 of file pns_meander_placer_base.cpp.

258 {
259  if( aStartItem->Kind() == ITEM::SEGMENT_T )
260  {
261  return static_cast<SEGMENT*>( aStartItem )->Seg().NearestPoint( aStartPoint );
262  }
263  else
264  {
265  wxASSERT( aStartItem->Kind() == ITEM::ARC_T );
266  ARC* arc = static_cast<ARC*>( aStartItem );
267 
268  if( ( VECTOR2I( arc->Anchor( 0 ) - aStartPoint ) ).SquaredEuclideanNorm() <=
269  ( VECTOR2I( arc->Anchor( 1 ) - aStartPoint ) ).SquaredEuclideanNorm() )
270  {
271  return arc->Anchor( 0 );
272  }
273  else
274  {
275  return arc->Anchor( 1 );
276  }
277  }
278 }
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623

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

202 {
203  int length = 0;
204  JOINT start;
205  JOINT end;
206 
207  m_world->FindLineEnds( aLine, start, end );
208 
209  // Extract the length of the pad to die for start and end pads
210  for( auto& link : start.LinkList() )
211  {
212  if( const SOLID* solid = dynamic_cast<const SOLID*>( link.item ) )
213  {
214  // If there are overlapping pads, choose the first with a non-zero length
215  if( solid->GetPadToDie() > 0 )
216  {
217  length += solid->GetPadToDie();
218  break;
219  }
220  }
221  }
222 
223  for( auto& link : end.LinkList() )
224  {
225  if( const SOLID* solid = dynamic_cast<const SOLID*>( link.item ) )
226  {
227  if( solid->GetPadToDie() > 0 )
228  {
229  length += solid->GetPadToDie();
230  break;
231  }
232  }
233  }
234 
235  return length;
236 }
void FindLineEnds(const LINE &aLine, JOINT &aA, JOINT &aB)
Destroy all child nodes. Applicable only to the root node.
Definition: pns_node.cpp:1028
NODE * m_world
Total length added by pad to die size.

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

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

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.

105  {
106  return false;
107  }

◆ lineLength()

long long int PNS::MEANDER_PLACER_BASE::lineLength ( const ITEM_SET aLine) const
protectedinherited

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

Parameters
aLine@returnPointer to world to search colliding items.

Definition at line 281 of file pns_meander_placer_base.cpp.

282 {
283  long long int total = 0;
284 
285  for( int idx = 0; idx < aLine.Size(); idx++ )
286  {
287  const ITEM* item = aLine[idx];
288 
289  if( const LINE* l = dyn_cast<const LINE*>( item ) )
290  {
291  total += l->CLine().Length();
292  }
293  else if( item->OfKind( ITEM::VIA_T ) && idx > 0 && idx < aLine.Size() - 1 )
294  {
295  int layerPrev = aLine[idx - 1]->Layer();
296  int layerNext = aLine[idx + 1]->Layer();
297 
298  if( layerPrev != layerNext )
299  total += m_router->GetInterface()->StackupHeight( layerPrev, layerNext );
300  }
301  }
302 
303  return total;
304 }
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:207

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

Referenced by PNS::MEANDER_SKEW_PLACER::origPathLength(), PNS::MEANDER_PLACER::origPathLength(), 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::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 239 of file pns_meander_placer_base.cpp.

240 {
241  return m_settings;
242 }
MEANDER_SETTINGS m_settings
The current end point.

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

170 {
171 // return false;
172 
173  DIFF_PAIR::COUPLED_SEGMENTS_VEC coupledSegments;
174 
175  if( m_currentNode )
176  delete m_currentNode;
177 
179 
180  SHAPE_LINE_CHAIN preP, tunedP, postP;
181  SHAPE_LINE_CHAIN preN, tunedN, postN;
182 
183  cutTunedLine( m_originPair.CP(), m_currentStart, aP, preP, tunedP, postP );
184  cutTunedLine( m_originPair.CN(), m_currentStart, aP, preN, tunedN, postN );
185 
186  DIFF_PAIR tuned( m_originPair );
187 
188  tuned.SetShape( tunedP, tunedN );
189 
190  tuned.CoupledSegmentPairs( coupledSegments );
191 
192  if( coupledSegments.size() == 0 )
193  return false;
194 
195  m_result = MEANDERED_LINE( this, true );
196  m_result.SetWidth( tuned.Width() );
197 
198  int offset = ( tuned.Gap() + tuned.Width() ) / 2;
199 
200  if( pairOrientation( coupledSegments[0] ) )
201  offset *= -1;
202 
203  m_result.SetBaselineOffset( offset );
204 
205  for( const ITEM* item : m_tunedPathP.CItems() )
206  {
207  if( const LINE* l = dyn_cast<const LINE*>( item ) )
208  PNS_DBG( Dbg(), AddLine, l->CLine(), YELLOW, 10000, "tuned-path-p" );
209  }
210 
211  for( const ITEM* item : m_tunedPathN.CItems() )
212  {
213  if( const LINE* l = dyn_cast<const LINE*>( item ) )
214  PNS_DBG( Dbg(), AddLine, l->CLine(), YELLOW, 10000, "tuned-path-n" );
215  }
216 
217  int curIndexP = 0, curIndexN = 0;
218 
219  for( const DIFF_PAIR::COUPLED_SEGMENTS& sp : coupledSegments )
220  {
221  SEG base = baselineSegment( sp );
222 
223  PNS_DBG( Dbg(), AddSegment, base, GREEN, "dp-baseline" );
224 
225  while( sp.indexP >= curIndexP && curIndexP != -1 )
226  {
227  if( tunedP.IsArcSegment( curIndexP ) )
228  {
229  ssize_t arcIndex = tunedP.ArcIndex( curIndexP );
230 
231  m_result.AddArcAndPt( tunedP.Arc( arcIndex ), tunedN.CPoint( curIndexN ) );
232  }
233  else
234  {
235  m_result.AddCorner( tunedP.CPoint( curIndexP ), tunedN.CPoint( curIndexN ) );
236  }
237 
238  curIndexP = tunedP.NextShape( curIndexP );
239  }
240 
241  while( sp.indexN >= curIndexN && curIndexN != -1 )
242  {
243  if( tunedN.IsArcSegment( curIndexN ) )
244  {
245  ssize_t arcIndex = tunedN.ArcIndex( curIndexN );
246 
247  m_result.AddPtAndArc( tunedP.CPoint( sp.indexP ), tunedN.Arc( arcIndex ) );
248  }
249  else
250  {
251  m_result.AddCorner( tunedP.CPoint( sp.indexP ), tunedN.CPoint( curIndexN ) );
252  }
253 
254  curIndexN = tunedN.NextShape( curIndexN );
255  }
256 
257  m_result.MeanderSegment( base );
258  }
259 
260  while( curIndexP < tunedP.PointCount() && curIndexP != -1 )
261  {
262  if( tunedP.IsArcSegment( curIndexP ) )
263  {
264  ssize_t arcIndex = tunedP.ArcIndex( curIndexP );
265 
266  m_result.AddArcAndPt( tunedP.Arc( arcIndex ), tunedN.CPoint( curIndexN ) );
267  }
268  else
269  {
270  m_result.AddCorner( tunedP.CPoint( curIndexP ), tunedN.CPoint( curIndexN ) );
271  }
272 
273  curIndexP = tunedP.NextShape( curIndexP );
274  }
275 
276  while( curIndexN < tunedN.PointCount() && curIndexN != -1 )
277  {
278  if( tunedN.IsArcSegment( curIndexN ) )
279  {
280  ssize_t arcIndex = tunedN.ArcIndex( curIndexN );
281 
282  m_result.AddPtAndArc( tunedP.CPoint( -1 ), tunedN.Arc( arcIndex ) );
283  }
284  else
285  {
286  m_result.AddCorner( tunedP.CPoint( -1 ), tunedN.CPoint( curIndexN ) );
287  }
288 
289  curIndexN = tunedN.NextShape( curIndexN );
290  }
291 
292  long long int dpLen = origPathLength();
293 
295 
297  {
299  m_lastLength = dpLen;
300  }
301  else
302  {
303  m_lastLength = dpLen - std::max( tunedP.Length(), tunedN.Length() );
305  }
306 
307  if( m_lastStatus != TOO_LONG )
308  {
309  tunedP.Clear();
310  tunedN.Clear();
311 
312  for( MEANDER_SHAPE* m : m_result.Meanders() )
313  {
314  if( m->Type() != MT_EMPTY )
315  {
316  tunedP.Append( m->CLine( 0 ) );
317  tunedN.Append( m->CLine( 1 ) );
318  }
319  }
320 
321  m_lastLength += std::max( tunedP.Length(), tunedN.Length() );
322 
325 
326  if( comp > 0 )
328  else if( comp < 0 )
330  else
332  }
333 
335  m_finalShapeP.Append( preP );
336  m_finalShapeP.Append( tunedP );
337  m_finalShapeP.Append( postP );
339 
341  m_finalShapeN.Append( preN );
342  m_finalShapeN.Append( tunedN );
343  m_finalShapeN.Append( postN );
345 
346  return true;
347 }
SHAPE_LINE_CHAIN & Simplify(bool aRemoveColinear=true)
Simplify the line chain by removing colinear adjacent segments and duplicate vertices.
void AddCorner(const VECTOR2I &aA, const VECTOR2I &aB=VECTOR2I(0, 0))
Create a dummy meander shape representing a line corner.
const SHAPE_LINE_CHAIN & CN() const
void AddPtAndArc(const VECTOR2I &aPt1, const SHAPE_ARC &aArc2)
Create a dummy meander shape representing an arc corner.
void MeanderSegment(const SEG &aSeg, int aBaseIndex=0)
Fit maximum amplitude meanders on a given segment and adds to the current line.
Definition: pns_meander.cpp:45
VECTOR2I m_currentStart
Current world state.
NODE * Branch()
Create a lightweight copy (called branch) of self that tracks the changes (added/removed items) wrs t...
Definition: pns_node.cpp:137
void AddArcAndPt(const SHAPE_ARC &aArc1, const VECTOR2I &aPt2)
Create a dummy meander shape representing an arc corner.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
void SetWidth(int aWidth)
Set the line width.
Definition: pns_meander.h:466
bool pairOrientation(const DIFF_PAIR::COUPLED_SEGMENTS &aPair)
const SEG baselineSegment(const DIFF_PAIR::COUPLED_SEGMENTS &aCoupledSegs)
Definition: color4d.h:67
std::vector< COUPLED_SEGMENTS > COUPLED_SEGMENTS_VEC
long long int origPathLength() const
Current routing start point (end of tail, beginning of head).
std::vector< MEANDER_SHAPE * > & Meanders()
Definition: pns_meander.h:488
Definition: color4d.h:57
NODE * m_world
Total length added by pad to die size.
#define PNS_DBG(dbg, method,...)
DEBUG_DECORATOR * Dbg() const
Definition: pns_algo_base.h:78
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...
Definition: seg.h:40
const SHAPE_LINE_CHAIN & CP() const
MEANDER_SETTINGS m_settings
The current end point.
int m_lengthTolerance
Target skew value for diff pair de-skewing.
Definition: pns_meander.h:101
Represent a polyline (an zero-thickness chain of connected line segments).
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:92
const ENTRIES & CItems() const
Definition: pns_itemset.h:136
void Clear()
Remove all points from the line chain.
void SetBaselineOffset(int aOffset)
Set the parallel offset between the base segment and the meandered line.
Definition: pns_meander.h:480
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.

References PNS::MEANDERED_LINE::AddArcAndPt(), PNS::MEANDERED_LINE::AddCorner(), PNS::MEANDERED_LINE::AddPtAndArc(), 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(), GREEN, 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_DBG, 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, PNS::MEANDER_PLACER_BASE::tuneLineLength(), 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 142 of file pns_dp_meander_placer.cpp.

143 {
144  long long int totalP = m_padToDieLength + lineLength( m_tunedPathP );
145  long long int totalN = m_padToDieLength + lineLength( m_tunedPathN );
146  return std::max( totalP, totalN );
147 }
int m_padToDieLength
Width of the meandered trace(s).
long long int lineLength(const ITEM_SET &aLine) 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_padToDieLength, 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 159 of file pns_dp_meander_placer.cpp.

160 {
161  VECTOR2I midp = ( aPair.coupledP.A + aPair.coupledN.A ) / 2;
162 
163  //DrawDebugPoint(midp, 6);
164 
165  return aPair.coupledP.Side( midp ) > 0;
166 }

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

138 {
139 }

◆ 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  }
DEBUG_DECORATOR * m_debugDecorator
Definition: pns_algo_base.h:86

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.

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

183  {
184  }

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

54 {
55  int s = m_settings.m_spacing + aSign * m_settings.m_step;
56  s = std::max( s, m_currentWidth + Clearance() );
57 
59 }
virtual int Clearance()
Return the clearance of the track(s) being length tuned.
int m_currentWidth
Meander settings.
int m_step
Length PadToDie.
Definition: pns_meander.h:86
MEANDER_SETTINGS m_settings
The current end point.
int m_spacing
Amplitude/spacing adjustment step.
Definition: pns_meander.h:83

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  SOLID* padA = nullptr;
104  SOLID* padB = nullptr;
105 
106  m_tunedPathP = topo.AssembleTuningPath( m_originPair.PLine().GetLink( 0 ), &padA, &padB );
107 
108  m_padToDieP = 0;
109 
110  if( padA )
111  m_padToDieP += padA->GetPadToDie();
112 
113  if( padB )
114  m_padToDieP += padB->GetPadToDie();
115 
116  m_tunedPathN = topo.AssembleTuningPath( m_originPair.NLine().GetLink( 0 ), &padA, &padB );
117 
118  m_padToDieN = 0;
119 
120  if( padA )
121  m_padToDieN += padA->GetPadToDie();
122 
123  if( padB )
124  m_padToDieN += padB->GetPadToDie();
125 
127 
130 
132 
133  return true;
134 }
ROUTER * Router() const
Return current router settings.
Definition: pns_algo_base.h:54
int Gap() const
int SegmentCount() const
Definition: pns_line.h:139
int Width() const
VECTOR2I m_currentStart
Current world state.
NODE * Branch()
Create a lightweight copy (called branch) of self that tracks the changes (added/removed items) wrs t...
Definition: pns_node.cpp:137
int m_currentWidth
Meander settings.
void Remove(ARC *aArc)
Remove an item from this branch.
Definition: pns_node.cpp:836
int m_padToDieLength
Width of the meandered trace(s).
void SetGap(int aGap)
NODE * m_world
Total length added by pad to die size.
void SetFailureReason(const wxString &aReason)
Definition: pns_router.h:202
#define _(s)
VECTOR2I getSnappedStartPoint(LINKED_ITEM *aStartItem, VECTOR2I aStartPoint)
NODE * GetWorld() const
Definition: pns_router.h:153

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, m_initialSegment, m_originPair, PNS::MEANDER_PLACER_BASE::m_padToDieLength, 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.

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

406 {
409 
410  ITEM_SET traces;
411 
412  traces.Add( &m_currentTraceP );
413  traces.Add( &m_currentTraceN );
414 
415  return traces;
416 }

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

132 {
133  long long int remaining = aElongation;
134  bool finished = false;
135 
136  for( MEANDER_SHAPE* m : aTuned.Meanders() )
137  {
138  if( m->Type() != MT_CORNER && m->Type() != MT_ARC )
139  {
140  if( remaining >= 0 )
141  remaining -= m->MaxTunableLength() - m->BaselineLength();
142 
143  if( remaining < 0 )
144  {
145  if( !finished )
146  {
147  MEANDER_TYPE newType;
148 
149  if( m->Type() == MT_START || m->Type() == MT_SINGLE )
150  newType = MT_SINGLE;
151  else
152  newType = MT_FINISH;
153 
154  m->SetType( newType );
155  m->Recalculate();
156 
157  finished = true;
158  }
159  else
160  {
161  m->MakeEmpty();
162  }
163  }
164  }
165  }
166 
167  remaining = aElongation;
168  int meanderCount = 0;
169 
170  for( MEANDER_SHAPE* m : aTuned.Meanders() )
171  {
172  if( m->Type() != MT_CORNER && m->Type() != MT_ARC && m->Type() != MT_EMPTY )
173  {
174  if(remaining >= 0)
175  {
176  remaining -= m->MaxTunableLength() - m->BaselineLength();
177  meanderCount ++;
178  }
179  }
180  }
181 
182  long long int balance = 0;
183 
184  if( meanderCount )
185  balance = -remaining / meanderCount;
186 
187  if( balance >= 0 )
188  {
189  for( MEANDER_SHAPE* m : aTuned.Meanders() )
190  {
191  if( m->Type() != MT_CORNER && m->Type() != MT_ARC && m->Type() != MT_EMPTY )
192  {
193  m->Resize( std::max( m->Amplitude() - balance / 2,
194  (long long int) m_settings.m_minAmplitude ) );
195  }
196  }
197  }
198 }
int m_minAmplitude
Maximum meandering amplitude.
Definition: pns_meander.h:77
MEANDER_TYPE
Shapes of available meanders.
Definition: pns_meander.h:37
MEANDER_SETTINGS m_settings
The current end point.

References PNS::MEANDER_SETTINGS::m_minAmplitude, PNS::MEANDER_PLACER_BASE::m_settings, PNS::MEANDERED_LINE::Meanders(), PNS::MT_ARC, 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 431 of file pns_dp_meander_placer.cpp.

432 {
433  wxString status;
434 
435  switch( m_lastStatus )
436  {
437  case TOO_LONG:
438  status = _( "Too long: " );
439  break;
440  case TOO_SHORT:
441  status = _("Too short: " );
442  break;
443  case TUNED:
444  status = _( "Tuned: " );
445  break;
446  default:
447  return _( "?" );
448  }
449 
450  status += ::MessageTextFromValue( aUnits, m_lastLength );
451  status += "/";
452  status += ::MessageTextFromValue( aUnits, m_settings.m_targetLength );
453  status += " (gap: ";
454  status += ::MessageTextFromValue( aUnits, m_originPair.Gap() );
455  status += ")";
456 
457  return status;
458 }
wxString MessageTextFromValue(EDA_UNITS aUnits, int aValue, bool aAddUnitLabel, EDA_DATA_TYPE aType)
Convert a value to a string using double notation.
Definition: base_units.cpp:104
int Gap() const
#define _(s)
MEANDER_SETTINGS m_settings
The current end point.
long long int m_targetLength
Type of corners for the meandered line.
Definition: pns_meander.h:92

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

462 {
463  return m_lastStatus;
464 }

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

Definition at line 79 of file pns_meander_placer_base.cpp.

80 {
81  m_settings = aSettings;
82 }
MEANDER_SETTINGS m_settings
The current end point.

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.

172  {
173  }

◆ 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 }
ROUTER * m_router
Definition: pns_algo_base.h:87
const BOX2I & VisibleViewArea() const
Definition: pns_router.h:210

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

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

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

◆ m_originPair

DIFF_PAIR PNS::DP_MEANDER_PLACER::m_originPair
private

◆ m_padToDieLength

int PNS::MEANDER_PLACER_BASE::m_padToDieLength
protectedinherited

◆ 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

◆ m_settings

◆ 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


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